bfd/elfcode.h

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