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