home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / binutils-2.7-src.tgz / tar.out / fsf / binutils / bfd / elfcode.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  41KB  |  1,320 lines
  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. extern struct bfd_strtab_hash *_bfd_elf_stringtab_init PARAMS ((void));
  158. #define section_from_elf_index bfd_section_from_elf_index
  159. extern boolean bfd_section_from_phdr PARAMS ((bfd *, Elf_Internal_Phdr *,
  160.                           int));
  161.  
  162. static boolean elf_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
  163.  
  164. static void write_relocs PARAMS ((bfd *, asection *, PTR));
  165.  
  166. #ifdef DEBUG
  167. static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
  168. static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
  169. static char *elf_symbol_flags PARAMS ((flagword));
  170. #endif
  171.  
  172. /* Structure swapping routines */
  173.  
  174. /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
  175.    can be handled by explicitly specifying 32 bits or "the long type".  */
  176. #if ARCH_SIZE == 64
  177. #define put_word    bfd_h_put_64
  178. #define get_word    bfd_h_get_64
  179. #endif
  180. #if ARCH_SIZE == 32
  181. #define put_word    bfd_h_put_32
  182. #define get_word    bfd_h_get_32
  183. #endif
  184.  
  185. /* Translate an ELF symbol in external format into an ELF symbol in internal
  186.    format. */
  187.  
  188. void
  189. elf_swap_symbol_in (abfd, src, dst)
  190.      bfd *abfd;
  191.      const Elf_External_Sym *src;
  192.      Elf_Internal_Sym *dst;
  193. {
  194.   dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
  195.   dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
  196.   dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
  197.   dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
  198.   dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
  199.   dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
  200. }
  201.  
  202. /* Translate an ELF symbol in internal format into an ELF symbol in external
  203.    format. */
  204.  
  205. void
  206. elf_swap_symbol_out (abfd, src, cdst)
  207.      bfd *abfd;
  208.      const Elf_Internal_Sym *src;
  209.      PTR cdst;
  210. {
  211.   Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
  212.   bfd_h_put_32 (abfd, src->st_name, dst->st_name);
  213.   put_word (abfd, src->st_value, dst->st_value);
  214.   put_word (abfd, src->st_size, dst->st_size);
  215.   bfd_h_put_8 (abfd, src->st_info, dst->st_info);
  216.   bfd_h_put_8 (abfd, src->st_other, dst->st_other);
  217.   bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
  218. }
  219.  
  220.  
  221. /* Translate an ELF file header in external format into an ELF file header in
  222.    internal format. */
  223.  
  224. static void
  225. elf_swap_ehdr_in (abfd, src, dst)
  226.      bfd *abfd;
  227.      const Elf_External_Ehdr *src;
  228.      Elf_Internal_Ehdr *dst;
  229. {
  230.   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
  231.   dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
  232.   dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
  233.   dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
  234.   dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
  235.   dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
  236.   dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
  237.   dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
  238.   dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
  239.   dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
  240.   dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
  241.   dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
  242.   dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
  243.   dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
  244. }
  245.  
  246. /* Translate an ELF file header in internal format into an ELF file header in
  247.    external format. */
  248.  
  249. static void
  250. elf_swap_ehdr_out (abfd, src, dst)
  251.      bfd *abfd;
  252.      const Elf_Internal_Ehdr *src;
  253.      Elf_External_Ehdr *dst;
  254. {
  255.   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
  256.   /* note that all elements of dst are *arrays of unsigned char* already... */
  257.   bfd_h_put_16 (abfd, src->e_type, dst->e_type);
  258.   bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
  259.   bfd_h_put_32 (abfd, src->e_version, dst->e_version);
  260.   put_word (abfd, src->e_entry, dst->e_entry);
  261.   put_word (abfd, src->e_phoff, dst->e_phoff);
  262.   put_word (abfd, src->e_shoff, dst->e_shoff);
  263.   bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
  264.   bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
  265.   bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
  266.   bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
  267.   bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
  268.   bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
  269.   bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
  270. }
  271.  
  272.  
  273. /* Translate an ELF section header table entry in external format into an
  274.    ELF section header table entry in internal format. */
  275.  
  276. static void
  277. elf_swap_shdr_in (abfd, src, dst)
  278.      bfd *abfd;
  279.      const Elf_External_Shdr *src;
  280.      Elf_Internal_Shdr *dst;
  281. {
  282.   dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
  283.   dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
  284.   dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
  285.   dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
  286.   dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
  287.   dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
  288.   dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
  289.   dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
  290.   dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
  291.   dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
  292.   dst->bfd_section = NULL;
  293.   dst->contents = NULL;
  294. }
  295.  
  296. /* Translate an ELF section header table entry in internal format into an
  297.    ELF section header table entry in external format. */
  298.  
  299. static void
  300. elf_swap_shdr_out (abfd, src, dst)
  301.      bfd *abfd;
  302.      const Elf_Internal_Shdr *src;
  303.      Elf_External_Shdr *dst;
  304. {
  305.   /* note that all elements of dst are *arrays of unsigned char* already... */
  306.   bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
  307.   bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
  308.   put_word (abfd, src->sh_flags, dst->sh_flags);
  309.   put_word (abfd, src->sh_addr, dst->sh_addr);
  310.   put_word (abfd, src->sh_offset, dst->sh_offset);
  311.   put_word (abfd, src->sh_size, dst->sh_size);
  312.   bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
  313.   bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
  314.   put_word (abfd, src->sh_addralign, dst->sh_addralign);
  315.   put_word (abfd, src->sh_entsize, dst->sh_entsize);
  316. }
  317.  
  318.  
  319. /* Translate an ELF program header table entry in external format into an
  320.    ELF program header table entry in internal format. */
  321.  
  322. void
  323. elf_swap_phdr_in (abfd, src, dst)
  324.      bfd *abfd;
  325.      const Elf_External_Phdr *src;
  326.      Elf_Internal_Phdr *dst;
  327. {
  328.   dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
  329.   dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
  330.   dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
  331.   dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
  332.   dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
  333.   dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
  334.   dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
  335.   dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
  336. }
  337.  
  338. void
  339. elf_swap_phdr_out (abfd, src, dst)
  340.      bfd *abfd;
  341.      const Elf_Internal_Phdr *src;
  342.      Elf_External_Phdr *dst;
  343. {
  344.   /* note that all elements of dst are *arrays of unsigned char* already... */
  345.   bfd_h_put_32 (abfd, src->p_type, dst->p_type);
  346.   put_word (abfd, src->p_offset, dst->p_offset);
  347.   put_word (abfd, src->p_vaddr, dst->p_vaddr);
  348.   put_word (abfd, src->p_paddr, dst->p_paddr);
  349.   put_word (abfd, src->p_filesz, dst->p_filesz);
  350.   put_word (abfd, src->p_memsz, dst->p_memsz);
  351.   bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
  352.   put_word (abfd, src->p_align, dst->p_align);
  353. }
  354.  
  355. /* Translate an ELF reloc from external format to internal format. */
  356. INLINE void
  357. elf_swap_reloc_in (abfd, src, dst)
  358.      bfd *abfd;
  359.      const Elf_External_Rel *src;
  360.      Elf_Internal_Rel *dst;
  361. {
  362.   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
  363.   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
  364. }
  365.  
  366. INLINE void
  367. elf_swap_reloca_in (abfd, src, dst)
  368.      bfd *abfd;
  369.      const Elf_External_Rela *src;
  370.      Elf_Internal_Rela *dst;
  371. {
  372.   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
  373.   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
  374.   dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
  375. }
  376.  
  377. /* Translate an ELF reloc from internal format to external format. */
  378. INLINE void
  379. elf_swap_reloc_out (abfd, src, dst)
  380.      bfd *abfd;
  381.      const Elf_Internal_Rel *src;
  382.      Elf_External_Rel *dst;
  383. {
  384.   put_word (abfd, src->r_offset, dst->r_offset);
  385.   put_word (abfd, src->r_info, dst->r_info);
  386. }
  387.  
  388. INLINE void
  389. elf_swap_reloca_out (abfd, src, dst)
  390.      bfd *abfd;
  391.      const Elf_Internal_Rela *src;
  392.      Elf_External_Rela *dst;
  393. {
  394.   put_word (abfd, src->r_offset, dst->r_offset);
  395.   put_word (abfd, src->r_info, dst->r_info);
  396.   put_word (abfd, src->r_addend, dst->r_addend);
  397. }
  398.  
  399. INLINE void
  400. elf_swap_dyn_in (abfd, p, dst)
  401.      bfd *abfd;
  402.      const PTR p;
  403.      Elf_Internal_Dyn *dst;
  404. {
  405.   const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
  406.  
  407.   dst->d_tag = get_word (abfd, src->d_tag);
  408.   dst->d_un.d_val = get_word (abfd, src->d_un.d_val);
  409. }
  410.  
  411. INLINE void
  412. elf_swap_dyn_out (abfd, src, dst)
  413.      bfd *abfd;
  414.      const Elf_Internal_Dyn *src;
  415.      Elf_External_Dyn *dst;
  416. {
  417.   put_word (abfd, src->d_tag, dst->d_tag);
  418.   put_word (abfd, src->d_un.d_val, dst->d_un.d_val);
  419. }
  420.  
  421. /* ELF .o/exec file reading */
  422.  
  423.  
  424. /* Begin processing a given object.
  425.  
  426.    First we validate the file by reading in the ELF header and checking
  427.    the magic number.  */
  428.  
  429. static INLINE boolean
  430. elf_file_p (x_ehdrp)
  431.      Elf_External_Ehdr *x_ehdrp;
  432. {
  433.   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
  434.       && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
  435.       && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
  436.       && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
  437. }
  438.  
  439. /* Check to see if the file associated with ABFD matches the target vector
  440.    that ABFD points to.
  441.  
  442.    Note that we may be called several times with the same ABFD, but different
  443.    target vectors, most of which will not match.  We have to avoid leaving
  444.    any side effects in ABFD, or any data it points to (like tdata), if the
  445.    file does not match the target vector.  */
  446.  
  447. const bfd_target *
  448. elf_object_p (abfd)
  449.      bfd *abfd;
  450. {
  451.   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form */
  452.   Elf_Internal_Ehdr *i_ehdrp;    /* Elf file header, internal form */
  453.   Elf_External_Shdr x_shdr;    /* Section header table entry, external form */
  454.   Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */
  455.   unsigned int shindex;
  456.   char *shstrtab;        /* Internal copy of section header stringtab */
  457.   struct elf_backend_data *ebd;
  458.   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
  459.   struct elf_obj_tdata *new_tdata = NULL;
  460.  
  461.   /* Read in the ELF header in external format.  */
  462.  
  463.   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
  464.     {
  465.       if (bfd_get_error () != bfd_error_system_call)
  466.     goto got_wrong_format_error;
  467.       else
  468.     goto got_no_match;
  469.     }
  470.  
  471.   /* Now check to see if we have a valid ELF file, and one that BFD can
  472.      make use of.  The magic number must match, the address size ('class')
  473.      and byte-swapping must match our XVEC entry, and it must have a
  474.      section header table (FIXME: See comments re sections at top of this
  475.      file). */
  476.  
  477.   if ((elf_file_p (&x_ehdr) == false) ||
  478.       (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
  479.       (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
  480.     goto got_wrong_format_error;
  481.  
  482.   /* Check that file's byte order matches xvec's */
  483.   switch (x_ehdr.e_ident[EI_DATA])
  484.     {
  485.     case ELFDATA2MSB:        /* Big-endian */
  486.       if (! bfd_header_big_endian (abfd))
  487.     goto got_wrong_format_error;
  488.       break;
  489.     case ELFDATA2LSB:        /* Little-endian */
  490.       if (! bfd_header_little_endian (abfd))
  491.     goto got_wrong_format_error;
  492.       break;
  493.     case ELFDATANONE:        /* No data encoding specified */
  494.     default:            /* Unknown data encoding specified */
  495.       goto got_wrong_format_error;
  496.     }
  497.  
  498.   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
  499.      the tdata pointer in the bfd.  */
  500.  
  501.   new_tdata = ((struct elf_obj_tdata *)
  502.            bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)));
  503.   if (new_tdata == NULL)
  504.     goto got_no_match;
  505.   elf_tdata (abfd) = new_tdata;
  506.  
  507.   /* Now that we know the byte order, swap in the rest of the header */
  508.   i_ehdrp = elf_elfheader (abfd);
  509.   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
  510. #if DEBUG & 1
  511.   elf_debug_file (i_ehdrp);
  512. #endif
  513.  
  514.   /* If there is no section header table, we're hosed. */
  515.   if (i_ehdrp->e_shoff == 0)
  516.     goto got_wrong_format_error;
  517.  
  518.   /* As a simple sanity check, verify that the what BFD thinks is the
  519.      size of each section header table entry actually matches the size
  520.      recorded in the file. */
  521.   if (i_ehdrp->e_shentsize != sizeof (x_shdr))
  522.     goto got_wrong_format_error;
  523.  
  524.   ebd = get_elf_backend_data (abfd);
  525.  
  526.   /* Check that the ELF e_machine field matches what this particular
  527.      BFD format expects.  */
  528.   if (ebd->elf_machine_code != i_ehdrp->e_machine
  529.       && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
  530.       && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
  531.     {
  532.       const bfd_target * const *target_ptr;
  533.  
  534.       if (ebd->elf_machine_code != EM_NONE)
  535.     goto got_wrong_format_error;
  536.  
  537.       /* This is the generic ELF target.  Let it match any ELF target
  538.      for which we do not have a specific backend.  */
  539.       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
  540.     {
  541.       struct elf_backend_data *back;
  542.  
  543.       if ((*target_ptr)->flavour != bfd_target_elf_flavour)
  544.         continue;
  545.       back = (struct elf_backend_data *) (*target_ptr)->backend_data;
  546.       if (back->elf_machine_code == i_ehdrp->e_machine
  547.           || (back->elf_machine_alt1 != 0
  548.           && back->elf_machine_alt1 == i_ehdrp->e_machine)
  549.           || (back->elf_machine_alt2 != 0
  550.           && back->elf_machine_alt2 == i_ehdrp->e_machine))
  551.         {
  552.           /* target_ptr is an ELF backend which matches this
  553.          object file, so reject the generic ELF target.  */
  554.           goto got_wrong_format_error;
  555.         }
  556.     }
  557.     }
  558.  
  559.   if (i_ehdrp->e_type == ET_EXEC)
  560.     abfd->flags |= EXEC_P;
  561.   else if (i_ehdrp->e_type == ET_DYN)
  562.     abfd->flags |= DYNAMIC;
  563.  
  564.   if (i_ehdrp->e_phnum > 0)
  565.     abfd->flags |= D_PAGED;
  566.  
  567.   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
  568.     goto got_no_match;
  569.  
  570.   /* Remember the entry point specified in the ELF file header. */
  571.   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
  572.  
  573.   /* Allocate space for a copy of the section header table in
  574.      internal form, seek to the section header table in the file,
  575.      read it in, and convert it to internal form.  */
  576.   i_shdrp = ((Elf_Internal_Shdr *)
  577.          bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
  578.   elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
  579.                 bfd_alloc (abfd,
  580.                        sizeof (i_shdrp) * i_ehdrp->e_shnum));
  581.   if (!i_shdrp || !elf_elfsections (abfd))
  582.     goto got_no_match;
  583.   if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0)
  584.     goto got_no_match;
  585.   for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
  586.     {
  587.       if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
  588.     goto got_no_match;
  589.       elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
  590.       elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
  591.     }
  592.   if (i_ehdrp->e_shstrndx)
  593.     {
  594.       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
  595.     goto got_no_match;
  596.     }
  597.  
  598.   /* Read in the program headers.  */
  599.   if (i_ehdrp->e_phnum == 0)
  600.     elf_tdata (abfd)->phdr = NULL;
  601.   else
  602.     {
  603.       Elf_Internal_Phdr *i_phdr;
  604.       unsigned int i;
  605.  
  606.       elf_tdata (abfd)->phdr = ((Elf_Internal_Phdr *)
  607.                 bfd_alloc (abfd,
  608.                        (i_ehdrp->e_phnum
  609.                         * sizeof (Elf_Internal_Phdr))));
  610.       if (elf_tdata (abfd)->phdr == NULL)
  611.     goto got_no_match;
  612.       if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
  613.     goto got_no_match;
  614.       i_phdr = elf_tdata (abfd)->phdr;
  615.       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
  616.     {
  617.       Elf_External_Phdr x_phdr;
  618.  
  619.       if (bfd_read ((PTR) &x_phdr, sizeof x_phdr, 1, abfd)
  620.           != sizeof x_phdr)
  621.         goto got_no_match;
  622.       elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
  623.     }
  624.     }
  625.  
  626.   /* Read in the string table containing the names of the sections.  We
  627.      will need the base pointer to this table later. */
  628.   /* We read this inline now, so that we don't have to go through
  629.      bfd_section_from_shdr with it (since this particular strtab is
  630.      used to find all of the ELF section names.) */
  631.  
  632.   shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
  633.   if (!shstrtab)
  634.     goto got_no_match;
  635.  
  636.   /* Once all of the section headers have been read and converted, we
  637.      can start processing them.  Note that the first section header is
  638.      a dummy placeholder entry, so we ignore it.  */
  639.  
  640.   for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
  641.     {
  642.       if (! bfd_section_from_shdr (abfd, shindex))
  643.     goto got_no_match;
  644.     }
  645.  
  646.   /* Let the backend double check the format and override global
  647.      information.  */
  648.   if (ebd->elf_backend_object_p)
  649.     {
  650.       if ((*ebd->elf_backend_object_p) (abfd) == false)
  651.     goto got_wrong_format_error;
  652.     }
  653.  
  654.   return (abfd->xvec);
  655.  
  656. got_wrong_format_error:
  657.   bfd_set_error (bfd_error_wrong_format);
  658.   goto got_no_match;
  659. got_no_match:
  660.   if (new_tdata != NULL
  661.       && new_tdata->elf_sect_ptr != NULL)
  662.     bfd_release (abfd, new_tdata->elf_sect_ptr);
  663.   if (i_shdrp != NULL)
  664.     bfd_release (abfd, i_shdrp);
  665.   if (new_tdata != NULL)
  666.     bfd_release (abfd, new_tdata);
  667.   elf_tdata (abfd) = preserved_tdata;
  668.   return (NULL);
  669. }
  670.  
  671. /* ELF .o/exec file writing */
  672.  
  673. /* Write out the relocs.  */
  674.  
  675. static void
  676. write_relocs (abfd, sec, data)
  677.      bfd *abfd;
  678.      asection *sec;
  679.      PTR data;
  680. {
  681.   boolean *failedp = (boolean *) data;
  682.   Elf_Internal_Shdr *rela_hdr;
  683.   Elf_External_Rela *outbound_relocas;
  684.   Elf_External_Rel *outbound_relocs;
  685.   unsigned int idx;
  686.   int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
  687.   asymbol *last_sym = 0;
  688.   int last_sym_idx = 0;
  689.  
  690.   /* If we have already failed, don't do anything.  */
  691.   if (*failedp)
  692.     return;
  693.  
  694.   if ((sec->flags & SEC_RELOC) == 0)
  695.     return;
  696.  
  697.   /* The linker backend writes the relocs out itself, and sets the
  698.      reloc_count field to zero to inhibit writing them here.  Also,
  699.      sometimes the SEC_RELOC flag gets set even when there aren't any
  700.      relocs.  */
  701.   if (sec->reloc_count == 0)
  702.     return;
  703.  
  704.   rela_hdr = &elf_section_data (sec)->rel_hdr;
  705.  
  706.   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
  707.   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
  708.   if (rela_hdr->contents == NULL)
  709.     {
  710.       *failedp = true;
  711.       return;
  712.     }
  713.  
  714.   /* orelocation has the data, reloc_count has the count... */
  715.   if (use_rela_p)
  716.     {
  717.       outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
  718.  
  719.       for (idx = 0; idx < sec->reloc_count; idx++)
  720.     {
  721.       Elf_Internal_Rela dst_rela;
  722.       Elf_External_Rela *src_rela;
  723.       arelent *ptr;
  724.       asymbol *sym;
  725.       int n;
  726.  
  727.       ptr = sec->orelocation[idx];
  728.       src_rela = outbound_relocas + idx;
  729.  
  730.       /* The address of an ELF reloc is section relative for an object
  731.          file, and absolute for an executable file or shared library.
  732.          The address of a BFD reloc is always section relative.  */
  733.       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
  734.         dst_rela.r_offset = ptr->address;
  735.       else
  736.         dst_rela.r_offset = ptr->address + sec->vma;
  737.  
  738.       sym = *ptr->sym_ptr_ptr;
  739.       if (sym == last_sym)
  740.         n = last_sym_idx;
  741.       else
  742.         {
  743.           last_sym = sym;
  744.           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
  745.           if (n < 0)
  746.         {
  747.           *failedp = true;
  748.           return;
  749.         }
  750.           last_sym_idx = n;
  751.         }
  752.  
  753.       if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
  754.           && ! _bfd_elf_validate_reloc (abfd, ptr))
  755.         {
  756.           *failedp = true;
  757.           return;
  758.         }
  759.  
  760.       dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
  761.  
  762.       dst_rela.r_addend = ptr->addend;
  763.       elf_swap_reloca_out (abfd, &dst_rela, src_rela);
  764.     }
  765.     }
  766.   else
  767.     /* REL relocations */
  768.     {
  769.       outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
  770.  
  771.       for (idx = 0; idx < sec->reloc_count; idx++)
  772.     {
  773.       Elf_Internal_Rel dst_rel;
  774.       Elf_External_Rel *src_rel;
  775.       arelent *ptr;
  776.       int n;
  777.       asymbol *sym;
  778.  
  779.       ptr = sec->orelocation[idx];
  780.       sym = *ptr->sym_ptr_ptr;
  781.       src_rel = outbound_relocs + idx;
  782.  
  783.       /* The address of an ELF reloc is section relative for an object
  784.          file, and absolute for an executable file or shared library.
  785.          The address of a BFD reloc is always section relative.  */
  786.       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
  787.         dst_rel.r_offset = ptr->address;
  788.       else
  789.         dst_rel.r_offset = ptr->address + sec->vma;
  790.  
  791.       if (sym == last_sym)
  792.         n = last_sym_idx;
  793.       else
  794.         {
  795.           last_sym = sym;
  796.           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
  797.           if (n < 0)
  798.         {
  799.           *failedp = true;
  800.           return;
  801.         }
  802.           last_sym_idx = n;
  803.         }
  804.  
  805.       if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
  806.           && ! _bfd_elf_validate_reloc (abfd, ptr))
  807.         {
  808.           *failedp = true;
  809.           return;
  810.         }
  811.  
  812.       dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
  813.  
  814.       elf_swap_reloc_out (abfd, &dst_rel, src_rel);
  815.     }
  816.     }
  817. }
  818.  
  819. /* Write out the program headers.  */
  820.  
  821. int
  822. elf_write_out_phdrs (abfd, phdr, count)
  823.      bfd *abfd;
  824.      const Elf_Internal_Phdr *phdr;
  825.      int count;
  826. {
  827.   while (count--)
  828.     {
  829.       Elf_External_Phdr extphdr;
  830.       elf_swap_phdr_out (abfd, phdr, &extphdr);
  831.       if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
  832.       != sizeof (Elf_External_Phdr))
  833.     return -1;
  834.       phdr++;
  835.     }
  836.   return 0;
  837. }
  838.  
  839. /* Write out the section headers and the ELF file header.  */
  840.  
  841. boolean
  842. elf_write_shdrs_and_ehdr (abfd)
  843.      bfd *abfd;
  844. {
  845.   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form */
  846.   Elf_Internal_Ehdr *i_ehdrp;    /* Elf file header, internal form */
  847.   Elf_External_Shdr *x_shdrp;    /* Section header table, external form */
  848.   Elf_Internal_Shdr **i_shdrp;    /* Section header table, internal form */
  849.   unsigned int count;
  850.  
  851.   i_ehdrp = elf_elfheader (abfd);
  852.   i_shdrp = elf_elfsections (abfd);
  853.  
  854.   /* swap the header before spitting it out... */
  855.  
  856. #if DEBUG & 1
  857.   elf_debug_file (i_ehdrp);
  858. #endif
  859.   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
  860.   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
  861.       || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
  862.       != sizeof (x_ehdr)))
  863.     return false;
  864.  
  865.   /* at this point we've concocted all the ELF sections... */
  866.   x_shdrp = (Elf_External_Shdr *)
  867.     bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
  868.   if (!x_shdrp)
  869.     return false;
  870.  
  871.   for (count = 0; count < i_ehdrp->e_shnum; count++)
  872.     {
  873. #if DEBUG & 2
  874.       elf_debug_section (count, i_shdrp[count]);
  875. #endif
  876.       elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
  877.     }
  878.   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
  879.       || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
  880.       != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
  881.     return false;
  882.  
  883.   /* need to dump the string table too... */
  884.  
  885.   return true;
  886. }
  887.  
  888. long
  889. elf_slurp_symbol_table (abfd, symptrs, dynamic)
  890.      bfd *abfd;
  891.      asymbol **symptrs;        /* Buffer for generated bfd symbols */
  892.      boolean dynamic;
  893. {
  894.   Elf_Internal_Shdr *hdr;
  895.   long symcount;        /* Number of external ELF symbols */
  896.   elf_symbol_type *sym;        /* Pointer to current bfd symbol */
  897.   elf_symbol_type *symbase;    /* Buffer for generated bfd symbols */
  898.   Elf_Internal_Sym i_sym;
  899.   Elf_External_Sym *x_symp = NULL;
  900.  
  901.   /* Read each raw ELF symbol, converting from external ELF form to
  902.      internal ELF form, and then using the information to create a
  903.      canonical bfd symbol table entry.
  904.  
  905.      Note that we allocate the initial bfd canonical symbol buffer
  906.      based on a one-to-one mapping of the ELF symbols to canonical
  907.      symbols.  We actually use all the ELF symbols, so there will be no
  908.      space left over at the end.  When we have all the symbols, we
  909.      build the caller's pointer vector. */
  910.  
  911.   if (dynamic)
  912.     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
  913.   else
  914.     hdr = &elf_tdata (abfd)->symtab_hdr;
  915.   if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
  916.     return -1;
  917.  
  918.   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
  919.  
  920.   if (symcount == 0)
  921.     sym = symbase = NULL;
  922.   else
  923.     {
  924.       long i;
  925.  
  926.       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
  927.     return -1;
  928.  
  929.       symbase = ((elf_symbol_type *)
  930.          bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
  931.       if (symbase == (elf_symbol_type *) NULL)
  932.     return -1;
  933.       sym = symbase;
  934.  
  935.       /* Temporarily allocate room for the raw ELF symbols.  */
  936.       x_symp = ((Elf_External_Sym *)
  937.         bfd_malloc (symcount * sizeof (Elf_External_Sym)));
  938.       if (x_symp == NULL && symcount != 0)
  939.     goto error_return;
  940.  
  941.       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
  942.       != symcount * sizeof (Elf_External_Sym))
  943.     goto error_return;
  944.       /* Skip first symbol, which is a null dummy.  */
  945.       for (i = 1; i < symcount; i++)
  946.     {
  947.       elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
  948.       memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
  949. #ifdef ELF_KEEP_EXTSYM
  950.       memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
  951. #endif
  952.       sym->symbol.the_bfd = abfd;
  953.  
  954.       sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
  955.                                   hdr->sh_link,
  956.                                   i_sym.st_name);
  957.  
  958.       sym->symbol.value = i_sym.st_value;
  959.  
  960.       if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
  961.         {
  962.           sym->symbol.section = section_from_elf_index (abfd,
  963.                                 i_sym.st_shndx);
  964.           if (sym->symbol.section == NULL)
  965.         {
  966.           /* This symbol is in a section for which we did not
  967.              create a BFD section.  Just use bfd_abs_section,
  968.              although it is wrong.  FIXME.  */
  969.           sym->symbol.section = bfd_abs_section_ptr;
  970.         }
  971.         }
  972.       else if (i_sym.st_shndx == SHN_ABS)
  973.         {
  974.           sym->symbol.section = bfd_abs_section_ptr;
  975.         }
  976.       else if (i_sym.st_shndx == SHN_COMMON)
  977.         {
  978.           sym->symbol.section = bfd_com_section_ptr;
  979.           /* Elf puts the alignment into the `value' field, and
  980.          the size into the `size' field.  BFD wants to see the
  981.          size in the value field, and doesn't care (at the
  982.          moment) about the alignment.  */
  983.           sym->symbol.value = i_sym.st_size;
  984.         }
  985.       else if (i_sym.st_shndx == SHN_UNDEF)
  986.         {
  987.           sym->symbol.section = bfd_und_section_ptr;
  988.         }
  989.       else
  990.         sym->symbol.section = bfd_abs_section_ptr;
  991.  
  992.       sym->symbol.value -= sym->symbol.section->vma;
  993.  
  994.       switch (ELF_ST_BIND (i_sym.st_info))
  995.         {
  996.         case STB_LOCAL:
  997.           sym->symbol.flags |= BSF_LOCAL;
  998.           break;
  999.         case STB_GLOBAL:
  1000.           if (i_sym.st_shndx != SHN_UNDEF
  1001.           && i_sym.st_shndx != SHN_COMMON)
  1002.         sym->symbol.flags |= BSF_GLOBAL;
  1003.           break;
  1004.         case STB_WEAK:
  1005.           sym->symbol.flags |= BSF_WEAK;
  1006.           break;
  1007.         }
  1008.  
  1009.       switch (ELF_ST_TYPE (i_sym.st_info))
  1010.         {
  1011.         case STT_SECTION:
  1012.           sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
  1013.           break;
  1014.         case STT_FILE:
  1015.           sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
  1016.           break;
  1017.         case STT_FUNC:
  1018.           sym->symbol.flags |= BSF_FUNCTION;
  1019.           break;
  1020.         case STT_OBJECT:
  1021.           sym->symbol.flags |= BSF_OBJECT;
  1022.           break;
  1023.         }
  1024.  
  1025.       if (dynamic)
  1026.         sym->symbol.flags |= BSF_DYNAMIC;
  1027.  
  1028.       /* Do some backend-specific processing on this symbol.  */
  1029.       {
  1030.         struct elf_backend_data *ebd = get_elf_backend_data (abfd);
  1031.         if (ebd->elf_backend_symbol_processing)
  1032.           (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
  1033.       }
  1034.  
  1035.       sym++;
  1036.     }
  1037.     }
  1038.  
  1039.   /* Do some backend-specific processing on this symbol table.  */
  1040.   {
  1041.     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
  1042.     if (ebd->elf_backend_symbol_table_processing)
  1043.       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
  1044.   }
  1045.  
  1046.   /* We rely on the zalloc to clear out the final symbol entry.  */
  1047.  
  1048.   symcount = sym - symbase;
  1049.  
  1050.   /* Fill in the user's symbol pointer vector if needed.  */
  1051.   if (symptrs)
  1052.     {
  1053.       long l = symcount;
  1054.  
  1055.       sym = symbase;
  1056.       while (l-- > 0)
  1057.     {
  1058.       *symptrs++ = &sym->symbol;
  1059.       sym++;
  1060.     }
  1061.       *symptrs = 0;        /* Final null pointer */
  1062.     }
  1063.  
  1064.   if (x_symp != NULL)
  1065.     free (x_symp);
  1066.   return symcount;
  1067. error_return:
  1068.   if (x_symp != NULL)
  1069.     free (x_symp);
  1070.   return -1;
  1071. }
  1072.  
  1073. /* Read in and swap the external relocs.  */
  1074.  
  1075. static boolean
  1076. elf_slurp_reloc_table (abfd, asect, symbols)
  1077.      bfd *abfd;
  1078.      asection *asect;
  1079.      asymbol **symbols;
  1080. {
  1081.   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
  1082.   struct bfd_elf_section_data * const d = elf_section_data (asect);
  1083.   PTR allocated = NULL;
  1084.   bfd_byte *native_relocs;
  1085.   arelent *relents;
  1086.   arelent *relent;
  1087.   unsigned int i;
  1088.   int entsize;
  1089.  
  1090.   if (asect->relocation != NULL
  1091.       || (asect->flags & SEC_RELOC) == 0
  1092.       || asect->reloc_count == 0)
  1093.     return true;
  1094.  
  1095.   BFD_ASSERT (asect->rel_filepos == d->rel_hdr.sh_offset
  1096.           && (asect->reloc_count
  1097.           == d->rel_hdr.sh_size / d->rel_hdr.sh_entsize));
  1098.  
  1099.   allocated = (PTR) bfd_malloc ((size_t) d->rel_hdr.sh_size);
  1100.   if (allocated == NULL)
  1101.     goto error_return;
  1102.  
  1103.   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0
  1104.       || (bfd_read (allocated, 1, d->rel_hdr.sh_size, abfd)
  1105.       != d->rel_hdr.sh_size))
  1106.     goto error_return;
  1107.  
  1108.   native_relocs = (bfd_byte *) allocated;
  1109.  
  1110.   relents = ((arelent *)
  1111.          bfd_alloc (abfd, asect->reloc_count * sizeof (arelent)));
  1112.   if (relents == NULL)
  1113.     goto error_return;
  1114.  
  1115.   entsize = d->rel_hdr.sh_entsize;
  1116.   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
  1117.           || entsize == sizeof (Elf_External_Rela));
  1118.  
  1119.   for (i = 0, relent = relents;
  1120.        i < asect->reloc_count;
  1121.        i++, relent++, native_relocs += entsize)
  1122.     {
  1123.       Elf_Internal_Rela rela;
  1124.       Elf_Internal_Rel rel;
  1125.  
  1126.       if (entsize == sizeof (Elf_External_Rela))
  1127.     elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
  1128.       else
  1129.     {
  1130.       elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
  1131.       rela.r_offset = rel.r_offset;
  1132.       rela.r_info = rel.r_info;
  1133.       rela.r_addend = 0;
  1134.     }
  1135.  
  1136.       /* The address of an ELF reloc is section relative for an object
  1137.      file, and absolute for an executable file or shared library.
  1138.      The address of a BFD reloc is always section relative.  */
  1139.       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
  1140.     relent->address = rela.r_offset;
  1141.       else
  1142.     relent->address = rela.r_offset - asect->vma;
  1143.  
  1144.       if (ELF_R_SYM (rela.r_info) == 0)
  1145.     relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
  1146.       else
  1147.     {
  1148.       asymbol **ps, *s;
  1149.  
  1150.       ps = symbols + ELF_R_SYM (rela.r_info) - 1;
  1151.       s = *ps;
  1152.  
  1153.       /* Canonicalize ELF section symbols.  FIXME: Why?  */
  1154.       if ((s->flags & BSF_SECTION_SYM) == 0)
  1155.         relent->sym_ptr_ptr = ps;
  1156.       else
  1157.         relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
  1158.     }
  1159.  
  1160.       relent->addend = rela.r_addend;
  1161.  
  1162.       if (entsize == sizeof (Elf_External_Rela))
  1163.     (*ebd->elf_info_to_howto) (abfd, relent, &rela);
  1164.       else
  1165.     (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
  1166.     }
  1167.  
  1168.   asect->relocation = relents;
  1169.  
  1170.   if (allocated != NULL)
  1171.     free (allocated);
  1172.  
  1173.   return true;
  1174.  
  1175.  error_return:
  1176.   if (allocated != NULL)
  1177.     free (allocated);
  1178.   return false;
  1179. }
  1180.  
  1181. #ifdef DEBUG
  1182. static void
  1183. elf_debug_section (num, hdr)
  1184.      int num;
  1185.      Elf_Internal_Shdr *hdr;
  1186. {
  1187.   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
  1188.        hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
  1189.        (long) hdr);
  1190.   fprintf (stderr,
  1191.        "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
  1192.        (long) hdr->sh_name,
  1193.        (long) hdr->sh_type,
  1194.        (long) hdr->sh_flags);
  1195.   fprintf (stderr,
  1196.        "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
  1197.        (long) hdr->sh_addr,
  1198.        (long) hdr->sh_offset,
  1199.        (long) hdr->sh_size);
  1200.   fprintf (stderr,
  1201.        "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
  1202.        (long) hdr->sh_link,
  1203.        (long) hdr->sh_info,
  1204.        (long) hdr->sh_addralign);
  1205.   fprintf (stderr, "sh_entsize   = %ld\n",
  1206.        (long) hdr->sh_entsize);
  1207.   fflush (stderr);
  1208. }
  1209.  
  1210. static void
  1211. elf_debug_file (ehdrp)
  1212.      Elf_Internal_Ehdr *ehdrp;
  1213. {
  1214.   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
  1215.   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
  1216.   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
  1217.   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
  1218.   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
  1219.   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
  1220.   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
  1221. }
  1222.  
  1223. static char *
  1224. elf_symbol_flags (flags)
  1225.      flagword flags;
  1226. {
  1227.   static char buffer[1024];
  1228.  
  1229.   buffer[0] = '\0';
  1230.   if (flags & BSF_LOCAL)
  1231.     strcat (buffer, " local");
  1232.  
  1233.   if (flags & BSF_GLOBAL)
  1234.     strcat (buffer, " global");
  1235.  
  1236.   if (flags & BSF_DEBUGGING)
  1237.     strcat (buffer, " debug");
  1238.  
  1239.   if (flags & BSF_FUNCTION)
  1240.     strcat (buffer, " function");
  1241.  
  1242.   if (flags & BSF_KEEP)
  1243.     strcat (buffer, " keep");
  1244.  
  1245.   if (flags & BSF_KEEP_G)
  1246.     strcat (buffer, " keep_g");
  1247.  
  1248.   if (flags & BSF_WEAK)
  1249.     strcat (buffer, " weak");
  1250.  
  1251.   if (flags & BSF_SECTION_SYM)
  1252.     strcat (buffer, " section-sym");
  1253.  
  1254.   if (flags & BSF_OLD_COMMON)
  1255.     strcat (buffer, " old-common");
  1256.  
  1257.   if (flags & BSF_NOT_AT_END)
  1258.     strcat (buffer, " not-at-end");
  1259.  
  1260.   if (flags & BSF_CONSTRUCTOR)
  1261.     strcat (buffer, " constructor");
  1262.  
  1263.   if (flags & BSF_WARNING)
  1264.     strcat (buffer, " warning");
  1265.  
  1266.   if (flags & BSF_INDIRECT)
  1267.     strcat (buffer, " indirect");
  1268.  
  1269.   if (flags & BSF_FILE)
  1270.     strcat (buffer, " file");
  1271.  
  1272.   if (flags & DYNAMIC)
  1273.     strcat (buffer, " dynamic");
  1274.  
  1275.   if (flags & ~(BSF_LOCAL
  1276.         | BSF_GLOBAL
  1277.         | BSF_DEBUGGING
  1278.         | BSF_FUNCTION
  1279.         | BSF_KEEP
  1280.         | BSF_KEEP_G
  1281.         | BSF_WEAK
  1282.         | BSF_SECTION_SYM
  1283.         | BSF_OLD_COMMON
  1284.         | BSF_NOT_AT_END
  1285.         | BSF_CONSTRUCTOR
  1286.         | BSF_WARNING
  1287.         | BSF_INDIRECT
  1288.         | BSF_FILE
  1289.         | BSF_DYNAMIC))
  1290.     strcat (buffer, " unknown-bits");
  1291.  
  1292.   return buffer;
  1293. }
  1294. #endif
  1295.  
  1296. #include "elfcore.h"
  1297. #include "elflink.h"
  1298.  
  1299. /* Size-dependent data and functions.  */
  1300. const struct elf_size_info NAME(_bfd_elf,size_info) = {
  1301.   sizeof (Elf_External_Ehdr),
  1302.   sizeof (Elf_External_Phdr),
  1303.   sizeof (Elf_External_Shdr),
  1304.   sizeof (Elf_External_Rel),
  1305.   sizeof (Elf_External_Rela),
  1306.   sizeof (Elf_External_Sym),
  1307.   sizeof (Elf_External_Dyn),
  1308.   sizeof (Elf_External_Note),
  1309.  
  1310.   ARCH_SIZE, FILE_ALIGN,
  1311.   ELFCLASS, EV_CURRENT,
  1312.   elf_write_out_phdrs,
  1313.   elf_write_shdrs_and_ehdr,
  1314.   write_relocs,
  1315.   elf_swap_symbol_out,
  1316.   elf_slurp_reloc_table,
  1317.   elf_slurp_symbol_table,
  1318.   elf_swap_dyn_in
  1319. };
  1320.