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