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