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