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