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