bfd/elfcode.h

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