bfd/elfcode.h

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