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