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