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