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
 861             {
 862               last_sym = sym;
 863               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 864               if (n < 0)
 865                 {
 866                   *failedp = true;
 867                   return;
 868                 }
 869               last_sym_idx = n;
 870             }
 871
 872           if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 873               && ! _bfd_elf_validate_reloc (abfd, ptr))
 874             {
 875               *failedp = true;
 876               return;
 877             }
 878
 879           dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
 880
 881           elf_swap_reloc_out (abfd, &dst_rel, src_rel);
 882         }
 883     }
 884 }
 885
 886 /* Write out the program headers.  */
 887
 888 int
 889 elf_write_out_phdrs (abfd, phdr, count)
 890      bfd *abfd;
 891      const Elf_Internal_Phdr *phdr;
 892      int count;
 893 {
 894   while (count--)
 895     {
 896       Elf_External_Phdr extphdr;
 897       elf_swap_phdr_out (abfd, phdr, &extphdr);
 898       if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
 899           != sizeof (Elf_External_Phdr))
 900         return -1;
 901       phdr++;
 902     }
 903   return 0;
 904 }
 905
 906 /* Write out the section headers and the ELF file header.  */
 907
 908 boolean
 909 elf_write_shdrs_and_ehdr (abfd)
 910      bfd *abfd;
 911 {
 912   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 913   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 914   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 915   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 916   unsigned int count;
 917
 918   i_ehdrp = elf_elfheader (abfd);
 919   i_shdrp = elf_elfsections (abfd);
 920
 921   /* swap the header before spitting it out... */
 922
 923 #if DEBUG & 1
 924   elf_debug_file (i_ehdrp);
 925 #endif
 926   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
 927   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 928       || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
 929           != sizeof (x_ehdr)))
 930     return false;
 931
 932   /* at this point we've concocted all the ELF sections... */
 933   x_shdrp = (Elf_External_Shdr *)
 934     bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
 935   if (!x_shdrp)
 936     return false;
 937
 938   for (count = 0; count < i_ehdrp->e_shnum; count++)
 939     {
 940 #if DEBUG & 2
 941       elf_debug_section (count, i_shdrp[count]);
 942 #endif
 943       elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
 944     }
 945   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
 946       || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
 947           != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
 948     return false;
 949
 950   /* need to dump the string table too... */
 951
 952   return true;
 953 }
 954
 955 long
 956 elf_slurp_symbol_table (abfd, symptrs, dynamic)
 957      bfd *abfd;
 958      asymbol **symptrs;         /* Buffer for generated bfd symbols */
 959      boolean dynamic;
 960 {
 961   Elf_Internal_Shdr *hdr;
 962   Elf_Internal_Shdr *verhdr;
 963   unsigned long symcount;       /* Number of external ELF symbols */
 964   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
 965   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
 966   Elf_Internal_Sym i_sym;
 967   Elf_External_Sym *x_symp = NULL;
 968   Elf_External_Versym *x_versymp = NULL;
 969
 970   /* Read each raw ELF symbol, converting from external ELF form to
 971      internal ELF form, and then using the information to create a
 972      canonical bfd symbol table entry.
 973
 974      Note that we allocate the initial bfd canonical symbol buffer
 975      based on a one-to-one mapping of the ELF symbols to canonical
 976      symbols.  We actually use all the ELF symbols, so there will be no
 977      space left over at the end.  When we have all the symbols, we
 978      build the caller's pointer vector. */
 979
 980   if (! dynamic)
 981     {
 982       hdr = &elf_tdata (abfd)->symtab_hdr;
 983       verhdr = NULL;
 984     }
 985   else
 986     {
 987       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
 988       if (elf_dynversym (abfd) == 0)
 989         verhdr = NULL;
 990       else
 991         verhdr = &elf_tdata (abfd)->dynversym_hdr;
 992       if ((elf_tdata (abfd)->dynverdef_section != 0
 993            && elf_tdata (abfd)->verdef == NULL)
 994           || (elf_tdata (abfd)->dynverref_section != 0
 995               && elf_tdata (abfd)->verref == NULL))
 996         {
 997           if (! _bfd_elf_slurp_version_tables (abfd))
 998             return -1;
 999         }
1000     }
1001
1002   if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1003     return -1;
1004
1005   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1006
1007   if (symcount == 0)
1008     sym = symbase = NULL;
1009   else
1010     {
1011       unsigned long i;
1012
1013       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1014         return -1;
1015
1016       symbase = ((elf_symbol_type *)
1017                  bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
1018       if (symbase == (elf_symbol_type *) NULL)
1019         return -1;
1020       sym = symbase;
1021
1022       /* Temporarily allocate room for the raw ELF symbols.  */
1023       x_symp = ((Elf_External_Sym *)
1024                 bfd_malloc (symcount * sizeof (Elf_External_Sym)));
1025       if (x_symp == NULL && symcount != 0)
1026         goto error_return;
1027
1028       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
1029           != symcount * sizeof (Elf_External_Sym))
1030         goto error_return;
1031
1032       /* Read the raw ELF version symbol information.  */
1033
1034       if (verhdr != NULL
1035           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1036         {
1037           (*_bfd_error_handler)
1038             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1039              abfd->filename,
1040              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1041              symcount);
1042
1043           /* Slurp in the symbols without the version information,
1044              since that is more helpful than just quitting.  */
1045           verhdr = NULL;
1046         }
1047
1048       if (verhdr != NULL)
1049         {
1050           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1051             goto error_return;
1052
1053           x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1054           if (x_versymp == NULL && verhdr->sh_size != 0)
1055             goto error_return;
1056
1057           if (bfd_read ((PTR) x_versymp, 1, verhdr->sh_size, abfd)
1058               != verhdr->sh_size)
1059             goto error_return;
1060         }
1061
1062       /* Skip first symbol, which is a null dummy.  */
1063       for (i = 1; i < symcount; i++)
1064         {
1065           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1066           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1067 #ifdef ELF_KEEP_EXTSYM
1068           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1069 #endif
1070           sym->symbol.the_bfd = abfd;
1071
1072           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1073                                                               hdr->sh_link,
1074                                                               i_sym.st_name);
1075
1076           sym->symbol.value = i_sym.st_value;
1077
1078           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1079             {
1080               sym->symbol.section = section_from_elf_index (abfd,
1081                                                             i_sym.st_shndx);
1082               if (sym->symbol.section == NULL)
1083                 {
1084                   /* This symbol is in a section for which we did not
1085                      create a BFD section.  Just use bfd_abs_section,
1086                      although it is wrong.  FIXME.  */
1087                   sym->symbol.section = bfd_abs_section_ptr;
1088                 }
1089             }
1090           else if (i_sym.st_shndx == SHN_ABS)
1091             {
1092               sym->symbol.section = bfd_abs_section_ptr;
1093             }
1094           else if (i_sym.st_shndx == SHN_COMMON)
1095             {
1096               sym->symbol.section = bfd_com_section_ptr;
1097               /* Elf puts the alignment into the `value' field, and
1098                  the size into the `size' field.  BFD wants to see the
1099                  size in the value field, and doesn't care (at the
1100                  moment) about the alignment.  */
1101               sym->symbol.value = i_sym.st_size;
1102             }
1103           else if (i_sym.st_shndx == SHN_UNDEF)
1104             {
1105               sym->symbol.section = bfd_und_section_ptr;
1106             }
1107           else
1108             sym->symbol.section = bfd_abs_section_ptr;
1109
1110           /* If this is a relocateable file, then the symbol value is
1111              already section relative.  */
1112           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1113             sym->symbol.value -= sym->symbol.section->vma;
1114
1115           switch (ELF_ST_BIND (i_sym.st_info))
1116             {
1117             case STB_LOCAL:
1118               sym->symbol.flags |= BSF_LOCAL;
1119               break;
1120             case STB_GLOBAL:
1121               if (i_sym.st_shndx != SHN_UNDEF
1122                   && i_sym.st_shndx != SHN_COMMON)
1123                 sym->symbol.flags |= BSF_GLOBAL;
1124               break;
1125             case STB_WEAK:
1126               sym->symbol.flags |= BSF_WEAK;
1127               break;
1128             }
1129
1130           switch (ELF_ST_TYPE (i_sym.st_info))
1131             {
1132             case STT_SECTION:
1133               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1134               break;
1135             case STT_FILE:
1136               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1137               break;
1138             case STT_FUNC:
1139               sym->symbol.flags |= BSF_FUNCTION;
1140               break;
1141             case STT_OBJECT:
1142               sym->symbol.flags |= BSF_OBJECT;
1143               break;
1144             }
1145
1146           if (dynamic)
1147             sym->symbol.flags |= BSF_DYNAMIC;
1148
1149           if (x_versymp != NULL)
1150             {
1151               Elf_Internal_Versym iversym;
1152
1153               _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1154               sym->version = iversym.vs_vers;
1155             }
1156
1157           /* Do some backend-specific processing on this symbol.  */
1158           {
1159             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1160             if (ebd->elf_backend_symbol_processing)
1161               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1162           }
1163
1164           sym++;
1165         }
1166     }
1167
1168   /* Do some backend-specific processing on this symbol table.  */
1169   {
1170     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1171     if (ebd->elf_backend_symbol_table_processing)
1172       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1173   }
1174
1175   /* We rely on the zalloc to clear out the final symbol entry.  */
1176
1177   symcount = sym - symbase;
1178
1179   /* Fill in the user's symbol pointer vector if needed.  */
1180   if (symptrs)
1181     {
1182       long l = symcount;
1183
1184       sym = symbase;
1185       while (l-- > 0)
1186         {
1187           *symptrs++ = &sym->symbol;
1188           sym++;
1189         }
1190       *symptrs = 0;             /* Final null pointer */
1191     }
1192
1193   if (x_versymp != NULL)
1194     free (x_versymp);
1195   if (x_symp != NULL)
1196     free (x_symp);
1197   return symcount;
1198 error_return:
1199   if (x_versymp != NULL)
1200     free (x_versymp);
1201   if (x_symp != NULL)
1202     free (x_symp);
1203   return -1;
1204 }
1205
1206 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1207    them.  */
1208
1209 static boolean
1210 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1211                                     relents, symbols, dynamic)
1212      bfd *abfd;
1213      asection *asect;
1214      Elf_Internal_Shdr *rel_hdr;
1215      bfd_size_type reloc_count;
1216      arelent *relents;
1217      asymbol **symbols;
1218      boolean dynamic;
1219 {
1220   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1221   PTR allocated = NULL;
1222   bfd_byte *native_relocs;
1223   arelent *relent;
1224   unsigned int i;
1225   int entsize;
1226
1227   allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
1228   if (allocated == NULL)
1229     goto error_return;
1230
1231   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1232       || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
1233           != rel_hdr->sh_size))
1234     goto error_return;
1235
1236   native_relocs = (bfd_byte *) allocated;
1237
1238   entsize = rel_hdr->sh_entsize;
1239   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1240               || entsize == sizeof (Elf_External_Rela));
1241
1242   for (i = 0, relent = relents;
1243        i < reloc_count;
1244        i++, relent++, native_relocs += entsize)
1245     {
1246       Elf_Internal_Rela rela;
1247       Elf_Internal_Rel rel;
1248
1249       if (entsize == sizeof (Elf_External_Rela))
1250         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1251       else
1252         {
1253           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1254           rela.r_offset = rel.r_offset;
1255           rela.r_info = rel.r_info;
1256           rela.r_addend = 0;
1257         }
1258
1259       /* The address of an ELF reloc is section relative for an object
1260          file, and absolute for an executable file or shared library.
1261          The address of a normal BFD reloc is always section relative,
1262          and the address of a dynamic reloc is absolute..  */
1263       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1264         relent->address = rela.r_offset;
1265       else
1266         relent->address = rela.r_offset - asect->vma;
1267
1268       if (ELF_R_SYM (rela.r_info) == 0)
1269         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1270       else
1271         {
1272           asymbol **ps, *s;
1273
1274           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1275           s = *ps;
1276
1277           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1278           if ((s->flags & BSF_SECTION_SYM) == 0)
1279             relent->sym_ptr_ptr = ps;
1280           else
1281             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1282         }
1283
1284       relent->addend = rela.r_addend;
1285
1286       if (entsize == sizeof (Elf_External_Rela))
1287         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1288       else
1289         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1290     }
1291
1292   if (allocated != NULL)
1293     free (allocated);
1294
1295   return true;
1296
1297  error_return:
1298   if (allocated != NULL)
1299     free (allocated);
1300   return false;
1301 }
1302
1303 /* Read in and swap the external relocs.  */
1304
1305 static boolean
1306 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1307      bfd *abfd;
1308      asection *asect;
1309      asymbol **symbols;
1310      boolean dynamic;
1311 {
1312   struct bfd_elf_section_data * const d = elf_section_data (asect);
1313   Elf_Internal_Shdr *rel_hdr;
1314   Elf_Internal_Shdr *rel_hdr2;
1315   bfd_size_type reloc_count;
1316   bfd_size_type reloc_count2;
1317   arelent *relents;
1318
1319   if (asect->relocation != NULL)
1320     return true;
1321
1322   if (! dynamic)
1323     {
1324       if ((asect->flags & SEC_RELOC) == 0
1325           || asect->reloc_count == 0)
1326         return true;
1327
1328       rel_hdr = &d->rel_hdr;
1329       reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
1330       rel_hdr2 = d->rel_hdr2;
1331       reloc_count2 = (rel_hdr2
1332                       ? (rel_hdr2->sh_size / rel_hdr2->sh_entsize)
1333                       : 0);
1334
1335       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1336       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1337                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1338
1339     }
1340   else
1341     {
1342       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1343          case because relocations against this section may use the
1344          dynamic symbol table, and in that case bfd_section_from_shdr
1345          in elf.c does not update the RELOC_COUNT.  */
1346       if (asect->_raw_size == 0)
1347         return true;
1348
1349       rel_hdr = &d->this_hdr;
1350       reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
1351       rel_hdr2 = NULL;
1352       reloc_count2 = 0;
1353     }
1354
1355   relents = ((arelent *)
1356              bfd_alloc (abfd,
1357                         (reloc_count + reloc_count2) * sizeof (arelent)));
1358   if (relents == NULL)
1359     return false;
1360
1361   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1362                                            rel_hdr, reloc_count,
1363                                            relents,
1364                                            symbols, dynamic))
1365     return false;
1366
1367   if (rel_hdr2
1368       && !elf_slurp_reloc_table_from_section (abfd, asect,
1369                                               rel_hdr2, reloc_count2,
1370                                               relents + reloc_count,
1371                                               symbols, dynamic))
1372     return false;
1373
1374
1375   asect->relocation = relents;
1376   return true;
1377 }
1378
1379 #ifdef DEBUG
1380 static void
1381 elf_debug_section (num, hdr)
1382      int num;
1383      Elf_Internal_Shdr *hdr;
1384 {
1385   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1386            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1387            (long) hdr);
1388   fprintf (stderr,
1389            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1390            (long) hdr->sh_name,
1391            (long) hdr->sh_type,
1392            (long) hdr->sh_flags);
1393   fprintf (stderr,
1394            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1395            (long) hdr->sh_addr,
1396            (long) hdr->sh_offset,
1397            (long) hdr->sh_size);
1398   fprintf (stderr,
1399            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1400            (long) hdr->sh_link,
1401            (long) hdr->sh_info,
1402            (long) hdr->sh_addralign);
1403   fprintf (stderr, "sh_entsize   = %ld\n",
1404            (long) hdr->sh_entsize);
1405   fflush (stderr);
1406 }
1407
1408 static void
1409 elf_debug_file (ehdrp)
1410      Elf_Internal_Ehdr *ehdrp;
1411 {
1412   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1413   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1414   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1415   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1416   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1417   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1418   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1419 }
1420
1421 static char *
1422 elf_symbol_flags (flags)
1423      flagword flags;
1424 {
1425   static char buffer[1024];
1426
1427   buffer[0] = '\0';
1428   if (flags & BSF_LOCAL)
1429     strcat (buffer, " local");
1430
1431   if (flags & BSF_GLOBAL)
1432     strcat (buffer, " global");
1433
1434   if (flags & BSF_DEBUGGING)
1435     strcat (buffer, " debug");
1436
1437   if (flags & BSF_FUNCTION)
1438     strcat (buffer, " function");
1439
1440   if (flags & BSF_KEEP)
1441     strcat (buffer, " keep");
1442
1443   if (flags & BSF_KEEP_G)
1444     strcat (buffer, " keep_g");
1445
1446   if (flags & BSF_WEAK)
1447     strcat (buffer, " weak");
1448
1449   if (flags & BSF_SECTION_SYM)
1450     strcat (buffer, " section-sym");
1451
1452   if (flags & BSF_OLD_COMMON)
1453     strcat (buffer, " old-common");
1454
1455   if (flags & BSF_NOT_AT_END)
1456     strcat (buffer, " not-at-end");
1457
1458   if (flags & BSF_CONSTRUCTOR)
1459     strcat (buffer, " constructor");
1460
1461   if (flags & BSF_WARNING)
1462     strcat (buffer, " warning");
1463
1464   if (flags & BSF_INDIRECT)
1465     strcat (buffer, " indirect");
1466
1467   if (flags & BSF_FILE)
1468     strcat (buffer, " file");
1469
1470   if (flags & DYNAMIC)
1471     strcat (buffer, " dynamic");
1472
1473   if (flags & ~(BSF_LOCAL
1474                 | BSF_GLOBAL
1475                 | BSF_DEBUGGING
1476                 | BSF_FUNCTION
1477                 | BSF_KEEP
1478                 | BSF_KEEP_G
1479                 | BSF_WEAK
1480                 | BSF_SECTION_SYM
1481                 | BSF_OLD_COMMON
1482                 | BSF_NOT_AT_END
1483                 | BSF_CONSTRUCTOR
1484                 | BSF_WARNING
1485                 | BSF_INDIRECT
1486                 | BSF_FILE
1487                 | BSF_DYNAMIC))
1488     strcat (buffer, " unknown-bits");
1489
1490   return buffer;
1491 }
1492 #endif
1493 \f
1494 #include "elfcore.h"
1495 #include "elflink.h"
1496 \f
1497 /* Size-dependent data and functions.  */
1498 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1499   sizeof (Elf_External_Ehdr),
1500   sizeof (Elf_External_Phdr),
1501   sizeof (Elf_External_Shdr),
1502   sizeof (Elf_External_Rel),
1503   sizeof (Elf_External_Rela),
1504   sizeof (Elf_External_Sym),
1505   sizeof (Elf_External_Dyn),
1506   sizeof (Elf_External_Note),
1507   ARCH_SIZE / 8,
1508   1,
1509   ARCH_SIZE, FILE_ALIGN,
1510   ELFCLASS, EV_CURRENT,
1511   elf_write_out_phdrs,
1512   elf_write_shdrs_and_ehdr,
1513   write_relocs,
1514   elf_swap_symbol_out,
1515   elf_slurp_reloc_table,
1516   elf_slurp_symbol_table,
1517   elf_swap_dyn_in,
1518   elf_swap_dyn_out,
1519   NULL,
1520   NULL,
1521   NULL,
1522   NULL
1523 };