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_size != 0
 660           && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
 661           && i_shdrp[shindex].sh_type != SHT_NOBITS
 662           && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
 663                % ebd->maxpagesize)
 664               != 0))
 665         abfd->flags &= ~D_PAGED;
 666     }
 667   if (i_ehdrp->e_shstrndx)
 668     {
 669       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 670         goto got_no_match;
 671     }
 672
 673   /* Read in the program headers.  */
 674   if (i_ehdrp->e_phnum == 0)
 675     elf_tdata (abfd)->phdr = NULL;
 676   else
 677     {
 678       Elf_Internal_Phdr *i_phdr;
 679       unsigned int i;
 680
 681       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
 682       elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 683       if (elf_tdata (abfd)->phdr == NULL)
 684         goto got_no_match;
 685       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 686         goto got_no_match;
 687       i_phdr = elf_tdata (abfd)->phdr;
 688       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
 689         {
 690           Elf_External_Phdr x_phdr;
 691
 692           if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
 693               != sizeof x_phdr)
 694             goto got_no_match;
 695           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
 696         }
 697     }
 698
 699   /* Read in the string table containing the names of the sections.  We
 700      will need the base pointer to this table later.  */
 701   /* We read this inline now, so that we don't have to go through
 702      bfd_section_from_shdr with it (since this particular strtab is
 703      used to find all of the ELF section names.) */
 704
 705   if (i_ehdrp->e_shstrndx != 0)
 706     {
 707       shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 708       if (!shstrtab)
 709         goto got_no_match;
 710
 711       /* Once all of the section headers have been read and converted, we
 712          can start processing them.  Note that the first section header is
 713          a dummy placeholder entry, so we ignore it.  */
 714
 715       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 716         {
 717           if (! bfd_section_from_shdr (abfd, shindex))
 718             goto got_no_match;
 719         }
 720     }
 721
 722   /* Let the backend double check the format and override global
 723      information.  */
 724   if (ebd->elf_backend_object_p)
 725     {
 726       if ((*ebd->elf_backend_object_p) (abfd) == false)
 727         goto got_wrong_format_error;
 728     }
 729
 730   /* If we have created any reloc sections that are associated with
 731      debugging sections, mark the reloc sections as debugging as well.  */
 732   for (s = abfd->sections; s != NULL; s = s->next)
 733     {
 734       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 735            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 736           && elf_section_data (s)->this_hdr.sh_info > 0)
 737         {
 738           unsigned long targ_index;
 739           asection *targ_sec;
 740
 741           targ_index = elf_section_data (s)->this_hdr.sh_info;
 742           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 743           if (targ_sec != NULL
 744               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 745             s->flags |= SEC_DEBUGGING;
 746         }
 747     }
 748
 749   return (abfd->xvec);
 750
 751  got_wrong_format_error:
 752   /* There is way too much undoing of half-known state here.  The caller,
 753      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 754      check match/no-match like it does.  We have to rely on that a call to
 755      bfd_default_set_arch_mach with the previously known mach, undoes what
 756      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 757      For this to work, only elf-data and the mach may be changed by the
 758      target-specific elf_backend_object_p function.  Note that saving the
 759      whole bfd here and restoring it would be even worse; the first thing
 760      you notice is that the cached bfd file position gets out of sync.  */
 761   bfd_default_set_arch_mach (abfd, previous_arch, previous_mach);
 762   bfd_set_error (bfd_error_wrong_format);
 763  got_no_match:
 764   if (new_tdata != NULL
 765       && new_tdata->elf_sect_ptr != NULL)
 766     bfd_release (abfd, new_tdata->elf_sect_ptr);
 767   if (i_shdrp != NULL)
 768     bfd_release (abfd, i_shdrp);
 769   if (new_tdata != NULL)
 770     bfd_release (abfd, new_tdata);
 771   elf_tdata (abfd) = preserved_tdata;
 772   abfd->sections = preserved_sections;
 773   abfd->section_count = preserved_section_count;
 774   return (NULL);
 775 }
 776 \f
 777 /* ELF .o/exec file writing */
 778
 779 /* Write out the relocs.  */
 780
 781 void
 782 elf_write_relocs (abfd, sec, data)
 783      bfd *abfd;
 784      asection *sec;
 785      PTR data;
 786 {
 787   boolean *failedp = (boolean *) data;
 788   Elf_Internal_Shdr *rela_hdr;
 789   Elf_External_Rela *outbound_relocas;
 790   Elf_External_Rel *outbound_relocs;
 791   unsigned int idx;
 792   int use_rela_p;
 793   asymbol *last_sym = 0;
 794   int last_sym_idx = 0;
 795
 796   /* If we have already failed, don't do anything.  */
 797   if (*failedp)
 798     return;
 799
 800   if ((sec->flags & SEC_RELOC) == 0)
 801     return;
 802
 803   /* The linker backend writes the relocs out itself, and sets the
 804      reloc_count field to zero to inhibit writing them here.  Also,
 805      sometimes the SEC_RELOC flag gets set even when there aren't any
 806      relocs.  */
 807   if (sec->reloc_count == 0)
 808     return;
 809
 810   rela_hdr = &elf_section_data (sec)->rel_hdr;
 811
 812   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 813   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
 814   if (rela_hdr->contents == NULL)
 815     {
 816       *failedp = true;
 817       return;
 818     }
 819
 820   /* Figure out whether the relocations are RELA or REL relocations.  */
 821   if (rela_hdr->sh_type == SHT_RELA)
 822     use_rela_p = true;
 823   else if (rela_hdr->sh_type == SHT_REL)
 824     use_rela_p = false;
 825   else
 826     /* Every relocation section should be either an SHT_RELA or an
 827        SHT_REL section.  */
 828     abort ();
 829
 830   /* orelocation has the data, reloc_count has the count...  */
 831   if (use_rela_p)
 832     {
 833       outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
 834
 835       for (idx = 0; idx < sec->reloc_count; idx++)
 836         {
 837           Elf_Internal_Rela dst_rela;
 838           Elf_External_Rela *src_rela;
 839           arelent *ptr;
 840           asymbol *sym;
 841           int n;
 842
 843           ptr = sec->orelocation[idx];
 844           src_rela = outbound_relocas + idx;
 845
 846           /* The address of an ELF reloc is section relative for an object
 847              file, and absolute for an executable file or shared library.
 848              The address of a BFD reloc is always section relative.  */
 849           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 850             dst_rela.r_offset = ptr->address;
 851           else
 852             dst_rela.r_offset = ptr->address + sec->vma;
 853
 854           sym = *ptr->sym_ptr_ptr;
 855           if (sym == last_sym)
 856             n = last_sym_idx;
 857           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 858             n = STN_UNDEF;
 859           else
 860             {
 861               last_sym = sym;
 862               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 863               if (n < 0)
 864                 {
 865                   *failedp = true;
 866                   return;
 867                 }
 868               last_sym_idx = n;
 869             }
 870
 871           if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 872               && (*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_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 880
 881           dst_rela.r_addend = ptr->addend;
 882           elf_swap_reloca_out (abfd, &dst_rela, src_rela);
 883         }
 884     }
 885   else
 886     /* REL relocations */
 887     {
 888       outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
 889
 890       for (idx = 0; idx < sec->reloc_count; idx++)
 891         {
 892           Elf_Internal_Rel dst_rel;
 893           Elf_External_Rel *src_rel;
 894           arelent *ptr;
 895           int n;
 896           asymbol *sym;
 897
 898           ptr = sec->orelocation[idx];
 899           sym = *ptr->sym_ptr_ptr;
 900           src_rel = outbound_relocs + idx;
 901
 902           /* The address of an ELF reloc is section relative for an object
 903              file, and absolute for an executable file or shared library.
 904              The address of a BFD reloc is always section relative.  */
 905           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 906             dst_rel.r_offset = ptr->address;
 907           else
 908             dst_rel.r_offset = ptr->address + sec->vma;
 909
 910           if (sym == last_sym)
 911             n = last_sym_idx;
 912           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 913             n = STN_UNDEF;
 914           else
 915             {
 916               last_sym = sym;
 917               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 918               if (n < 0)
 919                 {
 920                   *failedp = true;
 921                   return;
 922                 }
 923               last_sym_idx = n;
 924             }
 925
 926           if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 927               && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 928               && ! _bfd_elf_validate_reloc (abfd, ptr))
 929             {
 930               *failedp = true;
 931               return;
 932             }
 933
 934           dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
 935
 936           elf_swap_reloc_out (abfd, &dst_rel, src_rel);
 937         }
 938     }
 939 }
 940
 941 /* Write out the program headers.  */
 942
 943 int
 944 elf_write_out_phdrs (abfd, phdr, count)
 945      bfd *abfd;
 946      const Elf_Internal_Phdr *phdr;
 947      unsigned int count;
 948 {
 949   while (count--)
 950     {
 951       Elf_External_Phdr extphdr;
 952       elf_swap_phdr_out (abfd, phdr, &extphdr);
 953       if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
 954                      abfd) != sizeof (Elf_External_Phdr))
 955         return -1;
 956       phdr++;
 957     }
 958   return 0;
 959 }
 960
 961 /* Write out the section headers and the ELF file header.  */
 962
 963 boolean
 964 elf_write_shdrs_and_ehdr (abfd)
 965      bfd *abfd;
 966 {
 967   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 968   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 969   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 970   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 971   unsigned int count;
 972   bfd_size_type amt;
 973
 974   i_ehdrp = elf_elfheader (abfd);
 975   i_shdrp = elf_elfsections (abfd);
 976
 977   /* swap the header before spitting it out...  */
 978
 979 #if DEBUG & 1
 980   elf_debug_file (i_ehdrp);
 981 #endif
 982   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
 983   amt = sizeof (x_ehdr);
 984   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 985       || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
 986     return false;
 987
 988   /* at this point we've concocted all the ELF sections...  */
 989   amt = sizeof (*x_shdrp) * i_ehdrp->e_shnum;
 990   x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
 991   if (!x_shdrp)
 992     return false;
 993
 994   for (count = 0; count < i_ehdrp->e_shnum; count++)
 995     {
 996 #if DEBUG & 2
 997       elf_debug_section (count, i_shdrp[count]);
 998 #endif
 999       elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
1000     }
1001   amt = i_ehdrp->e_shnum;
1002   amt *= sizeof (*x_shdrp);
1003   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1004       || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
1005     return false;
1006
1007   /* need to dump the string table too...  */
1008
1009   return true;
1010 }
1011
1012 long
1013 elf_slurp_symbol_table (abfd, symptrs, dynamic)
1014      bfd *abfd;
1015      asymbol **symptrs;         /* Buffer for generated bfd symbols */
1016      boolean dynamic;
1017 {
1018   Elf_Internal_Shdr *hdr;
1019   Elf_Internal_Shdr *verhdr;
1020   unsigned long symcount;       /* Number of external ELF symbols */
1021   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1022   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1023   Elf_Internal_Sym i_sym;
1024   Elf_External_Sym *x_symp = NULL;
1025   Elf_External_Versym *x_versymp = NULL;
1026   bfd_size_type amt;
1027
1028   /* Read each raw ELF symbol, converting from external ELF form to
1029      internal ELF form, and then using the information to create a
1030      canonical bfd symbol table entry.
1031
1032      Note that we allocate the initial bfd canonical symbol buffer
1033      based on a one-to-one mapping of the ELF symbols to canonical
1034      symbols.  We actually use all the ELF symbols, so there will be no
1035      space left over at the end.  When we have all the symbols, we
1036      build the caller's pointer vector.  */
1037
1038   if (! dynamic)
1039     {
1040       hdr = &elf_tdata (abfd)->symtab_hdr;
1041       verhdr = NULL;
1042     }
1043   else
1044     {
1045       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1046       if (elf_dynversym (abfd) == 0)
1047         verhdr = NULL;
1048       else
1049         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1050       if ((elf_tdata (abfd)->dynverdef_section != 0
1051            && elf_tdata (abfd)->verdef == NULL)
1052           || (elf_tdata (abfd)->dynverref_section != 0
1053               && elf_tdata (abfd)->verref == NULL))
1054         {
1055           if (! _bfd_elf_slurp_version_tables (abfd))
1056             return -1;
1057         }
1058     }
1059
1060   if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
1061     return -1;
1062
1063   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1064
1065   if (symcount == 0)
1066     sym = symbase = NULL;
1067   else
1068     {
1069       unsigned long i;
1070
1071       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
1072         return -1;
1073
1074       amt = symcount;
1075       amt *= sizeof (elf_symbol_type);
1076       symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1077       if (symbase == (elf_symbol_type *) NULL)
1078         return -1;
1079       sym = symbase;
1080
1081       /* Temporarily allocate room for the raw ELF symbols.  */
1082       amt = symcount;
1083       amt *= sizeof (Elf_External_Sym);
1084       x_symp = (Elf_External_Sym *) bfd_malloc (amt);
1085       if (x_symp == NULL && symcount != 0)
1086         goto error_return;
1087
1088       if (bfd_bread ((PTR) x_symp, amt, abfd) != amt)
1089         goto error_return;
1090
1091       /* Read the raw ELF version symbol information.  */
1092
1093       if (verhdr != NULL
1094           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1095         {
1096           (*_bfd_error_handler)
1097             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1098              abfd->filename,
1099              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1100              symcount);
1101
1102           /* Slurp in the symbols without the version information,
1103              since that is more helpful than just quitting.  */
1104           verhdr = NULL;
1105         }
1106
1107       if (verhdr != NULL)
1108         {
1109           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1110             goto error_return;
1111
1112           x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1113           if (x_versymp == NULL && verhdr->sh_size != 0)
1114             goto error_return;
1115
1116           if (bfd_bread ((PTR) x_versymp, verhdr->sh_size, abfd)
1117               != verhdr->sh_size)
1118             goto error_return;
1119         }
1120
1121       /* Skip first symbol, which is a null dummy.  */
1122       for (i = 1; i < symcount; i++)
1123         {
1124           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1125           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1126 #ifdef ELF_KEEP_EXTSYM
1127           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1128 #endif
1129           sym->symbol.the_bfd = abfd;
1130
1131           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1132                                                               hdr->sh_link,
1133                                                               i_sym.st_name);
1134
1135           sym->symbol.value = i_sym.st_value;
1136
1137           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1138             {
1139               sym->symbol.section = section_from_elf_index (abfd,
1140                                                             i_sym.st_shndx);
1141               if (sym->symbol.section == NULL)
1142                 {
1143                   /* This symbol is in a section for which we did not
1144                      create a BFD section.  Just use bfd_abs_section,
1145                      although it is wrong.  FIXME.  */
1146                   sym->symbol.section = bfd_abs_section_ptr;
1147                 }
1148             }
1149           else if (i_sym.st_shndx == SHN_ABS)
1150             {
1151               sym->symbol.section = bfd_abs_section_ptr;
1152             }
1153           else if (i_sym.st_shndx == SHN_COMMON)
1154             {
1155               sym->symbol.section = bfd_com_section_ptr;
1156               /* Elf puts the alignment into the `value' field, and
1157                  the size into the `size' field.  BFD wants to see the
1158                  size in the value field, and doesn't care (at the
1159                  moment) about the alignment.  */
1160               sym->symbol.value = i_sym.st_size;
1161             }
1162           else if (i_sym.st_shndx == SHN_UNDEF)
1163             {
1164               sym->symbol.section = bfd_und_section_ptr;
1165             }
1166           else
1167             sym->symbol.section = bfd_abs_section_ptr;
1168
1169           /* If this is a relocateable file, then the symbol value is
1170              already section relative.  */
1171           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1172             sym->symbol.value -= sym->symbol.section->vma;
1173
1174           switch (ELF_ST_BIND (i_sym.st_info))
1175             {
1176             case STB_LOCAL:
1177               sym->symbol.flags |= BSF_LOCAL;
1178               break;
1179             case STB_GLOBAL:
1180               if (i_sym.st_shndx != SHN_UNDEF
1181                   && i_sym.st_shndx != SHN_COMMON)
1182                 sym->symbol.flags |= BSF_GLOBAL;
1183               break;
1184             case STB_WEAK:
1185               sym->symbol.flags |= BSF_WEAK;
1186               break;
1187             }
1188
1189           switch (ELF_ST_TYPE (i_sym.st_info))
1190             {
1191             case STT_SECTION:
1192               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1193               break;
1194             case STT_FILE:
1195               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1196               break;
1197             case STT_FUNC:
1198               sym->symbol.flags |= BSF_FUNCTION;
1199               break;
1200             case STT_OBJECT:
1201               sym->symbol.flags |= BSF_OBJECT;
1202               break;
1203             }
1204
1205           if (dynamic)
1206             sym->symbol.flags |= BSF_DYNAMIC;
1207
1208           if (x_versymp != NULL)
1209             {
1210               Elf_Internal_Versym iversym;
1211
1212               _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1213               sym->version = iversym.vs_vers;
1214             }
1215
1216           /* Do some backend-specific processing on this symbol.  */
1217           {
1218             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1219             if (ebd->elf_backend_symbol_processing)
1220               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1221           }
1222
1223           sym++;
1224         }
1225     }
1226
1227   /* Do some backend-specific processing on this symbol table.  */
1228   {
1229     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1230     if (ebd->elf_backend_symbol_table_processing)
1231       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1232   }
1233
1234   /* We rely on the zalloc to clear out the final symbol entry.  */
1235
1236   symcount = sym - symbase;
1237
1238   /* Fill in the user's symbol pointer vector if needed.  */
1239   if (symptrs)
1240     {
1241       long l = symcount;
1242
1243       sym = symbase;
1244       while (l-- > 0)
1245         {
1246           *symptrs++ = &sym->symbol;
1247           sym++;
1248         }
1249       *symptrs = 0;             /* Final null pointer */
1250     }
1251
1252   if (x_versymp != NULL)
1253     free (x_versymp);
1254   if (x_symp != NULL)
1255     free (x_symp);
1256   return symcount;
1257 error_return:
1258   if (x_versymp != NULL)
1259     free (x_versymp);
1260   if (x_symp != NULL)
1261     free (x_symp);
1262   return -1;
1263 }
1264
1265 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1266    them.  */
1267
1268 static boolean
1269 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1270                                     relents, symbols, dynamic)
1271      bfd *abfd;
1272      asection *asect;
1273      Elf_Internal_Shdr *rel_hdr;
1274      bfd_size_type reloc_count;
1275      arelent *relents;
1276      asymbol **symbols;
1277      boolean dynamic;
1278 {
1279   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1280   PTR allocated = NULL;
1281   bfd_byte *native_relocs;
1282   arelent *relent;
1283   unsigned int i;
1284   int entsize;
1285
1286   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
1287   if (allocated == NULL)
1288     goto error_return;
1289
1290   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1291       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1292           != rel_hdr->sh_size))
1293     goto error_return;
1294
1295   native_relocs = (bfd_byte *) allocated;
1296
1297   entsize = rel_hdr->sh_entsize;
1298   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1299               || entsize == sizeof (Elf_External_Rela));
1300
1301   for (i = 0, relent = relents;
1302        i < reloc_count;
1303        i++, relent++, native_relocs += entsize)
1304     {
1305       Elf_Internal_Rela rela;
1306       Elf_Internal_Rel rel;
1307
1308       if (entsize == sizeof (Elf_External_Rela))
1309         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1310       else
1311         {
1312           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1313           rela.r_offset = rel.r_offset;
1314           rela.r_info = rel.r_info;
1315           rela.r_addend = 0;
1316         }
1317
1318       /* The address of an ELF reloc is section relative for an object
1319          file, and absolute for an executable file or shared library.
1320          The address of a normal BFD reloc is always section relative,
1321          and the address of a dynamic reloc is absolute..  */
1322       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1323         relent->address = rela.r_offset;
1324       else
1325         relent->address = rela.r_offset - asect->vma;
1326
1327       if (ELF_R_SYM (rela.r_info) == 0)
1328         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1329       else
1330         {
1331           asymbol **ps, *s;
1332
1333           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1334           s = *ps;
1335
1336           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1337           if ((s->flags & BSF_SECTION_SYM) == 0)
1338             relent->sym_ptr_ptr = ps;
1339           else
1340             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1341         }
1342
1343       relent->addend = rela.r_addend;
1344
1345       if (entsize == sizeof (Elf_External_Rela))
1346         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1347       else
1348         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1349     }
1350
1351   if (allocated != NULL)
1352     free (allocated);
1353
1354   return true;
1355
1356  error_return:
1357   if (allocated != NULL)
1358     free (allocated);
1359   return false;
1360 }
1361
1362 /* Read in and swap the external relocs.  */
1363
1364 boolean
1365 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1366      bfd *abfd;
1367      asection *asect;
1368      asymbol **symbols;
1369      boolean dynamic;
1370 {
1371   struct bfd_elf_section_data * const d = elf_section_data (asect);
1372   Elf_Internal_Shdr *rel_hdr;
1373   Elf_Internal_Shdr *rel_hdr2;
1374   bfd_size_type reloc_count;
1375   bfd_size_type reloc_count2;
1376   arelent *relents;
1377   bfd_size_type amt;
1378
1379   if (asect->relocation != NULL)
1380     return true;
1381
1382   if (! dynamic)
1383     {
1384       if ((asect->flags & SEC_RELOC) == 0
1385           || asect->reloc_count == 0)
1386         return true;
1387
1388       rel_hdr = &d->rel_hdr;
1389       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1390       rel_hdr2 = d->rel_hdr2;
1391       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1392
1393       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1394       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1395                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1396
1397     }
1398   else
1399     {
1400       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1401          case because relocations against this section may use the
1402          dynamic symbol table, and in that case bfd_section_from_shdr
1403          in elf.c does not update the RELOC_COUNT.  */
1404       if (asect->_raw_size == 0)
1405         return true;
1406
1407       rel_hdr = &d->this_hdr;
1408       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1409       rel_hdr2 = NULL;
1410       reloc_count2 = 0;
1411     }
1412
1413   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1414   relents = (arelent *) bfd_alloc (abfd, amt);
1415   if (relents == NULL)
1416     return false;
1417
1418   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1419                                            rel_hdr, reloc_count,
1420                                            relents,
1421                                            symbols, dynamic))
1422     return false;
1423
1424   if (rel_hdr2
1425       && !elf_slurp_reloc_table_from_section (abfd, asect,
1426                                               rel_hdr2, reloc_count2,
1427                                               relents + reloc_count,
1428                                               symbols, dynamic))
1429     return false;
1430
1431   asect->relocation = relents;
1432   return true;
1433 }
1434
1435 #ifdef DEBUG
1436 static void
1437 elf_debug_section (num, hdr)
1438      int num;
1439      Elf_Internal_Shdr *hdr;
1440 {
1441   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1442            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1443            (long) hdr);
1444   fprintf (stderr,
1445            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1446            (long) hdr->sh_name,
1447            (long) hdr->sh_type,
1448            (long) hdr->sh_flags);
1449   fprintf (stderr,
1450            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1451            (long) hdr->sh_addr,
1452            (long) hdr->sh_offset,
1453            (long) hdr->sh_size);
1454   fprintf (stderr,
1455            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1456            (long) hdr->sh_link,
1457            (long) hdr->sh_info,
1458            (long) hdr->sh_addralign);
1459   fprintf (stderr, "sh_entsize   = %ld\n",
1460            (long) hdr->sh_entsize);
1461   fflush (stderr);
1462 }
1463
1464 static void
1465 elf_debug_file (ehdrp)
1466      Elf_Internal_Ehdr *ehdrp;
1467 {
1468   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1469   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1470   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1471   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1472   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1473   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1474   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1475 }
1476
1477 static char *
1478 elf_symbol_flags (flags)
1479      flagword flags;
1480 {
1481   static char buffer[1024];
1482
1483   buffer[0] = '\0';
1484   if (flags & BSF_LOCAL)
1485     strcat (buffer, " local");
1486
1487   if (flags & BSF_GLOBAL)
1488     strcat (buffer, " global");
1489
1490   if (flags & BSF_DEBUGGING)
1491     strcat (buffer, " debug");
1492
1493   if (flags & BSF_FUNCTION)
1494     strcat (buffer, " function");
1495
1496   if (flags & BSF_KEEP)
1497     strcat (buffer, " keep");
1498
1499   if (flags & BSF_KEEP_G)
1500     strcat (buffer, " keep_g");
1501
1502   if (flags & BSF_WEAK)
1503     strcat (buffer, " weak");
1504
1505   if (flags & BSF_SECTION_SYM)
1506     strcat (buffer, " section-sym");
1507
1508   if (flags & BSF_OLD_COMMON)
1509     strcat (buffer, " old-common");
1510
1511   if (flags & BSF_NOT_AT_END)
1512     strcat (buffer, " not-at-end");
1513
1514   if (flags & BSF_CONSTRUCTOR)
1515     strcat (buffer, " constructor");
1516
1517   if (flags & BSF_WARNING)
1518     strcat (buffer, " warning");
1519
1520   if (flags & BSF_INDIRECT)
1521     strcat (buffer, " indirect");
1522
1523   if (flags & BSF_FILE)
1524     strcat (buffer, " file");
1525
1526   if (flags & DYNAMIC)
1527     strcat (buffer, " dynamic");
1528
1529   if (flags & ~(BSF_LOCAL
1530                 | BSF_GLOBAL
1531                 | BSF_DEBUGGING
1532                 | BSF_FUNCTION
1533                 | BSF_KEEP
1534                 | BSF_KEEP_G
1535                 | BSF_WEAK
1536                 | BSF_SECTION_SYM
1537                 | BSF_OLD_COMMON
1538                 | BSF_NOT_AT_END
1539                 | BSF_CONSTRUCTOR
1540                 | BSF_WARNING
1541                 | BSF_INDIRECT
1542                 | BSF_FILE
1543                 | BSF_DYNAMIC))
1544     strcat (buffer, " unknown-bits");
1545
1546   return buffer;
1547 }
1548 #endif
1549 \f
1550 #include "elfcore.h"
1551 #include "elflink.h"
1552 \f
1553 /* Size-dependent data and functions.  */
1554 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1555   sizeof (Elf_External_Ehdr),
1556   sizeof (Elf_External_Phdr),
1557   sizeof (Elf_External_Shdr),
1558   sizeof (Elf_External_Rel),
1559   sizeof (Elf_External_Rela),
1560   sizeof (Elf_External_Sym),
1561   sizeof (Elf_External_Dyn),
1562   sizeof (Elf_External_Note),
1563   4,
1564   1,
1565   ARCH_SIZE, FILE_ALIGN,
1566   ELFCLASS, EV_CURRENT,
1567   elf_write_out_phdrs,
1568   elf_write_shdrs_and_ehdr,
1569   elf_write_relocs,
1570   elf_swap_symbol_out,
1571   elf_slurp_reloc_table,
1572   elf_slurp_symbol_table,
1573   elf_swap_dyn_in,
1574   elf_swap_dyn_out,
1575   NULL,
1576   NULL,
1577   NULL,
1578   NULL
1579 };