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