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