bfd/elfcode.h

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