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, amt, abfd) != amt)
1088         goto error_return;
1089
1090       /* Read the raw ELF version symbol information.  */
1091
1092       if (verhdr != NULL
1093           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1094         {
1095           (*_bfd_error_handler)
1096             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1097              abfd->filename,
1098              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1099              symcount);
1100
1101           /* Slurp in the symbols without the version information,
1102              since that is more helpful than just quitting.  */
1103           verhdr = NULL;
1104         }
1105
1106       if (verhdr != NULL)
1107         {
1108           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1109             goto error_return;
1110
1111           x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1112           if (x_versymp == NULL && verhdr->sh_size != 0)
1113             goto error_return;
1114
1115           if (bfd_bread ((PTR) x_versymp, verhdr->sh_size, abfd)
1116               != verhdr->sh_size)
1117             goto error_return;
1118         }
1119
1120       /* Skip first symbol, which is a null dummy.  */
1121       for (i = 1; i < symcount; i++)
1122         {
1123           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1124           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1125 #ifdef ELF_KEEP_EXTSYM
1126           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1127 #endif
1128           sym->symbol.the_bfd = abfd;
1129
1130           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1131                                                               hdr->sh_link,
1132                                                               i_sym.st_name);
1133
1134           sym->symbol.value = i_sym.st_value;
1135
1136           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1137             {
1138               sym->symbol.section = section_from_elf_index (abfd,
1139                                                             i_sym.st_shndx);
1140               if (sym->symbol.section == NULL)
1141                 {
1142                   /* This symbol is in a section for which we did not
1143                      create a BFD section.  Just use bfd_abs_section,
1144                      although it is wrong.  FIXME.  */
1145                   sym->symbol.section = bfd_abs_section_ptr;
1146                 }
1147             }
1148           else if (i_sym.st_shndx == SHN_ABS)
1149             {
1150               sym->symbol.section = bfd_abs_section_ptr;
1151             }
1152           else if (i_sym.st_shndx == SHN_COMMON)
1153             {
1154               sym->symbol.section = bfd_com_section_ptr;
1155               /* Elf puts the alignment into the `value' field, and
1156                  the size into the `size' field.  BFD wants to see the
1157                  size in the value field, and doesn't care (at the
1158                  moment) about the alignment.  */
1159               sym->symbol.value = i_sym.st_size;
1160             }
1161           else if (i_sym.st_shndx == SHN_UNDEF)
1162             {
1163               sym->symbol.section = bfd_und_section_ptr;
1164             }
1165           else
1166             sym->symbol.section = bfd_abs_section_ptr;
1167
1168           /* If this is a relocateable file, then the symbol value is
1169              already section relative.  */
1170           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1171             sym->symbol.value -= sym->symbol.section->vma;
1172
1173           switch (ELF_ST_BIND (i_sym.st_info))
1174             {
1175             case STB_LOCAL:
1176               sym->symbol.flags |= BSF_LOCAL;
1177               break;
1178             case STB_GLOBAL:
1179               if (i_sym.st_shndx != SHN_UNDEF
1180                   && i_sym.st_shndx != SHN_COMMON)
1181                 sym->symbol.flags |= BSF_GLOBAL;
1182               break;
1183             case STB_WEAK:
1184               sym->symbol.flags |= BSF_WEAK;
1185               break;
1186             }
1187
1188           switch (ELF_ST_TYPE (i_sym.st_info))
1189             {
1190             case STT_SECTION:
1191               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1192               break;
1193             case STT_FILE:
1194               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1195               break;
1196             case STT_FUNC:
1197               sym->symbol.flags |= BSF_FUNCTION;
1198               break;
1199             case STT_OBJECT:
1200               sym->symbol.flags |= BSF_OBJECT;
1201               break;
1202             }
1203
1204           if (dynamic)
1205             sym->symbol.flags |= BSF_DYNAMIC;
1206
1207           if (x_versymp != NULL)
1208             {
1209               Elf_Internal_Versym iversym;
1210
1211               _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1212               sym->version = iversym.vs_vers;
1213             }
1214
1215           /* Do some backend-specific processing on this symbol.  */
1216           {
1217             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1218             if (ebd->elf_backend_symbol_processing)
1219               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1220           }
1221
1222           sym++;
1223         }
1224     }
1225
1226   /* Do some backend-specific processing on this symbol table.  */
1227   {
1228     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1229     if (ebd->elf_backend_symbol_table_processing)
1230       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1231   }
1232
1233   /* We rely on the zalloc to clear out the final symbol entry.  */
1234
1235   symcount = sym - symbase;
1236
1237   /* Fill in the user's symbol pointer vector if needed.  */
1238   if (symptrs)
1239     {
1240       long l = symcount;
1241
1242       sym = symbase;
1243       while (l-- > 0)
1244         {
1245           *symptrs++ = &sym->symbol;
1246           sym++;
1247         }
1248       *symptrs = 0;             /* Final null pointer */
1249     }
1250
1251   if (x_versymp != NULL)
1252     free (x_versymp);
1253   if (x_symp != NULL)
1254     free (x_symp);
1255   return symcount;
1256 error_return:
1257   if (x_versymp != NULL)
1258     free (x_versymp);
1259   if (x_symp != NULL)
1260     free (x_symp);
1261   return -1;
1262 }
1263
1264 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1265    them.  */
1266
1267 static boolean
1268 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1269                                     relents, symbols, dynamic)
1270      bfd *abfd;
1271      asection *asect;
1272      Elf_Internal_Shdr *rel_hdr;
1273      bfd_size_type reloc_count;
1274      arelent *relents;
1275      asymbol **symbols;
1276      boolean dynamic;
1277 {
1278   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1279   PTR allocated = NULL;
1280   bfd_byte *native_relocs;
1281   arelent *relent;
1282   unsigned int i;
1283   int entsize;
1284
1285   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
1286   if (allocated == NULL)
1287     goto error_return;
1288
1289   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1290       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1291           != rel_hdr->sh_size))
1292     goto error_return;
1293
1294   native_relocs = (bfd_byte *) allocated;
1295
1296   entsize = rel_hdr->sh_entsize;
1297   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1298               || entsize == sizeof (Elf_External_Rela));
1299
1300   for (i = 0, relent = relents;
1301        i < reloc_count;
1302        i++, relent++, native_relocs += entsize)
1303     {
1304       Elf_Internal_Rela rela;
1305       Elf_Internal_Rel rel;
1306
1307       if (entsize == sizeof (Elf_External_Rela))
1308         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1309       else
1310         {
1311           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1312           rela.r_offset = rel.r_offset;
1313           rela.r_info = rel.r_info;
1314           rela.r_addend = 0;
1315         }
1316
1317       /* The address of an ELF reloc is section relative for an object
1318          file, and absolute for an executable file or shared library.
1319          The address of a normal BFD reloc is always section relative,
1320          and the address of a dynamic reloc is absolute..  */
1321       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1322         relent->address = rela.r_offset;
1323       else
1324         relent->address = rela.r_offset - asect->vma;
1325
1326       if (ELF_R_SYM (rela.r_info) == 0)
1327         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1328       else
1329         {
1330           asymbol **ps, *s;
1331
1332           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1333           s = *ps;
1334
1335           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1336           if ((s->flags & BSF_SECTION_SYM) == 0)
1337             relent->sym_ptr_ptr = ps;
1338           else
1339             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1340         }
1341
1342       relent->addend = rela.r_addend;
1343
1344       if (entsize == sizeof (Elf_External_Rela))
1345         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1346       else
1347         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1348     }
1349
1350   if (allocated != NULL)
1351     free (allocated);
1352
1353   return true;
1354
1355  error_return:
1356   if (allocated != NULL)
1357     free (allocated);
1358   return false;
1359 }
1360
1361 /* Read in and swap the external relocs.  */
1362
1363 boolean
1364 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1365      bfd *abfd;
1366      asection *asect;
1367      asymbol **symbols;
1368      boolean dynamic;
1369 {
1370   struct bfd_elf_section_data * const d = elf_section_data (asect);
1371   Elf_Internal_Shdr *rel_hdr;
1372   Elf_Internal_Shdr *rel_hdr2;
1373   bfd_size_type reloc_count;
1374   bfd_size_type reloc_count2;
1375   arelent *relents;
1376   bfd_size_type amt;
1377
1378   if (asect->relocation != NULL)
1379     return true;
1380
1381   if (! dynamic)
1382     {
1383       if ((asect->flags & SEC_RELOC) == 0
1384           || asect->reloc_count == 0)
1385         return true;
1386
1387       rel_hdr = &d->rel_hdr;
1388       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1389       rel_hdr2 = d->rel_hdr2;
1390       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1391
1392       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1393       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1394                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1395
1396     }
1397   else
1398     {
1399       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1400          case because relocations against this section may use the
1401          dynamic symbol table, and in that case bfd_section_from_shdr
1402          in elf.c does not update the RELOC_COUNT.  */
1403       if (asect->_raw_size == 0)
1404         return true;
1405
1406       rel_hdr = &d->this_hdr;
1407       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1408       rel_hdr2 = NULL;
1409       reloc_count2 = 0;
1410     }
1411
1412   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1413   relents = (arelent *) bfd_alloc (abfd, amt);
1414   if (relents == NULL)
1415     return false;
1416
1417   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1418                                            rel_hdr, reloc_count,
1419                                            relents,
1420                                            symbols, dynamic))
1421     return false;
1422
1423   if (rel_hdr2
1424       && !elf_slurp_reloc_table_from_section (abfd, asect,
1425                                               rel_hdr2, reloc_count2,
1426                                               relents + reloc_count,
1427                                               symbols, dynamic))
1428     return false;
1429
1430   asect->relocation = relents;
1431   return true;
1432 }
1433
1434 #ifdef DEBUG
1435 static void
1436 elf_debug_section (num, hdr)
1437      int num;
1438      Elf_Internal_Shdr *hdr;
1439 {
1440   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1441            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1442            (long) hdr);
1443   fprintf (stderr,
1444            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1445            (long) hdr->sh_name,
1446            (long) hdr->sh_type,
1447            (long) hdr->sh_flags);
1448   fprintf (stderr,
1449            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1450            (long) hdr->sh_addr,
1451            (long) hdr->sh_offset,
1452            (long) hdr->sh_size);
1453   fprintf (stderr,
1454            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1455            (long) hdr->sh_link,
1456            (long) hdr->sh_info,
1457            (long) hdr->sh_addralign);
1458   fprintf (stderr, "sh_entsize   = %ld\n",
1459            (long) hdr->sh_entsize);
1460   fflush (stderr);
1461 }
1462
1463 static void
1464 elf_debug_file (ehdrp)
1465      Elf_Internal_Ehdr *ehdrp;
1466 {
1467   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1468   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1469   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1470   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1471   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1472   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1473   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1474 }
1475
1476 static char *
1477 elf_symbol_flags (flags)
1478      flagword flags;
1479 {
1480   static char buffer[1024];
1481
1482   buffer[0] = '\0';
1483   if (flags & BSF_LOCAL)
1484     strcat (buffer, " local");
1485
1486   if (flags & BSF_GLOBAL)
1487     strcat (buffer, " global");
1488
1489   if (flags & BSF_DEBUGGING)
1490     strcat (buffer, " debug");
1491
1492   if (flags & BSF_FUNCTION)
1493     strcat (buffer, " function");
1494
1495   if (flags & BSF_KEEP)
1496     strcat (buffer, " keep");
1497
1498   if (flags & BSF_KEEP_G)
1499     strcat (buffer, " keep_g");
1500
1501   if (flags & BSF_WEAK)
1502     strcat (buffer, " weak");
1503
1504   if (flags & BSF_SECTION_SYM)
1505     strcat (buffer, " section-sym");
1506
1507   if (flags & BSF_OLD_COMMON)
1508     strcat (buffer, " old-common");
1509
1510   if (flags & BSF_NOT_AT_END)
1511     strcat (buffer, " not-at-end");
1512
1513   if (flags & BSF_CONSTRUCTOR)
1514     strcat (buffer, " constructor");
1515
1516   if (flags & BSF_WARNING)
1517     strcat (buffer, " warning");
1518
1519   if (flags & BSF_INDIRECT)
1520     strcat (buffer, " indirect");
1521
1522   if (flags & BSF_FILE)
1523     strcat (buffer, " file");
1524
1525   if (flags & DYNAMIC)
1526     strcat (buffer, " dynamic");
1527
1528   if (flags & ~(BSF_LOCAL
1529                 | BSF_GLOBAL
1530                 | BSF_DEBUGGING
1531                 | BSF_FUNCTION
1532                 | BSF_KEEP
1533                 | BSF_KEEP_G
1534                 | BSF_WEAK
1535                 | BSF_SECTION_SYM
1536                 | BSF_OLD_COMMON
1537                 | BSF_NOT_AT_END
1538                 | BSF_CONSTRUCTOR
1539                 | BSF_WARNING
1540                 | BSF_INDIRECT
1541                 | BSF_FILE
1542                 | BSF_DYNAMIC))
1543     strcat (buffer, " unknown-bits");
1544
1545   return buffer;
1546 }
1547 #endif
1548 \f
1549 #include "elfcore.h"
1550 #include "elflink.h"
1551 \f
1552 /* Size-dependent data and functions.  */
1553 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1554   sizeof (Elf_External_Ehdr),
1555   sizeof (Elf_External_Phdr),
1556   sizeof (Elf_External_Shdr),
1557   sizeof (Elf_External_Rel),
1558   sizeof (Elf_External_Rela),
1559   sizeof (Elf_External_Sym),
1560   sizeof (Elf_External_Dyn),
1561   sizeof (Elf_External_Note),
1562   4,
1563   1,
1564   ARCH_SIZE, FILE_ALIGN,
1565   ELFCLASS, EV_CURRENT,
1566   elf_write_out_phdrs,
1567   elf_write_shdrs_and_ehdr,
1568   elf_write_relocs,
1569   elf_swap_symbol_out,
1570   elf_slurp_reloc_table,
1571   elf_slurp_symbol_table,
1572   elf_swap_dyn_in,
1573   elf_swap_dyn_out,
1574   NULL,
1575   NULL,
1576   NULL,
1577   NULL
1578 };