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