include/elf/
[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, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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   const bfd_target * const *target_ptr;
503
504   preserve.marker = NULL;
505
506   /* Read in the ELF header in external format.  */
507
508   if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
509     {
510       if (bfd_get_error () != bfd_error_system_call)
511         goto got_wrong_format_error;
512       else
513         goto got_no_match;
514     }
515
516   /* Now check to see if we have a valid ELF file, and one that BFD can
517      make use of.  The magic number must match, the address size ('class')
518      and byte-swapping must match our XVEC entry, and it must have a
519      section header table (FIXME: See comments re sections at top of this
520      file).  */
521
522   if (! elf_file_p (&x_ehdr)
523       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
524       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
525     goto got_wrong_format_error;
526
527   /* Check that file's byte order matches xvec's */
528   switch (x_ehdr.e_ident[EI_DATA])
529     {
530     case ELFDATA2MSB:           /* Big-endian */
531       if (! bfd_header_big_endian (abfd))
532         goto got_wrong_format_error;
533       break;
534     case ELFDATA2LSB:           /* Little-endian */
535       if (! bfd_header_little_endian (abfd))
536         goto got_wrong_format_error;
537       break;
538     case ELFDATANONE:           /* No data encoding specified */
539     default:                    /* Unknown data encoding specified */
540       goto got_wrong_format_error;
541     }
542
543   if (!bfd_preserve_save (abfd, &preserve))
544     goto got_no_match;
545
546   target = abfd->xvec;
547
548   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
549      the tdata pointer in the bfd.  */
550
551   if (! (*target->_bfd_set_format[bfd_object]) (abfd))
552     goto got_no_match;
553   preserve.marker = elf_tdata (abfd);
554
555   /* Now that we know the byte order, swap in the rest of the header */
556   i_ehdrp = elf_elfheader (abfd);
557   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
558 #if DEBUG & 1
559   elf_debug_file (i_ehdrp);
560 #endif
561
562   /* Reject ET_CORE (header indicates core file, not object file) */
563   if (i_ehdrp->e_type == ET_CORE)
564     goto got_wrong_format_error;
565
566   /* If this is a relocatable file and there is no section header
567      table, then we're hosed.  */
568   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
569     goto got_wrong_format_error;
570
571   /* As a simple sanity check, verify that what BFD thinks is the
572      size of each section header table entry actually matches the size
573      recorded in the file, but only if there are any sections.  */
574   if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
575     goto got_wrong_format_error;
576
577   /* Further sanity check.  */
578   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
579     goto got_wrong_format_error;
580
581   ebd = get_elf_backend_data (abfd);
582   if (ebd->s->arch_size != ARCH_SIZE)
583     goto got_wrong_format_error;
584
585   /* Check that the ELF e_machine field matches what this particular
586      BFD format expects.  */
587   if (ebd->elf_machine_code != i_ehdrp->e_machine
588       && (ebd->elf_machine_alt1 == 0
589           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
590       && (ebd->elf_machine_alt2 == 0
591           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
592     {
593       if (ebd->elf_machine_code != EM_NONE)
594         goto got_wrong_format_error;
595
596       /* This is the generic ELF target.  Let it match any ELF target
597          for which we do not have a specific backend.  */
598       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
599         {
600           const struct elf_backend_data *back;
601
602           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
603             continue;
604           back = xvec_get_elf_backend_data (*target_ptr);
605           if (back->s->arch_size != ARCH_SIZE)
606             continue;
607           if (back->elf_machine_code == i_ehdrp->e_machine
608               || (back->elf_machine_alt1 != 0
609                   && back->elf_machine_alt1 == i_ehdrp->e_machine)
610               || (back->elf_machine_alt2 != 0
611                   && back->elf_machine_alt2 == i_ehdrp->e_machine))
612             {
613               /* target_ptr is an ELF backend which matches this
614                  object file, so reject the generic ELF target.  */
615               goto got_wrong_format_error;
616             }
617         }
618     }
619
620   if (i_ehdrp->e_type == ET_EXEC)
621     abfd->flags |= EXEC_P;
622   else if (i_ehdrp->e_type == ET_DYN)
623     abfd->flags |= DYNAMIC;
624
625   if (i_ehdrp->e_phnum > 0)
626     abfd->flags |= D_PAGED;
627
628   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
629     {
630       /* It's OK if this fails for the generic target.  */
631       if (ebd->elf_machine_code != EM_NONE)
632         goto got_no_match;
633     }
634
635   if (ebd->elf_machine_code != EM_NONE
636       && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
637     {
638       if (ebd->elf_osabi != ELFOSABI_NONE)
639         goto got_wrong_format_error;
640
641       /* This is an ELFOSABI_NONE ELF target.  Let it match any ELF
642          target of the compatible machine for which we do not have a
643          backend with matching ELFOSABI.  */
644       for (target_ptr = bfd_target_vector;
645            *target_ptr != NULL;
646            target_ptr++)
647         {
648           const struct elf_backend_data *back;
649
650           /* Skip this target and targets with incompatible byte
651              order.  */
652           if (*target_ptr == target
653               || (*target_ptr)->flavour != bfd_target_elf_flavour
654               || (*target_ptr)->byteorder != target->byteorder
655               || ((*target_ptr)->header_byteorder
656                   != target->header_byteorder))
657             continue;
658
659           back = xvec_get_elf_backend_data (*target_ptr);
660           if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
661               && (back->elf_machine_code == i_ehdrp->e_machine
662                   || (back->elf_machine_alt1 != 0
663                       && back->elf_machine_alt1 == i_ehdrp->e_machine)
664                   || (back->elf_machine_alt2 != 0
665                       && back->elf_machine_alt2 == i_ehdrp->e_machine)))
666             {
667               /* target_ptr is an ELF backend which matches this
668                  object file, so reject the ELFOSABI_NONE ELF target.  */
669               goto got_wrong_format_error;
670             }
671         }
672     }
673
674   if (i_ehdrp->e_shoff != 0)
675     {
676       bfd_signed_vma where = i_ehdrp->e_shoff;
677
678       if (where != (file_ptr) where)
679         goto got_wrong_format_error;
680
681       /* Seek to the section header table in the file.  */
682       if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
683         goto got_no_match;
684
685       /* Read the first section header at index 0, and convert to internal
686          form.  */
687       if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
688         goto got_no_match;
689       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
690
691       /* If the section count is zero, the actual count is in the first
692          section header.  */
693       if (i_ehdrp->e_shnum == SHN_UNDEF)
694         {
695           i_ehdrp->e_shnum = i_shdr.sh_size;
696           if (i_ehdrp->e_shnum != i_shdr.sh_size
697               || i_ehdrp->e_shnum == 0)
698             goto got_wrong_format_error;
699         }
700
701       /* And similarly for the string table index.  */
702       if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
703         {
704           i_ehdrp->e_shstrndx = i_shdr.sh_link;
705           if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
706             goto got_wrong_format_error;
707         }
708
709       /* And program headers.  */
710       if (i_ehdrp->e_phnum == PN_XNUM && i_shdr.sh_info != 0)
711         {
712           i_ehdrp->e_phnum = i_shdr.sh_info;
713           if (i_ehdrp->e_phnum != i_shdr.sh_info)
714             goto got_wrong_format_error;
715         }
716
717       /* Sanity check that we can read all of the section headers.
718          It ought to be good enough to just read the last one.  */
719       if (i_ehdrp->e_shnum != 1)
720         {
721           /* Check that we don't have a totally silly number of sections.  */
722           if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
723               || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
724             goto got_wrong_format_error;
725
726           where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
727           if (where != (file_ptr) where)
728             goto got_wrong_format_error;
729           if ((bfd_size_type) where <= i_ehdrp->e_shoff)
730             goto got_wrong_format_error;
731
732           if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
733             goto got_no_match;
734           if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
735             goto got_no_match;
736
737           /* Back to where we were.  */
738           where = i_ehdrp->e_shoff + sizeof (x_shdr);
739           if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
740             goto got_no_match;
741         }
742     }
743
744   /* Allocate space for a copy of the section header table in
745      internal form.  */
746   if (i_ehdrp->e_shnum != 0)
747     {
748       Elf_Internal_Shdr *shdrp;
749       unsigned int num_sec;
750
751       amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
752       i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
753       if (!i_shdrp)
754         goto got_no_match;
755       num_sec = i_ehdrp->e_shnum;
756       elf_numsections (abfd) = num_sec;
757       amt = sizeof (i_shdrp) * num_sec;
758       elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
759       if (!elf_elfsections (abfd))
760         goto got_no_match;
761
762       memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
763       for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
764         elf_elfsections (abfd)[shindex] = shdrp++;
765
766       /* Read in the rest of the section header table and convert it
767          to internal form.  */
768       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
769         {
770           if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
771             goto got_no_match;
772           elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
773
774           /* Sanity check sh_link and sh_info.  */
775           if (i_shdrp[shindex].sh_link >= num_sec)
776             {
777               /* PR 10478: Accept Solaris binaries with a sh_link
778                  field set to SHN_BEFORE or SHN_AFTER.  */
779               switch (ebd->elf_machine_code)
780                 {
781                 case EM_386:
782                 case EM_486:
783                 case EM_X86_64:
784                 case EM_OLD_SPARCV9:
785                 case EM_SPARC32PLUS:
786                 case EM_SPARCV9:
787                 case EM_SPARC:
788                   if (i_shdrp[shindex].sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
789                       || i_shdrp[shindex].sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
790                     break;
791                   /* Otherwise fall through.  */
792                 default:
793                   goto got_wrong_format_error;
794                 }
795             }
796
797           if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
798                || i_shdrp[shindex].sh_type == SHT_RELA
799                || i_shdrp[shindex].sh_type == SHT_REL)
800               && i_shdrp[shindex].sh_info >= num_sec)
801             goto got_wrong_format_error;
802
803           /* If the section is loaded, but not page aligned, clear
804              D_PAGED.  */
805           if (i_shdrp[shindex].sh_size != 0
806               && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
807               && i_shdrp[shindex].sh_type != SHT_NOBITS
808               && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
809                    % ebd->minpagesize)
810                   != 0))
811             abfd->flags &= ~D_PAGED;
812         }
813     }
814
815   /* A further sanity check.  */
816   if (i_ehdrp->e_shnum != 0)
817     {
818       if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
819         {
820           /* PR 2257:
821              We used to just goto got_wrong_format_error here
822              but there are binaries in existance for which this test
823              will prevent the binutils from working with them at all.
824              So we are kind, and reset the string index value to 0
825              so that at least some processing can be done.  */
826           i_ehdrp->e_shstrndx = SHN_UNDEF;
827           _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
828         }
829     }
830   else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
831     goto got_wrong_format_error;
832
833   /* Read in the program headers.  */
834   if (i_ehdrp->e_phnum == 0)
835     elf_tdata (abfd)->phdr = NULL;
836   else
837     {
838       Elf_Internal_Phdr *i_phdr;
839       unsigned int i;
840
841       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
842       elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
843       if (elf_tdata (abfd)->phdr == NULL)
844         goto got_no_match;
845       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
846         goto got_no_match;
847       i_phdr = elf_tdata (abfd)->phdr;
848       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
849         {
850           Elf_External_Phdr x_phdr;
851
852           if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
853             goto got_no_match;
854           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
855         }
856     }
857
858   if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
859     {
860       unsigned int num_sec;
861
862       /* Once all of the section headers have been read and converted, we
863          can start processing them.  Note that the first section header is
864          a dummy placeholder entry, so we ignore it.  */
865       num_sec = elf_numsections (abfd);
866       for (shindex = 1; shindex < num_sec; shindex++)
867         if (!bfd_section_from_shdr (abfd, shindex))
868           goto got_no_match;
869
870       /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER.  */
871       if (! _bfd_elf_setup_sections (abfd))
872         goto got_wrong_format_error;
873     }
874
875   /* Let the backend double check the format and override global
876      information.  */
877   if (ebd->elf_backend_object_p)
878     {
879       if (! (*ebd->elf_backend_object_p) (abfd))
880         goto got_wrong_format_error;
881     }
882
883   /* Remember the entry point specified in the ELF file header.  */
884   bfd_set_start_address (abfd, i_ehdrp->e_entry);
885
886   /* If we have created any reloc sections that are associated with
887      debugging sections, mark the reloc sections as debugging as well.  */
888   for (s = abfd->sections; s != NULL; s = s->next)
889     {
890       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
891            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
892           && elf_section_data (s)->this_hdr.sh_info > 0)
893         {
894           unsigned long targ_index;
895           asection *targ_sec;
896
897           targ_index = elf_section_data (s)->this_hdr.sh_info;
898           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
899           if (targ_sec != NULL
900               && (targ_sec->flags & SEC_DEBUGGING) != 0)
901             s->flags |= SEC_DEBUGGING;
902         }
903     }
904
905   bfd_preserve_finish (abfd, &preserve);
906   return target;
907
908  got_wrong_format_error:
909   /* There is way too much undoing of half-known state here.  The caller,
910      bfd_check_format_matches, really shouldn't iterate on live bfd's to
911      check match/no-match like it does.  We have to rely on that a call to
912      bfd_default_set_arch_mach with the previously known mach, undoes what
913      was done by the first bfd_default_set_arch_mach (with mach 0) here.
914      For this to work, only elf-data and the mach may be changed by the
915      target-specific elf_backend_object_p function.  Note that saving the
916      whole bfd here and restoring it would be even worse; the first thing
917      you notice is that the cached bfd file position gets out of sync.  */
918   bfd_set_error (bfd_error_wrong_format);
919
920  got_no_match:
921   if (preserve.marker != NULL)
922     bfd_preserve_restore (abfd, &preserve);
923   return NULL;
924 }
925 \f
926 /* ELF .o/exec file writing */
927
928 /* Write out the relocs.  */
929
930 void
931 elf_write_relocs (bfd *abfd, asection *sec, void *data)
932 {
933   bfd_boolean *failedp = (bfd_boolean *) data;
934   Elf_Internal_Shdr *rela_hdr;
935   bfd_vma addr_offset;
936   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
937   size_t extsize;
938   bfd_byte *dst_rela;
939   unsigned int idx;
940   asymbol *last_sym;
941   int last_sym_idx;
942
943   /* If we have already failed, don't do anything.  */
944   if (*failedp)
945     return;
946
947   if ((sec->flags & SEC_RELOC) == 0)
948     return;
949
950   /* The linker backend writes the relocs out itself, and sets the
951      reloc_count field to zero to inhibit writing them here.  Also,
952      sometimes the SEC_RELOC flag gets set even when there aren't any
953      relocs.  */
954   if (sec->reloc_count == 0)
955     return;
956
957   /* If we have opened an existing file for update, reloc_count may be
958      set even though we are not linking.  In that case we have nothing
959      to do.  */
960   if (sec->orelocation == NULL)
961     return;
962
963   rela_hdr = elf_section_data (sec)->rela.hdr;
964   if (rela_hdr == NULL)
965     rela_hdr = elf_section_data (sec)->rel.hdr;
966
967   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
968   rela_hdr->contents = (unsigned char *) bfd_alloc (abfd, rela_hdr->sh_size);
969   if (rela_hdr->contents == NULL)
970     {
971       *failedp = TRUE;
972       return;
973     }
974
975   /* Figure out whether the relocations are RELA or REL relocations.  */
976   if (rela_hdr->sh_type == SHT_RELA)
977     {
978       swap_out = elf_swap_reloca_out;
979       extsize = sizeof (Elf_External_Rela);
980     }
981   else if (rela_hdr->sh_type == SHT_REL)
982     {
983       swap_out = elf_swap_reloc_out;
984       extsize = sizeof (Elf_External_Rel);
985     }
986   else
987     /* Every relocation section should be either an SHT_RELA or an
988        SHT_REL section.  */
989     abort ();
990
991   /* The address of an ELF reloc is section relative for an object
992      file, and absolute for an executable file or shared library.
993      The address of a BFD reloc is always section relative.  */
994   addr_offset = 0;
995   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
996     addr_offset = sec->vma;
997
998   /* orelocation has the data, reloc_count has the count...  */
999   last_sym = 0;
1000   last_sym_idx = 0;
1001   dst_rela = rela_hdr->contents;
1002
1003   for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
1004     {
1005       Elf_Internal_Rela src_rela;
1006       arelent *ptr;
1007       asymbol *sym;
1008       int n;
1009
1010       ptr = sec->orelocation[idx];
1011       sym = *ptr->sym_ptr_ptr;
1012       if (sym == last_sym)
1013         n = last_sym_idx;
1014       else if (bfd_is_abs_section (sym->section) && sym->value == 0)
1015         n = STN_UNDEF;
1016       else
1017         {
1018           last_sym = sym;
1019           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
1020           if (n < 0)
1021             {
1022               *failedp = TRUE;
1023               return;
1024             }
1025           last_sym_idx = n;
1026         }
1027
1028       if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
1029           && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
1030           && ! _bfd_elf_validate_reloc (abfd, ptr))
1031         {
1032           *failedp = TRUE;
1033           return;
1034         }
1035
1036       src_rela.r_offset = ptr->address + addr_offset;
1037       src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1038       src_rela.r_addend = ptr->addend;
1039       (*swap_out) (abfd, &src_rela, dst_rela);
1040     }
1041 }
1042
1043 /* Write out the program headers.  */
1044
1045 int
1046 elf_write_out_phdrs (bfd *abfd,
1047                      const Elf_Internal_Phdr *phdr,
1048                      unsigned int count)
1049 {
1050   while (count--)
1051     {
1052       Elf_External_Phdr extphdr;
1053       elf_swap_phdr_out (abfd, phdr, &extphdr);
1054       if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1055           != sizeof (Elf_External_Phdr))
1056         return -1;
1057       phdr++;
1058     }
1059   return 0;
1060 }
1061
1062 /* Write out the section headers and the ELF file header.  */
1063
1064 bfd_boolean
1065 elf_write_shdrs_and_ehdr (bfd *abfd)
1066 {
1067   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1068   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
1069   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
1070   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
1071   unsigned int count;
1072   bfd_size_type amt;
1073
1074   i_ehdrp = elf_elfheader (abfd);
1075   i_shdrp = elf_elfsections (abfd);
1076
1077   /* swap the header before spitting it out...  */
1078
1079 #if DEBUG & 1
1080   elf_debug_file (i_ehdrp);
1081 #endif
1082   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1083   amt = sizeof (x_ehdr);
1084   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1085       || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1086     return FALSE;
1087
1088   /* Some fields in the first section header handle overflow of ehdr
1089      fields.  */
1090   if (i_ehdrp->e_phnum >= PN_XNUM)
1091     i_shdrp[0]->sh_info = i_ehdrp->e_phnum;
1092   if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1093     i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1094   if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1095     i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1096
1097   /* at this point we've concocted all the ELF sections...  */
1098   amt = i_ehdrp->e_shnum;
1099   amt *= sizeof (*x_shdrp);
1100   x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1101   if (!x_shdrp)
1102     return FALSE;
1103
1104   for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1105     {
1106 #if DEBUG & 2
1107       elf_debug_section (count, *i_shdrp);
1108 #endif
1109       elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1110     }
1111   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1112       || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1113     return FALSE;
1114
1115   /* need to dump the string table too...  */
1116
1117   return TRUE;
1118 }
1119
1120 bfd_boolean
1121 elf_checksum_contents (bfd *abfd,
1122                        void (*process) (const void *, size_t, void *),
1123                        void *arg)
1124 {
1125   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1126   Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1127   Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1128   unsigned int count, num;
1129
1130   {
1131     Elf_External_Ehdr x_ehdr;
1132     Elf_Internal_Ehdr i_ehdr;
1133
1134     i_ehdr = *i_ehdrp;
1135     i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1136     elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1137     (*process) (&x_ehdr, sizeof x_ehdr, arg);
1138   }
1139
1140   num = i_ehdrp->e_phnum;
1141   for (count = 0; count < num; count++)
1142     {
1143       Elf_External_Phdr x_phdr;
1144       elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1145       (*process) (&x_phdr, sizeof x_phdr, arg);
1146     }
1147
1148   num = elf_numsections (abfd);
1149   for (count = 0; count < num; count++)
1150     {
1151       Elf_Internal_Shdr i_shdr;
1152       Elf_External_Shdr x_shdr;
1153
1154       i_shdr = *i_shdrp[count];
1155       i_shdr.sh_offset = 0;
1156
1157       elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1158       (*process) (&x_shdr, sizeof x_shdr, arg);
1159
1160       if (i_shdr.contents)
1161         (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1162     }
1163
1164   return TRUE;
1165 }
1166
1167 long
1168 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1169 {
1170   Elf_Internal_Shdr *hdr;
1171   Elf_Internal_Shdr *verhdr;
1172   unsigned long symcount;       /* Number of external ELF symbols */
1173   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1174   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1175   Elf_Internal_Sym *isym;
1176   Elf_Internal_Sym *isymend;
1177   Elf_Internal_Sym *isymbuf = NULL;
1178   Elf_External_Versym *xver;
1179   Elf_External_Versym *xverbuf = NULL;
1180   const struct elf_backend_data *ebd;
1181   bfd_size_type amt;
1182
1183   /* Read each raw ELF symbol, converting from external ELF form to
1184      internal ELF form, and then using the information to create a
1185      canonical bfd symbol table entry.
1186
1187      Note that we allocate the initial bfd canonical symbol buffer
1188      based on a one-to-one mapping of the ELF symbols to canonical
1189      symbols.  We actually use all the ELF symbols, so there will be no
1190      space left over at the end.  When we have all the symbols, we
1191      build the caller's pointer vector.  */
1192
1193   if (! dynamic)
1194     {
1195       hdr = &elf_tdata (abfd)->symtab_hdr;
1196       verhdr = NULL;
1197     }
1198   else
1199     {
1200       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1201       if (elf_dynversym (abfd) == 0)
1202         verhdr = NULL;
1203       else
1204         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1205       if ((elf_tdata (abfd)->dynverdef_section != 0
1206            && elf_tdata (abfd)->verdef == NULL)
1207           || (elf_tdata (abfd)->dynverref_section != 0
1208               && elf_tdata (abfd)->verref == NULL))
1209         {
1210           if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1211             return -1;
1212         }
1213     }
1214
1215   ebd = get_elf_backend_data (abfd);
1216   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1217   if (symcount == 0)
1218     sym = symbase = NULL;
1219   else
1220     {
1221       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1222                                       NULL, NULL, NULL);
1223       if (isymbuf == NULL)
1224         return -1;
1225
1226       amt = symcount;
1227       amt *= sizeof (elf_symbol_type);
1228       symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1229       if (symbase == (elf_symbol_type *) NULL)
1230         goto error_return;
1231
1232       /* Read the raw ELF version symbol information.  */
1233       if (verhdr != NULL
1234           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1235         {
1236           (*_bfd_error_handler)
1237             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1238              abfd->filename,
1239              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1240              symcount);
1241
1242           /* Slurp in the symbols without the version information,
1243              since that is more helpful than just quitting.  */
1244           verhdr = NULL;
1245         }
1246
1247       if (verhdr != NULL)
1248         {
1249           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1250             goto error_return;
1251
1252           xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1253           if (xverbuf == NULL && verhdr->sh_size != 0)
1254             goto error_return;
1255
1256           if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1257             goto error_return;
1258         }
1259
1260       /* Skip first symbol, which is a null dummy.  */
1261       xver = xverbuf;
1262       if (xver != NULL)
1263         ++xver;
1264       isymend = isymbuf + symcount;
1265       for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1266         {
1267           memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1268           sym->symbol.the_bfd = abfd;
1269
1270           sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1271
1272           sym->symbol.value = isym->st_value;
1273
1274           if (isym->st_shndx == SHN_UNDEF)
1275             {
1276               sym->symbol.section = bfd_und_section_ptr;
1277             }
1278           else if (isym->st_shndx == SHN_ABS)
1279             {
1280               sym->symbol.section = bfd_abs_section_ptr;
1281             }
1282           else if (isym->st_shndx == SHN_COMMON)
1283             {
1284               sym->symbol.section = bfd_com_section_ptr;
1285               /* Elf puts the alignment into the `value' field, and
1286                  the size into the `size' field.  BFD wants to see the
1287                  size in the value field, and doesn't care (at the
1288                  moment) about the alignment.  */
1289               sym->symbol.value = isym->st_size;
1290             }
1291           else
1292             {
1293               sym->symbol.section
1294                 = bfd_section_from_elf_index (abfd, isym->st_shndx);
1295               if (sym->symbol.section == NULL)
1296                 {
1297                   /* This symbol is in a section for which we did not
1298                      create a BFD section.  Just use bfd_abs_section,
1299                      although it is wrong.  FIXME.  */
1300                   sym->symbol.section = bfd_abs_section_ptr;
1301                 }
1302             }
1303
1304           /* If this is a relocatable file, then the symbol value is
1305              already section relative.  */
1306           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1307             sym->symbol.value -= sym->symbol.section->vma;
1308
1309           switch (ELF_ST_BIND (isym->st_info))
1310             {
1311             case STB_LOCAL:
1312               sym->symbol.flags |= BSF_LOCAL;
1313               break;
1314             case STB_GLOBAL:
1315               if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1316                 sym->symbol.flags |= BSF_GLOBAL;
1317               break;
1318             case STB_WEAK:
1319               sym->symbol.flags |= BSF_WEAK;
1320               break;
1321             case STB_GNU_UNIQUE:
1322               sym->symbol.flags |= BSF_GNU_UNIQUE;
1323               break;
1324             }
1325
1326           switch (ELF_ST_TYPE (isym->st_info))
1327             {
1328             case STT_SECTION:
1329               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1330               break;
1331             case STT_FILE:
1332               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1333               break;
1334             case STT_FUNC:
1335               sym->symbol.flags |= BSF_FUNCTION;
1336               break;
1337             case STT_COMMON:
1338               /* FIXME: Do we have to put the size field into the value field
1339                  as we do with symbols in SHN_COMMON sections (see above) ?  */
1340               /* Fall through.  */
1341             case STT_OBJECT:
1342               sym->symbol.flags |= BSF_OBJECT;
1343               break;
1344             case STT_TLS:
1345               sym->symbol.flags |= BSF_THREAD_LOCAL;
1346               break;
1347             case STT_RELC:
1348               sym->symbol.flags |= BSF_RELC;
1349               break;
1350             case STT_SRELC:
1351               sym->symbol.flags |= BSF_SRELC;
1352               break;
1353             case STT_GNU_IFUNC:
1354               sym->symbol.flags |= BSF_GNU_INDIRECT_FUNCTION;
1355               break;
1356             }
1357
1358           if (dynamic)
1359             sym->symbol.flags |= BSF_DYNAMIC;
1360
1361           if (xver != NULL)
1362             {
1363               Elf_Internal_Versym iversym;
1364
1365               _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1366               sym->version = iversym.vs_vers;
1367               xver++;
1368             }
1369
1370           /* Do some backend-specific processing on this symbol.  */
1371           if (ebd->elf_backend_symbol_processing)
1372             (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1373         }
1374     }
1375
1376   /* Do some backend-specific processing on this symbol table.  */
1377   if (ebd->elf_backend_symbol_table_processing)
1378     (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1379
1380   /* We rely on the zalloc to clear out the final symbol entry.  */
1381
1382   symcount = sym - symbase;
1383
1384   /* Fill in the user's symbol pointer vector if needed.  */
1385   if (symptrs)
1386     {
1387       long l = symcount;
1388
1389       sym = symbase;
1390       while (l-- > 0)
1391         {
1392           *symptrs++ = &sym->symbol;
1393           sym++;
1394         }
1395       *symptrs = 0;             /* Final null pointer */
1396     }
1397
1398   if (xverbuf != NULL)
1399     free (xverbuf);
1400   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1401     free (isymbuf);
1402   return symcount;
1403
1404 error_return:
1405   if (xverbuf != NULL)
1406     free (xverbuf);
1407   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1408     free (isymbuf);
1409   return -1;
1410 }
1411
1412 /* Read relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1413    them.  */
1414
1415 static bfd_boolean
1416 elf_slurp_reloc_table_from_section (bfd *abfd,
1417                                     asection *asect,
1418                                     Elf_Internal_Shdr *rel_hdr,
1419                                     bfd_size_type reloc_count,
1420                                     arelent *relents,
1421                                     asymbol **symbols,
1422                                     bfd_boolean dynamic)
1423 {
1424   const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1425   void *allocated = NULL;
1426   bfd_byte *native_relocs;
1427   arelent *relent;
1428   unsigned int i;
1429   int entsize;
1430   unsigned int symcount;
1431
1432   allocated = bfd_malloc (rel_hdr->sh_size);
1433   if (allocated == NULL)
1434     goto error_return;
1435
1436   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1437       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1438           != rel_hdr->sh_size))
1439     goto error_return;
1440
1441   native_relocs = (bfd_byte *) allocated;
1442
1443   entsize = rel_hdr->sh_entsize;
1444   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1445               || entsize == sizeof (Elf_External_Rela));
1446
1447   if (dynamic)
1448     symcount = bfd_get_dynamic_symcount (abfd);
1449   else
1450     symcount = bfd_get_symcount (abfd);
1451
1452   for (i = 0, relent = relents;
1453        i < reloc_count;
1454        i++, relent++, native_relocs += entsize)
1455     {
1456       Elf_Internal_Rela rela;
1457
1458       if (entsize == sizeof (Elf_External_Rela))
1459         elf_swap_reloca_in (abfd, native_relocs, &rela);
1460       else
1461         elf_swap_reloc_in (abfd, native_relocs, &rela);
1462
1463       /* The address of an ELF reloc is section relative for an object
1464          file, and absolute for an executable file or shared library.
1465          The address of a normal BFD reloc is always section relative,
1466          and the address of a dynamic reloc is absolute..  */
1467       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1468         relent->address = rela.r_offset;
1469       else
1470         relent->address = rela.r_offset - asect->vma;
1471
1472       if (ELF_R_SYM (rela.r_info) == STN_UNDEF)
1473         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1474       else if (ELF_R_SYM (rela.r_info) > symcount)
1475         {
1476           (*_bfd_error_handler)
1477             (_("%s(%s): relocation %d has invalid symbol index %ld"),
1478              abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1479           relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1480         }
1481       else
1482         {
1483           asymbol **ps;
1484
1485           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1486
1487           relent->sym_ptr_ptr = ps;
1488         }
1489
1490       relent->addend = rela.r_addend;
1491
1492       if ((entsize == sizeof (Elf_External_Rela)
1493            && ebd->elf_info_to_howto != NULL)
1494           || ebd->elf_info_to_howto_rel == NULL)
1495         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1496       else
1497         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1498     }
1499
1500   if (allocated != NULL)
1501     free (allocated);
1502
1503   return TRUE;
1504
1505  error_return:
1506   if (allocated != NULL)
1507     free (allocated);
1508   return FALSE;
1509 }
1510
1511 /* Read in and swap the external relocs.  */
1512
1513 bfd_boolean
1514 elf_slurp_reloc_table (bfd *abfd,
1515                        asection *asect,
1516                        asymbol **symbols,
1517                        bfd_boolean dynamic)
1518 {
1519   struct bfd_elf_section_data * const d = elf_section_data (asect);
1520   Elf_Internal_Shdr *rel_hdr;
1521   Elf_Internal_Shdr *rel_hdr2;
1522   bfd_size_type reloc_count;
1523   bfd_size_type reloc_count2;
1524   arelent *relents;
1525   bfd_size_type amt;
1526
1527   if (asect->relocation != NULL)
1528     return TRUE;
1529
1530   if (! dynamic)
1531     {
1532       if ((asect->flags & SEC_RELOC) == 0
1533           || asect->reloc_count == 0)
1534         return TRUE;
1535
1536       rel_hdr = d->rel.hdr;
1537       reloc_count = rel_hdr ? NUM_SHDR_ENTRIES (rel_hdr) : 0;
1538       rel_hdr2 = d->rela.hdr;
1539       reloc_count2 = rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0;
1540
1541       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1542       BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
1543                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1544
1545     }
1546   else
1547     {
1548       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1549          case because relocations against this section may use the
1550          dynamic symbol table, and in that case bfd_section_from_shdr
1551          in elf.c does not update the RELOC_COUNT.  */
1552       if (asect->size == 0)
1553         return TRUE;
1554
1555       rel_hdr = &d->this_hdr;
1556       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1557       rel_hdr2 = NULL;
1558       reloc_count2 = 0;
1559     }
1560
1561   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1562   relents = (arelent *) bfd_alloc (abfd, amt);
1563   if (relents == NULL)
1564     return FALSE;
1565
1566   if (rel_hdr
1567       && !elf_slurp_reloc_table_from_section (abfd, asect,
1568                                               rel_hdr, reloc_count,
1569                                               relents,
1570                                               symbols, dynamic))
1571     return FALSE;
1572
1573   if (rel_hdr2
1574       && !elf_slurp_reloc_table_from_section (abfd, asect,
1575                                               rel_hdr2, reloc_count2,
1576                                               relents + reloc_count,
1577                                               symbols, dynamic))
1578     return FALSE;
1579
1580   asect->relocation = relents;
1581   return TRUE;
1582 }
1583
1584 #if DEBUG & 2
1585 static void
1586 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1587 {
1588   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1589            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1590            (long) hdr);
1591   fprintf (stderr,
1592            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1593            (long) hdr->sh_name,
1594            (long) hdr->sh_type,
1595            (long) hdr->sh_flags);
1596   fprintf (stderr,
1597            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1598            (long) hdr->sh_addr,
1599            (long) hdr->sh_offset,
1600            (long) hdr->sh_size);
1601   fprintf (stderr,
1602            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1603            (long) hdr->sh_link,
1604            (long) hdr->sh_info,
1605            (long) hdr->sh_addralign);
1606   fprintf (stderr, "sh_entsize   = %ld\n",
1607            (long) hdr->sh_entsize);
1608   fflush (stderr);
1609 }
1610 #endif
1611
1612 #if DEBUG & 1
1613 static void
1614 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1615 {
1616   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1617   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1618   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1619   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1620   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1621   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1622   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1623 }
1624 #endif
1625 \f
1626 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
1627    reconstruct an ELF file by reading the segments out of remote memory
1628    based on the ELF file header at EHDR_VMA and the ELF program headers it
1629    points to.  If not null, *LOADBASEP is filled in with the difference
1630    between the VMAs from which the segments were read, and the VMAs the
1631    file headers (and hence BFD's idea of each section's VMA) put them at.
1632
1633    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1634    remote memory at target address VMA into the local buffer at MYADDR; it
1635    should return zero on success or an `errno' code on failure.  TEMPL must
1636    be a BFD for a target with the word size and byte order found in the
1637    remote memory.  */
1638
1639 bfd *
1640 NAME(_bfd_elf,bfd_from_remote_memory)
1641   (bfd *templ,
1642    bfd_vma ehdr_vma,
1643    bfd_vma *loadbasep,
1644    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1645 {
1646   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1647   Elf_Internal_Ehdr i_ehdr;     /* Elf file header, internal form */
1648   Elf_External_Phdr *x_phdrs;
1649   Elf_Internal_Phdr *i_phdrs, *last_phdr;
1650   bfd *nbfd;
1651   struct bfd_in_memory *bim;
1652   int contents_size;
1653   bfd_byte *contents;
1654   int err;
1655   unsigned int i;
1656   bfd_vma loadbase;
1657   bfd_boolean loadbase_set;
1658
1659   /* Read in the ELF header in external format.  */
1660   err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1661   if (err)
1662     {
1663       bfd_set_error (bfd_error_system_call);
1664       errno = err;
1665       return NULL;
1666     }
1667
1668   /* Now check to see if we have a valid ELF file, and one that BFD can
1669      make use of.  The magic number must match, the address size ('class')
1670      and byte-swapping must match our XVEC entry.  */
1671
1672   if (! elf_file_p (&x_ehdr)
1673       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1674       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1675     {
1676       bfd_set_error (bfd_error_wrong_format);
1677       return NULL;
1678     }
1679
1680   /* Check that file's byte order matches xvec's */
1681   switch (x_ehdr.e_ident[EI_DATA])
1682     {
1683     case ELFDATA2MSB:           /* Big-endian */
1684       if (! bfd_header_big_endian (templ))
1685         {
1686           bfd_set_error (bfd_error_wrong_format);
1687           return NULL;
1688         }
1689       break;
1690     case ELFDATA2LSB:           /* Little-endian */
1691       if (! bfd_header_little_endian (templ))
1692         {
1693           bfd_set_error (bfd_error_wrong_format);
1694           return NULL;
1695         }
1696       break;
1697     case ELFDATANONE:           /* No data encoding specified */
1698     default:                    /* Unknown data encoding specified */
1699       bfd_set_error (bfd_error_wrong_format);
1700       return NULL;
1701     }
1702
1703   elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1704
1705   /* The file header tells where to find the program headers.
1706      These are what we use to actually choose what to read.  */
1707
1708   if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1709     {
1710       bfd_set_error (bfd_error_wrong_format);
1711       return NULL;
1712     }
1713
1714   x_phdrs = (Elf_External_Phdr *)
1715       bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1716   if (x_phdrs == NULL)
1717     {
1718       bfd_set_error (bfd_error_no_memory);
1719       return NULL;
1720     }
1721   err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1722                             i_ehdr.e_phnum * sizeof x_phdrs[0]);
1723   if (err)
1724     {
1725       free (x_phdrs);
1726       bfd_set_error (bfd_error_system_call);
1727       errno = err;
1728       return NULL;
1729     }
1730   i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1731
1732   contents_size = 0;
1733   last_phdr = NULL;
1734   loadbase = ehdr_vma;
1735   loadbase_set = FALSE;
1736   for (i = 0; i < i_ehdr.e_phnum; ++i)
1737     {
1738       elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1739       if (i_phdrs[i].p_type == PT_LOAD)
1740         {
1741           bfd_vma segment_end;
1742           segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1743                          + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1744           if (segment_end > (bfd_vma) contents_size)
1745             contents_size = segment_end;
1746
1747           /* LOADADDR is the `Base address' from the gELF specification:
1748              `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1749              first PT_LOAD as PT_LOADs are ordered by P_VADDR.  */
1750           if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1751             {
1752               loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1753               loadbase_set = TRUE;
1754             }
1755
1756           last_phdr = &i_phdrs[i];
1757         }
1758     }
1759   if (last_phdr == NULL)
1760     {
1761       /* There were no PT_LOAD segments, so we don't have anything to read.  */
1762       free (x_phdrs);
1763       bfd_set_error (bfd_error_wrong_format);
1764       return NULL;
1765     }
1766
1767   /* Trim the last segment so we don't bother with zeros in the last page
1768      that are off the end of the file.  However, if the extra bit in that
1769      page includes the section headers, keep them.  */
1770   if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1771       && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1772                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1773     {
1774       contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1775       if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1776                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1777         contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1778     }
1779   else
1780     contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1781
1782   /* Now we know the size of the whole image we want read in.  */
1783   contents = (bfd_byte *) bfd_zmalloc (contents_size);
1784   if (contents == NULL)
1785     {
1786       free (x_phdrs);
1787       bfd_set_error (bfd_error_no_memory);
1788       return NULL;
1789     }
1790
1791   for (i = 0; i < i_ehdr.e_phnum; ++i)
1792     if (i_phdrs[i].p_type == PT_LOAD)
1793       {
1794         bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1795         bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1796                        + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1797         if (end > (bfd_vma) contents_size)
1798           end = contents_size;
1799         err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1800                                   & -i_phdrs[i].p_align,
1801                                   contents + start, end - start);
1802         if (err)
1803           {
1804             free (x_phdrs);
1805             free (contents);
1806             bfd_set_error (bfd_error_system_call);
1807             errno = err;
1808             return NULL;
1809           }
1810       }
1811   free (x_phdrs);
1812
1813   /* If the segments visible in memory didn't include the section headers,
1814      then clear them from the file header.  */
1815   if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1816                                  + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1817     {
1818       memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1819       memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1820       memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1821     }
1822
1823   /* This will normally have been in the first PT_LOAD segment.  But it
1824      conceivably could be missing, and we might have just changed it.  */
1825   memcpy (contents, &x_ehdr, sizeof x_ehdr);
1826
1827   /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
1828   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1829   if (bim == NULL)
1830     {
1831       free (contents);
1832       bfd_set_error (bfd_error_no_memory);
1833       return NULL;
1834     }
1835   nbfd = _bfd_new_bfd ();
1836   if (nbfd == NULL)
1837     {
1838       free (bim);
1839       free (contents);
1840       bfd_set_error (bfd_error_no_memory);
1841       return NULL;
1842     }
1843   nbfd->filename = "<in-memory>";
1844   nbfd->xvec = templ->xvec;
1845   bim->size = contents_size;
1846   bim->buffer = contents;
1847   nbfd->iostream = bim;
1848   nbfd->flags = BFD_IN_MEMORY;
1849   nbfd->iovec = &_bfd_memory_iovec;
1850   nbfd->origin = 0;
1851   nbfd->direction = read_direction;
1852   nbfd->mtime = time (NULL);
1853   nbfd->mtime_set = TRUE;
1854
1855   if (loadbasep)
1856     *loadbasep = loadbase;
1857   return nbfd;
1858 }
1859
1860 /* Function for ELF_R_INFO.  */
1861
1862 bfd_vma
1863 NAME(elf,r_info) (bfd_vma sym, bfd_vma type)
1864 {
1865   return ELF_R_INFO (sym, type);
1866 }
1867
1868 /* Function for ELF_R_SYM.  */
1869
1870 bfd_vma
1871 NAME(elf,r_sym) (bfd_vma r_info)
1872 {
1873   return ELF_R_SYM (r_info);
1874 }
1875 \f
1876 #include "elfcore.h"
1877 \f
1878 /* Size-dependent data and functions.  */
1879 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1880   sizeof (Elf_External_Ehdr),
1881   sizeof (Elf_External_Phdr),
1882   sizeof (Elf_External_Shdr),
1883   sizeof (Elf_External_Rel),
1884   sizeof (Elf_External_Rela),
1885   sizeof (Elf_External_Sym),
1886   sizeof (Elf_External_Dyn),
1887   sizeof (Elf_External_Note),
1888   4,
1889   1,
1890   ARCH_SIZE, LOG_FILE_ALIGN,
1891   ELFCLASS, EV_CURRENT,
1892   elf_write_out_phdrs,
1893   elf_write_shdrs_and_ehdr,
1894   elf_checksum_contents,
1895   elf_write_relocs,
1896   elf_swap_symbol_in,
1897   elf_swap_symbol_out,
1898   elf_slurp_reloc_table,
1899   elf_slurp_symbol_table,
1900   elf_swap_dyn_in,
1901   elf_swap_dyn_out,
1902   elf_swap_reloc_in,
1903   elf_swap_reloc_out,
1904   elf_swap_reloca_in,
1905   elf_swap_reloca_out
1906 };