bfd/elfcode.h

   1 /* ELF executable support for BFD.
   2    Copyright 1991, 1992, 1993, 1994, 1995 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  int _bfd_elf_section_from_bfd_section PARAMS ((bfd *, struct sec *));
 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 void write_relocs PARAMS ((bfd *, asection *, PTR));
 159
 160  boolean bfd_section_from_shdr PARAMS ((bfd *, unsigned int shindex));
 161
 162 #ifdef DEBUG
 163 static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
 164 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
 165 static char *elf_symbol_flags PARAMS ((flagword));
 166 #endif
 167 \f
 168 /* Structure swapping routines */
 169
 170 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
 171    can be handled by explicitly specifying 32 bits or "the long type".  */
 172 #if ARCH_SIZE == 64
 173 #define put_word        bfd_h_put_64
 174 #define get_word        bfd_h_get_64
 175 #endif
 176 #if ARCH_SIZE == 32
 177 #define put_word        bfd_h_put_32
 178 #define get_word        bfd_h_get_32
 179 #endif
 180
 181 /* Translate an ELF symbol in external format into an ELF symbol in internal
 182    format. */
 183
 184 void
 185 elf_swap_symbol_in (abfd, src, dst)
 186      bfd *abfd;
 187      Elf_External_Sym *src;
 188      Elf_Internal_Sym *dst;
 189 {
 190   dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
 191   dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
 192   dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
 193   dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
 194   dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
 195   dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
 196 }
 197
 198 /* Translate an ELF symbol in internal format into an ELF symbol in external
 199    format. */
 200
 201 void
 202 elf_swap_symbol_out (abfd, src, cdst)
 203      bfd *abfd;
 204      Elf_Internal_Sym *src;
 205      PTR cdst;
 206 {
 207   Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
 208   bfd_h_put_32 (abfd, src->st_name, dst->st_name);
 209   put_word (abfd, src->st_value, dst->st_value);
 210   put_word (abfd, src->st_size, dst->st_size);
 211   bfd_h_put_8 (abfd, src->st_info, dst->st_info);
 212   bfd_h_put_8 (abfd, src->st_other, dst->st_other);
 213   bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
 214 }
 215
 216
 217 /* Translate an ELF file header in external format into an ELF file header in
 218    internal format. */
 219
 220 static void
 221 elf_swap_ehdr_in (abfd, src, dst)
 222      bfd *abfd;
 223      Elf_External_Ehdr *src;
 224      Elf_Internal_Ehdr *dst;
 225 {
 226   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 227   dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
 228   dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
 229   dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
 230   dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
 231   dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
 232   dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
 233   dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
 234   dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
 235   dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
 236   dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
 237   dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
 238   dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
 239   dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
 240 }
 241
 242 /* Translate an ELF file header in internal format into an ELF file header in
 243    external format. */
 244
 245 static void
 246 elf_swap_ehdr_out (abfd, src, dst)
 247      bfd *abfd;
 248      Elf_Internal_Ehdr *src;
 249      Elf_External_Ehdr *dst;
 250 {
 251   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 252   /* note that all elements of dst are *arrays of unsigned char* already... */
 253   bfd_h_put_16 (abfd, src->e_type, dst->e_type);
 254   bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
 255   bfd_h_put_32 (abfd, src->e_version, dst->e_version);
 256   put_word (abfd, src->e_entry, dst->e_entry);
 257   put_word (abfd, src->e_phoff, dst->e_phoff);
 258   put_word (abfd, src->e_shoff, dst->e_shoff);
 259   bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
 260   bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
 261   bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
 262   bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
 263   bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
 264   bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
 265   bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
 266 }
 267
 268
 269 /* Translate an ELF section header table entry in external format into an
 270    ELF section header table entry in internal format. */
 271
 272 static void
 273 elf_swap_shdr_in (abfd, src, dst)
 274      bfd *abfd;
 275      Elf_External_Shdr *src;
 276      Elf_Internal_Shdr *dst;
 277 {
 278   dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
 279   dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
 280   dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
 281   dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
 282   dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
 283   dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
 284   dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
 285   dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
 286   dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
 287   dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
 288   dst->bfd_section = NULL;
 289   dst->contents = NULL;
 290 }
 291
 292 /* Translate an ELF section header table entry in internal format into an
 293    ELF section header table entry in external format. */
 294
 295 static void
 296 elf_swap_shdr_out (abfd, src, dst)
 297      bfd *abfd;
 298      Elf_Internal_Shdr *src;
 299      Elf_External_Shdr *dst;
 300 {
 301   /* note that all elements of dst are *arrays of unsigned char* already... */
 302   bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
 303   bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
 304   put_word (abfd, src->sh_flags, dst->sh_flags);
 305   put_word (abfd, src->sh_addr, dst->sh_addr);
 306   put_word (abfd, src->sh_offset, dst->sh_offset);
 307   put_word (abfd, src->sh_size, dst->sh_size);
 308   bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
 309   bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
 310   put_word (abfd, src->sh_addralign, dst->sh_addralign);
 311   put_word (abfd, src->sh_entsize, dst->sh_entsize);
 312 }
 313
 314
 315 /* Translate an ELF program header table entry in external format into an
 316    ELF program header table entry in internal format. */
 317
 318 void
 319 elf_swap_phdr_in (abfd, src, dst)
 320      bfd *abfd;
 321      Elf_External_Phdr *src;
 322      Elf_Internal_Phdr *dst;
 323 {
 324   dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
 325   dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
 326   dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
 327   dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
 328   dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
 329   dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
 330   dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
 331   dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
 332 }
 333
 334 void
 335 elf_swap_phdr_out (abfd, src, dst)
 336      bfd *abfd;
 337      Elf_Internal_Phdr *src;
 338      Elf_External_Phdr *dst;
 339 {
 340   /* note that all elements of dst are *arrays of unsigned char* already... */
 341   bfd_h_put_32 (abfd, src->p_type, dst->p_type);
 342   put_word (abfd, src->p_offset, dst->p_offset);
 343   put_word (abfd, src->p_vaddr, dst->p_vaddr);
 344   put_word (abfd, src->p_paddr, dst->p_paddr);
 345   put_word (abfd, src->p_filesz, dst->p_filesz);
 346   put_word (abfd, src->p_memsz, dst->p_memsz);
 347   bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
 348   put_word (abfd, src->p_align, dst->p_align);
 349 }
 350
 351 /* Translate an ELF reloc from external format to internal format. */
 352 INLINE void
 353 elf_swap_reloc_in (abfd, src, dst)
 354      bfd *abfd;
 355      Elf_External_Rel *src;
 356      Elf_Internal_Rel *dst;
 357 {
 358   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 359   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 360 }
 361
 362 INLINE void
 363 elf_swap_reloca_in (abfd, src, dst)
 364      bfd *abfd;
 365      Elf_External_Rela *src;
 366      Elf_Internal_Rela *dst;
 367 {
 368   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 369   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 370   dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
 371 }
 372
 373 /* Translate an ELF reloc from internal format to external format. */
 374 INLINE void
 375 elf_swap_reloc_out (abfd, src, dst)
 376      bfd *abfd;
 377      Elf_Internal_Rel *src;
 378      Elf_External_Rel *dst;
 379 {
 380   put_word (abfd, src->r_offset, dst->r_offset);
 381   put_word (abfd, src->r_info, dst->r_info);
 382 }
 383
 384 INLINE void
 385 elf_swap_reloca_out (abfd, src, dst)
 386      bfd *abfd;
 387      Elf_Internal_Rela *src;
 388      Elf_External_Rela *dst;
 389 {
 390   put_word (abfd, src->r_offset, dst->r_offset);
 391   put_word (abfd, src->r_info, dst->r_info);
 392   put_word (abfd, src->r_addend, dst->r_addend);
 393 }
 394
 395 INLINE void
 396 elf_swap_dyn_in (abfd, src, dst)
 397      bfd *abfd;
 398      const Elf_External_Dyn *src;
 399      Elf_Internal_Dyn *dst;
 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 (!abfd->xvec->header_byteorder_big_p)
 481         goto got_wrong_format_error;
 482       break;
 483     case ELFDATA2LSB:           /* Little-endian */
 484       if (abfd->xvec->header_byteorder_big_p)
 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                 malloc (symcount * sizeof (Elf_External_Sym)));
 895       if (x_symp == NULL && symcount != 0)
 896         {
 897           bfd_set_error (bfd_error_no_memory);
 898           goto error_return;
 899         }
 900
 901       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
 902           != symcount * sizeof (Elf_External_Sym))
 903         goto error_return;
 904       /* Skip first symbol, which is a null dummy.  */
 905       for (i = 1; i < symcount; i++)
 906         {
 907           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
 908           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
 909 #ifdef ELF_KEEP_EXTSYM
 910           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
 911 #endif
 912           sym->symbol.the_bfd = abfd;
 913
 914           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
 915                                                               hdr->sh_link,
 916                                                               i_sym.st_name);
 917
 918           sym->symbol.value = i_sym.st_value;
 919
 920           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
 921             {
 922               sym->symbol.section = section_from_elf_index (abfd,
 923                                                             i_sym.st_shndx);
 924               if (sym->symbol.section == NULL)
 925                 {
 926                   /* This symbol is in a section for which we did not
 927                      create a BFD section.  Just use bfd_abs_section,
 928                      although it is wrong.  FIXME.  */
 929                   sym->symbol.section = bfd_abs_section_ptr;
 930                 }
 931             }
 932           else if (i_sym.st_shndx == SHN_ABS)
 933             {
 934               sym->symbol.section = bfd_abs_section_ptr;
 935             }
 936           else if (i_sym.st_shndx == SHN_COMMON)
 937             {
 938               sym->symbol.section = bfd_com_section_ptr;
 939               /* Elf puts the alignment into the `value' field, and
 940                  the size into the `size' field.  BFD wants to see the
 941                  size in the value field, and doesn't care (at the
 942                  moment) about the alignment.  */
 943               sym->symbol.value = i_sym.st_size;
 944             }
 945           else if (i_sym.st_shndx == SHN_UNDEF)
 946             {
 947               sym->symbol.section = bfd_und_section_ptr;
 948             }
 949           else
 950             sym->symbol.section = bfd_abs_section_ptr;
 951
 952           sym->symbol.value -= sym->symbol.section->vma;
 953
 954           switch (ELF_ST_BIND (i_sym.st_info))
 955             {
 956             case STB_LOCAL:
 957               sym->symbol.flags |= BSF_LOCAL;
 958               break;
 959             case STB_GLOBAL:
 960               if (i_sym.st_shndx != SHN_UNDEF
 961                   && i_sym.st_shndx != SHN_COMMON)
 962                 sym->symbol.flags |= BSF_GLOBAL;
 963               break;
 964             case STB_WEAK:
 965               sym->symbol.flags |= BSF_WEAK;
 966               break;
 967             }
 968
 969           switch (ELF_ST_TYPE (i_sym.st_info))
 970             {
 971             case STT_SECTION:
 972               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
 973               break;
 974             case STT_FILE:
 975               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
 976               break;
 977             case STT_FUNC:
 978               sym->symbol.flags |= BSF_FUNCTION;
 979               break;
 980             }
 981
 982           if (dynamic)
 983             sym->symbol.flags |= BSF_DYNAMIC;
 984
 985           /* Do some backend-specific processing on this symbol.  */
 986           {
 987             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
 988             if (ebd->elf_backend_symbol_processing)
 989               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
 990           }
 991
 992           sym++;
 993         }
 994     }
 995
 996   /* Do some backend-specific processing on this symbol table.  */
 997   {
 998     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
 999     if (ebd->elf_backend_symbol_table_processing)
1000       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1001   }
1002
1003   /* We rely on the zalloc to clear out the final symbol entry.  */
1004
1005   symcount = sym - symbase;
1006
1007   /* Fill in the user's symbol pointer vector if needed.  */
1008   if (symptrs)
1009     {
1010       long l = symcount;
1011
1012       sym = symbase;
1013       while (l-- > 0)
1014         {
1015           *symptrs++ = &sym->symbol;
1016           sym++;
1017         }
1018       *symptrs = 0;             /* Final null pointer */
1019     }
1020
1021   if (x_symp != NULL)
1022     free (x_symp);
1023   return symcount;
1024 error_return:
1025   if (x_symp != NULL)
1026     free (x_symp);
1027   return -1;
1028 }
1029
1030 /* Read in and swap the external relocs.  */
1031
1032 static boolean
1033 elf_slurp_reloc_table (abfd, asect, symbols)
1034      bfd *abfd;
1035      asection *asect;
1036      asymbol **symbols;
1037 {
1038   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1039   struct bfd_elf_section_data * const d = elf_section_data (asect);
1040   PTR allocated = NULL;
1041   bfd_byte *native_relocs;
1042   arelent *relents;
1043   arelent *relent;
1044   unsigned int i;
1045   int entsize;
1046
1047   if (asect->relocation != NULL
1048       || (asect->flags & SEC_RELOC) == 0
1049       || asect->reloc_count == 0)
1050     return true;
1051
1052   BFD_ASSERT (asect->rel_filepos == d->rel_hdr.sh_offset
1053               && (asect->reloc_count
1054                   == d->rel_hdr.sh_size / d->rel_hdr.sh_entsize));
1055
1056   allocated = (PTR) malloc ((size_t) d->rel_hdr.sh_size);
1057   if (allocated == NULL)
1058     {
1059       bfd_set_error (bfd_error_no_memory);
1060       goto error_return;
1061     }
1062
1063   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0
1064       || (bfd_read (allocated, 1, d->rel_hdr.sh_size, abfd)
1065           != d->rel_hdr.sh_size))
1066     goto error_return;
1067
1068   native_relocs = (bfd_byte *) allocated;
1069
1070   relents = ((arelent *)
1071              bfd_alloc (abfd, asect->reloc_count * sizeof (arelent)));
1072   if (relents == NULL)
1073     goto error_return;
1074
1075   entsize = d->rel_hdr.sh_entsize;
1076   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1077               || entsize == sizeof (Elf_External_Rela));
1078
1079   for (i = 0, relent = relents;
1080        i < asect->reloc_count;
1081        i++, relent++, native_relocs += entsize)
1082     {
1083       Elf_Internal_Rela rela;
1084       Elf_Internal_Rel rel;
1085
1086       if (entsize == sizeof (Elf_External_Rela))
1087         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1088       else
1089         {
1090           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1091           rela.r_offset = rel.r_offset;
1092           rela.r_info = rel.r_info;
1093           rela.r_addend = 0;
1094         }
1095
1096       /* The address of an ELF reloc is section relative for an object
1097          file, and absolute for an executable file or shared library.
1098          The address of a BFD reloc is always section relative.  */
1099       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
1100         relent->address = rela.r_offset;
1101       else
1102         relent->address = rela.r_offset - asect->vma;
1103
1104       if (ELF_R_SYM (rela.r_info) == 0)
1105         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1106       else
1107         {
1108           asymbol **ps, *s;
1109
1110           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1111           s = *ps;
1112
1113           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1114           if ((s->flags & BSF_SECTION_SYM) == 0)
1115             relent->sym_ptr_ptr = ps;
1116           else
1117             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1118         }
1119
1120       relent->addend = rela.r_addend;
1121
1122       if (entsize == sizeof (Elf_External_Rela))
1123         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1124       else
1125         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1126     }
1127
1128   asect->relocation = relents;
1129
1130   if (allocated != NULL)
1131     free (allocated);
1132
1133   return true;
1134
1135  error_return:
1136   if (allocated != NULL)
1137     free (allocated);
1138   return false;
1139 }
1140
1141 #ifdef DEBUG
1142 static void
1143 elf_debug_section (num, hdr)
1144      int num;
1145      Elf_Internal_Shdr *hdr;
1146 {
1147   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1148            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1149            (long) hdr);
1150   fprintf (stderr,
1151            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1152            (long) hdr->sh_name,
1153            (long) hdr->sh_type,
1154            (long) hdr->sh_flags);
1155   fprintf (stderr,
1156            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1157            (long) hdr->sh_addr,
1158            (long) hdr->sh_offset,
1159            (long) hdr->sh_size);
1160   fprintf (stderr,
1161            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1162            (long) hdr->sh_link,
1163            (long) hdr->sh_info,
1164            (long) hdr->sh_addralign);
1165   fprintf (stderr, "sh_entsize   = %ld\n",
1166            (long) hdr->sh_entsize);
1167   fflush (stderr);
1168 }
1169
1170 static void
1171 elf_debug_file (ehdrp)
1172      Elf_Internal_Ehdr *ehdrp;
1173 {
1174   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1175   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1176   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1177   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1178   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1179   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1180   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1181 }
1182
1183 static char *
1184 elf_symbol_flags (flags)
1185      flagword flags;
1186 {
1187   static char buffer[1024];
1188
1189   buffer[0] = '\0';
1190   if (flags & BSF_LOCAL)
1191     strcat (buffer, " local");
1192
1193   if (flags & BSF_GLOBAL)
1194     strcat (buffer, " global");
1195
1196   if (flags & BSF_DEBUGGING)
1197     strcat (buffer, " debug");
1198
1199   if (flags & BSF_FUNCTION)
1200     strcat (buffer, " function");
1201
1202   if (flags & BSF_KEEP)
1203     strcat (buffer, " keep");
1204
1205   if (flags & BSF_KEEP_G)
1206     strcat (buffer, " keep_g");
1207
1208   if (flags & BSF_WEAK)
1209     strcat (buffer, " weak");
1210
1211   if (flags & BSF_SECTION_SYM)
1212     strcat (buffer, " section-sym");
1213
1214   if (flags & BSF_OLD_COMMON)
1215     strcat (buffer, " old-common");
1216
1217   if (flags & BSF_NOT_AT_END)
1218     strcat (buffer, " not-at-end");
1219
1220   if (flags & BSF_CONSTRUCTOR)
1221     strcat (buffer, " constructor");
1222
1223   if (flags & BSF_WARNING)
1224     strcat (buffer, " warning");
1225
1226   if (flags & BSF_INDIRECT)
1227     strcat (buffer, " indirect");
1228
1229   if (flags & BSF_FILE)
1230     strcat (buffer, " file");
1231
1232   if (flags & DYNAMIC)
1233     strcat (buffer, " dynamic");
1234
1235   if (flags & ~(BSF_LOCAL
1236                 | BSF_GLOBAL
1237                 | BSF_DEBUGGING
1238                 | BSF_FUNCTION
1239                 | BSF_KEEP
1240                 | BSF_KEEP_G
1241                 | BSF_WEAK
1242                 | BSF_SECTION_SYM
1243                 | BSF_OLD_COMMON
1244                 | BSF_NOT_AT_END
1245                 | BSF_CONSTRUCTOR
1246                 | BSF_WARNING
1247                 | BSF_INDIRECT
1248                 | BSF_FILE
1249                 | BSF_DYNAMIC))
1250     strcat (buffer, " unknown-bits");
1251
1252   return buffer;
1253 }
1254 #endif
1255 \f
1256 #include "elfcore.h"
1257 #include "elflink.h"
1258 \f
1259 /* Size-dependent data and functions.  */
1260 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1261   sizeof (Elf_External_Ehdr),
1262   sizeof (Elf_External_Phdr),
1263   sizeof (Elf_External_Shdr),
1264   sizeof (Elf_External_Rel),
1265   sizeof (Elf_External_Rela),
1266   sizeof (Elf_External_Sym),
1267   sizeof (Elf_External_Dyn),
1268   sizeof (Elf_External_Note),
1269
1270   ARCH_SIZE, FILE_ALIGN,
1271   ELFCLASS, EV_CURRENT,
1272   write_out_phdrs,
1273   write_shdrs_and_ehdr,
1274   write_relocs,
1275   elf_swap_symbol_out,
1276   elf_slurp_reloc_table,
1277   elf_slurp_symbol_table,
1278 };