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