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