bfd/elfcode.h

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