bfd/elfcode.h

   1 /* ELF executable support for BFD.
   2    Copyright 1991, 92, 93, 94, 95, 96, 97, 98, 1999 Free Software
   3    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 "bfdlink.h"
  70 #include "libbfd.h"
  71 #include "elf-bfd.h"
  72
  73 /* Renaming structures, typedefs, macros and functions to be size-specific.  */
  74 #define Elf_External_Ehdr       NAME(Elf,External_Ehdr)
  75 #define Elf_External_Sym        NAME(Elf,External_Sym)
  76 #define Elf_External_Shdr       NAME(Elf,External_Shdr)
  77 #define Elf_External_Phdr       NAME(Elf,External_Phdr)
  78 #define Elf_External_Rel        NAME(Elf,External_Rel)
  79 #define Elf_External_Rela       NAME(Elf,External_Rela)
  80 #define Elf_External_Dyn        NAME(Elf,External_Dyn)
  81
  82 #define elf_core_file_failing_command   NAME(bfd_elf,core_file_failing_command)
  83 #define elf_core_file_failing_signal    NAME(bfd_elf,core_file_failing_signal)
  84 #define elf_core_file_matches_executable_p \
  85   NAME(bfd_elf,core_file_matches_executable_p)
  86 #define elf_object_p                    NAME(bfd_elf,object_p)
  87 #define elf_core_file_p                 NAME(bfd_elf,core_file_p)
  88 #define elf_get_symtab_upper_bound      NAME(bfd_elf,get_symtab_upper_bound)
  89 #define elf_get_dynamic_symtab_upper_bound \
  90   NAME(bfd_elf,get_dynamic_symtab_upper_bound)
  91 #define elf_swap_reloc_in               NAME(bfd_elf,swap_reloc_in)
  92 #define elf_swap_reloca_in              NAME(bfd_elf,swap_reloca_in)
  93 #define elf_swap_reloc_out              NAME(bfd_elf,swap_reloc_out)
  94 #define elf_swap_reloca_out             NAME(bfd_elf,swap_reloca_out)
  95 #define elf_swap_symbol_in              NAME(bfd_elf,swap_symbol_in)
  96 #define elf_swap_symbol_out             NAME(bfd_elf,swap_symbol_out)
  97 #define elf_swap_phdr_in                NAME(bfd_elf,swap_phdr_in)
  98 #define elf_swap_phdr_out               NAME(bfd_elf,swap_phdr_out)
  99 #define elf_swap_dyn_in                 NAME(bfd_elf,swap_dyn_in)
 100 #define elf_swap_dyn_out                NAME(bfd_elf,swap_dyn_out)
 101 #define elf_get_reloc_upper_bound       NAME(bfd_elf,get_reloc_upper_bound)
 102 #define elf_canonicalize_reloc          NAME(bfd_elf,canonicalize_reloc)
 103 #define elf_slurp_symbol_table          NAME(bfd_elf,slurp_symbol_table)
 104 #define elf_get_symtab                  NAME(bfd_elf,get_symtab)
 105 #define elf_canonicalize_dynamic_symtab \
 106   NAME(bfd_elf,canonicalize_dynamic_symtab)
 107 #define elf_make_empty_symbol           NAME(bfd_elf,make_empty_symbol)
 108 #define elf_get_symbol_info             NAME(bfd_elf,get_symbol_info)
 109 #define elf_get_lineno                  NAME(bfd_elf,get_lineno)
 110 #define elf_set_arch_mach               NAME(bfd_elf,set_arch_mach)
 111 #define elf_find_nearest_line           NAME(bfd_elf,find_nearest_line)
 112 #define elf_sizeof_headers              NAME(bfd_elf,sizeof_headers)
 113 #define elf_set_section_contents        NAME(bfd_elf,set_section_contents)
 114 #define elf_no_info_to_howto            NAME(bfd_elf,no_info_to_howto)
 115 #define elf_no_info_to_howto_rel        NAME(bfd_elf,no_info_to_howto_rel)
 116 #define elf_find_section                NAME(bfd_elf,find_section)
 117 #define elf_bfd_link_add_symbols        NAME(bfd_elf,bfd_link_add_symbols)
 118 #define elf_add_dynamic_entry           NAME(bfd_elf,add_dynamic_entry)
 119 #define elf_write_shdrs_and_ehdr        NAME(bfd_elf,write_shdrs_and_ehdr)
 120 #define elf_write_out_phdrs             NAME(bfd_elf,write_out_phdrs)
 121 #define elf_link_create_dynamic_sections \
 122   NAME(bfd_elf,link_create_dynamic_sections)
 123 #define elf_link_record_dynamic_symbol  _bfd_elf_link_record_dynamic_symbol
 124 #define elf_bfd_final_link              NAME(bfd_elf,bfd_final_link)
 125 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
 126 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
 127 #define elf_gc_sections                 NAME(_bfd_elf,gc_sections)
 128 #define elf_gc_common_finalize_got_offsets \
 129   NAME(_bfd_elf,gc_common_finalize_got_offsets)
 130 #define elf_gc_common_final_link        NAME(_bfd_elf,gc_common_final_link)
 131 #define elf_gc_record_vtinherit         NAME(_bfd_elf,gc_record_vtinherit)
 132 #define elf_gc_record_vtentry           NAME(_bfd_elf,gc_record_vtentry)
 133 #define elf_link_record_local_dynamic_symbol \
 134   NAME(_bfd_elf,link_record_local_dynamic_symbol)
 135
 136 #if ARCH_SIZE == 64
 137 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
 138 #define ELF_R_SYM(X)    ELF64_R_SYM(X)
 139 #define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
 140 #define ELFCLASS        ELFCLASS64
 141 #define FILE_ALIGN      8
 142 #define LOG_FILE_ALIGN  3
 143 #endif
 144 #if ARCH_SIZE == 32
 145 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
 146 #define ELF_R_SYM(X)    ELF32_R_SYM(X)
 147 #define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
 148 #define ELFCLASS        ELFCLASS32
 149 #define FILE_ALIGN      4
 150 #define LOG_FILE_ALIGN  2
 151 #endif
 152
 153 /* Static functions */
 154
 155 static void elf_swap_ehdr_in
 156   PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
 157 static void elf_swap_ehdr_out
 158   PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
 159 static void elf_swap_shdr_in
 160   PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
 161 static void elf_swap_shdr_out
 162   PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
 163
 164 #define elf_stringtab_init _bfd_elf_stringtab_init
 165
 166 #define section_from_elf_index bfd_section_from_elf_index
 167
 168 static boolean elf_slurp_reloc_table_from_section
 169   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
 170            arelent *, asymbol **, boolean));
 171 static boolean elf_slurp_reloc_table
 172   PARAMS ((bfd *, asection *, asymbol **, boolean));
 173
 174 static void write_relocs PARAMS ((bfd *, asection *, PTR));
 175
 176 static boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
 177
 178 #ifdef DEBUG
 179 static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
 180 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
 181 static char *elf_symbol_flags PARAMS ((flagword));
 182 #endif
 183 \f
 184 /* Structure swapping routines */
 185
 186 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
 187    can be handled by explicitly specifying 32 bits or "the long type".  */
 188 #if ARCH_SIZE == 64
 189 #define put_word        bfd_h_put_64
 190 #define put_signed_word bfd_h_put_signed_64
 191 #define get_word        bfd_h_get_64
 192 #define get_signed_word bfd_h_get_signed_64
 193 #endif
 194 #if ARCH_SIZE == 32
 195 #define put_word        bfd_h_put_32
 196 #define put_signed_word bfd_h_put_signed_32
 197 #define get_word        bfd_h_get_32
 198 #define get_signed_word bfd_h_get_signed_32
 199 #endif
 200
 201 /* Translate an ELF symbol in external format into an ELF symbol in internal
 202    format. */
 203
 204 void
 205 elf_swap_symbol_in (abfd, src, dst)
 206      bfd *abfd;
 207      const Elf_External_Sym *src;
 208      Elf_Internal_Sym *dst;
 209 {
 210   dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
 211   dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
 212   dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
 213   dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
 214   dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
 215   dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
 216 }
 217
 218 /* Translate an ELF symbol in internal format into an ELF symbol in external
 219    format. */
 220
 221 void
 222 elf_swap_symbol_out (abfd, src, cdst)
 223      bfd *abfd;
 224      const Elf_Internal_Sym *src;
 225      PTR cdst;
 226 {
 227   Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
 228   bfd_h_put_32 (abfd, src->st_name, dst->st_name);
 229   put_word (abfd, src->st_value, dst->st_value);
 230   put_word (abfd, src->st_size, dst->st_size);
 231   bfd_h_put_8 (abfd, src->st_info, dst->st_info);
 232   bfd_h_put_8 (abfd, src->st_other, dst->st_other);
 233   bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
 234 }
 235
 236
 237 /* Translate an ELF file header in external format into an ELF file header in
 238    internal format. */
 239
 240 static void
 241 elf_swap_ehdr_in (abfd, src, dst)
 242      bfd *abfd;
 243      const Elf_External_Ehdr *src;
 244      Elf_Internal_Ehdr *dst;
 245 {
 246   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 247   dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
 248   dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
 249   dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
 250   dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
 251   dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
 252   dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
 253   dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
 254   dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
 255   dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
 256   dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
 257   dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
 258   dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
 259   dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
 260 }
 261
 262 /* Translate an ELF file header in internal format into an ELF file header in
 263    external format. */
 264
 265 static void
 266 elf_swap_ehdr_out (abfd, src, dst)
 267      bfd *abfd;
 268      const Elf_Internal_Ehdr *src;
 269      Elf_External_Ehdr *dst;
 270 {
 271   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 272   /* note that all elements of dst are *arrays of unsigned char* already... */
 273   bfd_h_put_16 (abfd, src->e_type, dst->e_type);
 274   bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
 275   bfd_h_put_32 (abfd, src->e_version, dst->e_version);
 276   put_word (abfd, src->e_entry, dst->e_entry);
 277   put_word (abfd, src->e_phoff, dst->e_phoff);
 278   put_word (abfd, src->e_shoff, dst->e_shoff);
 279   bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
 280   bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
 281   bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
 282   bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
 283   bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
 284   bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
 285   bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
 286 }
 287
 288
 289 /* Translate an ELF section header table entry in external format into an
 290    ELF section header table entry in internal format. */
 291
 292 static void
 293 elf_swap_shdr_in (abfd, src, dst)
 294      bfd *abfd;
 295      const Elf_External_Shdr *src;
 296      Elf_Internal_Shdr *dst;
 297 {
 298   dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
 299   dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
 300   dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
 301   dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
 302   dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
 303   dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
 304   dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
 305   dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
 306   dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
 307   dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
 308   dst->bfd_section = NULL;
 309   dst->contents = NULL;
 310 }
 311
 312 /* Translate an ELF section header table entry in internal format into an
 313    ELF section header table entry in external format. */
 314
 315 static void
 316 elf_swap_shdr_out (abfd, src, dst)
 317      bfd *abfd;
 318      const Elf_Internal_Shdr *src;
 319      Elf_External_Shdr *dst;
 320 {
 321   /* note that all elements of dst are *arrays of unsigned char* already... */
 322   bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
 323   bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
 324   put_word (abfd, src->sh_flags, dst->sh_flags);
 325   put_word (abfd, src->sh_addr, dst->sh_addr);
 326   put_word (abfd, src->sh_offset, dst->sh_offset);
 327   put_word (abfd, src->sh_size, dst->sh_size);
 328   bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
 329   bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
 330   put_word (abfd, src->sh_addralign, dst->sh_addralign);
 331   put_word (abfd, src->sh_entsize, dst->sh_entsize);
 332 }
 333
 334
 335 /* Translate an ELF program header table entry in external format into an
 336    ELF program header table entry in internal format. */
 337
 338 void
 339 elf_swap_phdr_in (abfd, src, dst)
 340      bfd *abfd;
 341      const Elf_External_Phdr *src;
 342      Elf_Internal_Phdr *dst;
 343 {
 344   dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
 345   dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
 346   dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
 347   dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
 348   dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
 349   dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
 350   dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
 351   dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
 352 }
 353
 354 void
 355 elf_swap_phdr_out (abfd, src, dst)
 356      bfd *abfd;
 357      const Elf_Internal_Phdr *src;
 358      Elf_External_Phdr *dst;
 359 {
 360   /* note that all elements of dst are *arrays of unsigned char* already... */
 361   bfd_h_put_32 (abfd, src->p_type, dst->p_type);
 362   put_word (abfd, src->p_offset, dst->p_offset);
 363   put_word (abfd, src->p_vaddr, dst->p_vaddr);
 364   put_word (abfd, src->p_paddr, dst->p_paddr);
 365   put_word (abfd, src->p_filesz, dst->p_filesz);
 366   put_word (abfd, src->p_memsz, dst->p_memsz);
 367   bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
 368   put_word (abfd, src->p_align, dst->p_align);
 369 }
 370
 371 /* Translate an ELF reloc from external format to internal format. */
 372 INLINE void
 373 elf_swap_reloc_in (abfd, src, dst)
 374      bfd *abfd;
 375      const Elf_External_Rel *src;
 376      Elf_Internal_Rel *dst;
 377 {
 378   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 379   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 380 }
 381
 382 INLINE void
 383 elf_swap_reloca_in (abfd, src, dst)
 384      bfd *abfd;
 385      const Elf_External_Rela *src;
 386      Elf_Internal_Rela *dst;
 387 {
 388   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 389   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 390   dst->r_addend = get_signed_word (abfd, (bfd_byte *) src->r_addend);
 391 }
 392
 393 /* Translate an ELF reloc from internal format to external format. */
 394 INLINE void
 395 elf_swap_reloc_out (abfd, src, dst)
 396      bfd *abfd;
 397      const Elf_Internal_Rel *src;
 398      Elf_External_Rel *dst;
 399 {
 400   put_word (abfd, src->r_offset, dst->r_offset);
 401   put_word (abfd, src->r_info, dst->r_info);
 402 }
 403
 404 INLINE void
 405 elf_swap_reloca_out (abfd, src, dst)
 406      bfd *abfd;
 407      const Elf_Internal_Rela *src;
 408      Elf_External_Rela *dst;
 409 {
 410   put_word (abfd, src->r_offset, dst->r_offset);
 411   put_word (abfd, src->r_info, dst->r_info);
 412   put_signed_word (abfd, src->r_addend, dst->r_addend);
 413 }
 414
 415 INLINE void
 416 elf_swap_dyn_in (abfd, p, dst)
 417      bfd *abfd;
 418      const PTR p;
 419      Elf_Internal_Dyn *dst;
 420 {
 421   const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
 422
 423   dst->d_tag = get_word (abfd, src->d_tag);
 424   dst->d_un.d_val = get_word (abfd, src->d_un.d_val);
 425 }
 426
 427 INLINE void
 428 elf_swap_dyn_out (abfd, src, p)
 429      bfd *abfd;
 430      const Elf_Internal_Dyn *src;
 431      PTR p;
 432 {
 433   Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
 434
 435   put_word (abfd, src->d_tag, dst->d_tag);
 436   put_word (abfd, src->d_un.d_val, dst->d_un.d_val);
 437 }
 438 \f
 439 /* ELF .o/exec file reading */
 440
 441
 442 /* Begin processing a given object.
 443
 444    First we validate the file by reading in the ELF header and checking
 445    the magic number.  */
 446
 447 static INLINE boolean
 448 elf_file_p (x_ehdrp)
 449      Elf_External_Ehdr *x_ehdrp;
 450 {
 451   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
 452           && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
 453           && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
 454           && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
 455 }
 456
 457 /* Check to see if the file associated with ABFD matches the target vector
 458    that ABFD points to.
 459
 460    Note that we may be called several times with the same ABFD, but different
 461    target vectors, most of which will not match.  We have to avoid leaving
 462    any side effects in ABFD, or any data it points to (like tdata), if the
 463    file does not match the target vector.  */
 464
 465 const bfd_target *
 466 elf_object_p (abfd)
 467      bfd *abfd;
 468 {
 469   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 470   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 471   Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
 472   Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */
 473   unsigned int shindex;
 474   char *shstrtab;               /* Internal copy of section header stringtab */
 475   struct elf_backend_data *ebd;
 476   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
 477   struct elf_obj_tdata *new_tdata = NULL;
 478   asection *s;
 479
 480   /* Read in the ELF header in external format.  */
 481
 482   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
 483     {
 484       if (bfd_get_error () != bfd_error_system_call)
 485         goto got_wrong_format_error;
 486       else
 487         goto got_no_match;
 488     }
 489
 490   /* Now check to see if we have a valid ELF file, and one that BFD can
 491      make use of.  The magic number must match, the address size ('class')
 492      and byte-swapping must match our XVEC entry, and it must have a
 493      section header table (FIXME: See comments re sections at top of this
 494      file). */
 495
 496   if ((elf_file_p (&x_ehdr) == false) ||
 497       (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
 498       (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
 499     goto got_wrong_format_error;
 500
 501   /* Check that file's byte order matches xvec's */
 502   switch (x_ehdr.e_ident[EI_DATA])
 503     {
 504     case ELFDATA2MSB:           /* Big-endian */
 505       if (! bfd_header_big_endian (abfd))
 506         goto got_wrong_format_error;
 507       break;
 508     case ELFDATA2LSB:           /* Little-endian */
 509       if (! bfd_header_little_endian (abfd))
 510         goto got_wrong_format_error;
 511       break;
 512     case ELFDATANONE:           /* No data encoding specified */
 513     default:                    /* Unknown data encoding specified */
 514       goto got_wrong_format_error;
 515     }
 516
 517   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
 518      the tdata pointer in the bfd.  */
 519
 520   new_tdata = ((struct elf_obj_tdata *)
 521                bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)));
 522   if (new_tdata == NULL)
 523     goto got_no_match;
 524   elf_tdata (abfd) = new_tdata;
 525
 526   /* Now that we know the byte order, swap in the rest of the header */
 527   i_ehdrp = elf_elfheader (abfd);
 528   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 529 #if DEBUG & 1
 530   elf_debug_file (i_ehdrp);
 531 #endif
 532
 533   /* Reject ET_CORE (header indicates core file, not object file) */
 534   if (i_ehdrp->e_type == ET_CORE)
 535     goto got_wrong_format_error;
 536
 537   /* If there is no section header table, we're hosed. */
 538   if (i_ehdrp->e_shoff == 0)
 539     goto got_wrong_format_error;
 540
 541   /* As a simple sanity check, verify that the what BFD thinks is the
 542      size of each section header table entry actually matches the size
 543      recorded in the file. */
 544   if (i_ehdrp->e_shentsize != sizeof (x_shdr))
 545     goto got_wrong_format_error;
 546
 547   ebd = get_elf_backend_data (abfd);
 548
 549   /* Check that the ELF e_machine field matches what this particular
 550      BFD format expects.  */
 551   if (ebd->elf_machine_code != i_ehdrp->e_machine
 552       && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 553       && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 554     {
 555       const bfd_target * const *target_ptr;
 556
 557       if (ebd->elf_machine_code != EM_NONE)
 558         goto got_wrong_format_error;
 559
 560       /* This is the generic ELF target.  Let it match any ELF target
 561          for which we do not have a specific backend.  */
 562       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 563         {
 564           struct elf_backend_data *back;
 565
 566           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 567             continue;
 568           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 569           if (back->elf_machine_code == i_ehdrp->e_machine
 570               || (back->elf_machine_alt1 != 0
 571                   && back->elf_machine_alt1 == i_ehdrp->e_machine)
 572               || (back->elf_machine_alt2 != 0
 573                   && back->elf_machine_alt2 == i_ehdrp->e_machine))
 574             {
 575               /* target_ptr is an ELF backend which matches this
 576                  object file, so reject the generic ELF target.  */
 577               goto got_wrong_format_error;
 578             }
 579         }
 580     }
 581
 582   if (i_ehdrp->e_type == ET_EXEC)
 583     abfd->flags |= EXEC_P;
 584   else if (i_ehdrp->e_type == ET_DYN)
 585     abfd->flags |= DYNAMIC;
 586
 587   if (i_ehdrp->e_phnum > 0)
 588     abfd->flags |= D_PAGED;
 589
 590   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 591     {
 592       /* It's OK if this fails for the generic target.  */
 593       if (ebd->elf_machine_code != EM_NONE)
 594         goto got_no_match;
 595     }
 596
 597   /* Remember the entry point specified in the ELF file header. */
 598   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 599
 600   /* Allocate space for a copy of the section header table in
 601      internal form, seek to the section header table in the file,
 602      read it in, and convert it to internal form.  */
 603   i_shdrp = ((Elf_Internal_Shdr *)
 604              bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
 605   elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
 606                             bfd_alloc (abfd,
 607                                        sizeof (i_shdrp) * i_ehdrp->e_shnum));
 608   if (!i_shdrp || !elf_elfsections (abfd))
 609     goto got_no_match;
 610   if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0)
 611     goto got_no_match;
 612   for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
 613     {
 614       if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
 615         goto got_no_match;
 616       elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 617       elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
 618
 619       /* If the section is loaded, but not page aligned, clear
 620          D_PAGED.  */
 621       if ((i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
 622           && i_shdrp[shindex].sh_type != SHT_NOBITS
 623           && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
 624                % ebd->maxpagesize)
 625               != 0))
 626         abfd->flags &= ~D_PAGED;
 627     }
 628   if (i_ehdrp->e_shstrndx)
 629     {
 630       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 631         goto got_no_match;
 632     }
 633
 634   /* Read in the program headers.  */
 635   if (i_ehdrp->e_phnum == 0)
 636     elf_tdata (abfd)->phdr = NULL;
 637   else
 638     {
 639       Elf_Internal_Phdr *i_phdr;
 640       unsigned int i;
 641
 642       elf_tdata (abfd)->phdr = ((Elf_Internal_Phdr *)
 643                                 bfd_alloc (abfd,
 644                                            (i_ehdrp->e_phnum
 645                                             * sizeof (Elf_Internal_Phdr))));
 646       if (elf_tdata (abfd)->phdr == NULL)
 647         goto got_no_match;
 648       if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
 649         goto got_no_match;
 650       i_phdr = elf_tdata (abfd)->phdr;
 651       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
 652         {
 653           Elf_External_Phdr x_phdr;
 654
 655           if (bfd_read ((PTR) &x_phdr, sizeof x_phdr, 1, abfd)
 656               != sizeof x_phdr)
 657             goto got_no_match;
 658           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
 659         }
 660     }
 661
 662   /* Read in the string table containing the names of the sections.  We
 663      will need the base pointer to this table later. */
 664   /* We read this inline now, so that we don't have to go through
 665      bfd_section_from_shdr with it (since this particular strtab is
 666      used to find all of the ELF section names.) */
 667
 668   shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 669   if (!shstrtab)
 670     goto got_no_match;
 671
 672   /* Once all of the section headers have been read and converted, we
 673      can start processing them.  Note that the first section header is
 674      a dummy placeholder entry, so we ignore it.  */
 675
 676   for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 677     {
 678       if (! bfd_section_from_shdr (abfd, shindex))
 679         goto got_no_match;
 680     }
 681
 682   /* Let the backend double check the format and override global
 683      information.  */
 684   if (ebd->elf_backend_object_p)
 685     {
 686       if ((*ebd->elf_backend_object_p) (abfd) == false)
 687         goto got_wrong_format_error;
 688     }
 689
 690   /* If we have created any reloc sections that are associated with
 691      debugging sections, mark the reloc sections as debugging as well.  */
 692   for (s = abfd->sections; s != NULL; s = s->next)
 693     {
 694       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 695            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 696           && elf_section_data (s)->this_hdr.sh_info > 0)
 697         {
 698           unsigned long targ_index;
 699           asection *targ_sec;
 700
 701           targ_index = elf_section_data (s)->this_hdr.sh_info;
 702           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 703           if (targ_sec != NULL
 704               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 705             s->flags |= SEC_DEBUGGING;
 706         }
 707     }
 708
 709   return (abfd->xvec);
 710
 711  got_wrong_format_error:
 712   bfd_set_error (bfd_error_wrong_format);
 713  got_no_match:
 714   if (new_tdata != NULL
 715       && new_tdata->elf_sect_ptr != NULL)
 716     bfd_release (abfd, new_tdata->elf_sect_ptr);
 717   if (i_shdrp != NULL)
 718     bfd_release (abfd, i_shdrp);
 719   if (new_tdata != NULL)
 720     bfd_release (abfd, new_tdata);
 721   elf_tdata (abfd) = preserved_tdata;
 722   return (NULL);
 723 }
 724 \f
 725 /* ELF .o/exec file writing */
 726
 727 /* Write out the relocs.  */
 728
 729 static void
 730 write_relocs (abfd, sec, data)
 731      bfd *abfd;
 732      asection *sec;
 733      PTR data;
 734 {
 735   boolean *failedp = (boolean *) data;
 736   Elf_Internal_Shdr *rela_hdr;
 737   Elf_External_Rela *outbound_relocas;
 738   Elf_External_Rel *outbound_relocs;
 739   unsigned int idx;
 740   int use_rela_p;
 741   asymbol *last_sym = 0;
 742   int last_sym_idx = 0;
 743
 744   /* If we have already failed, don't do anything.  */
 745   if (*failedp)
 746     return;
 747
 748   if ((sec->flags & SEC_RELOC) == 0)
 749     return;
 750
 751   /* The linker backend writes the relocs out itself, and sets the
 752      reloc_count field to zero to inhibit writing them here.  Also,
 753      sometimes the SEC_RELOC flag gets set even when there aren't any
 754      relocs.  */
 755   if (sec->reloc_count == 0)
 756     return;
 757
 758   rela_hdr = &elf_section_data (sec)->rel_hdr;
 759
 760   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 761   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
 762   if (rela_hdr->contents == NULL)
 763     {
 764       *failedp = true;
 765       return;
 766     }
 767
 768   /* Figure out whether the relocations are RELA or REL relocations.  */
 769   if (rela_hdr->sh_type == SHT_RELA)
 770     use_rela_p = true;
 771   else if (rela_hdr->sh_type == SHT_REL)
 772     use_rela_p = false;
 773   else
 774     /* Every relocation section should be either an SHT_RELA or an
 775        SHT_REL section.  */
 776     abort ();
 777
 778   /* orelocation has the data, reloc_count has the count... */
 779   if (use_rela_p)
 780     {
 781       outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
 782
 783       for (idx = 0; idx < sec->reloc_count; idx++)
 784         {
 785           Elf_Internal_Rela dst_rela;
 786           Elf_External_Rela *src_rela;
 787           arelent *ptr;
 788           asymbol *sym;
 789           int n;
 790
 791           ptr = sec->orelocation[idx];
 792           src_rela = outbound_relocas + idx;
 793
 794           /* The address of an ELF reloc is section relative for an object
 795              file, and absolute for an executable file or shared library.
 796              The address of a BFD reloc is always section relative.  */
 797           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 798             dst_rela.r_offset = ptr->address;
 799           else
 800             dst_rela.r_offset = ptr->address + sec->vma;
 801
 802           sym = *ptr->sym_ptr_ptr;
 803           if (sym == last_sym)
 804             n = last_sym_idx;
 805           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 806             n = STN_UNDEF;
 807           else
 808             {
 809               last_sym = sym;
 810               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 811               if (n < 0)
 812                 {
 813                   *failedp = true;
 814                   return;
 815                 }
 816               last_sym_idx = n;
 817             }
 818
 819           if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 820               && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 821               && ! _bfd_elf_validate_reloc (abfd, ptr))
 822             {
 823               *failedp = true;
 824               return;
 825             }
 826
 827           dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 828
 829           dst_rela.r_addend = ptr->addend;
 830           elf_swap_reloca_out (abfd, &dst_rela, src_rela);
 831         }
 832     }
 833   else
 834     /* REL relocations */
 835     {
 836       outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
 837
 838       for (idx = 0; idx < sec->reloc_count; idx++)
 839         {
 840           Elf_Internal_Rel dst_rel;
 841           Elf_External_Rel *src_rel;
 842           arelent *ptr;
 843           int n;
 844           asymbol *sym;
 845
 846           ptr = sec->orelocation[idx];
 847           sym = *ptr->sym_ptr_ptr;
 848           src_rel = outbound_relocs + idx;
 849
 850           /* The address of an ELF reloc is section relative for an object
 851              file, and absolute for an executable file or shared library.
 852              The address of a BFD reloc is always section relative.  */
 853           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 854             dst_rel.r_offset = ptr->address;
 855           else
 856             dst_rel.r_offset = ptr->address + sec->vma;
 857
 858           if (sym == last_sym)
 859             n = last_sym_idx;
 860           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 861             n = STN_UNDEF;
 862           else
 863             {
 864               last_sym = sym;
 865               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 866               if (n < 0)
 867                 {
 868                   *failedp = true;
 869                   return;
 870                 }
 871               last_sym_idx = n;
 872             }
 873
 874           if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 875               && ! _bfd_elf_validate_reloc (abfd, ptr))
 876             {
 877               *failedp = true;
 878               return;
 879             }
 880
 881           dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
 882
 883           elf_swap_reloc_out (abfd, &dst_rel, src_rel);
 884         }
 885     }
 886 }
 887
 888 /* Write out the program headers.  */
 889
 890 int
 891 elf_write_out_phdrs (abfd, phdr, count)
 892      bfd *abfd;
 893      const Elf_Internal_Phdr *phdr;
 894      int count;
 895 {
 896   while (count--)
 897     {
 898       Elf_External_Phdr extphdr;
 899       elf_swap_phdr_out (abfd, phdr, &extphdr);
 900       if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
 901           != sizeof (Elf_External_Phdr))
 902         return -1;
 903       phdr++;
 904     }
 905   return 0;
 906 }
 907
 908 /* Write out the section headers and the ELF file header.  */
 909
 910 boolean
 911 elf_write_shdrs_and_ehdr (abfd)
 912      bfd *abfd;
 913 {
 914   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 915   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 916   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 917   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 918   unsigned int count;
 919
 920   i_ehdrp = elf_elfheader (abfd);
 921   i_shdrp = elf_elfsections (abfd);
 922
 923   /* swap the header before spitting it out... */
 924
 925 #if DEBUG & 1
 926   elf_debug_file (i_ehdrp);
 927 #endif
 928   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
 929   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 930       || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
 931           != sizeof (x_ehdr)))
 932     return false;
 933
 934   /* at this point we've concocted all the ELF sections... */
 935   x_shdrp = (Elf_External_Shdr *)
 936     bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
 937   if (!x_shdrp)
 938     return false;
 939
 940   for (count = 0; count < i_ehdrp->e_shnum; count++)
 941     {
 942 #if DEBUG & 2
 943       elf_debug_section (count, i_shdrp[count]);
 944 #endif
 945       elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
 946     }
 947   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
 948       || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
 949           != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
 950     return false;
 951
 952   /* need to dump the string table too... */
 953
 954   return true;
 955 }
 956
 957 long
 958 elf_slurp_symbol_table (abfd, symptrs, dynamic)
 959      bfd *abfd;
 960      asymbol **symptrs;         /* Buffer for generated bfd symbols */
 961      boolean dynamic;
 962 {
 963   Elf_Internal_Shdr *hdr;
 964   Elf_Internal_Shdr *verhdr;
 965   unsigned long symcount;       /* Number of external ELF symbols */
 966   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
 967   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
 968   Elf_Internal_Sym i_sym;
 969   Elf_External_Sym *x_symp = NULL;
 970   Elf_External_Versym *x_versymp = NULL;
 971
 972   /* Read each raw ELF symbol, converting from external ELF form to
 973      internal ELF form, and then using the information to create a
 974      canonical bfd symbol table entry.
 975
 976      Note that we allocate the initial bfd canonical symbol buffer
 977      based on a one-to-one mapping of the ELF symbols to canonical
 978      symbols.  We actually use all the ELF symbols, so there will be no
 979      space left over at the end.  When we have all the symbols, we
 980      build the caller's pointer vector. */
 981
 982   if (! dynamic)
 983     {
 984       hdr = &elf_tdata (abfd)->symtab_hdr;
 985       verhdr = NULL;
 986     }
 987   else
 988     {
 989       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
 990       if (elf_dynversym (abfd) == 0)
 991         verhdr = NULL;
 992       else
 993         verhdr = &elf_tdata (abfd)->dynversym_hdr;
 994       if ((elf_tdata (abfd)->dynverdef_section != 0
 995            && elf_tdata (abfd)->verdef == NULL)
 996           || (elf_tdata (abfd)->dynverref_section != 0
 997               && elf_tdata (abfd)->verref == NULL))
 998         {
 999           if (! _bfd_elf_slurp_version_tables (abfd))
1000             return -1;
1001         }
1002     }
1003
1004   if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1005     return -1;
1006
1007   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1008
1009   if (symcount == 0)
1010     sym = symbase = NULL;
1011   else
1012     {
1013       unsigned long i;
1014
1015       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1016         return -1;
1017
1018       symbase = ((elf_symbol_type *)
1019                  bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
1020       if (symbase == (elf_symbol_type *) NULL)
1021         return -1;
1022       sym = symbase;
1023
1024       /* Temporarily allocate room for the raw ELF symbols.  */
1025       x_symp = ((Elf_External_Sym *)
1026                 bfd_malloc (symcount * sizeof (Elf_External_Sym)));
1027       if (x_symp == NULL && symcount != 0)
1028         goto error_return;
1029
1030       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
1031           != symcount * sizeof (Elf_External_Sym))
1032         goto error_return;
1033
1034       /* Read the raw ELF version symbol information.  */
1035
1036       if (verhdr != NULL
1037           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1038         {
1039           (*_bfd_error_handler)
1040             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1041              abfd->filename,
1042              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1043              symcount);
1044
1045           /* Slurp in the symbols without the version information,
1046              since that is more helpful than just quitting.  */
1047           verhdr = NULL;
1048         }
1049
1050       if (verhdr != NULL)
1051         {
1052           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1053             goto error_return;
1054
1055           x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1056           if (x_versymp == NULL && verhdr->sh_size != 0)
1057             goto error_return;
1058
1059           if (bfd_read ((PTR) x_versymp, 1, verhdr->sh_size, abfd)
1060               != verhdr->sh_size)
1061             goto error_return;
1062         }
1063
1064       /* Skip first symbol, which is a null dummy.  */
1065       for (i = 1; i < symcount; i++)
1066         {
1067           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1068           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1069 #ifdef ELF_KEEP_EXTSYM
1070           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1071 #endif
1072           sym->symbol.the_bfd = abfd;
1073
1074           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1075                                                               hdr->sh_link,
1076                                                               i_sym.st_name);
1077
1078           sym->symbol.value = i_sym.st_value;
1079
1080           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1081             {
1082               sym->symbol.section = section_from_elf_index (abfd,
1083                                                             i_sym.st_shndx);
1084               if (sym->symbol.section == NULL)
1085                 {
1086                   /* This symbol is in a section for which we did not
1087                      create a BFD section.  Just use bfd_abs_section,
1088                      although it is wrong.  FIXME.  */
1089                   sym->symbol.section = bfd_abs_section_ptr;
1090                 }
1091             }
1092           else if (i_sym.st_shndx == SHN_ABS)
1093             {
1094               sym->symbol.section = bfd_abs_section_ptr;
1095             }
1096           else if (i_sym.st_shndx == SHN_COMMON)
1097             {
1098               sym->symbol.section = bfd_com_section_ptr;
1099               /* Elf puts the alignment into the `value' field, and
1100                  the size into the `size' field.  BFD wants to see the
1101                  size in the value field, and doesn't care (at the
1102                  moment) about the alignment.  */
1103               sym->symbol.value = i_sym.st_size;
1104             }
1105           else if (i_sym.st_shndx == SHN_UNDEF)
1106             {
1107               sym->symbol.section = bfd_und_section_ptr;
1108             }
1109           else
1110             sym->symbol.section = bfd_abs_section_ptr;
1111
1112           /* If this is a relocateable file, then the symbol value is
1113              already section relative.  */
1114           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1115             sym->symbol.value -= sym->symbol.section->vma;
1116
1117           switch (ELF_ST_BIND (i_sym.st_info))
1118             {
1119             case STB_LOCAL:
1120               sym->symbol.flags |= BSF_LOCAL;
1121               break;
1122             case STB_GLOBAL:
1123               if (i_sym.st_shndx != SHN_UNDEF
1124                   && i_sym.st_shndx != SHN_COMMON)
1125                 sym->symbol.flags |= BSF_GLOBAL;
1126               break;
1127             case STB_WEAK:
1128               sym->symbol.flags |= BSF_WEAK;
1129               break;
1130             }
1131
1132           switch (ELF_ST_TYPE (i_sym.st_info))
1133             {
1134             case STT_SECTION:
1135               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1136               break;
1137             case STT_FILE:
1138               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1139               break;
1140             case STT_FUNC:
1141               sym->symbol.flags |= BSF_FUNCTION;
1142               break;
1143             case STT_OBJECT:
1144               sym->symbol.flags |= BSF_OBJECT;
1145               break;
1146             }
1147
1148           if (dynamic)
1149             sym->symbol.flags |= BSF_DYNAMIC;
1150
1151           if (x_versymp != NULL)
1152             {
1153               Elf_Internal_Versym iversym;
1154
1155               _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1156               sym->version = iversym.vs_vers;
1157             }
1158
1159           /* Do some backend-specific processing on this symbol.  */
1160           {
1161             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1162             if (ebd->elf_backend_symbol_processing)
1163               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1164           }
1165
1166           sym++;
1167         }
1168     }
1169
1170   /* Do some backend-specific processing on this symbol table.  */
1171   {
1172     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1173     if (ebd->elf_backend_symbol_table_processing)
1174       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1175   }
1176
1177   /* We rely on the zalloc to clear out the final symbol entry.  */
1178
1179   symcount = sym - symbase;
1180
1181   /* Fill in the user's symbol pointer vector if needed.  */
1182   if (symptrs)
1183     {
1184       long l = symcount;
1185
1186       sym = symbase;
1187       while (l-- > 0)
1188         {
1189           *symptrs++ = &sym->symbol;
1190           sym++;
1191         }
1192       *symptrs = 0;             /* Final null pointer */
1193     }
1194
1195   if (x_versymp != NULL)
1196     free (x_versymp);
1197   if (x_symp != NULL)
1198     free (x_symp);
1199   return symcount;
1200 error_return:
1201   if (x_versymp != NULL)
1202     free (x_versymp);
1203   if (x_symp != NULL)
1204     free (x_symp);
1205   return -1;
1206 }
1207
1208 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1209    them.  */
1210
1211 static boolean
1212 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1213                                     relents, symbols, dynamic)
1214      bfd *abfd;
1215      asection *asect;
1216      Elf_Internal_Shdr *rel_hdr;
1217      bfd_size_type reloc_count;
1218      arelent *relents;
1219      asymbol **symbols;
1220      boolean dynamic;
1221 {
1222   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1223   PTR allocated = NULL;
1224   bfd_byte *native_relocs;
1225   arelent *relent;
1226   unsigned int i;
1227   int entsize;
1228
1229   allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
1230   if (allocated == NULL)
1231     goto error_return;
1232
1233   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1234       || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
1235           != rel_hdr->sh_size))
1236     goto error_return;
1237
1238   native_relocs = (bfd_byte *) allocated;
1239
1240   entsize = rel_hdr->sh_entsize;
1241   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1242               || entsize == sizeof (Elf_External_Rela));
1243
1244   for (i = 0, relent = relents;
1245        i < reloc_count;
1246        i++, relent++, native_relocs += entsize)
1247     {
1248       Elf_Internal_Rela rela;
1249       Elf_Internal_Rel rel;
1250
1251       if (entsize == sizeof (Elf_External_Rela))
1252         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1253       else
1254         {
1255           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1256           rela.r_offset = rel.r_offset;
1257           rela.r_info = rel.r_info;
1258           rela.r_addend = 0;
1259         }
1260
1261       /* The address of an ELF reloc is section relative for an object
1262          file, and absolute for an executable file or shared library.
1263          The address of a normal BFD reloc is always section relative,
1264          and the address of a dynamic reloc is absolute..  */
1265       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1266         relent->address = rela.r_offset;
1267       else
1268         relent->address = rela.r_offset - asect->vma;
1269
1270       if (ELF_R_SYM (rela.r_info) == 0)
1271         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1272       else
1273         {
1274           asymbol **ps, *s;
1275
1276           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1277           s = *ps;
1278
1279           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1280           if ((s->flags & BSF_SECTION_SYM) == 0)
1281             relent->sym_ptr_ptr = ps;
1282           else
1283             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1284         }
1285
1286       relent->addend = rela.r_addend;
1287
1288       if (entsize == sizeof (Elf_External_Rela))
1289         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1290       else
1291         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1292     }
1293
1294   if (allocated != NULL)
1295     free (allocated);
1296
1297   return true;
1298
1299  error_return:
1300   if (allocated != NULL)
1301     free (allocated);
1302   return false;
1303 }
1304
1305 /* Read in and swap the external relocs.  */
1306
1307 static boolean
1308 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1309      bfd *abfd;
1310      asection *asect;
1311      asymbol **symbols;
1312      boolean dynamic;
1313 {
1314   struct bfd_elf_section_data * const d = elf_section_data (asect);
1315   Elf_Internal_Shdr *rel_hdr;
1316   Elf_Internal_Shdr *rel_hdr2;
1317   bfd_size_type reloc_count;
1318   bfd_size_type reloc_count2;
1319   arelent *relents;
1320
1321   if (asect->relocation != NULL)
1322     return true;
1323
1324   if (! dynamic)
1325     {
1326       if ((asect->flags & SEC_RELOC) == 0
1327           || asect->reloc_count == 0)
1328         return true;
1329
1330       rel_hdr = &d->rel_hdr;
1331       reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
1332       rel_hdr2 = d->rel_hdr2;
1333       reloc_count2 = (rel_hdr2
1334                       ? (rel_hdr2->sh_size / rel_hdr2->sh_entsize)
1335                       : 0);
1336
1337       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1338       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1339                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1340
1341     }
1342   else
1343     {
1344       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1345          case because relocations against this section may use the
1346          dynamic symbol table, and in that case bfd_section_from_shdr
1347          in elf.c does not update the RELOC_COUNT.  */
1348       if (asect->_raw_size == 0)
1349         return true;
1350
1351       rel_hdr = &d->this_hdr;
1352       reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
1353       rel_hdr2 = NULL;
1354       reloc_count2 = 0;
1355     }
1356
1357   relents = ((arelent *)
1358              bfd_alloc (abfd,
1359                         (reloc_count + reloc_count2) * sizeof (arelent)));
1360   if (relents == NULL)
1361     return false;
1362
1363   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1364                                            rel_hdr, reloc_count,
1365                                            relents,
1366                                            symbols, dynamic))
1367     return false;
1368
1369   if (rel_hdr2
1370       && !elf_slurp_reloc_table_from_section (abfd, asect,
1371                                               rel_hdr2, reloc_count2,
1372                                               relents + reloc_count,
1373                                               symbols, dynamic))
1374     return false;
1375
1376
1377   asect->relocation = relents;
1378   return true;
1379 }
1380
1381 #ifdef DEBUG
1382 static void
1383 elf_debug_section (num, hdr)
1384      int num;
1385      Elf_Internal_Shdr *hdr;
1386 {
1387   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1388            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1389            (long) hdr);
1390   fprintf (stderr,
1391            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1392            (long) hdr->sh_name,
1393            (long) hdr->sh_type,
1394            (long) hdr->sh_flags);
1395   fprintf (stderr,
1396            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1397            (long) hdr->sh_addr,
1398            (long) hdr->sh_offset,
1399            (long) hdr->sh_size);
1400   fprintf (stderr,
1401            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1402            (long) hdr->sh_link,
1403            (long) hdr->sh_info,
1404            (long) hdr->sh_addralign);
1405   fprintf (stderr, "sh_entsize   = %ld\n",
1406            (long) hdr->sh_entsize);
1407   fflush (stderr);
1408 }
1409
1410 static void
1411 elf_debug_file (ehdrp)
1412      Elf_Internal_Ehdr *ehdrp;
1413 {
1414   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1415   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1416   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1417   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1418   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1419   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1420   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1421 }
1422
1423 static char *
1424 elf_symbol_flags (flags)
1425      flagword flags;
1426 {
1427   static char buffer[1024];
1428
1429   buffer[0] = '\0';
1430   if (flags & BSF_LOCAL)
1431     strcat (buffer, " local");
1432
1433   if (flags & BSF_GLOBAL)
1434     strcat (buffer, " global");
1435
1436   if (flags & BSF_DEBUGGING)
1437     strcat (buffer, " debug");
1438
1439   if (flags & BSF_FUNCTION)
1440     strcat (buffer, " function");
1441
1442   if (flags & BSF_KEEP)
1443     strcat (buffer, " keep");
1444
1445   if (flags & BSF_KEEP_G)
1446     strcat (buffer, " keep_g");
1447
1448   if (flags & BSF_WEAK)
1449     strcat (buffer, " weak");
1450
1451   if (flags & BSF_SECTION_SYM)
1452     strcat (buffer, " section-sym");
1453
1454   if (flags & BSF_OLD_COMMON)
1455     strcat (buffer, " old-common");
1456
1457   if (flags & BSF_NOT_AT_END)
1458     strcat (buffer, " not-at-end");
1459
1460   if (flags & BSF_CONSTRUCTOR)
1461     strcat (buffer, " constructor");
1462
1463   if (flags & BSF_WARNING)
1464     strcat (buffer, " warning");
1465
1466   if (flags & BSF_INDIRECT)
1467     strcat (buffer, " indirect");
1468
1469   if (flags & BSF_FILE)
1470     strcat (buffer, " file");
1471
1472   if (flags & DYNAMIC)
1473     strcat (buffer, " dynamic");
1474
1475   if (flags & ~(BSF_LOCAL
1476                 | BSF_GLOBAL
1477                 | BSF_DEBUGGING
1478                 | BSF_FUNCTION
1479                 | BSF_KEEP
1480                 | BSF_KEEP_G
1481                 | BSF_WEAK
1482                 | BSF_SECTION_SYM
1483                 | BSF_OLD_COMMON
1484                 | BSF_NOT_AT_END
1485                 | BSF_CONSTRUCTOR
1486                 | BSF_WARNING
1487                 | BSF_INDIRECT
1488                 | BSF_FILE
1489                 | BSF_DYNAMIC))
1490     strcat (buffer, " unknown-bits");
1491
1492   return buffer;
1493 }
1494 #endif
1495 \f
1496 #include "elfcore.h"
1497 #include "elflink.h"
1498 \f
1499 /* Size-dependent data and functions.  */
1500 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1501   sizeof (Elf_External_Ehdr),
1502   sizeof (Elf_External_Phdr),
1503   sizeof (Elf_External_Shdr),
1504   sizeof (Elf_External_Rel),
1505   sizeof (Elf_External_Rela),
1506   sizeof (Elf_External_Sym),
1507   sizeof (Elf_External_Dyn),
1508   sizeof (Elf_External_Note),
1509   ARCH_SIZE / 8,
1510   1,
1511   ARCH_SIZE, FILE_ALIGN,
1512   ELFCLASS, EV_CURRENT,
1513   elf_write_out_phdrs,
1514   elf_write_shdrs_and_ehdr,
1515   write_relocs,
1516   elf_swap_symbol_out,
1517   elf_slurp_reloc_table,
1518   elf_slurp_symbol_table,
1519   elf_swap_dyn_in,
1520   elf_swap_dyn_out,
1521   NULL,
1522   NULL,
1523   NULL,
1524   NULL
1525 };