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