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