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 boolean elf_slurp_reloc_table_from_section
 174   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
 175            arelent *, asymbol **, boolean));
 176
 177 static 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 INLINE void
 425 elf_swap_reloc_in (abfd, src, dst)
 426      bfd *abfd;
 427      const Elf_External_Rel *src;
 428      Elf_Internal_Rel *dst;
 429 {
 430   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 431   dst->r_info = H_GET_WORD (abfd, src->r_info);
 432 }
 433
 434 INLINE void
 435 elf_swap_reloca_in (abfd, src, dst)
 436      bfd *abfd;
 437      const Elf_External_Rela *src;
 438      Elf_Internal_Rela *dst;
 439 {
 440   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 441   dst->r_info = H_GET_WORD (abfd, src->r_info);
 442   dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
 443 }
 444
 445 /* Translate an ELF reloc from internal format to external format.  */
 446 INLINE void
 447 elf_swap_reloc_out (abfd, src, dst)
 448      bfd *abfd;
 449      const Elf_Internal_Rel *src;
 450      Elf_External_Rel *dst;
 451 {
 452   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 453   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 454 }
 455
 456 INLINE void
 457 elf_swap_reloca_out (abfd, src, dst)
 458      bfd *abfd;
 459      const Elf_Internal_Rela *src;
 460      Elf_External_Rela *dst;
 461 {
 462   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 463   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 464   H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
 465 }
 466
 467 INLINE void
 468 elf_swap_dyn_in (abfd, p, dst)
 469      bfd *abfd;
 470      const PTR p;
 471      Elf_Internal_Dyn *dst;
 472 {
 473   const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
 474
 475   dst->d_tag = H_GET_WORD (abfd, src->d_tag);
 476   dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
 477 }
 478
 479 INLINE void
 480 elf_swap_dyn_out (abfd, src, p)
 481      bfd *abfd;
 482      const Elf_Internal_Dyn *src;
 483      PTR p;
 484 {
 485   Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
 486
 487   H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
 488   H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
 489 }
 490 \f
 491 /* ELF .o/exec file reading */
 492
 493 /* Begin processing a given object.
 494
 495    First we validate the file by reading in the ELF header and checking
 496    the magic number.  */
 497
 498 static INLINE boolean
 499 elf_file_p (x_ehdrp)
 500      Elf_External_Ehdr *x_ehdrp;
 501 {
 502   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
 503           && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
 504           && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
 505           && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
 506 }
 507
 508 /* Check to see if the file associated with ABFD matches the target vector
 509    that ABFD points to.
 510
 511    Note that we may be called several times with the same ABFD, but different
 512    target vectors, most of which will not match.  We have to avoid leaving
 513    any side effects in ABFD, or any data it points to (like tdata), if the
 514    file does not match the target vector.  */
 515
 516 const bfd_target *
 517 elf_object_p (abfd)
 518      bfd *abfd;
 519 {
 520   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 521   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 522   Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
 523   Elf_Internal_Shdr i_shdr;
 524   Elf_Internal_Shdr *i_shdrp;   /* Section header table, internal form */
 525   unsigned int shindex;
 526   char *shstrtab;               /* Internal copy of section header stringtab */
 527   struct elf_backend_data *ebd;
 528   struct bfd_preserve preserve;
 529   asection *s;
 530   bfd_size_type amt;
 531
 532   preserve.marker = NULL;
 533
 534   /* Read in the ELF header in external format.  */
 535
 536   if (bfd_bread ((PTR) & x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
 537       != sizeof (x_ehdr))
 538     {
 539       if (bfd_get_error () != bfd_error_system_call)
 540         goto got_wrong_format_error;
 541       else
 542         goto got_no_match;
 543     }
 544
 545   /* Now check to see if we have a valid ELF file, and one that BFD can
 546      make use of.  The magic number must match, the address size ('class')
 547      and byte-swapping must match our XVEC entry, and it must have a
 548      section header table (FIXME: See comments re sections at top of this
 549      file).  */
 550
 551   if (! elf_file_p (&x_ehdr)
 552       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
 553       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 554     goto got_wrong_format_error;
 555
 556   /* Check that file's byte order matches xvec's */
 557   switch (x_ehdr.e_ident[EI_DATA])
 558     {
 559     case ELFDATA2MSB:           /* Big-endian */
 560       if (! bfd_header_big_endian (abfd))
 561         goto got_wrong_format_error;
 562       break;
 563     case ELFDATA2LSB:           /* Little-endian */
 564       if (! bfd_header_little_endian (abfd))
 565         goto got_wrong_format_error;
 566       break;
 567     case ELFDATANONE:           /* No data encoding specified */
 568     default:                    /* Unknown data encoding specified */
 569       goto got_wrong_format_error;
 570     }
 571
 572   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
 573      the tdata pointer in the bfd.  */
 574
 575   amt = sizeof (struct elf_obj_tdata);
 576   preserve.marker = bfd_zalloc (abfd, amt);
 577   if (preserve.marker == NULL)
 578     goto got_no_match;
 579   if (!bfd_preserve_save (abfd, &preserve))
 580     goto got_no_match;
 581
 582   elf_tdata (abfd) = preserve.marker;
 583
 584   /* Now that we know the byte order, swap in the rest of the header */
 585   i_ehdrp = elf_elfheader (abfd);
 586   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 587 #if DEBUG & 1
 588   elf_debug_file (i_ehdrp);
 589 #endif
 590
 591   /* Reject ET_CORE (header indicates core file, not object file) */
 592   if (i_ehdrp->e_type == ET_CORE)
 593     goto got_wrong_format_error;
 594
 595   /* If this is a relocatable file and there is no section header
 596      table, then we're hosed.  */
 597   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
 598     goto got_wrong_format_error;
 599
 600   /* As a simple sanity check, verify that the what BFD thinks is the
 601      size of each section header table entry actually matches the size
 602      recorded in the file, but only if there are any sections.  */
 603   if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
 604     goto got_wrong_format_error;
 605
 606   /* Further sanity check.  */
 607   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
 608     goto got_wrong_format_error;
 609
 610   ebd = get_elf_backend_data (abfd);
 611
 612   /* Check that the ELF e_machine field matches what this particular
 613      BFD format expects.  */
 614   if (ebd->elf_machine_code != i_ehdrp->e_machine
 615       && (ebd->elf_machine_alt1 == 0
 616           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 617       && (ebd->elf_machine_alt2 == 0
 618           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 619     {
 620       const bfd_target * const *target_ptr;
 621
 622       if (ebd->elf_machine_code != EM_NONE)
 623         goto got_wrong_format_error;
 624
 625       /* This is the generic ELF target.  Let it match any ELF target
 626          for which we do not have a specific backend.  */
 627       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 628         {
 629           struct elf_backend_data *back;
 630
 631           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 632             continue;
 633           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 634           if (back->elf_machine_code == i_ehdrp->e_machine
 635               || (back->elf_machine_alt1 != 0
 636                   && back->elf_machine_alt1 == i_ehdrp->e_machine)
 637               || (back->elf_machine_alt2 != 0
 638                   && back->elf_machine_alt2 == i_ehdrp->e_machine))
 639             {
 640               /* target_ptr is an ELF backend which matches this
 641                  object file, so reject the generic ELF target.  */
 642               goto got_wrong_format_error;
 643             }
 644         }
 645     }
 646
 647   if (i_ehdrp->e_type == ET_EXEC)
 648     abfd->flags |= EXEC_P;
 649   else if (i_ehdrp->e_type == ET_DYN)
 650     abfd->flags |= DYNAMIC;
 651
 652   if (i_ehdrp->e_phnum > 0)
 653     abfd->flags |= D_PAGED;
 654
 655   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 656     {
 657       /* It's OK if this fails for the generic target.  */
 658       if (ebd->elf_machine_code != EM_NONE)
 659         goto got_no_match;
 660     }
 661
 662   /* Remember the entry point specified in the ELF file header.  */
 663   bfd_set_start_address (abfd, i_ehdrp->e_entry);
 664
 665   if (i_ehdrp->e_shoff != 0)
 666     {
 667       /* Seek to the section header table in the file.  */
 668       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
 669         goto got_no_match;
 670
 671       /* Read the first section header at index 0, and convert to internal
 672          form.  */
 673       if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
 674           != sizeof (x_shdr))
 675         goto got_no_match;
 676       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
 677
 678       /* If the section count is zero, the actual count is in the first
 679          section header.  */
 680       if (i_ehdrp->e_shnum == SHN_UNDEF)
 681         i_ehdrp->e_shnum = i_shdr.sh_size;
 682
 683       /* And similarly for the string table index.  */
 684       if (i_ehdrp->e_shstrndx == SHN_XINDEX)
 685         i_ehdrp->e_shstrndx = i_shdr.sh_link;
 686     }
 687
 688   /* Allocate space for a copy of the section header table in
 689      internal form.  */
 690   if (i_ehdrp->e_shnum != 0)
 691     {
 692       Elf_Internal_Shdr *shdrp;
 693       unsigned int num_sec;
 694
 695       amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
 696       i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
 697       if (!i_shdrp)
 698         goto got_no_match;
 699       num_sec = i_ehdrp->e_shnum;
 700       if (num_sec > SHN_LORESERVE)
 701         num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 702       elf_numsections (abfd) = num_sec;
 703       amt = sizeof (i_shdrp) * num_sec;
 704       elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
 705       if (!elf_elfsections (abfd))
 706         goto got_no_match;
 707
 708       memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
 709       shdrp = i_shdrp;
 710       shindex = 0;
 711       if (num_sec > SHN_LORESERVE)
 712         {
 713           for ( ; shindex < SHN_LORESERVE; shindex++)
 714             elf_elfsections (abfd)[shindex] = shdrp++;
 715           for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
 716             elf_elfsections (abfd)[shindex] = i_shdrp;
 717         }
 718       for ( ; shindex < num_sec; shindex++)
 719         elf_elfsections (abfd)[shindex] = shdrp++;
 720
 721       /* Read in the rest of the section header table and convert it
 722          to internal form.  */
 723       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 724         {
 725           if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
 726               != sizeof (x_shdr))
 727             goto got_no_match;
 728           elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 729
 730           /* If the section is loaded, but not page aligned, clear
 731              D_PAGED.  */
 732           if (i_shdrp[shindex].sh_size != 0
 733               && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
 734               && i_shdrp[shindex].sh_type != SHT_NOBITS
 735               && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
 736                    % ebd->maxpagesize)
 737                   != 0))
 738             abfd->flags &= ~D_PAGED;
 739         }
 740     }
 741
 742   if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff)
 743     {
 744       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 745         goto got_no_match;
 746     }
 747
 748   /* Read in the program headers.  */
 749   if (i_ehdrp->e_phnum == 0)
 750     elf_tdata (abfd)->phdr = NULL;
 751   else
 752     {
 753       Elf_Internal_Phdr *i_phdr;
 754       unsigned int i;
 755
 756       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
 757       elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 758       if (elf_tdata (abfd)->phdr == NULL)
 759         goto got_no_match;
 760       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 761         goto got_no_match;
 762       i_phdr = elf_tdata (abfd)->phdr;
 763       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
 764         {
 765           Elf_External_Phdr x_phdr;
 766
 767           if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
 768               != sizeof x_phdr)
 769             goto got_no_match;
 770           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
 771         }
 772     }
 773
 774   /* Read in the string table containing the names of the sections.  We
 775      will need the base pointer to this table later.  */
 776   /* We read this inline now, so that we don't have to go through
 777      bfd_section_from_shdr with it (since this particular strtab is
 778      used to find all of the ELF section names.) */
 779
 780   if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff)
 781     {
 782       unsigned int num_sec;
 783
 784       shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 785       if (!shstrtab)
 786         goto got_no_match;
 787
 788       /* Once all of the section headers have been read and converted, we
 789          can start processing them.  Note that the first section header is
 790          a dummy placeholder entry, so we ignore it.  */
 791       num_sec = elf_numsections (abfd);
 792       for (shindex = 1; shindex < num_sec; shindex++)
 793         {
 794           if (! bfd_section_from_shdr (abfd, shindex))
 795             goto got_no_match;
 796           if (shindex == SHN_LORESERVE - 1)
 797             shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 798         }
 799     }
 800
 801   /* Let the backend double check the format and override global
 802      information.  */
 803   if (ebd->elf_backend_object_p)
 804     {
 805       if (! (*ebd->elf_backend_object_p) (abfd))
 806         goto got_wrong_format_error;
 807     }
 808
 809   /* If we have created any reloc sections that are associated with
 810      debugging sections, mark the reloc sections as debugging as well.  */
 811   for (s = abfd->sections; s != NULL; s = s->next)
 812     {
 813       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 814            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 815           && elf_section_data (s)->this_hdr.sh_info > 0)
 816         {
 817           unsigned long targ_index;
 818           asection *targ_sec;
 819
 820           targ_index = elf_section_data (s)->this_hdr.sh_info;
 821           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 822           if (targ_sec != NULL
 823               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 824             s->flags |= SEC_DEBUGGING;
 825         }
 826     }
 827
 828   bfd_preserve_finish (abfd, &preserve);
 829   return abfd->xvec;
 830
 831  got_wrong_format_error:
 832   /* There is way too much undoing of half-known state here.  The caller,
 833      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 834      check match/no-match like it does.  We have to rely on that a call to
 835      bfd_default_set_arch_mach with the previously known mach, undoes what
 836      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 837      For this to work, only elf-data and the mach may be changed by the
 838      target-specific elf_backend_object_p function.  Note that saving the
 839      whole bfd here and restoring it would be even worse; the first thing
 840      you notice is that the cached bfd file position gets out of sync.  */
 841   bfd_set_error (bfd_error_wrong_format);
 842
 843  got_no_match:
 844   abfd->arch_info = preserve.arch_info;
 845   if (preserve.marker != NULL)
 846     bfd_preserve_restore (abfd, &preserve);
 847   return NULL;
 848 }
 849 \f
 850 /* ELF .o/exec file writing */
 851
 852 /* Write out the relocs.  */
 853
 854 void
 855 elf_write_relocs (abfd, sec, data)
 856      bfd *abfd;
 857      asection *sec;
 858      PTR data;
 859 {
 860   boolean *failedp = (boolean *) data;
 861   Elf_Internal_Shdr *rela_hdr;
 862   Elf_External_Rela *outbound_relocas;
 863   Elf_External_Rel *outbound_relocs;
 864   unsigned int idx;
 865   int use_rela_p;
 866   asymbol *last_sym = 0;
 867   int last_sym_idx = 0;
 868
 869   /* If we have already failed, don't do anything.  */
 870   if (*failedp)
 871     return;
 872
 873   if ((sec->flags & SEC_RELOC) == 0)
 874     return;
 875
 876   /* The linker backend writes the relocs out itself, and sets the
 877      reloc_count field to zero to inhibit writing them here.  Also,
 878      sometimes the SEC_RELOC flag gets set even when there aren't any
 879      relocs.  */
 880   if (sec->reloc_count == 0)
 881     return;
 882
 883   rela_hdr = &elf_section_data (sec)->rel_hdr;
 884
 885   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 886   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
 887   if (rela_hdr->contents == NULL)
 888     {
 889       *failedp = true;
 890       return;
 891     }
 892
 893   /* Figure out whether the relocations are RELA or REL relocations.  */
 894   if (rela_hdr->sh_type == SHT_RELA)
 895     use_rela_p = true;
 896   else if (rela_hdr->sh_type == SHT_REL)
 897     use_rela_p = false;
 898   else
 899     /* Every relocation section should be either an SHT_RELA or an
 900        SHT_REL section.  */
 901     abort ();
 902
 903   /* orelocation has the data, reloc_count has the count...  */
 904   if (use_rela_p)
 905     {
 906       outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
 907
 908       for (idx = 0; idx < sec->reloc_count; idx++)
 909         {
 910           Elf_Internal_Rela dst_rela;
 911           Elf_External_Rela *src_rela;
 912           arelent *ptr;
 913           asymbol *sym;
 914           int n;
 915
 916           ptr = sec->orelocation[idx];
 917           src_rela = outbound_relocas + idx;
 918
 919           /* The address of an ELF reloc is section relative for an object
 920              file, and absolute for an executable file or shared library.
 921              The address of a BFD reloc is always section relative.  */
 922           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 923             dst_rela.r_offset = ptr->address;
 924           else
 925             dst_rela.r_offset = ptr->address + sec->vma;
 926
 927           sym = *ptr->sym_ptr_ptr;
 928           if (sym == last_sym)
 929             n = last_sym_idx;
 930           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 931             n = STN_UNDEF;
 932           else
 933             {
 934               last_sym = sym;
 935               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 936               if (n < 0)
 937                 {
 938                   *failedp = true;
 939                   return;
 940                 }
 941               last_sym_idx = n;
 942             }
 943
 944           if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 945               && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 946               && ! _bfd_elf_validate_reloc (abfd, ptr))
 947             {
 948               *failedp = true;
 949               return;
 950             }
 951
 952           dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 953
 954           dst_rela.r_addend = ptr->addend;
 955           elf_swap_reloca_out (abfd, &dst_rela, src_rela);
 956         }
 957     }
 958   else
 959     /* REL relocations */
 960     {
 961       outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
 962
 963       for (idx = 0; idx < sec->reloc_count; idx++)
 964         {
 965           Elf_Internal_Rel dst_rel;
 966           Elf_External_Rel *src_rel;
 967           arelent *ptr;
 968           int n;
 969           asymbol *sym;
 970
 971           ptr = sec->orelocation[idx];
 972           sym = *ptr->sym_ptr_ptr;
 973           src_rel = outbound_relocs + idx;
 974
 975           /* The address of an ELF reloc is section relative for an object
 976              file, and absolute for an executable file or shared library.
 977              The address of a BFD reloc is always section relative.  */
 978           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 979             dst_rel.r_offset = ptr->address;
 980           else
 981             dst_rel.r_offset = ptr->address + sec->vma;
 982
 983           if (sym == last_sym)
 984             n = last_sym_idx;
 985           else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 986             n = STN_UNDEF;
 987           else
 988             {
 989               last_sym = sym;
 990               n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 991               if (n < 0)
 992                 {
 993                   *failedp = true;
 994                   return;
 995                 }
 996               last_sym_idx = n;
 997             }
 998
 999           if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
1000               && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
1001               && ! _bfd_elf_validate_reloc (abfd, ptr))
1002             {
1003               *failedp = true;
1004               return;
1005             }
1006
1007           dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
1008
1009           elf_swap_reloc_out (abfd, &dst_rel, src_rel);
1010         }
1011     }
1012 }
1013
1014 /* Write out the program headers.  */
1015
1016 int
1017 elf_write_out_phdrs (abfd, phdr, count)
1018      bfd *abfd;
1019      const Elf_Internal_Phdr *phdr;
1020      unsigned int count;
1021 {
1022   while (count--)
1023     {
1024       Elf_External_Phdr extphdr;
1025       elf_swap_phdr_out (abfd, phdr, &extphdr);
1026       if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
1027                      abfd) != sizeof (Elf_External_Phdr))
1028         return -1;
1029       phdr++;
1030     }
1031   return 0;
1032 }
1033
1034 /* Write out the section headers and the ELF file header.  */
1035
1036 boolean
1037 elf_write_shdrs_and_ehdr (abfd)
1038      bfd *abfd;
1039 {
1040   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1041   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
1042   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
1043   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
1044   unsigned int count;
1045   bfd_size_type amt;
1046
1047   i_ehdrp = elf_elfheader (abfd);
1048   i_shdrp = elf_elfsections (abfd);
1049
1050   /* swap the header before spitting it out...  */
1051
1052 #if DEBUG & 1
1053   elf_debug_file (i_ehdrp);
1054 #endif
1055   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1056   amt = sizeof (x_ehdr);
1057   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1058       || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
1059     return false;
1060
1061   /* Some fields in the first section header handle overflow of ehdr
1062      fields.  */
1063   if (i_ehdrp->e_shnum >= SHN_LORESERVE)
1064     i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1065   if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
1066     i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1067
1068   /* at this point we've concocted all the ELF sections...  */
1069   amt = i_ehdrp->e_shnum;
1070   amt *= sizeof (*x_shdrp);
1071   x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1072   if (!x_shdrp)
1073     return false;
1074
1075   for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1076     {
1077 #if DEBUG & 2
1078       elf_debug_section (count, *i_shdrp);
1079 #endif
1080       elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1081
1082       if (count == SHN_LORESERVE - 1)
1083         i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
1084     }
1085   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1086       || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
1087     return false;
1088
1089   /* need to dump the string table too...  */
1090
1091   return true;
1092 }
1093
1094 long
1095 elf_slurp_symbol_table (abfd, symptrs, dynamic)
1096      bfd *abfd;
1097      asymbol **symptrs;         /* Buffer for generated bfd symbols */
1098      boolean dynamic;
1099 {
1100   Elf_Internal_Shdr *hdr;
1101   Elf_Internal_Shdr *verhdr;
1102   unsigned long symcount;       /* Number of external ELF symbols */
1103   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1104   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1105   Elf_Internal_Sym *isym;
1106   Elf_Internal_Sym *isymend;
1107   Elf_Internal_Sym *isymbuf = NULL;
1108   Elf_External_Versym *xver;
1109   Elf_External_Versym *xverbuf = NULL;
1110   struct elf_backend_data *ebd;
1111   bfd_size_type amt;
1112
1113   /* Read each raw ELF symbol, converting from external ELF form to
1114      internal ELF form, and then using the information to create a
1115      canonical bfd symbol table entry.
1116
1117      Note that we allocate the initial bfd canonical symbol buffer
1118      based on a one-to-one mapping of the ELF symbols to canonical
1119      symbols.  We actually use all the ELF symbols, so there will be no
1120      space left over at the end.  When we have all the symbols, we
1121      build the caller's pointer vector.  */
1122
1123   if (! dynamic)
1124     {
1125       hdr = &elf_tdata (abfd)->symtab_hdr;
1126       verhdr = NULL;
1127     }
1128   else
1129     {
1130       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1131       if (elf_dynversym (abfd) == 0)
1132         verhdr = NULL;
1133       else
1134         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1135       if ((elf_tdata (abfd)->dynverdef_section != 0
1136            && elf_tdata (abfd)->verdef == NULL)
1137           || (elf_tdata (abfd)->dynverref_section != 0
1138               && elf_tdata (abfd)->verref == NULL))
1139         {
1140           if (! _bfd_elf_slurp_version_tables (abfd))
1141             return -1;
1142         }
1143     }
1144
1145   ebd = get_elf_backend_data (abfd);
1146   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1147   if (symcount == 0)
1148     sym = symbase = NULL;
1149   else
1150     {
1151       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1152                                       NULL, NULL, NULL);
1153       if (isymbuf == NULL)
1154         return -1;
1155
1156       amt = symcount;
1157       amt *= sizeof (elf_symbol_type);
1158       symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1159       if (symbase == (elf_symbol_type *) NULL)
1160         goto error_return;
1161
1162       /* Read the raw ELF version symbol information.  */
1163       if (verhdr != NULL
1164           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1165         {
1166           (*_bfd_error_handler)
1167             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1168              abfd->filename,
1169              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1170              symcount);
1171
1172           /* Slurp in the symbols without the version information,
1173              since that is more helpful than just quitting.  */
1174           verhdr = NULL;
1175         }
1176
1177       if (verhdr != NULL)
1178         {
1179           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1180             goto error_return;
1181
1182           xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1183           if (xverbuf == NULL && verhdr->sh_size != 0)
1184             goto error_return;
1185
1186           if (bfd_bread ((PTR) xverbuf, verhdr->sh_size, abfd)
1187               != verhdr->sh_size)
1188             goto error_return;
1189         }
1190
1191       /* Skip first symbol, which is a null dummy.  */
1192       xver = xverbuf;
1193       if (xver != NULL)
1194         ++xver;
1195       isymend = isymbuf + symcount;
1196       for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1197         {
1198           memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1199           sym->symbol.the_bfd = abfd;
1200
1201           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1202                                                               hdr->sh_link,
1203                                                               isym->st_name);
1204
1205           sym->symbol.value = isym->st_value;
1206
1207           if (isym->st_shndx == SHN_UNDEF)
1208             {
1209               sym->symbol.section = bfd_und_section_ptr;
1210             }
1211           else if (isym->st_shndx < SHN_LORESERVE
1212                    || isym->st_shndx > SHN_HIRESERVE)
1213             {
1214               sym->symbol.section = section_from_elf_index (abfd,
1215                                                             isym->st_shndx);
1216               if (sym->symbol.section == NULL)
1217                 {
1218                   /* This symbol is in a section for which we did not
1219                      create a BFD section.  Just use bfd_abs_section,
1220                      although it is wrong.  FIXME.  */
1221                   sym->symbol.section = bfd_abs_section_ptr;
1222                 }
1223             }
1224           else if (isym->st_shndx == SHN_ABS)
1225             {
1226               sym->symbol.section = bfd_abs_section_ptr;
1227             }
1228           else if (isym->st_shndx == SHN_COMMON)
1229             {
1230               sym->symbol.section = bfd_com_section_ptr;
1231               /* Elf puts the alignment into the `value' field, and
1232                  the size into the `size' field.  BFD wants to see the
1233                  size in the value field, and doesn't care (at the
1234                  moment) about the alignment.  */
1235               sym->symbol.value = isym->st_size;
1236             }
1237           else
1238             sym->symbol.section = bfd_abs_section_ptr;
1239
1240           /* If this is a relocateable file, then the symbol value is
1241              already section relative.  */
1242           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1243             sym->symbol.value -= sym->symbol.section->vma;
1244
1245           switch (ELF_ST_BIND (isym->st_info))
1246             {
1247             case STB_LOCAL:
1248               sym->symbol.flags |= BSF_LOCAL;
1249               break;
1250             case STB_GLOBAL:
1251               if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1252                 sym->symbol.flags |= BSF_GLOBAL;
1253               break;
1254             case STB_WEAK:
1255               sym->symbol.flags |= BSF_WEAK;
1256               break;
1257             }
1258
1259           switch (ELF_ST_TYPE (isym->st_info))
1260             {
1261             case STT_SECTION:
1262               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1263               break;
1264             case STT_FILE:
1265               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1266               break;
1267             case STT_FUNC:
1268               sym->symbol.flags |= BSF_FUNCTION;
1269               break;
1270             case STT_OBJECT:
1271               sym->symbol.flags |= BSF_OBJECT;
1272               break;
1273             }
1274
1275           if (dynamic)
1276             sym->symbol.flags |= BSF_DYNAMIC;
1277
1278           if (xver != NULL)
1279             {
1280               Elf_Internal_Versym iversym;
1281
1282               _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1283               sym->version = iversym.vs_vers;
1284               xver++;
1285             }
1286
1287           /* Do some backend-specific processing on this symbol.  */
1288           if (ebd->elf_backend_symbol_processing)
1289             (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1290         }
1291     }
1292
1293   /* Do some backend-specific processing on this symbol table.  */
1294   if (ebd->elf_backend_symbol_table_processing)
1295     (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1296
1297   /* We rely on the zalloc to clear out the final symbol entry.  */
1298
1299   symcount = sym - symbase;
1300
1301   /* Fill in the user's symbol pointer vector if needed.  */
1302   if (symptrs)
1303     {
1304       long l = symcount;
1305
1306       sym = symbase;
1307       while (l-- > 0)
1308         {
1309           *symptrs++ = &sym->symbol;
1310           sym++;
1311         }
1312       *symptrs = 0;             /* Final null pointer */
1313     }
1314
1315   if (xverbuf != NULL)
1316     free (xverbuf);
1317   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1318     free (isymbuf);
1319   return symcount;
1320
1321 error_return:
1322   if (xverbuf != NULL)
1323     free (xverbuf);
1324   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1325     free (isymbuf);
1326   return -1;
1327 }
1328
1329 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1330    them.  */
1331
1332 static boolean
1333 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1334                                     relents, symbols, dynamic)
1335      bfd *abfd;
1336      asection *asect;
1337      Elf_Internal_Shdr *rel_hdr;
1338      bfd_size_type reloc_count;
1339      arelent *relents;
1340      asymbol **symbols;
1341      boolean dynamic;
1342 {
1343   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1344   PTR allocated = NULL;
1345   bfd_byte *native_relocs;
1346   arelent *relent;
1347   unsigned int i;
1348   int entsize;
1349   unsigned int symcount;
1350
1351   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
1352   if (allocated == NULL)
1353     goto error_return;
1354
1355   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1356       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1357           != rel_hdr->sh_size))
1358     goto error_return;
1359
1360   native_relocs = (bfd_byte *) allocated;
1361
1362   entsize = rel_hdr->sh_entsize;
1363   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1364               || entsize == sizeof (Elf_External_Rela));
1365
1366   if (dynamic)
1367     symcount = bfd_get_dynamic_symcount (abfd);
1368   else
1369     symcount = bfd_get_symcount (abfd);
1370
1371   for (i = 0, relent = relents;
1372        i < reloc_count;
1373        i++, relent++, native_relocs += entsize)
1374     {
1375       Elf_Internal_Rela rela;
1376       Elf_Internal_Rel rel;
1377
1378       if (entsize == sizeof (Elf_External_Rela))
1379         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1380       else
1381         {
1382           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1383           rela.r_offset = rel.r_offset;
1384           rela.r_info = rel.r_info;
1385           rela.r_addend = 0;
1386         }
1387
1388       /* The address of an ELF reloc is section relative for an object
1389          file, and absolute for an executable file or shared library.
1390          The address of a normal BFD reloc is always section relative,
1391          and the address of a dynamic reloc is absolute..  */
1392       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1393         relent->address = rela.r_offset;
1394       else
1395         relent->address = rela.r_offset - asect->vma;
1396
1397       if (ELF_R_SYM (rela.r_info) == 0)
1398         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1399       else if (ELF_R_SYM (rela.r_info) > symcount)
1400         {
1401           (*_bfd_error_handler)
1402             (_("%s(%s): relocation %d has invalid symbol index %ld"),
1403              abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1404           relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1405         }
1406       else
1407         {
1408           asymbol **ps, *s;
1409
1410           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1411           s = *ps;
1412
1413           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1414           if ((s->flags & BSF_SECTION_SYM) == 0)
1415             relent->sym_ptr_ptr = ps;
1416           else
1417             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1418         }
1419
1420       relent->addend = rela.r_addend;
1421
1422       if (entsize == sizeof (Elf_External_Rela))
1423         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1424       else
1425         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1426     }
1427
1428   if (allocated != NULL)
1429     free (allocated);
1430
1431   return true;
1432
1433  error_return:
1434   if (allocated != NULL)
1435     free (allocated);
1436   return false;
1437 }
1438
1439 /* Read in and swap the external relocs.  */
1440
1441 boolean
1442 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1443      bfd *abfd;
1444      asection *asect;
1445      asymbol **symbols;
1446      boolean dynamic;
1447 {
1448   struct bfd_elf_section_data * const d = elf_section_data (asect);
1449   Elf_Internal_Shdr *rel_hdr;
1450   Elf_Internal_Shdr *rel_hdr2;
1451   bfd_size_type reloc_count;
1452   bfd_size_type reloc_count2;
1453   arelent *relents;
1454   bfd_size_type amt;
1455
1456   if (asect->relocation != NULL)
1457     return true;
1458
1459   if (! dynamic)
1460     {
1461       if ((asect->flags & SEC_RELOC) == 0
1462           || asect->reloc_count == 0)
1463         return true;
1464
1465       rel_hdr = &d->rel_hdr;
1466       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1467       rel_hdr2 = d->rel_hdr2;
1468       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1469
1470       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1471       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1472                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1473
1474     }
1475   else
1476     {
1477       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1478          case because relocations against this section may use the
1479          dynamic symbol table, and in that case bfd_section_from_shdr
1480          in elf.c does not update the RELOC_COUNT.  */
1481       if (asect->_raw_size == 0)
1482         return true;
1483
1484       rel_hdr = &d->this_hdr;
1485       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1486       rel_hdr2 = NULL;
1487       reloc_count2 = 0;
1488     }
1489
1490   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1491   relents = (arelent *) bfd_alloc (abfd, amt);
1492   if (relents == NULL)
1493     return false;
1494
1495   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1496                                            rel_hdr, reloc_count,
1497                                            relents,
1498                                            symbols, dynamic))
1499     return false;
1500
1501   if (rel_hdr2
1502       && !elf_slurp_reloc_table_from_section (abfd, asect,
1503                                               rel_hdr2, reloc_count2,
1504                                               relents + reloc_count,
1505                                               symbols, dynamic))
1506     return false;
1507
1508   asect->relocation = relents;
1509   return true;
1510 }
1511
1512 #ifdef DEBUG
1513 static void
1514 elf_debug_section (num, hdr)
1515      int num;
1516      Elf_Internal_Shdr *hdr;
1517 {
1518   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1519            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1520            (long) hdr);
1521   fprintf (stderr,
1522            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1523            (long) hdr->sh_name,
1524            (long) hdr->sh_type,
1525            (long) hdr->sh_flags);
1526   fprintf (stderr,
1527            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1528            (long) hdr->sh_addr,
1529            (long) hdr->sh_offset,
1530            (long) hdr->sh_size);
1531   fprintf (stderr,
1532            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1533            (long) hdr->sh_link,
1534            (long) hdr->sh_info,
1535            (long) hdr->sh_addralign);
1536   fprintf (stderr, "sh_entsize   = %ld\n",
1537            (long) hdr->sh_entsize);
1538   fflush (stderr);
1539 }
1540
1541 static void
1542 elf_debug_file (ehdrp)
1543      Elf_Internal_Ehdr *ehdrp;
1544 {
1545   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1546   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1547   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1548   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1549   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1550   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1551   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1552 }
1553
1554 static char *
1555 elf_symbol_flags (flags)
1556      flagword flags;
1557 {
1558   static char buffer[1024];
1559
1560   buffer[0] = '\0';
1561   if (flags & BSF_LOCAL)
1562     strcat (buffer, " local");
1563
1564   if (flags & BSF_GLOBAL)
1565     strcat (buffer, " global");
1566
1567   if (flags & BSF_DEBUGGING)
1568     strcat (buffer, " debug");
1569
1570   if (flags & BSF_FUNCTION)
1571     strcat (buffer, " function");
1572
1573   if (flags & BSF_KEEP)
1574     strcat (buffer, " keep");
1575
1576   if (flags & BSF_KEEP_G)
1577     strcat (buffer, " keep_g");
1578
1579   if (flags & BSF_WEAK)
1580     strcat (buffer, " weak");
1581
1582   if (flags & BSF_SECTION_SYM)
1583     strcat (buffer, " section-sym");
1584
1585   if (flags & BSF_OLD_COMMON)
1586     strcat (buffer, " old-common");
1587
1588   if (flags & BSF_NOT_AT_END)
1589     strcat (buffer, " not-at-end");
1590
1591   if (flags & BSF_CONSTRUCTOR)
1592     strcat (buffer, " constructor");
1593
1594   if (flags & BSF_WARNING)
1595     strcat (buffer, " warning");
1596
1597   if (flags & BSF_INDIRECT)
1598     strcat (buffer, " indirect");
1599
1600   if (flags & BSF_FILE)
1601     strcat (buffer, " file");
1602
1603   if (flags & DYNAMIC)
1604     strcat (buffer, " dynamic");
1605
1606   if (flags & ~(BSF_LOCAL
1607                 | BSF_GLOBAL
1608                 | BSF_DEBUGGING
1609                 | BSF_FUNCTION
1610                 | BSF_KEEP
1611                 | BSF_KEEP_G
1612                 | BSF_WEAK
1613                 | BSF_SECTION_SYM
1614                 | BSF_OLD_COMMON
1615                 | BSF_NOT_AT_END
1616                 | BSF_CONSTRUCTOR
1617                 | BSF_WARNING
1618                 | BSF_INDIRECT
1619                 | BSF_FILE
1620                 | BSF_DYNAMIC))
1621     strcat (buffer, " unknown-bits");
1622
1623   return buffer;
1624 }
1625 #endif
1626 \f
1627 #include "elfcore.h"
1628 #include "elflink.h"
1629 \f
1630 /* Size-dependent data and functions.  */
1631 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1632   sizeof (Elf_External_Ehdr),
1633   sizeof (Elf_External_Phdr),
1634   sizeof (Elf_External_Shdr),
1635   sizeof (Elf_External_Rel),
1636   sizeof (Elf_External_Rela),
1637   sizeof (Elf_External_Sym),
1638   sizeof (Elf_External_Dyn),
1639   sizeof (Elf_External_Note),
1640   4,
1641   1,
1642   ARCH_SIZE, FILE_ALIGN,
1643   ELFCLASS, EV_CURRENT,
1644   elf_write_out_phdrs,
1645   elf_write_shdrs_and_ehdr,
1646   elf_write_relocs,
1647   elf_swap_symbol_in,
1648   elf_swap_symbol_out,
1649   elf_slurp_reloc_table,
1650   elf_slurp_symbol_table,
1651   elf_swap_dyn_in,
1652   elf_swap_dyn_out,
1653   NULL,
1654   NULL,
1655   NULL,
1656   NULL
1657 };