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