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