bfd/elfcode.h

   1 /* ELF executable support for BFD.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002 Free Software Foundation, Inc.
   4
   5    Written by Fred Fish @ Cygnus Support, from information published
   6    in "UNIX System V Release 4, Programmers Guide: ANSI C and
   7    Programming Support Tools".  Sufficient support for gdb.
   8
   9    Rewritten by Mark Eichin @ Cygnus Support, from information
  10    published in "System V Application Binary Interface", chapters 4
  11    and 5, as well as the various "Processor Supplement" documents
  12    derived from it. Added support for assembler and other object file
  13    utilities.  Further work done by Ken Raeburn (Cygnus Support), Michael
  14    Meissner (Open Software Foundation), and Peter Hoogenboom (University
  15    of Utah) to finish and extend this.
  16
  17 This file is part of BFD, the Binary File Descriptor library.
  18
  19 This program is free software; you can redistribute it and/or modify
  20 it under the terms of the GNU General Public License as published by
  21 the Free Software Foundation; either version 2 of the License, or
  22 (at your option) any later version.
  23
  24 This program is distributed in the hope that it will be useful,
  25 but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 GNU General Public License for more details.
  28
  29 You should have received a copy of the GNU General Public License
  30 along with this program; if not, write to the Free Software
  31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  32
  33 /* Problems and other issues to resolve.
  34
  35    (1)  BFD expects there to be some fixed number of "sections" in
  36         the object file.  I.E. there is a "section_count" variable in the
  37         bfd structure which contains the number of sections.  However, ELF
  38         supports multiple "views" of a file.  In particular, with current
  39         implementations, executable files typically have two tables, a
  40         program header table and a section header table, both of which
  41         partition the executable.
  42
  43         In ELF-speak, the "linking view" of the file uses the section header
  44         table to access "sections" within the file, and the "execution view"
  45         uses the program header table to access "segments" within the file.
  46         "Segments" typically may contain all the data from one or more
  47         "sections".
  48
  49         Note that the section header table is optional in ELF executables,
  50         but it is this information that is most useful to gdb.  If the
  51         section header table is missing, then gdb should probably try
  52         to make do with the program header table.  (FIXME)
  53
  54    (2)  The code in this file is compiled twice, once in 32-bit mode and
  55         once in 64-bit mode.  More of it should be made size-independent
  56         and moved into elf.c.
  57
  58    (3)  ELF section symbols are handled rather sloppily now.  This should
  59         be cleaned up, and ELF section symbols reconciled with BFD section
  60         symbols.
  61
  62    (4)  We need a published spec for 64-bit ELF.  We've got some stuff here
  63         that we're using for SPARC V9 64-bit chips, but don't assume that
  64         it's cast in stone.
  65  */
  66
  67 #include "bfd.h"
  68 #include "sysdep.h"
  69 #include "libiberty.h"
  70 #include "bfdlink.h"
  71 #include "libbfd.h"
  72 #include "elf-bfd.h"
  73
  74 /* Renaming structures, typedefs, macros and functions to be size-specific.  */
  75 #define Elf_External_Ehdr       NAME(Elf,External_Ehdr)
  76 #define Elf_External_Sym        NAME(Elf,External_Sym)
  77 #define Elf_External_Shdr       NAME(Elf,External_Shdr)
  78 #define Elf_External_Phdr       NAME(Elf,External_Phdr)
  79 #define Elf_External_Rel        NAME(Elf,External_Rel)
  80 #define Elf_External_Rela       NAME(Elf,External_Rela)
  81 #define Elf_External_Dyn        NAME(Elf,External_Dyn)
  82
  83 #define elf_core_file_failing_command   NAME(bfd_elf,core_file_failing_command)
  84 #define elf_core_file_failing_signal    NAME(bfd_elf,core_file_failing_signal)
  85 #define elf_core_file_matches_executable_p \
  86   NAME(bfd_elf,core_file_matches_executable_p)
  87 #define elf_object_p                    NAME(bfd_elf,object_p)
  88 #define elf_core_file_p                 NAME(bfd_elf,core_file_p)
  89 #define elf_get_symtab_upper_bound      NAME(bfd_elf,get_symtab_upper_bound)
  90 #define elf_get_dynamic_symtab_upper_bound \
  91   NAME(bfd_elf,get_dynamic_symtab_upper_bound)
  92 #define elf_swap_reloc_in               NAME(bfd_elf,swap_reloc_in)
  93 #define elf_swap_reloca_in              NAME(bfd_elf,swap_reloca_in)
  94 #define elf_swap_reloc_out              NAME(bfd_elf,swap_reloc_out)
  95 #define elf_swap_reloca_out             NAME(bfd_elf,swap_reloca_out)
  96 #define elf_swap_symbol_in              NAME(bfd_elf,swap_symbol_in)
  97 #define elf_swap_symbol_out             NAME(bfd_elf,swap_symbol_out)
  98 #define elf_swap_phdr_in                NAME(bfd_elf,swap_phdr_in)
  99 #define elf_swap_phdr_out               NAME(bfd_elf,swap_phdr_out)
 100 #define elf_swap_dyn_in                 NAME(bfd_elf,swap_dyn_in)
 101 #define elf_swap_dyn_out                NAME(bfd_elf,swap_dyn_out)
 102 #define elf_get_reloc_upper_bound       NAME(bfd_elf,get_reloc_upper_bound)
 103 #define elf_canonicalize_reloc          NAME(bfd_elf,canonicalize_reloc)
 104 #define elf_slurp_symbol_table          NAME(bfd_elf,slurp_symbol_table)
 105 #define elf_get_symtab                  NAME(bfd_elf,get_symtab)
 106 #define elf_canonicalize_dynamic_symtab \
 107   NAME(bfd_elf,canonicalize_dynamic_symtab)
 108 #define elf_make_empty_symbol           NAME(bfd_elf,make_empty_symbol)
 109 #define elf_get_symbol_info             NAME(bfd_elf,get_symbol_info)
 110 #define elf_get_lineno                  NAME(bfd_elf,get_lineno)
 111 #define elf_set_arch_mach               NAME(bfd_elf,set_arch_mach)
 112 #define elf_find_nearest_line           NAME(bfd_elf,find_nearest_line)
 113 #define elf_sizeof_headers              NAME(bfd_elf,sizeof_headers)
 114 #define elf_set_section_contents        NAME(bfd_elf,set_section_contents)
 115 #define elf_no_info_to_howto            NAME(bfd_elf,no_info_to_howto)
 116 #define elf_no_info_to_howto_rel        NAME(bfd_elf,no_info_to_howto_rel)
 117 #define elf_find_section                NAME(bfd_elf,find_section)
 118 #define elf_bfd_link_add_symbols        NAME(bfd_elf,bfd_link_add_symbols)
 119 #define elf_add_dynamic_entry           NAME(bfd_elf,add_dynamic_entry)
 120 #define elf_write_shdrs_and_ehdr        NAME(bfd_elf,write_shdrs_and_ehdr)
 121 #define elf_write_out_phdrs             NAME(bfd_elf,write_out_phdrs)
 122 #define elf_write_relocs                NAME(bfd_elf,write_relocs)
 123 #define elf_slurp_reloc_table           NAME(bfd_elf,slurp_reloc_table)
 124 #define elf_link_create_dynamic_sections \
 125   NAME(bfd_elf,link_create_dynamic_sections)
 126 #define elf_bfd_discard_info            NAME(bfd_elf,discard_info)
 127 #define elf_reloc_symbol_deleted_p      NAME(_bfd_elf,reloc_symbol_deleted_p)
 128 #define elf_link_record_dynamic_symbol  _bfd_elf_link_record_dynamic_symbol
 129 #define elf_bfd_final_link              NAME(bfd_elf,bfd_final_link)
 130 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
 131 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
 132 #define elf_gc_sections                 NAME(_bfd_elf,gc_sections)
 133 #define elf_gc_common_finalize_got_offsets \
 134   NAME(_bfd_elf,gc_common_finalize_got_offsets)
 135 #define elf_gc_common_final_link        NAME(_bfd_elf,gc_common_final_link)
 136 #define elf_gc_record_vtinherit         NAME(_bfd_elf,gc_record_vtinherit)
 137 #define elf_gc_record_vtentry           NAME(_bfd_elf,gc_record_vtentry)
 138 #define elf_link_record_local_dynamic_symbol \
 139   NAME(_bfd_elf,link_record_local_dynamic_symbol)
 140
 141 #if ARCH_SIZE == 64
 142 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
 143 #define ELF_R_SYM(X)    ELF64_R_SYM(X)
 144 #define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
 145 #define ELFCLASS        ELFCLASS64
 146 #define FILE_ALIGN      8
 147 #define LOG_FILE_ALIGN  3
 148 #endif
 149 #if ARCH_SIZE == 32
 150 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
 151 #define ELF_R_SYM(X)    ELF32_R_SYM(X)
 152 #define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
 153 #define ELFCLASS        ELFCLASS32
 154 #define FILE_ALIGN      4
 155 #define LOG_FILE_ALIGN  2
 156 #endif
 157
 158 /* Static functions */
 159
 160 static void elf_swap_ehdr_in
 161   PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
 162 static void elf_swap_ehdr_out
 163   PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
 164 static void elf_swap_shdr_in
 165   PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
 166 static void elf_swap_shdr_out
 167   PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
 168
 169 #define elf_stringtab_init _bfd_elf_stringtab_init
 170
 171 #define section_from_elf_index bfd_section_from_elf_index
 172
 173 static bfd_boolean elf_slurp_reloc_table_from_section
 174   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
 175            arelent *, asymbol **, bfd_boolean));
 176
 177 static bfd_boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
 178
 179 #ifdef DEBUG
 180 static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
 181 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
 182 static char *elf_symbol_flags PARAMS ((flagword));
 183 #endif
 184 \f
 185 /* Structure swapping routines */
 186
 187 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
 188    can be handled by explicitly specifying 32 bits or "the long type".  */
 189 #if ARCH_SIZE == 64
 190 #define H_PUT_WORD              H_PUT_64
 191 #define H_PUT_SIGNED_WORD       H_PUT_S64
 192 #define H_GET_WORD              H_GET_64
 193 #define H_GET_SIGNED_WORD       H_GET_S64
 194 #endif
 195 #if ARCH_SIZE == 32
 196 #define H_PUT_WORD              H_PUT_32
 197 #define H_PUT_SIGNED_WORD       H_PUT_S32
 198 #define H_GET_WORD              H_GET_32
 199 #define H_GET_SIGNED_WORD       H_GET_S32
 200 #endif
 201
 202 /* Translate an ELF symbol in external format into an ELF symbol in internal
 203    format.  */
 204
 205 void
 206 elf_swap_symbol_in (abfd, psrc, pshn, dst)
 207      bfd *abfd;
 208      const PTR psrc;
 209      const PTR pshn;
 210      Elf_Internal_Sym *dst;
 211 {
 212   const Elf_External_Sym *src = (const Elf_External_Sym *) psrc;
 213   const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn;
 214   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 215
 216   dst->st_name = H_GET_32 (abfd, src->st_name);
 217   if (signed_vma)
 218     dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
 219   else
 220     dst->st_value = H_GET_WORD (abfd, src->st_value);
 221   dst->st_size = H_GET_WORD (abfd, src->st_size);
 222   dst->st_info = H_GET_8 (abfd, src->st_info);
 223   dst->st_other = H_GET_8 (abfd, src->st_other);
 224   dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
 225   if (dst->st_shndx == SHN_XINDEX)
 226     {
 227       if (shndx == NULL)
 228         abort ();
 229       dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
 230     }
 231 }
 232
 233 /* Translate an ELF symbol in internal format into an ELF symbol in external
 234    format.  */
 235
 236 void
 237 elf_swap_symbol_out (abfd, src, cdst, shndx)
 238      bfd *abfd;
 239      const Elf_Internal_Sym *src;
 240      PTR cdst;
 241      PTR shndx;
 242 {
 243   unsigned int tmp;
 244   Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
 245   H_PUT_32 (abfd, src->st_name, dst->st_name);
 246   H_PUT_WORD (abfd, src->st_value, dst->st_value);
 247   H_PUT_WORD (abfd, src->st_size, dst->st_size);
 248   H_PUT_8 (abfd, src->st_info, dst->st_info);
 249   H_PUT_8 (abfd, src->st_other, dst->st_other);
 250   tmp = src->st_shndx;
 251   if (tmp > SHN_HIRESERVE)
 252     {
 253       if (shndx == NULL)
 254         abort ();
 255       H_PUT_32 (abfd, tmp, shndx);
 256       tmp = SHN_XINDEX;
 257     }
 258   H_PUT_16 (abfd, tmp, dst->st_shndx);
 259 }
 260
 261 /* Translate an ELF file header in external format into an ELF file header in
 262    internal format.  */
 263
 264 static void
 265 elf_swap_ehdr_in (abfd, src, dst)
 266      bfd *abfd;
 267      const Elf_External_Ehdr *src;
 268      Elf_Internal_Ehdr *dst;
 269 {
 270   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 271   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 272   dst->e_type = H_GET_16 (abfd, src->e_type);
 273   dst->e_machine = H_GET_16 (abfd, src->e_machine);
 274   dst->e_version = H_GET_32 (abfd, src->e_version);
 275   if (signed_vma)
 276     dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
 277   else
 278     dst->e_entry = H_GET_WORD (abfd, src->e_entry);
 279   dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
 280   dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
 281   dst->e_flags = H_GET_32 (abfd, src->e_flags);
 282   dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
 283   dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
 284   dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
 285   dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
 286   dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
 287   dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
 288 }
 289
 290 /* Translate an ELF file header in internal format into an ELF file header in
 291    external format.  */
 292
 293 static void
 294 elf_swap_ehdr_out (abfd, src, dst)
 295      bfd *abfd;
 296      const Elf_Internal_Ehdr *src;
 297      Elf_External_Ehdr *dst;
 298 {
 299   unsigned int tmp;
 300   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 301   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 302   /* note that all elements of dst are *arrays of unsigned char* already...  */
 303   H_PUT_16 (abfd, src->e_type, dst->e_type);
 304   H_PUT_16 (abfd, src->e_machine, dst->e_machine);
 305   H_PUT_32 (abfd, src->e_version, dst->e_version);
 306   if (signed_vma)
 307     H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
 308   else
 309     H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
 310   H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
 311   H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
 312   H_PUT_32 (abfd, src->e_flags, dst->e_flags);
 313   H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
 314   H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
 315   H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
 316   H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
 317   tmp = src->e_shnum;
 318   if (tmp >= SHN_LORESERVE)
 319     tmp = SHN_UNDEF;
 320   H_PUT_16 (abfd, tmp, dst->e_shnum);
 321   tmp = src->e_shstrndx;
 322   if (tmp >= SHN_LORESERVE)
 323     tmp = SHN_XINDEX;
 324   H_PUT_16 (abfd, tmp, dst->e_shstrndx);
 325 }
 326
 327 /* Translate an ELF section header table entry in external format into an
 328    ELF section header table entry in internal format.  */
 329
 330 static void
 331 elf_swap_shdr_in (abfd, src, dst)
 332      bfd *abfd;
 333      const Elf_External_Shdr *src;
 334      Elf_Internal_Shdr *dst;
 335 {
 336   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 337
 338   dst->sh_name = H_GET_32 (abfd, src->sh_name);
 339   dst->sh_type = H_GET_32 (abfd, src->sh_type);
 340   dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
 341   if (signed_vma)
 342     dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
 343   else
 344     dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
 345   dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
 346   dst->sh_size = H_GET_WORD (abfd, src->sh_size);
 347   dst->sh_link = H_GET_32 (abfd, src->sh_link);
 348   dst->sh_info = H_GET_32 (abfd, src->sh_info);
 349   dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
 350   dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
 351   dst->bfd_section = NULL;
 352   dst->contents = NULL;
 353 }
 354
 355 /* Translate an ELF section header table entry in internal format into an
 356    ELF section header table entry in external format.  */
 357
 358 static void
 359 elf_swap_shdr_out (abfd, src, dst)
 360      bfd *abfd;
 361      const Elf_Internal_Shdr *src;
 362      Elf_External_Shdr *dst;
 363 {
 364   /* note that all elements of dst are *arrays of unsigned char* already...  */
 365   H_PUT_32 (abfd, src->sh_name, dst->sh_name);
 366   H_PUT_32 (abfd, src->sh_type, dst->sh_type);
 367   H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
 368   H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
 369   H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
 370   H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
 371   H_PUT_32 (abfd, src->sh_link, dst->sh_link);
 372   H_PUT_32 (abfd, src->sh_info, dst->sh_info);
 373   H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
 374   H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
 375 }
 376
 377 /* Translate an ELF program header table entry in external format into an
 378    ELF program header table entry in internal format.  */
 379
 380 void
 381 elf_swap_phdr_in (abfd, src, dst)
 382      bfd *abfd;
 383      const Elf_External_Phdr *src;
 384      Elf_Internal_Phdr *dst;
 385 {
 386   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 387
 388   dst->p_type = H_GET_32 (abfd, src->p_type);
 389   dst->p_flags = H_GET_32 (abfd, src->p_flags);
 390   dst->p_offset = H_GET_WORD (abfd, src->p_offset);
 391   if (signed_vma)
 392     {
 393       dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
 394       dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
 395     }
 396   else
 397     {
 398       dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
 399       dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
 400     }
 401   dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
 402   dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
 403   dst->p_align = H_GET_WORD (abfd, src->p_align);
 404 }
 405
 406 void
 407 elf_swap_phdr_out (abfd, src, dst)
 408      bfd *abfd;
 409      const Elf_Internal_Phdr *src;
 410      Elf_External_Phdr *dst;
 411 {
 412   /* note that all elements of dst are *arrays of unsigned char* already...  */
 413   H_PUT_32 (abfd, src->p_type, dst->p_type);
 414   H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
 415   H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
 416   H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr);
 417   H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
 418   H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
 419   H_PUT_32 (abfd, src->p_flags, dst->p_flags);
 420   H_PUT_WORD (abfd, src->p_align, dst->p_align);
 421 }
 422
 423 /* Translate an ELF reloc from external format to internal format.  */
 424 void
 425 elf_swap_reloc_in (abfd, s, dst)
 426      bfd *abfd;
 427      const bfd_byte *s;
 428      Elf_Internal_Rela *dst;
 429 {
 430   const Elf_External_Rel *src = (const Elf_External_Rel *) s;
 431   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 432   dst->r_info = H_GET_WORD (abfd, src->r_info);
 433   dst->r_addend = 0;
 434 }
 435
 436 void
 437 elf_swap_reloca_in (abfd, s, dst)
 438      bfd *abfd;
 439      const bfd_byte *s;
 440      Elf_Internal_Rela *dst;
 441 {
 442   const Elf_External_Rela *src = (const Elf_External_Rela *) s;
 443   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 444   dst->r_info = H_GET_WORD (abfd, src->r_info);
 445   dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
 446 }
 447
 448 /* Translate an ELF reloc from internal format to external format.  */
 449 void
 450 elf_swap_reloc_out (abfd, src, d)
 451      bfd *abfd;
 452      const Elf_Internal_Rela *src;
 453      bfd_byte *d;
 454 {
 455   Elf_External_Rel *dst = (Elf_External_Rel *) d;
 456   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 457   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 458 }
 459
 460 void
 461 elf_swap_reloca_out (abfd, src, d)
 462      bfd *abfd;
 463      const Elf_Internal_Rela *src;
 464      bfd_byte *d;
 465 {
 466   Elf_External_Rela *dst = (Elf_External_Rela *) d;
 467   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 468   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 469   H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
 470 }
 471
 472 INLINE void
 473 elf_swap_dyn_in (abfd, p, dst)
 474      bfd *abfd;
 475      const PTR p;
 476      Elf_Internal_Dyn *dst;
 477 {
 478   const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
 479
 480   dst->d_tag = H_GET_WORD (abfd, src->d_tag);
 481   dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
 482 }
 483
 484 INLINE void
 485 elf_swap_dyn_out (abfd, src, p)
 486      bfd *abfd;
 487      const Elf_Internal_Dyn *src;
 488      PTR p;
 489 {
 490   Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
 491
 492   H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
 493   H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
 494 }
 495 \f
 496 /* ELF .o/exec file reading */
 497
 498 /* Begin processing a given object.
 499
 500    First we validate the file by reading in the ELF header and checking
 501    the magic number.  */
 502
 503 static INLINE bfd_boolean
 504 elf_file_p (x_ehdrp)
 505      Elf_External_Ehdr *x_ehdrp;
 506 {
 507   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
 508           && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
 509           && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
 510           && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
 511 }
 512
 513 /* Check to see if the file associated with ABFD matches the target vector
 514    that ABFD points to.
 515
 516    Note that we may be called several times with the same ABFD, but different
 517    target vectors, most of which will not match.  We have to avoid leaving
 518    any side effects in ABFD, or any data it points to (like tdata), if the
 519    file does not match the target vector.  */
 520
 521 const bfd_target *
 522 elf_object_p (abfd)
 523      bfd *abfd;
 524 {
 525   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 526   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 527   Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
 528   Elf_Internal_Shdr i_shdr;
 529   Elf_Internal_Shdr *i_shdrp;   /* Section header table, internal form */
 530   unsigned int shindex;
 531   char *shstrtab;               /* Internal copy of section header stringtab */
 532   struct elf_backend_data *ebd;
 533   struct bfd_preserve preserve;
 534   asection *s;
 535   bfd_size_type amt;
 536
 537   preserve.marker = NULL;
 538
 539   /* Read in the ELF header in external format.  */
 540
 541   if (bfd_bread ((PTR) & x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
 542       != sizeof (x_ehdr))
 543     {
 544       if (bfd_get_error () != bfd_error_system_call)
 545         goto got_wrong_format_error;
 546       else
 547         goto got_no_match;
 548     }
 549
 550   /* Now check to see if we have a valid ELF file, and one that BFD can
 551      make use of.  The magic number must match, the address size ('class')
 552      and byte-swapping must match our XVEC entry, and it must have a
 553      section header table (FIXME: See comments re sections at top of this
 554      file).  */
 555
 556   if (! elf_file_p (&x_ehdr)
 557       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
 558       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 559     goto got_wrong_format_error;
 560
 561   /* Check that file's byte order matches xvec's */
 562   switch (x_ehdr.e_ident[EI_DATA])
 563     {
 564     case ELFDATA2MSB:           /* Big-endian */
 565       if (! bfd_header_big_endian (abfd))
 566         goto got_wrong_format_error;
 567       break;
 568     case ELFDATA2LSB:           /* Little-endian */
 569       if (! bfd_header_little_endian (abfd))
 570         goto got_wrong_format_error;
 571       break;
 572     case ELFDATANONE:           /* No data encoding specified */
 573     default:                    /* Unknown data encoding specified */
 574       goto got_wrong_format_error;
 575     }
 576
 577   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
 578      the tdata pointer in the bfd.  */
 579
 580   amt = sizeof (struct elf_obj_tdata);
 581   preserve.marker = bfd_zalloc (abfd, amt);
 582   if (preserve.marker == NULL)
 583     goto got_no_match;
 584   if (!bfd_preserve_save (abfd, &preserve))
 585     goto got_no_match;
 586
 587   elf_tdata (abfd) = preserve.marker;
 588
 589   /* Now that we know the byte order, swap in the rest of the header */
 590   i_ehdrp = elf_elfheader (abfd);
 591   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 592 #if DEBUG & 1
 593   elf_debug_file (i_ehdrp);
 594 #endif
 595
 596   /* Reject ET_CORE (header indicates core file, not object file) */
 597   if (i_ehdrp->e_type == ET_CORE)
 598     goto got_wrong_format_error;
 599
 600   /* If this is a relocatable file and there is no section header
 601      table, then we're hosed.  */
 602   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
 603     goto got_wrong_format_error;
 604
 605   /* As a simple sanity check, verify that the what BFD thinks is the
 606      size of each section header table entry actually matches the size
 607      recorded in the file, but only if there are any sections.  */
 608   if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
 609     goto got_wrong_format_error;
 610
 611   /* Further sanity check.  */
 612   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
 613     goto got_wrong_format_error;
 614
 615   ebd = get_elf_backend_data (abfd);
 616
 617   /* Check that the ELF e_machine field matches what this particular
 618      BFD format expects.  */
 619   if (ebd->elf_machine_code != i_ehdrp->e_machine
 620       && (ebd->elf_machine_alt1 == 0
 621           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 622       && (ebd->elf_machine_alt2 == 0
 623           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 624     {
 625       const bfd_target * const *target_ptr;
 626
 627       if (ebd->elf_machine_code != EM_NONE)
 628         goto got_wrong_format_error;
 629
 630       /* This is the generic ELF target.  Let it match any ELF target
 631          for which we do not have a specific backend.  */
 632       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 633         {
 634           struct elf_backend_data *back;
 635
 636           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 637             continue;
 638           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 639           if (back->elf_machine_code == i_ehdrp->e_machine
 640               || (back->elf_machine_alt1 != 0
 641                   && back->elf_machine_alt1 == i_ehdrp->e_machine)
 642               || (back->elf_machine_alt2 != 0
 643                   && back->elf_machine_alt2 == i_ehdrp->e_machine))
 644             {
 645               /* target_ptr is an ELF backend which matches this
 646                  object file, so reject the generic ELF target.  */
 647               goto got_wrong_format_error;
 648             }
 649         }
 650     }
 651
 652   if (i_ehdrp->e_type == ET_EXEC)
 653     abfd->flags |= EXEC_P;
 654   else if (i_ehdrp->e_type == ET_DYN)
 655     abfd->flags |= DYNAMIC;
 656
 657   if (i_ehdrp->e_phnum > 0)
 658     abfd->flags |= D_PAGED;
 659
 660   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 661     {
 662       /* It's OK if this fails for the generic target.  */
 663       if (ebd->elf_machine_code != EM_NONE)
 664         goto got_no_match;
 665     }
 666
 667   /* Remember the entry point specified in the ELF file header.  */
 668   bfd_set_start_address (abfd, i_ehdrp->e_entry);
 669
 670   if (i_ehdrp->e_shoff != 0)
 671     {
 672       /* Seek to the section header table in the file.  */
 673       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
 674         goto got_no_match;
 675
 676       /* Read the first section header at index 0, and convert to internal
 677          form.  */
 678       if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
 679           != sizeof (x_shdr))
 680         goto got_no_match;
 681       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
 682
 683       /* If the section count is zero, the actual count is in the first
 684          section header.  */
 685       if (i_ehdrp->e_shnum == SHN_UNDEF)
 686         i_ehdrp->e_shnum = i_shdr.sh_size;
 687
 688       /* And similarly for the string table index.  */
 689       if (i_ehdrp->e_shstrndx == SHN_XINDEX)
 690         i_ehdrp->e_shstrndx = i_shdr.sh_link;
 691     }
 692
 693   /* Allocate space for a copy of the section header table in
 694      internal form.  */
 695   if (i_ehdrp->e_shnum != 0)
 696     {
 697       Elf_Internal_Shdr *shdrp;
 698       unsigned int num_sec;
 699
 700       amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
 701       i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
 702       if (!i_shdrp)
 703         goto got_no_match;
 704       num_sec = i_ehdrp->e_shnum;
 705       if (num_sec > SHN_LORESERVE)
 706         num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 707       elf_numsections (abfd) = num_sec;
 708       amt = sizeof (i_shdrp) * num_sec;
 709       elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
 710       if (!elf_elfsections (abfd))
 711         goto got_no_match;
 712
 713       memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
 714       shdrp = i_shdrp;
 715       shindex = 0;
 716       if (num_sec > SHN_LORESERVE)
 717         {
 718           for ( ; shindex < SHN_LORESERVE; shindex++)
 719             elf_elfsections (abfd)[shindex] = shdrp++;
 720           for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
 721             elf_elfsections (abfd)[shindex] = i_shdrp;
 722         }
 723       for ( ; shindex < num_sec; shindex++)
 724         elf_elfsections (abfd)[shindex] = shdrp++;
 725
 726       /* Read in the rest of the section header table and convert it
 727          to internal form.  */
 728       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 729         {
 730           if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
 731               != sizeof (x_shdr))
 732             goto got_no_match;
 733           elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 734
 735           /* If the section is loaded, but not page aligned, clear
 736              D_PAGED.  */
 737           if (i_shdrp[shindex].sh_size != 0
 738               && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
 739               && i_shdrp[shindex].sh_type != SHT_NOBITS
 740               && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
 741                    % ebd->maxpagesize)
 742                   != 0))
 743             abfd->flags &= ~D_PAGED;
 744         }
 745     }
 746
 747   if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff)
 748     {
 749       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 750         goto got_no_match;
 751     }
 752
 753   /* Read in the program headers.  */
 754   if (i_ehdrp->e_phnum == 0)
 755     elf_tdata (abfd)->phdr = NULL;
 756   else
 757     {
 758       Elf_Internal_Phdr *i_phdr;
 759       unsigned int i;
 760
 761       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
 762       elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 763       if (elf_tdata (abfd)->phdr == NULL)
 764         goto got_no_match;
 765       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 766         goto got_no_match;
 767       i_phdr = elf_tdata (abfd)->phdr;
 768       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
 769         {
 770           Elf_External_Phdr x_phdr;
 771
 772           if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
 773               != sizeof x_phdr)
 774             goto got_no_match;
 775           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
 776         }
 777     }
 778
 779   /* Read in the string table containing the names of the sections.  We
 780      will need the base pointer to this table later.  */
 781   /* We read this inline now, so that we don't have to go through
 782      bfd_section_from_shdr with it (since this particular strtab is
 783      used to find all of the ELF section names.) */
 784
 785   if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff)
 786     {
 787       unsigned int num_sec;
 788
 789       shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 790       if (!shstrtab)
 791         goto got_no_match;
 792
 793       /* Once all of the section headers have been read and converted, we
 794          can start processing them.  Note that the first section header is
 795          a dummy placeholder entry, so we ignore it.  */
 796       num_sec = elf_numsections (abfd);
 797       for (shindex = 1; shindex < num_sec; shindex++)
 798         {
 799           if (! bfd_section_from_shdr (abfd, shindex))
 800             goto got_no_match;
 801           if (shindex == SHN_LORESERVE - 1)
 802             shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 803         }
 804     }
 805
 806   /* Let the backend double check the format and override global
 807      information.  */
 808   if (ebd->elf_backend_object_p)
 809     {
 810       if (! (*ebd->elf_backend_object_p) (abfd))
 811         goto got_wrong_format_error;
 812     }
 813
 814   /* If we have created any reloc sections that are associated with
 815      debugging sections, mark the reloc sections as debugging as well.  */
 816   for (s = abfd->sections; s != NULL; s = s->next)
 817     {
 818       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 819            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 820           && elf_section_data (s)->this_hdr.sh_info > 0)
 821         {
 822           unsigned long targ_index;
 823           asection *targ_sec;
 824
 825           targ_index = elf_section_data (s)->this_hdr.sh_info;
 826           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 827           if (targ_sec != NULL
 828               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 829             s->flags |= SEC_DEBUGGING;
 830         }
 831     }
 832
 833   bfd_preserve_finish (abfd, &preserve);
 834   return abfd->xvec;
 835
 836  got_wrong_format_error:
 837   /* There is way too much undoing of half-known state here.  The caller,
 838      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 839      check match/no-match like it does.  We have to rely on that a call to
 840      bfd_default_set_arch_mach with the previously known mach, undoes what
 841      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 842      For this to work, only elf-data and the mach may be changed by the
 843      target-specific elf_backend_object_p function.  Note that saving the
 844      whole bfd here and restoring it would be even worse; the first thing
 845      you notice is that the cached bfd file position gets out of sync.  */
 846   bfd_set_error (bfd_error_wrong_format);
 847
 848  got_no_match:
 849   if (preserve.marker != NULL)
 850     bfd_preserve_restore (abfd, &preserve);
 851   return NULL;
 852 }
 853 \f
 854 /* ELF .o/exec file writing */
 855
 856 /* Write out the relocs.  */
 857
 858 void
 859 elf_write_relocs (abfd, sec, data)
 860      bfd *abfd;
 861      asection *sec;
 862      PTR data;
 863 {
 864   bfd_boolean *failedp = (bfd_boolean *) data;
 865   Elf_Internal_Shdr *rela_hdr;
 866   bfd_vma addr_offset;
 867   void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
 868   size_t extsize;
 869   bfd_byte *dst_rela;
 870   unsigned int idx;
 871   asymbol *last_sym;
 872   int last_sym_idx;
 873
 874   /* If we have already failed, don't do anything.  */
 875   if (*failedp)
 876     return;
 877
 878   if ((sec->flags & SEC_RELOC) == 0)
 879     return;
 880
 881   /* The linker backend writes the relocs out itself, and sets the
 882      reloc_count field to zero to inhibit writing them here.  Also,
 883      sometimes the SEC_RELOC flag gets set even when there aren't any
 884      relocs.  */
 885   if (sec->reloc_count == 0)
 886     return;
 887
 888   rela_hdr = &elf_section_data (sec)->rel_hdr;
 889
 890   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 891   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
 892   if (rela_hdr->contents == NULL)
 893     {
 894       *failedp = TRUE;
 895       return;
 896     }
 897
 898   /* Figure out whether the relocations are RELA or REL relocations.  */
 899   if (rela_hdr->sh_type == SHT_RELA)
 900     {
 901       swap_out = elf_swap_reloca_out;
 902       extsize = sizeof (Elf_External_Rela);
 903     }
 904   else if (rela_hdr->sh_type == SHT_REL)
 905     {
 906       swap_out = elf_swap_reloc_out;
 907       extsize = sizeof (Elf_External_Rel);
 908     }
 909   else
 910     /* Every relocation section should be either an SHT_RELA or an
 911        SHT_REL section.  */
 912     abort ();
 913
 914   /* The address of an ELF reloc is section relative for an object
 915      file, and absolute for an executable file or shared library.
 916      The address of a BFD reloc is always section relative.  */
 917   addr_offset = 0;
 918   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 919     addr_offset = sec->vma;
 920
 921   /* orelocation has the data, reloc_count has the count...  */
 922   last_sym = 0;
 923   last_sym_idx = 0;
 924   dst_rela = rela_hdr->contents;
 925
 926   for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
 927     {
 928       Elf_Internal_Rela src_rela;
 929       arelent *ptr;
 930       asymbol *sym;
 931       int n;
 932
 933       ptr = sec->orelocation[idx];
 934       sym = *ptr->sym_ptr_ptr;
 935       if (sym == last_sym)
 936         n = last_sym_idx;
 937       else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 938         n = STN_UNDEF;
 939       else
 940         {
 941           last_sym = sym;
 942           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 943           if (n < 0)
 944             {
 945               *failedp = TRUE;
 946               return;
 947             }
 948           last_sym_idx = n;
 949         }
 950
 951       if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 952           && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 953           && ! _bfd_elf_validate_reloc (abfd, ptr))
 954         {
 955           *failedp = TRUE;
 956           return;
 957         }
 958
 959       src_rela.r_offset = ptr->address + addr_offset;
 960       src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 961       src_rela.r_addend = ptr->addend;
 962       (*swap_out) (abfd, &src_rela, dst_rela);
 963     }
 964 }
 965
 966 /* Write out the program headers.  */
 967
 968 int
 969 elf_write_out_phdrs (abfd, phdr, count)
 970      bfd *abfd;
 971      const Elf_Internal_Phdr *phdr;
 972      unsigned int count;
 973 {
 974   while (count--)
 975     {
 976       Elf_External_Phdr extphdr;
 977       elf_swap_phdr_out (abfd, phdr, &extphdr);
 978       if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
 979                      abfd) != sizeof (Elf_External_Phdr))
 980         return -1;
 981       phdr++;
 982     }
 983   return 0;
 984 }
 985
 986 /* Write out the section headers and the ELF file header.  */
 987
 988 bfd_boolean
 989 elf_write_shdrs_and_ehdr (abfd)
 990      bfd *abfd;
 991 {
 992   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 993   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 994   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 995   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 996   unsigned int count;
 997   bfd_size_type amt;
 998
 999   i_ehdrp = elf_elfheader (abfd);
1000   i_shdrp = elf_elfsections (abfd);
1001
1002   /* swap the header before spitting it out...  */
1003
1004 #if DEBUG & 1
1005   elf_debug_file (i_ehdrp);
1006 #endif
1007   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1008   amt = sizeof (x_ehdr);
1009   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1010       || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
1011     return FALSE;
1012
1013   /* Some fields in the first section header handle overflow of ehdr
1014      fields.  */
1015   if (i_ehdrp->e_shnum >= SHN_LORESERVE)
1016     i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1017   if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
1018     i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1019
1020   /* at this point we've concocted all the ELF sections...  */
1021   amt = i_ehdrp->e_shnum;
1022   amt *= sizeof (*x_shdrp);
1023   x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1024   if (!x_shdrp)
1025     return FALSE;
1026
1027   for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1028     {
1029 #if DEBUG & 2
1030       elf_debug_section (count, *i_shdrp);
1031 #endif
1032       elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1033
1034       if (count == SHN_LORESERVE - 1)
1035         i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
1036     }
1037   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1038       || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
1039     return FALSE;
1040
1041   /* need to dump the string table too...  */
1042
1043   return TRUE;
1044 }
1045
1046 long
1047 elf_slurp_symbol_table (abfd, symptrs, dynamic)
1048      bfd *abfd;
1049      asymbol **symptrs;         /* Buffer for generated bfd symbols */
1050      bfd_boolean dynamic;
1051 {
1052   Elf_Internal_Shdr *hdr;
1053   Elf_Internal_Shdr *verhdr;
1054   unsigned long symcount;       /* Number of external ELF symbols */
1055   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1056   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1057   Elf_Internal_Sym *isym;
1058   Elf_Internal_Sym *isymend;
1059   Elf_Internal_Sym *isymbuf = NULL;
1060   Elf_External_Versym *xver;
1061   Elf_External_Versym *xverbuf = NULL;
1062   struct elf_backend_data *ebd;
1063   bfd_size_type amt;
1064
1065   /* Read each raw ELF symbol, converting from external ELF form to
1066      internal ELF form, and then using the information to create a
1067      canonical bfd symbol table entry.
1068
1069      Note that we allocate the initial bfd canonical symbol buffer
1070      based on a one-to-one mapping of the ELF symbols to canonical
1071      symbols.  We actually use all the ELF symbols, so there will be no
1072      space left over at the end.  When we have all the symbols, we
1073      build the caller's pointer vector.  */
1074
1075   if (! dynamic)
1076     {
1077       hdr = &elf_tdata (abfd)->symtab_hdr;
1078       verhdr = NULL;
1079     }
1080   else
1081     {
1082       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1083       if (elf_dynversym (abfd) == 0)
1084         verhdr = NULL;
1085       else
1086         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1087       if ((elf_tdata (abfd)->dynverdef_section != 0
1088            && elf_tdata (abfd)->verdef == NULL)
1089           || (elf_tdata (abfd)->dynverref_section != 0
1090               && elf_tdata (abfd)->verref == NULL))
1091         {
1092           if (! _bfd_elf_slurp_version_tables (abfd))
1093             return -1;
1094         }
1095     }
1096
1097   ebd = get_elf_backend_data (abfd);
1098   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1099   if (symcount == 0)
1100     sym = symbase = NULL;
1101   else
1102     {
1103       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1104                                       NULL, NULL, NULL);
1105       if (isymbuf == NULL)
1106         return -1;
1107
1108       amt = symcount;
1109       amt *= sizeof (elf_symbol_type);
1110       symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1111       if (symbase == (elf_symbol_type *) NULL)
1112         goto error_return;
1113
1114       /* Read the raw ELF version symbol information.  */
1115       if (verhdr != NULL
1116           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1117         {
1118           (*_bfd_error_handler)
1119             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1120              abfd->filename,
1121              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1122              symcount);
1123
1124           /* Slurp in the symbols without the version information,
1125              since that is more helpful than just quitting.  */
1126           verhdr = NULL;
1127         }
1128
1129       if (verhdr != NULL)
1130         {
1131           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1132             goto error_return;
1133
1134           xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1135           if (xverbuf == NULL && verhdr->sh_size != 0)
1136             goto error_return;
1137
1138           if (bfd_bread ((PTR) xverbuf, verhdr->sh_size, abfd)
1139               != verhdr->sh_size)
1140             goto error_return;
1141         }
1142
1143       /* Skip first symbol, which is a null dummy.  */
1144       xver = xverbuf;
1145       if (xver != NULL)
1146         ++xver;
1147       isymend = isymbuf + symcount;
1148       for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1149         {
1150           memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1151           sym->symbol.the_bfd = abfd;
1152
1153           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1154                                                               hdr->sh_link,
1155                                                               isym->st_name);
1156
1157           sym->symbol.value = isym->st_value;
1158
1159           if (isym->st_shndx == SHN_UNDEF)
1160             {
1161               sym->symbol.section = bfd_und_section_ptr;
1162             }
1163           else if (isym->st_shndx < SHN_LORESERVE
1164                    || isym->st_shndx > SHN_HIRESERVE)
1165             {
1166               sym->symbol.section = section_from_elf_index (abfd,
1167                                                             isym->st_shndx);
1168               if (sym->symbol.section == NULL)
1169                 {
1170                   /* This symbol is in a section for which we did not
1171                      create a BFD section.  Just use bfd_abs_section,
1172                      although it is wrong.  FIXME.  */
1173                   sym->symbol.section = bfd_abs_section_ptr;
1174                 }
1175             }
1176           else if (isym->st_shndx == SHN_ABS)
1177             {
1178               sym->symbol.section = bfd_abs_section_ptr;
1179             }
1180           else if (isym->st_shndx == SHN_COMMON)
1181             {
1182               sym->symbol.section = bfd_com_section_ptr;
1183               /* Elf puts the alignment into the `value' field, and
1184                  the size into the `size' field.  BFD wants to see the
1185                  size in the value field, and doesn't care (at the
1186                  moment) about the alignment.  */
1187               sym->symbol.value = isym->st_size;
1188             }
1189           else
1190             sym->symbol.section = bfd_abs_section_ptr;
1191
1192           /* If this is a relocateable file, then the symbol value is
1193              already section relative.  */
1194           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1195             sym->symbol.value -= sym->symbol.section->vma;
1196
1197           switch (ELF_ST_BIND (isym->st_info))
1198             {
1199             case STB_LOCAL:
1200               sym->symbol.flags |= BSF_LOCAL;
1201               break;
1202             case STB_GLOBAL:
1203               if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1204                 sym->symbol.flags |= BSF_GLOBAL;
1205               break;
1206             case STB_WEAK:
1207               sym->symbol.flags |= BSF_WEAK;
1208               break;
1209             }
1210
1211           switch (ELF_ST_TYPE (isym->st_info))
1212             {
1213             case STT_SECTION:
1214               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1215               break;
1216             case STT_FILE:
1217               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1218               break;
1219             case STT_FUNC:
1220               sym->symbol.flags |= BSF_FUNCTION;
1221               break;
1222             case STT_OBJECT:
1223               sym->symbol.flags |= BSF_OBJECT;
1224               break;
1225             }
1226
1227           if (dynamic)
1228             sym->symbol.flags |= BSF_DYNAMIC;
1229
1230           if (xver != NULL)
1231             {
1232               Elf_Internal_Versym iversym;
1233
1234               _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1235               sym->version = iversym.vs_vers;
1236               xver++;
1237             }
1238
1239           /* Do some backend-specific processing on this symbol.  */
1240           if (ebd->elf_backend_symbol_processing)
1241             (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1242         }
1243     }
1244
1245   /* Do some backend-specific processing on this symbol table.  */
1246   if (ebd->elf_backend_symbol_table_processing)
1247     (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1248
1249   /* We rely on the zalloc to clear out the final symbol entry.  */
1250
1251   symcount = sym - symbase;
1252
1253   /* Fill in the user's symbol pointer vector if needed.  */
1254   if (symptrs)
1255     {
1256       long l = symcount;
1257
1258       sym = symbase;
1259       while (l-- > 0)
1260         {
1261           *symptrs++ = &sym->symbol;
1262           sym++;
1263         }
1264       *symptrs = 0;             /* Final null pointer */
1265     }
1266
1267   if (xverbuf != NULL)
1268     free (xverbuf);
1269   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1270     free (isymbuf);
1271   return symcount;
1272
1273 error_return:
1274   if (xverbuf != NULL)
1275     free (xverbuf);
1276   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1277     free (isymbuf);
1278   return -1;
1279 }
1280
1281 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1282    them.  */
1283
1284 static bfd_boolean
1285 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1286                                     relents, symbols, dynamic)
1287      bfd *abfd;
1288      asection *asect;
1289      Elf_Internal_Shdr *rel_hdr;
1290      bfd_size_type reloc_count;
1291      arelent *relents;
1292      asymbol **symbols;
1293      bfd_boolean dynamic;
1294 {
1295   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1296   PTR allocated = NULL;
1297   bfd_byte *native_relocs;
1298   arelent *relent;
1299   unsigned int i;
1300   int entsize;
1301   unsigned int symcount;
1302
1303   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
1304   if (allocated == NULL)
1305     goto error_return;
1306
1307   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1308       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1309           != rel_hdr->sh_size))
1310     goto error_return;
1311
1312   native_relocs = (bfd_byte *) allocated;
1313
1314   entsize = rel_hdr->sh_entsize;
1315   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1316               || entsize == sizeof (Elf_External_Rela));
1317
1318   if (dynamic)
1319     symcount = bfd_get_dynamic_symcount (abfd);
1320   else
1321     symcount = bfd_get_symcount (abfd);
1322
1323   for (i = 0, relent = relents;
1324        i < reloc_count;
1325        i++, relent++, native_relocs += entsize)
1326     {
1327       Elf_Internal_Rela rela;
1328
1329       if (entsize == sizeof (Elf_External_Rela))
1330         elf_swap_reloca_in (abfd, native_relocs, &rela);
1331       else
1332         elf_swap_reloc_in (abfd, native_relocs, &rela);
1333
1334       /* The address of an ELF reloc is section relative for an object
1335          file, and absolute for an executable file or shared library.
1336          The address of a normal BFD reloc is always section relative,
1337          and the address of a dynamic reloc is absolute..  */
1338       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1339         relent->address = rela.r_offset;
1340       else
1341         relent->address = rela.r_offset - asect->vma;
1342
1343       if (ELF_R_SYM (rela.r_info) == 0)
1344         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1345       else if (ELF_R_SYM (rela.r_info) > symcount)
1346         {
1347           (*_bfd_error_handler)
1348             (_("%s(%s): relocation %d has invalid symbol index %ld"),
1349              abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1350           relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1351         }
1352       else
1353         {
1354           asymbol **ps, *s;
1355
1356           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1357           s = *ps;
1358
1359           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1360           if ((s->flags & BSF_SECTION_SYM) == 0)
1361             relent->sym_ptr_ptr = ps;
1362           else
1363             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1364         }
1365
1366       relent->addend = rela.r_addend;
1367
1368       if (entsize == sizeof (Elf_External_Rela))
1369         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1370       else
1371         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1372     }
1373
1374   if (allocated != NULL)
1375     free (allocated);
1376
1377   return TRUE;
1378
1379  error_return:
1380   if (allocated != NULL)
1381     free (allocated);
1382   return FALSE;
1383 }
1384
1385 /* Read in and swap the external relocs.  */
1386
1387 bfd_boolean
1388 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1389      bfd *abfd;
1390      asection *asect;
1391      asymbol **symbols;
1392      bfd_boolean dynamic;
1393 {
1394   struct bfd_elf_section_data * const d = elf_section_data (asect);
1395   Elf_Internal_Shdr *rel_hdr;
1396   Elf_Internal_Shdr *rel_hdr2;
1397   bfd_size_type reloc_count;
1398   bfd_size_type reloc_count2;
1399   arelent *relents;
1400   bfd_size_type amt;
1401
1402   if (asect->relocation != NULL)
1403     return TRUE;
1404
1405   if (! dynamic)
1406     {
1407       if ((asect->flags & SEC_RELOC) == 0
1408           || asect->reloc_count == 0)
1409         return TRUE;
1410
1411       rel_hdr = &d->rel_hdr;
1412       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1413       rel_hdr2 = d->rel_hdr2;
1414       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1415
1416       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1417       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1418                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1419
1420     }
1421   else
1422     {
1423       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1424          case because relocations against this section may use the
1425          dynamic symbol table, and in that case bfd_section_from_shdr
1426          in elf.c does not update the RELOC_COUNT.  */
1427       if (asect->_raw_size == 0)
1428         return TRUE;
1429
1430       rel_hdr = &d->this_hdr;
1431       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1432       rel_hdr2 = NULL;
1433       reloc_count2 = 0;
1434     }
1435
1436   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1437   relents = (arelent *) bfd_alloc (abfd, amt);
1438   if (relents == NULL)
1439     return FALSE;
1440
1441   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1442                                            rel_hdr, reloc_count,
1443                                            relents,
1444                                            symbols, dynamic))
1445     return FALSE;
1446
1447   if (rel_hdr2
1448       && !elf_slurp_reloc_table_from_section (abfd, asect,
1449                                               rel_hdr2, reloc_count2,
1450                                               relents + reloc_count,
1451                                               symbols, dynamic))
1452     return FALSE;
1453
1454   asect->relocation = relents;
1455   return TRUE;
1456 }
1457
1458 #ifdef DEBUG
1459 static void
1460 elf_debug_section (num, hdr)
1461      int num;
1462      Elf_Internal_Shdr *hdr;
1463 {
1464   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1465            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1466            (long) hdr);
1467   fprintf (stderr,
1468            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1469            (long) hdr->sh_name,
1470            (long) hdr->sh_type,
1471            (long) hdr->sh_flags);
1472   fprintf (stderr,
1473            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1474            (long) hdr->sh_addr,
1475            (long) hdr->sh_offset,
1476            (long) hdr->sh_size);
1477   fprintf (stderr,
1478            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1479            (long) hdr->sh_link,
1480            (long) hdr->sh_info,
1481            (long) hdr->sh_addralign);
1482   fprintf (stderr, "sh_entsize   = %ld\n",
1483            (long) hdr->sh_entsize);
1484   fflush (stderr);
1485 }
1486
1487 static void
1488 elf_debug_file (ehdrp)
1489      Elf_Internal_Ehdr *ehdrp;
1490 {
1491   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1492   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1493   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1494   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1495   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1496   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1497   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1498 }
1499
1500 static char *
1501 elf_symbol_flags (flags)
1502      flagword flags;
1503 {
1504   static char buffer[1024];
1505
1506   buffer[0] = '\0';
1507   if (flags & BSF_LOCAL)
1508     strcat (buffer, " local");
1509
1510   if (flags & BSF_GLOBAL)
1511     strcat (buffer, " global");
1512
1513   if (flags & BSF_DEBUGGING)
1514     strcat (buffer, " debug");
1515
1516   if (flags & BSF_FUNCTION)
1517     strcat (buffer, " function");
1518
1519   if (flags & BSF_KEEP)
1520     strcat (buffer, " keep");
1521
1522   if (flags & BSF_KEEP_G)
1523     strcat (buffer, " keep_g");
1524
1525   if (flags & BSF_WEAK)
1526     strcat (buffer, " weak");
1527
1528   if (flags & BSF_SECTION_SYM)
1529     strcat (buffer, " section-sym");
1530
1531   if (flags & BSF_OLD_COMMON)
1532     strcat (buffer, " old-common");
1533
1534   if (flags & BSF_NOT_AT_END)
1535     strcat (buffer, " not-at-end");
1536
1537   if (flags & BSF_CONSTRUCTOR)
1538     strcat (buffer, " constructor");
1539
1540   if (flags & BSF_WARNING)
1541     strcat (buffer, " warning");
1542
1543   if (flags & BSF_INDIRECT)
1544     strcat (buffer, " indirect");
1545
1546   if (flags & BSF_FILE)
1547     strcat (buffer, " file");
1548
1549   if (flags & DYNAMIC)
1550     strcat (buffer, " dynamic");
1551
1552   if (flags & ~(BSF_LOCAL
1553                 | BSF_GLOBAL
1554                 | BSF_DEBUGGING
1555                 | BSF_FUNCTION
1556                 | BSF_KEEP
1557                 | BSF_KEEP_G
1558                 | BSF_WEAK
1559                 | BSF_SECTION_SYM
1560                 | BSF_OLD_COMMON
1561                 | BSF_NOT_AT_END
1562                 | BSF_CONSTRUCTOR
1563                 | BSF_WARNING
1564                 | BSF_INDIRECT
1565                 | BSF_FILE
1566                 | BSF_DYNAMIC))
1567     strcat (buffer, " unknown-bits");
1568
1569   return buffer;
1570 }
1571 #endif
1572 \f
1573 #include "elfcore.h"
1574 #include "elflink.h"
1575 \f
1576 /* Size-dependent data and functions.  */
1577 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1578   sizeof (Elf_External_Ehdr),
1579   sizeof (Elf_External_Phdr),
1580   sizeof (Elf_External_Shdr),
1581   sizeof (Elf_External_Rel),
1582   sizeof (Elf_External_Rela),
1583   sizeof (Elf_External_Sym),
1584   sizeof (Elf_External_Dyn),
1585   sizeof (Elf_External_Note),
1586   4,
1587   1,
1588   ARCH_SIZE, FILE_ALIGN,
1589   ELFCLASS, EV_CURRENT,
1590   elf_write_out_phdrs,
1591   elf_write_shdrs_and_ehdr,
1592   elf_write_relocs,
1593   elf_swap_symbol_in,
1594   elf_swap_symbol_out,
1595   elf_slurp_reloc_table,
1596   elf_slurp_symbol_table,
1597   elf_swap_dyn_in,
1598   elf_swap_dyn_out,
1599   elf_swap_reloc_in,
1600   elf_swap_reloc_out,
1601   elf_swap_reloca_in,
1602   elf_swap_reloca_out
1603 };