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