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