bfd/elfcode.h

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