bfd/elfcode.h

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