bfd/elfcode.h

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