1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
63 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
82 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
83 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
84 #define elf_object_p NAME(bfd_elf,object_p)
85 #define elf_core_file_p NAME(bfd_elf,core_file_p)
86 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
87 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
88 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
89 #define elf_get_symtab NAME(bfd_elf,get_symtab)
90 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
91 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
92 #define elf_print_symbol NAME(bfd_elf,print_symbol)
93 #define elf_get_lineno NAME(bfd_elf,get_lineno)
94 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
95 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
96 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
97 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
98 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
99 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
100 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
101 #define write_relocs NAME(bfd_elf,_write_relocs)
102 #define elf_find_section NAME(bfd_elf,find_section)
105 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
106 #define ELF_R_SYM(X) ELF64_R_SYM(X)
107 #define ELFCLASS ELFCLASS64
111 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
112 #define ELF_R_SYM(X) ELF32_R_SYM(X)
113 #define ELFCLASS ELFCLASS32
117 static int shstrtab_length_fixed;
119 struct elf_sect_data {
124 /* Forward declarations of static functions */
126 static struct sec * section_from_elf_index PARAMS ((bfd *, int));
128 static int elf_section_from_bfd_section PARAMS ((bfd *, struct sec *));
130 static boolean elf_slurp_symbol_table PARAMS ((bfd *, asymbol **));
132 static int elf_symbol_from_bfd_symbol PARAMS ((bfd *,
133 struct symbol_cache_entry **));
135 static void elf_map_symbols PARAMS ((bfd *));
136 static void swap_out_syms PARAMS ((bfd *));
139 static void elf_debug_section PARAMS ((char *, int, Elf_Internal_Shdr *));
140 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
143 #define elf_string_from_elf_strtab(abfd,strindex) \
144 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
147 /* Structure swapping routines */
149 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
150 can be handled by explicitly specifying 32 bits or "the long type". */
152 #define put_word bfd_h_put_64
153 #define get_word bfd_h_get_64
156 #define put_word bfd_h_put_32
157 #define get_word bfd_h_get_32
160 /* Translate an ELF symbol in external format into an ELF symbol in internal
164 DEFUN (elf_swap_symbol_in, (abfd, src, dst),
166 Elf_External_Sym * src AND
167 Elf_Internal_Sym * dst)
169 dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
170 dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
171 dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
172 dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
173 dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
174 dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
177 /* Translate an ELF symbol in internal format into an ELF symbol in external
181 DEFUN (elf_swap_symbol_out, (abfd, src, dst),
183 Elf_Internal_Sym * src AND
184 Elf_External_Sym * dst)
186 bfd_h_put_32 (abfd, src->st_name, dst->st_name);
187 put_word (abfd, src->st_value, dst->st_value);
188 put_word (abfd, src->st_size, dst->st_size);
189 bfd_h_put_8 (abfd, src->st_info, dst->st_info);
190 bfd_h_put_8 (abfd, src->st_other, dst->st_other);
191 bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
195 /* Translate an ELF file header in external format into an ELF file header in
199 DEFUN (elf_swap_ehdr_in, (abfd, src, dst),
201 Elf_External_Ehdr * src AND
202 Elf_Internal_Ehdr * dst)
204 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
205 dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
206 dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
207 dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
208 dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
209 dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
210 dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
211 dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
212 dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
213 dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
214 dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
215 dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
216 dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
217 dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
220 /* Translate an ELF file header in internal format into an ELF file header in
224 DEFUN (elf_swap_ehdr_out, (abfd, src, dst),
226 Elf_Internal_Ehdr * src AND
227 Elf_External_Ehdr * dst)
229 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
230 /* note that all elements of dst are *arrays of unsigned char* already... */
231 bfd_h_put_16 (abfd, src->e_type, dst->e_type);
232 bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
233 bfd_h_put_32 (abfd, src->e_version, dst->e_version);
234 put_word (abfd, src->e_entry, dst->e_entry);
235 put_word (abfd, src->e_phoff, dst->e_phoff);
236 put_word (abfd, src->e_shoff, dst->e_shoff);
237 bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
238 bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
239 bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
240 bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
241 bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
242 bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
243 bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
247 /* Translate an ELF section header table entry in external format into an
248 ELF section header table entry in internal format. */
251 DEFUN (elf_swap_shdr_in, (abfd, src, dst),
253 Elf_External_Shdr * src AND
254 Elf_Internal_Shdr * dst)
256 dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
257 dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
258 dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
259 dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
260 dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
261 dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
262 dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
263 dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
264 dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
265 dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
266 /* we haven't done any processing on it yet, so... */
267 dst->rawdata = (void *) 0;
270 /* Translate an ELF section header table entry in internal format into an
271 ELF section header table entry in external format. */
274 DEFUN (elf_swap_shdr_out, (abfd, src, dst),
276 Elf_Internal_Shdr * src AND
277 Elf_External_Shdr * dst)
279 /* note that all elements of dst are *arrays of unsigned char* already... */
280 bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
281 bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
282 put_word (abfd, src->sh_flags, dst->sh_flags);
283 put_word (abfd, src->sh_addr, dst->sh_addr);
284 put_word (abfd, src->sh_offset, dst->sh_offset);
285 put_word (abfd, src->sh_size, dst->sh_size);
286 bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
287 bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
288 put_word (abfd, src->sh_addralign, dst->sh_addralign);
289 put_word (abfd, src->sh_entsize, dst->sh_entsize);
293 /* Translate an ELF program header table entry in external format into an
294 ELF program header table entry in internal format. */
297 DEFUN (elf_swap_phdr_in, (abfd, src, dst),
299 Elf_External_Phdr * src AND
300 Elf_Internal_Phdr * dst)
302 dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
303 dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
304 dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
305 dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
306 dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
307 dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
308 dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
309 dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
313 DEFUN (elf_swap_phdr_out, (abfd, src, dst),
315 Elf_Internal_Phdr * src AND
316 Elf_External_Phdr * dst)
318 /* note that all elements of dst are *arrays of unsigned char* already... */
319 bfd_h_put_32 (abfd, src->p_type, dst->p_type);
320 put_word (abfd, src->p_offset, dst->p_offset);
321 put_word (abfd, src->p_vaddr, dst->p_vaddr);
322 put_word (abfd, src->p_paddr, dst->p_paddr);
323 put_word (abfd, src->p_filesz, dst->p_filesz);
324 put_word (abfd, src->p_memsz, dst->p_memsz);
325 bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
326 put_word (abfd, src->p_align, dst->p_align);
329 /* Translate an ELF reloc from external format to internal format. */
331 DEFUN (elf_swap_reloc_in, (abfd, src, dst),
333 Elf_External_Rel * src AND
334 Elf_Internal_Rel * dst)
336 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
337 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
341 DEFUN (elf_swap_reloca_in, (abfd, src, dst),
343 Elf_External_Rela * src AND
344 Elf_Internal_Rela * dst)
346 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
347 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
348 dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
351 /* Translate an ELF reloc from internal format to external format. */
353 DEFUN (elf_swap_reloc_out, (abfd, src, dst),
355 Elf_Internal_Rel * src AND
356 Elf_External_Rel * dst)
358 put_word (abfd, src->r_offset, dst->r_offset);
359 put_word (abfd, src->r_info, dst->r_info);
363 DEFUN (elf_swap_reloca_out, (abfd, src, dst),
365 Elf_Internal_Rela * src AND
366 Elf_External_Rela * dst)
368 put_word (abfd, src->r_offset, dst->r_offset);
369 put_word (abfd, src->r_info, dst->r_info);
370 put_word (abfd, src->r_addend, dst->r_addend);
375 /* String table creation/manipulation routines */
377 static struct strtab *
378 DEFUN (bfd_new_strtab, (abfd),
383 ss = (struct strtab *) bfd_xmalloc (sizeof (struct strtab));
384 ss->tab = bfd_xmalloc (1);
385 BFD_ASSERT (ss->tab != 0);
394 DEFUN (bfd_add_to_strtab, (abfd, ss, str),
396 struct strtab *ss AND
399 /* should search first, but for now: */
400 /* include the trailing NUL */
401 int ln = strlen (str) + 1;
403 /* should this be using obstacks? */
404 ss->tab = realloc (ss->tab, ss->length + ln);
406 BFD_ASSERT (ss->tab != 0);
407 strcpy (ss->tab + ss->length, str);
411 return ss->length - ln;
415 DEFUN (bfd_add_2_to_strtab, (abfd, ss, str, str2),
417 struct strtab *ss AND
421 /* should search first, but for now: */
422 /* include the trailing NUL */
423 int ln = strlen (str) + strlen (str2) + 1;
425 /* should this be using obstacks? */
427 ss->tab = realloc (ss->tab, ss->length + ln);
429 ss->tab = bfd_xmalloc (ln);
431 BFD_ASSERT (ss->tab != 0);
432 strcpy (ss->tab + ss->length, str);
433 strcpy (ss->tab + ss->length + strlen (str), str2);
437 return ss->length - ln;
441 /* ELF .o/exec file reading */
443 /* Create a new bfd section from an ELF section header. */
446 DEFUN (bfd_section_from_shdr, (abfd, shindex),
448 unsigned int shindex)
450 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
451 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
455 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
457 switch (hdr->sh_type)
461 /* inactive section. Throw it away. */
465 /* Bits that get saved. This one is real. */
468 newsect = bfd_make_section (abfd, name);
471 newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
472 newsect->flags |= SEC_HAS_CONTENTS;
473 newsect->vma = hdr->sh_addr;
474 newsect->_raw_size = hdr->sh_size;
475 newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
477 if (hdr->sh_flags & SHF_ALLOC)
479 newsect->flags |= SEC_ALLOC;
480 newsect->flags |= SEC_LOAD;
483 if (!(hdr->sh_flags & SHF_WRITE))
484 newsect->flags |= SEC_READONLY;
486 if (hdr->sh_flags & SHF_EXECINSTR)
487 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
488 else if (newsect->flags & SEC_ALLOC)
489 newsect->flags |= SEC_DATA;
491 /* The debugging sections appear to recognized only by
493 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
494 || strncmp (name, ".line", sizeof ".line" - 1) == 0
495 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
496 newsect->flags |= SEC_DEBUGGING;
498 hdr->rawdata = (void *) newsect;
501 hdr->rawdata = (void *) bfd_get_section_by_name (abfd, name);
506 /* Bits that get saved. This one is real. */
509 newsect = bfd_make_section (abfd, name);
512 newsect->vma = hdr->sh_addr;
513 newsect->_raw_size = hdr->sh_size;
514 newsect->filepos = hdr->sh_offset; /* fake */
515 newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
516 if (hdr->sh_flags & SHF_ALLOC)
517 newsect->flags |= SEC_ALLOC;
519 if (!(hdr->sh_flags & SHF_WRITE))
520 newsect->flags |= SEC_READONLY;
522 /* FIXME: This section is empty. Does it really make
523 sense to set SEC_CODE for it? */
524 if (hdr->sh_flags & SHF_EXECINSTR)
525 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
527 hdr->rawdata = (void *) newsect;
532 case SHT_SYMTAB: /* A symbol table */
533 if (elf_onesymtab (abfd) == shindex)
536 BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym));
537 BFD_ASSERT (elf_onesymtab (abfd) == 0);
538 elf_onesymtab (abfd) = shindex;
539 elf_tdata(abfd)->symtab_hdr = *hdr;
540 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->symtab_hdr;
541 abfd->flags |= HAS_SYMS;
544 case SHT_STRTAB: /* A string table */
547 if (ehdr->e_shstrndx == shindex)
549 elf_tdata(abfd)->shstrtab_hdr = *hdr;
550 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->shstrtab_hdr;
551 hdr->rawdata = (PTR) &elf_tdata(abfd)->shstrtab_hdr;
557 for (i = 1; i < ehdr->e_shnum; i++)
559 Elf_Internal_Shdr *hdr2 = elf_elfsections(abfd)[i];
560 if (hdr2->sh_link == shindex)
562 bfd_section_from_shdr (abfd, i);
563 if (elf_onesymtab (abfd) == i)
565 elf_tdata(abfd)->strtab_hdr = *hdr;
566 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->strtab_hdr;
569 #if 0 /* Not handling other string tables specially right now. */
570 hdr2 = elf_elfsections(abfd)[i]; /* in case it moved */
571 /* We have a strtab for some random other section. */
572 newsect = (asection *) hdr2->rawdata;
575 hdr->rawdata = (PTR) newsect;
576 hdr2 = &elf_section_data (newsect)->str_hdr;
578 elf_elfsections(abfd)[shindex] = hdr2;
584 newsect = bfd_make_section (abfd, name);
587 newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
588 newsect->flags = SEC_HAS_CONTENTS;
589 hdr->rawdata = (PTR) newsect;
590 newsect->_raw_size = hdr->sh_size;
591 newsect->alignment_power = 0;
593 newsect->filepos = hdr->sh_offset;
595 if (hdr->sh_flags & SHF_ALLOC)
596 newsect->flags |= SEC_ALLOC|SEC_LOAD;
597 if (!(hdr->sh_flags & SHF_WRITE))
598 newsect->flags |= SEC_READONLY;
599 if (hdr->sh_flags & SHF_EXECINSTR)
600 newsect->flags |= SEC_CODE;
601 else if (newsect->flags & SEC_ALLOC)
602 newsect->flags |= SEC_DATA;
604 /* Check for debugging string tables. */
605 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
606 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
607 newsect->flags |= SEC_DEBUGGING;
614 /* *These* do a lot of work -- but build no sections!
615 The spec says there can be multiple strtabs, but only one symtab,
616 but there can be lots of REL* sections. */
617 /* FIXME: The above statement is wrong! There are typically at least
618 two symbol tables in a dynamically linked executable, ".dynsym"
619 which is the dynamic linkage symbol table and ".symtab", which is
620 the "traditional" symbol table. -fnf */
623 asection *target_sect;
624 Elf_Internal_Shdr *hdr2;
625 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
627 /* Don't allow REL relocations on a machine that uses RELA and
629 /* @@ Actually, the generic ABI does suggest that both might be
630 used in one file. But the four ABI Processor Supplements I
631 have access to right now all specify that only one is used on
632 each of those architectures. It's conceivable that, e.g., a
633 bunch of absolute 32-bit relocs might be more compact in REL
634 form even on a RELA machine... */
635 BFD_ASSERT (!(use_rela_p && (hdr->sh_type == SHT_REL)));
636 BFD_ASSERT (!(!use_rela_p && (hdr->sh_type == SHT_RELA)));
637 BFD_ASSERT (hdr->sh_entsize ==
639 ? sizeof (Elf_External_Rela)
640 : sizeof (Elf_External_Rel)));
642 bfd_section_from_shdr (abfd, hdr->sh_info); /* target */
643 bfd_section_from_shdr (abfd, hdr->sh_link); /* symbol table */
644 target_sect = section_from_elf_index (abfd, hdr->sh_info);
645 if (target_sect == NULL)
648 hdr2 = &elf_section_data (target_sect)->rel_hdr;
650 elf_elfsections(abfd)[shindex] = hdr2;
651 target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
652 target_sect->flags |= SEC_RELOC;
653 target_sect->relocation = 0;
654 target_sect->rel_filepos = hdr->sh_offset;
655 abfd->flags |= HAS_RELOC;
662 case SHT_DYNSYM: /* could treat this like symtab... */
664 fprintf (stderr, "Dynamic Linking sections not yet supported.\n");
671 fprintf (stderr, "Note Sections not yet supported.\n");
678 fprintf (stderr, "SHLIB Sections not supported (and non conforming.)\n");
683 /* Check for any processor-specific section types. */
685 struct elf_backend_data *bed = get_elf_backend_data (abfd);
687 if (bed->elf_backend_section_from_shdr)
688 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
697 DEFUN (elf_new_section_hook, (abfd, sec),
701 struct bfd_elf_section_data *sdata;
703 sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
704 sec->used_by_bfd = (PTR) sdata;
705 memset (sdata, 0, sizeof (*sdata));
709 /* Create a new bfd section from an ELF program header.
711 Since program segments have no names, we generate a synthetic name
712 of the form segment<NUM>, where NUM is generally the index in the
713 program header table. For segments that are split (see below) we
714 generate the names segment<NUM>a and segment<NUM>b.
716 Note that some program segments may have a file size that is different than
717 (less than) the memory size. All this means is that at execution the
718 system must allocate the amount of memory specified by the memory size,
719 but only initialize it with the first "file size" bytes read from the
720 file. This would occur for example, with program segments consisting
721 of combined data+bss.
723 To handle the above situation, this routine generates TWO bfd sections
724 for the single program segment. The first has the length specified by
725 the file size of the segment, and the second has the length specified
726 by the difference between the two sizes. In effect, the segment is split
727 into it's initialized and uninitialized parts.
732 DEFUN (bfd_section_from_phdr, (abfd, hdr, index),
734 Elf_Internal_Phdr * hdr AND
742 split = ((hdr->p_memsz > 0) &&
743 (hdr->p_filesz > 0) &&
744 (hdr->p_memsz > hdr->p_filesz));
745 sprintf (namebuf, split ? "segment%da" : "segment%d", index);
746 name = bfd_alloc (abfd, strlen (namebuf) + 1);
747 strcpy (name, namebuf);
748 newsect = bfd_make_section (abfd, name);
749 newsect->vma = hdr->p_vaddr;
750 newsect->_raw_size = hdr->p_filesz;
751 newsect->filepos = hdr->p_offset;
752 newsect->flags |= SEC_HAS_CONTENTS;
753 if (hdr->p_type == PT_LOAD)
755 newsect->flags |= SEC_ALLOC;
756 newsect->flags |= SEC_LOAD;
757 if (hdr->p_flags & PF_X)
759 /* FIXME: all we known is that it has execute PERMISSION,
761 newsect->flags |= SEC_CODE;
764 if (!(hdr->p_flags & PF_W))
766 newsect->flags |= SEC_READONLY;
771 sprintf (namebuf, "segment%db", index);
772 name = bfd_alloc (abfd, strlen (namebuf) + 1);
773 strcpy (name, namebuf);
774 newsect = bfd_make_section (abfd, name);
775 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
776 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
777 if (hdr->p_type == PT_LOAD)
779 newsect->flags |= SEC_ALLOC;
780 if (hdr->p_flags & PF_X)
781 newsect->flags |= SEC_CODE;
783 if (!(hdr->p_flags & PF_W))
784 newsect->flags |= SEC_READONLY;
790 /* Begin processing a given object.
792 First we validate the file by reading in the ELF header and checking
795 static INLINE boolean
796 DEFUN (elf_file_p, (x_ehdrp), Elf_External_Ehdr * x_ehdrp)
798 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
799 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
800 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
801 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
804 /* Check to see if the file associated with ABFD matches the target vector
807 Note that we may be called several times with the same ABFD, but different
808 target vectors, most of which will not match. We have to avoid leaving
809 any side effects in ABFD, or any data it points to (like tdata), if the
810 file does not match the target vector.
812 FIXME: There is memory leak if we are called more than once with the same
813 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
814 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
815 much we can do about this except possibly rewrite the code. There are
816 also other bfd_allocs that may be the source of memory leaks as well. */
819 DEFUN (elf_object_p, (abfd), bfd * abfd)
821 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
822 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
823 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
824 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
826 char *shstrtab; /* Internal copy of section header stringtab */
827 struct elf_backend_data *ebd; /* Use to get ELF_ARCH stored in xvec */
828 struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
830 /* Read in the ELF header in external format. */
832 if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
833 goto got_system_call_error;
835 /* Now check to see if we have a valid ELF file, and one that BFD can
836 make use of. The magic number must match, the address size ('class')
837 and byte-swapping must match our XVEC entry, and it must have a
838 section header table (FIXME: See comments re sections at top of this
841 if ((elf_file_p (&x_ehdr) == false) ||
842 (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
843 (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
844 goto got_wrong_format_error;
846 /* Check that file's byte order matches xvec's */
847 switch (x_ehdr.e_ident[EI_DATA])
849 case ELFDATA2MSB: /* Big-endian */
850 if (!abfd->xvec->header_byteorder_big_p)
851 goto got_wrong_format_error;
853 case ELFDATA2LSB: /* Little-endian */
854 if (abfd->xvec->header_byteorder_big_p)
855 goto got_wrong_format_error;
857 case ELFDATANONE: /* No data encoding specified */
858 default: /* Unknown data encoding specified */
859 goto got_wrong_format_error;
862 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
863 the tdata pointer in the bfd. FIXME: memory leak, see above. */
866 (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
867 if (elf_tdata (abfd) == NULL)
868 goto got_no_memory_error;
870 /* Now that we know the byte order, swap in the rest of the header */
871 i_ehdrp = elf_elfheader (abfd);
872 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
874 elf_debug_file (i_ehdrp);
877 /* If there is no section header table, we're hosed. */
878 if (i_ehdrp->e_shoff == 0)
879 goto got_wrong_format_error;
881 if (i_ehdrp->e_type == ET_EXEC || i_ehdrp->e_type == ET_DYN)
882 abfd->flags |= EXEC_P;
884 /* Retrieve the architecture information from the xvec and verify
885 that it matches the machine info stored in the ELF header.
886 This allows us to resolve ambiguous formats that might not
887 otherwise be distinguishable. */
889 ebd = get_elf_backend_data (abfd);
891 /* Perhaps the elf architecture value should be another field in the
892 elf backend data? If you change this to work that way, make sure
893 that you still get bfd_arch_unknown for unknown architecture types,
894 and that it still gets accepted by the `generic' elf target. */
897 enum bfd_architecture arch = bfd_arch_unknown;
899 for (i = 0; i < bfd_elf_arch_map_size; i++)
901 if (bfd_elf_arch_map[i].elf_arch == i_ehdrp->e_machine)
903 arch = bfd_elf_arch_map[i].bfd_arch;
907 /* start-sanitize-v9 */
908 if (i_ehdrp->e_machine == EM_SPARC64)
909 arch = bfd_arch_sparc;
910 /* end-sanitize-v9 */
911 if (ebd->arch != arch)
912 goto got_wrong_format_error;
913 bfd_default_set_arch_mach (abfd, arch, 0);
916 /* Allocate space for a copy of the section header table in
917 internal form, seek to the section header table in the file,
918 read it in, and convert it to internal form. As a simple sanity
919 check, verify that the what BFD thinks is the size of each section
920 header table entry actually matches the size recorded in the file. */
922 if (i_ehdrp->e_shentsize != sizeof (x_shdr))
923 goto got_wrong_format_error;
924 i_shdrp = (Elf_Internal_Shdr *)
925 bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum);
926 elf_elfsections (abfd) =
927 (Elf_Internal_Shdr **) bfd_alloc (abfd, sizeof (i_shdrp) * i_ehdrp->e_shnum);
928 if (!i_shdrp || !elf_elfsections(abfd))
929 goto got_no_memory_error;
930 if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1)
931 goto got_system_call_error;
932 for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
934 if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
935 goto got_system_call_error;
936 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
937 elf_elfsections(abfd)[shindex] = i_shdrp + shindex;
939 if (i_ehdrp->e_shstrndx)
941 bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx);
945 for (shindex = i_ehdrp->e_shnum - 1; shindex >= 0; shindex--)
947 if (!strcmp (elf_string_from_elf_strtab (abfd,
948 i_shdrp[shindex].sh_name),
951 elf_tdata(abfd)->strtab_hdr = i_shdrp[shindex];
952 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->strtab_hdr;
954 else if (!strcmp (elf_string_from_elf_strtab (abfd,
955 i_shdrp[shindex].sh_name),
958 elf_tdata(abfd)->symtab_hdr = i_shdrp[shindex];
959 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->symtab_hdr;
960 elf_onesymtab (abfd) = shindex;
965 /* Read in the string table containing the names of the sections. We
966 will need the base pointer to this table later. */
967 /* We read this inline now, so that we don't have to go through
968 bfd_section_from_shdr with it (since this particular strtab is
969 used to find all of the ELF section names.) */
971 shstrtab = elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
973 goto got_wrong_format_error;
975 /* Once all of the section headers have been read and converted, we
976 can start processing them. Note that the first section header is
977 a dummy placeholder entry, so we ignore it.
979 We also watch for the symbol table section and remember the file
980 offset and section size for both the symbol table section and the
981 associated string table section. */
983 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
985 bfd_section_from_shdr (abfd, shindex);
988 /* Remember the entry point specified in the ELF file header. */
990 bfd_get_start_address (abfd) = i_ehdrp->e_entry;
994 /* If we are going to use goto's to avoid duplicating error setting
995 and return(NULL) code, then this at least makes it more maintainable. */
997 got_system_call_error:
998 bfd_error = system_call_error;
1000 got_wrong_format_error:
1001 bfd_error = wrong_format;
1003 got_no_memory_error:
1004 bfd_error = no_memory;
1007 elf_tdata (abfd) = preserved_tdata;
1012 /* ELF .o/exec file writing */
1014 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1015 of the symbol if there is one. */
1016 static INLINE elf_symbol_type *
1017 DEFUN (elf_symbol_from, (ignore_abfd, symbol),
1018 bfd * ignore_abfd AND
1021 if (symbol->the_bfd->xvec->flavour != bfd_target_elf_flavour)
1024 if (symbol->the_bfd->tdata.elf_obj_data == (struct elf_obj_tdata *) NULL)
1027 return (elf_symbol_type *) symbol;
1030 /* Create ELF output from BFD sections.
1032 Essentially, just create the section header and forget about the program
1036 DEFUN (elf_make_sections, (abfd, asect, obj),
1038 asection * asect AND
1041 /* most of what is in bfd_shdr_from_section goes in here... */
1042 /* and all of these sections generate at *least* one ELF section. */
1043 Elf_Internal_Shdr *this_hdr;
1044 this_hdr = &elf_section_data (asect)->this_hdr;
1046 this_hdr->sh_addr = asect->vma;
1047 this_hdr->sh_size = asect->_raw_size;
1048 /* contents already set by elf_set_section_contents */
1050 if (asect->flags & SEC_RELOC)
1052 /* emit a reloc section, and thus strtab and symtab... */
1053 Elf_Internal_Shdr *rela_hdr;
1054 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1056 rela_hdr = &elf_section_data (asect)->rel_hdr;
1058 /* orelocation has the data, reloc_count has the count... */
1061 rela_hdr->sh_type = SHT_RELA;
1062 rela_hdr->sh_entsize = sizeof (Elf_External_Rela);
1065 /* REL relocations */
1067 rela_hdr->sh_type = SHT_REL;
1068 rela_hdr->sh_entsize = sizeof (Elf_External_Rel);
1070 rela_hdr->sh_flags = 0;
1071 rela_hdr->sh_addr = 0;
1072 rela_hdr->sh_offset = 0;
1073 rela_hdr->sh_addralign = 0;
1076 if (asect->flags & SEC_ALLOC)
1078 this_hdr->sh_flags |= SHF_ALLOC;
1079 if (asect->flags & SEC_LOAD)
1081 /* @@ Do something with sh_type? */
1086 /* If this section is not part of the program image during
1087 execution, leave the address fields at 0. */
1088 this_hdr->sh_addr = 0;
1091 if (!(asect->flags & SEC_READONLY))
1092 this_hdr->sh_flags |= SHF_WRITE;
1094 if (asect->flags & SEC_CODE)
1095 this_hdr->sh_flags |= SHF_EXECINSTR;
1099 write_relocs (abfd, sec, xxx)
1104 Elf_Internal_Shdr *rela_hdr;
1105 Elf_External_Rela *outbound_relocas;
1106 Elf_External_Rel *outbound_relocs;
1108 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1109 asymbol *last_sym = 0;
1112 if ((sec->flags & SEC_RELOC) == 0)
1114 /* Flags are sometimes inconsistent. */
1115 if (sec->reloc_count == 0)
1118 rela_hdr = &elf_section_data (sec)->rel_hdr;
1120 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
1121 rela_hdr->contents = (void *) bfd_alloc (abfd, rela_hdr->sh_size);
1123 /* orelocation has the data, reloc_count has the count... */
1126 outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
1128 for (idx = 0; idx < sec->reloc_count; idx++)
1130 Elf_Internal_Rela dst_rela;
1131 Elf_External_Rela *src_rela;
1136 ptr = sec->orelocation[idx];
1137 src_rela = outbound_relocas + idx;
1138 if (!(abfd->flags & EXEC_P))
1139 dst_rela.r_offset = ptr->address - sec->vma;
1141 dst_rela.r_offset = ptr->address;
1143 sym = *ptr->sym_ptr_ptr;
1144 if (sym == last_sym)
1149 last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1151 dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1153 dst_rela.r_addend = ptr->addend;
1154 elf_swap_reloca_out (abfd, &dst_rela, src_rela);
1158 /* REL relocations */
1160 outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
1162 for (idx = 0; idx < sec->reloc_count; idx++)
1164 Elf_Internal_Rel dst_rel;
1165 Elf_External_Rel *src_rel;
1170 ptr = sec->orelocation[idx];
1171 sym = *ptr->sym_ptr_ptr;
1172 src_rel = outbound_relocs + idx;
1173 if (!(abfd->flags & EXEC_P))
1174 dst_rel.r_offset = ptr->address - sec->vma;
1176 dst_rel.r_offset = ptr->address;
1178 if (sym == last_sym)
1183 last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1185 dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
1187 elf_swap_reloc_out (abfd, &dst_rel, src_rel);
1193 fix_up_strtabs (abfd, asect, obj)
1198 Elf_Internal_Shdr *this_hdr = &elf_section_data (asect)->this_hdr;
1199 int this_idx = elf_section_data(asect)->this_idx;
1201 /* @@ Check flags! */
1202 if (!strncmp (asect->name, ".stab", 5)
1203 && !strcmp ("str", asect->name + strlen (asect->name) - 3))
1205 size_t len = strlen (asect->name) + 1;
1206 char *s = (char *) alloca (len);
1207 strcpy (s, asect->name);
1209 asect = bfd_get_section_by_name (abfd, s);
1212 elf_section_data(asect)->this_hdr.sh_link = this_idx;
1213 /* @@ Assuming 32 bits! */
1214 elf_section_data(asect)->this_hdr.sh_entsize = 0xc;
1216 this_hdr->sh_type = SHT_STRTAB;
1221 DEFUN (elf_fake_sections, (abfd, asect, obj),
1223 asection * asect AND
1226 /* most of what is in bfd_shdr_from_section goes in here... */
1227 /* and all of these sections generate at *least* one ELF section. */
1229 Elf_Internal_Shdr *this_hdr;
1230 this_hdr = &elf_section_data (asect)->this_hdr;
1232 bfd_add_to_strtab (abfd, elf_shstrtab (abfd), asect->name);
1233 /* We need to log the type *now* so that elf_section_from_bfd_section
1234 can find us... have to set rawdata too. */
1235 this_hdr->rawdata = (void *) asect;
1236 this_hdr->sh_addralign = 1 << asect->alignment_power;
1237 if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD))
1238 this_hdr->sh_type = SHT_PROGBITS;
1239 else if ((asect->flags & SEC_ALLOC) && ((asect->flags & SEC_LOAD) == 0))
1241 BFD_ASSERT (!strcmp (asect->name, ".bss"));
1242 this_hdr->sh_type = SHT_NOBITS;
1244 /* FIXME I am not sure how to detect a .note section from the flags
1245 word of an `asection'. */
1246 else if (!strcmp (asect->name, ".note"))
1247 this_hdr->sh_type = SHT_NOTE;
1249 this_hdr->sh_type = SHT_PROGBITS;
1251 this_hdr->sh_flags = 0;
1252 this_hdr->sh_addr = 0;
1253 this_hdr->sh_size = 0;
1254 this_hdr->sh_entsize = 0;
1255 this_hdr->sh_info = 0;
1256 this_hdr->sh_link = 0;
1257 this_hdr->sh_offset = 0;
1260 /* Now, check for processor-specific section types. */
1262 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1264 if (bed->elf_backend_fake_sections)
1265 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1269 /* Emit a strtab and symtab, and possibly a reloc section. */
1270 Elf_Internal_Shdr *rela_hdr;
1272 /* Note that only one symtab is used, so just remember it
1275 if (asect->flags & SEC_RELOC)
1277 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1279 rela_hdr = &elf_section_data (asect)->rel_hdr;
1281 bfd_add_2_to_strtab (abfd, elf_shstrtab (abfd),
1282 use_rela_p ? ".rela" : ".rel",
1284 rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1285 rela_hdr->sh_entsize = (use_rela_p
1286 ? sizeof (Elf_External_Rela)
1287 : sizeof (Elf_External_Rel));
1289 rela_hdr->sh_flags = 0;
1290 rela_hdr->sh_addr = 0;
1291 rela_hdr->sh_size = 0;
1292 rela_hdr->sh_offset = 0;
1293 rela_hdr->sh_addralign = 0;
1297 if (asect->flags & SEC_ALLOC)
1299 this_hdr->sh_flags |= SHF_ALLOC;
1300 if (asect->flags & SEC_LOAD)
1302 /* @@ Do something with sh_type? */
1305 if (!(asect->flags & SEC_READONLY))
1306 this_hdr->sh_flags |= SHF_WRITE;
1307 if (asect->flags & SEC_CODE)
1308 this_hdr->sh_flags |= SHF_EXECINSTR;
1311 /* Map symbol from it's internal number to the external number, moving
1312 all local symbols to be at the head of the list. */
1318 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
1320 if (sym->flags & BSF_LOCAL)
1324 if (sym->section == 0)
1326 /* Is this valid? */
1331 if (sym->section == &bfd_und_section)
1333 if (bfd_is_com_section (sym->section))
1335 if (sym->flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE))
1341 DEFUN (elf_map_symbols, (abfd), bfd * abfd)
1343 int symcount = bfd_get_symcount (abfd);
1344 asymbol **syms = bfd_get_outsymbols (abfd);
1345 asymbol **sect_syms;
1347 int num_globals = 0;
1348 int num_locals2 = 0;
1349 int num_globals2 = 0;
1351 int num_sections = 0;
1352 Elf_Sym_Extra *sym_extra;
1357 fprintf (stderr, "elf_map_symbols\n");
1361 /* Add local symbols for each section for which there are relocs.
1362 FIXME: How can we tell which sections have relocs at this point?
1363 Will reloc_count always be accurate? Actually, I think most ELF
1364 targets create section symbols for all sections anyhow. */
1365 for (asect = abfd->sections; asect; asect = asect->next)
1367 if (max_index < asect->index)
1368 max_index = asect->index;
1372 elf_num_section_syms (abfd) = max_index;
1373 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1374 elf_section_syms (abfd) = sect_syms;
1376 BFD_ASSERT (sect_syms != 0);
1378 for (asect = abfd->sections; asect; asect = asect->next)
1380 asymbol *sym = bfd_make_empty_symbol (abfd);
1381 sym->the_bfd = abfd;
1382 sym->name = asect->name;
1383 sym->value = asect->vma;
1384 sym->flags = BSF_SECTION_SYM;
1385 sym->section = asect;
1386 sect_syms[asect->index] = sym;
1390 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1391 asect->name, (long) asect->vma, asect->index, (long) asect);
1398 syms = (asymbol **) bfd_realloc (abfd, syms,
1399 ((symcount + num_sections + 1)
1400 * sizeof (asymbol *)));
1402 syms = (asymbol **) bfd_alloc (abfd,
1403 (num_sections + 1) * sizeof (asymbol *));
1405 for (asect = abfd->sections; asect; asect = asect->next)
1407 if (sect_syms[asect->index])
1408 syms[symcount++] = sect_syms[asect->index];
1411 syms[symcount] = (asymbol *) 0;
1412 bfd_set_symtab (abfd, syms, symcount);
1415 elf_sym_extra (abfd) = sym_extra
1416 = (Elf_Sym_Extra *) bfd_alloc (abfd, symcount * sizeof (Elf_Sym_Extra));
1418 /* Identify and classify all of the symbols. */
1419 for (idx = 0; idx < symcount; idx++)
1421 if (!sym_is_global (syms[idx]))
1427 /* Now provide mapping information. Add +1 for skipping over the
1429 for (idx = 0; idx < symcount; idx++)
1431 syms[idx]->udata = (PTR) &sym_extra[idx];
1432 if (!sym_is_global (syms[idx]))
1433 sym_extra[idx].elf_sym_num = 1 + num_locals2++;
1435 sym_extra[idx].elf_sym_num = 1 + num_locals + num_globals2++;
1438 elf_num_locals (abfd) = num_locals;
1439 elf_num_globals (abfd) = num_globals;
1442 static void assign_section_numbers ();
1443 static void assign_file_positions_except_relocs ();
1446 DEFUN (elf_compute_section_file_positions, (abfd), bfd * abfd)
1448 bfd_map_over_sections (abfd, elf_fake_sections, 0);
1450 assign_section_numbers (abfd);
1452 bfd_map_over_sections (abfd, elf_make_sections, 0);
1454 bfd_map_over_sections (abfd, fix_up_strtabs, 0); /* .stab/.stabstr &c */
1456 swap_out_syms (abfd);
1458 assign_file_positions_except_relocs (abfd);
1464 DEFUN (elf_write_phdrs, (abfd, i_ehdrp, i_phdrp, phdr_cnt),
1466 Elf_Internal_Ehdr * i_ehdrp AND
1467 Elf_Internal_Phdr * i_phdrp AND
1468 Elf32_Half phdr_cnt)
1470 /* first program header entry goes after the file header */
1471 int outbase = i_ehdrp->e_phoff;
1473 Elf_External_Phdr x_phdr;
1475 for (i = 0; i < phdr_cnt; i++)
1477 elf_swap_phdr_out (abfd, i_phdrp + i, &x_phdr);
1478 bfd_seek (abfd, outbase, SEEK_SET);
1479 bfd_write ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd);
1480 outbase += sizeof (x_phdr);
1486 static const Elf_Internal_Shdr null_shdr;
1488 /* Assign all ELF section numbers. The dummy first section is handled here
1489 too. The link/info pointers for the standard section types are filled
1490 in here too, while we're at it. (Link pointers for .stab sections are
1491 not filled in here.) */
1493 assign_section_numbers (abfd)
1496 struct elf_obj_tdata *t = elf_tdata (abfd);
1498 int section_number = 1;
1500 Elf_Internal_Shdr **i_shdrp;
1502 t->shstrtab_hdr.sh_size = elf_shstrtab(abfd)->length;
1503 t->shstrtab_hdr.contents = (void *) elf_shstrtab(abfd)->tab;
1504 shstrtab_length_fixed = 1;
1506 t->shstrtab_section = section_number++;
1507 elf_elfheader(abfd)->e_shstrndx = t->shstrtab_section;
1510 t->symtab_section = section_number++;
1511 t->strtab_section = section_number++;
1512 t->symtab_hdr.sh_link = t->strtab_section;
1514 for (sec = abfd->sections; sec; sec = sec->next)
1516 struct bfd_elf_section_data *d = elf_section_data (sec);
1517 d->this_idx = section_number++;
1518 if (sec->flags & SEC_RELOC)
1520 d->rel_idx = section_number++;
1521 d->rel_hdr.sh_link = t->symtab_section;
1522 d->rel_hdr.sh_info = d->this_idx;
1526 /* No handling for per-section string tables currently. */
1528 elf_elfheader(abfd)->e_shnum = section_number;
1530 /* Set up the list of section header pointers, in agreement with the
1532 i_shdrp = (Elf_Internal_Shdr **)
1533 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *));
1534 elf_elfsections(abfd) = i_shdrp;
1535 for (i = 0; i < section_number; i++)
1538 i_shdrp[0] = (Elf_Internal_Shdr *) &null_shdr;
1539 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1542 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1543 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1545 for (sec = abfd->sections; sec; sec = sec->next)
1547 struct bfd_elf_section_data *d = elf_section_data (sec);
1548 i_shdrp[d->this_idx] = &d->this_hdr;
1550 i_shdrp[d->rel_idx] = &d->rel_hdr;
1552 /* Make sure we got everything.... */
1553 for (i = 0; i < section_number; i++)
1554 if (i_shdrp[i] == 0)
1558 static INLINE file_ptr
1559 assign_file_position_for_section (i_shdrp, offset)
1560 Elf_Internal_Shdr *i_shdrp;
1565 if (i_shdrp->sh_addralign != 0)
1566 align = i_shdrp->sh_addralign;
1569 i_shdrp->sh_offset = offset = BFD_ALIGN (offset, align);
1570 if (i_shdrp->sh_type != SHT_NOBITS)
1571 offset += i_shdrp->sh_size;
1575 static INLINE file_ptr
1576 align_file_position (off)
1579 return (off + FILE_ALIGN - 1) & ~(FILE_ALIGN - 1);
1582 static INLINE file_ptr
1583 assign_file_positions_for_symtab_and_strtabs (abfd, off)
1587 struct elf_obj_tdata *t = elf_tdata (abfd);
1589 off = align_file_position (off);
1590 off = assign_file_position_for_section (&t->symtab_hdr, off);
1591 off = assign_file_position_for_section (&t->shstrtab_hdr, off);
1592 off = assign_file_position_for_section (&t->strtab_hdr, off);
1597 bfd_vma low, mem_size;
1601 struct seg_info *next;
1605 map_program_segments (abfd)
1608 Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
1609 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1610 Elf_Internal_Shdr *i_shdrp;
1611 Elf_Internal_Phdr *phdr;
1614 file_ptr lowest_offset = 0;
1615 struct seg_info *seg = 0;
1617 done = (char *) alloca (i_ehdrp->e_shnum);
1618 memset (done, 0, i_ehdrp->e_shnum);
1619 for (i = 0; i < i_ehdrp->e_shnum; i++)
1621 i_shdrp = i_shdrpp[i];
1622 /* If it's going to be mapped in, it's been assigned a position. */
1623 if (i_shdrp->sh_offset + 1 == 0)
1625 /* Well, not really, but we won't process it here. */
1629 if (i_shdrp->sh_offset < lowest_offset
1630 || lowest_offset == 0)
1631 lowest_offset = i_shdrp->sh_offset;
1632 /* Only interested in PROGBITS or NOBITS for generating segments. */
1633 switch (i_shdrp->sh_type)
1646 bfd_vma lowest_vma = -1, high;
1651 for (i = 1; i < i_ehdrp->e_shnum; i++)
1653 i_shdrp = i_shdrpp[i];
1654 if (!done[i] && i_shdrp->sh_addr < lowest_vma)
1656 lowest_vma = i_shdrp->sh_addr;
1662 /* So now we know the lowest vma of any unassigned sections; start
1666 s = (struct seg_info *) bfd_alloc (abfd, sizeof (struct seg_info));
1670 seg->low = lowest_vma;
1671 i_shdrp = i_shdrpp[low_sec];
1672 seg->start_pos = i_shdrp->sh_offset;
1673 seg->sh_flags = i_shdrp->sh_flags;
1674 done[low_sec] = 1, n_left--;
1675 mem_size = i_shdrp->sh_size;
1676 high = lowest_vma + i_shdrp->sh_size;
1678 if (i_shdrp->sh_type == SHT_PROGBITS)
1679 file_size = i_shdrp->sh_size;
1681 for (i = 0; i < i_ehdrp->e_shnum; i++)
1685 if (file_size != mem_size)
1689 i_shdrp = i_shdrpp[i];
1690 /* position of next byte on disk */
1691 f1 = seg->start_pos + file_size;
1692 if (i_shdrp->sh_type == SHT_PROGBITS)
1694 if (i_shdrp->sh_offset - f1 != i_shdrp->sh_addr - high)
1697 else /* sh_type == NOBITS */
1699 /* If the section in question has no contents in the disk
1700 file, we really don't care where it supposedly starts.
1701 But we don't want to bother merging it into this segment
1702 if it doesn't start on this memory page. */
1703 bfd_vma page1, page2;
1704 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1706 /* page number in address space of current end of seg */
1707 page1 = (high - 1 + maxpagesize - 1) / maxpagesize;
1708 /* page number in address space of start of this section */
1709 page2 = (i_shdrp->sh_addr + maxpagesize - 1) / maxpagesize;
1714 done[i] = 1, n_left--;
1715 if (i_shdrp->sh_type == SHT_PROGBITS)
1716 file_size = i_shdrp->sh_offset + i_shdrp->sh_size - seg->start_pos;
1717 mem_size = i_shdrp->sh_addr + i_shdrp->sh_size - seg->low;
1718 high = i_shdrp->sh_addr + i_shdrp->sh_size;
1721 seg->file_size = file_size;
1722 seg->mem_size = mem_size;
1724 /* Now do something with the list of segments we've built up. */
1726 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1731 for (s = seg; s; s = s->next)
1735 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
1736 sz = sizeof (Elf_External_Phdr) * n_segs;
1737 if (align_file_position (i_ehdrp->e_ehsize) + sz <= lowest_offset)
1738 i_ehdrp->e_phoff = align_file_position (i_ehdrp->e_ehsize);
1741 i_ehdrp->e_phoff = align_file_position (elf_tdata (abfd)->next_file_pos);
1742 elf_tdata (abfd)->next_file_pos = i_ehdrp->e_phoff + sz;
1744 phdr = (Elf_Internal_Phdr*) bfd_alloc (abfd,
1745 n_segs * sizeof (Elf_Internal_Phdr));
1746 elf_tdata (abfd)->phdr = phdr;
1749 phdr->p_type = PT_LOAD; /* only type we really support so far */
1750 phdr->p_offset = seg->start_pos;
1751 phdr->p_vaddr = seg->low;
1753 phdr->p_filesz = seg->file_size;
1754 phdr->p_memsz = seg->mem_size;
1755 phdr->p_flags = PF_R;
1756 phdr->p_align = maxpagesize; /* ? */
1757 if (seg->sh_flags & SHF_WRITE)
1758 /* SysVr4 ELF docs say "data segments normally have read, write,
1759 and execute permissions." */
1760 phdr->p_flags |= (PF_W | PF_X);
1761 if (seg->sh_flags & SHF_EXECINSTR)
1762 phdr->p_flags |= PF_X;
1766 i_ehdrp->e_phnum = n_segs;
1768 elf_write_phdrs (abfd, i_ehdrp, elf_tdata (abfd)->phdr, i_ehdrp->e_phnum);
1772 assign_file_positions_except_relocs (abfd)
1775 /* For now, we ignore the possibility of having program segments, which
1776 may require some alignment in the file. That'll require padding, and
1777 some interesting calculations to optimize file space usage.
1779 Also, since the application may change the list of relocations for
1780 a given section, we don't figure them in here. We'll put them at the
1781 end of the file, at positions computed during bfd_close.
1783 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1784 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1788 Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
1789 Elf_Internal_Shdr *i_shdrp;
1790 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1791 int exec_p = (abfd->flags & EXEC_P) != 0;
1793 /* Everything starts after the ELF file header. */
1794 off = i_ehdrp->e_ehsize;
1798 /* Section headers. */
1799 off = align_file_position (off);
1800 i_ehdrp->e_shoff = off;
1801 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
1803 off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
1805 for (i = 0; i < i_ehdrp->e_shnum; i++)
1807 i_shdrp = i_shdrpp[i];
1808 if (i_shdrp->sh_type == SHT_REL || i_shdrp->sh_type == SHT_RELA)
1810 i_shdrp->sh_offset = -1;
1815 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1816 if (maxpagesize == 0)
1817 maxpagesize = 1; /* make the arithmetic work */
1818 /* This isn't necessarily going to give the best packing, if the
1819 segments require padding between them, but since that isn't
1820 usually the case, this'll do. */
1821 if ((i_shdrp->sh_flags & SHF_ALLOC) == 0)
1823 i_shdrp->sh_offset = -1;
1826 /* Blindly assume that the segments are ordered optimally. With
1827 the default LD script, they will be. */
1829 /* need big unsigned type */
1831 addtl_off = i_shdrp->sh_addr - off;
1832 addtl_off = addtl_off % maxpagesize;
1838 if (i_shdrp->sh_type == SHT_NOBITS)
1841 i_shdrp->sh_offset = off;
1842 if (off % maxpagesize != 0)
1843 off2 = maxpagesize - (off % maxpagesize);
1844 if (off2 > i_shdrp->sh_size)
1845 off2 = i_shdrp->sh_size;
1849 off = assign_file_position_for_section (i_shdrp, off);
1852 && get_elf_backend_data(abfd)->maxpagesize > 1
1853 && i_shdrp->sh_type == SHT_PROGBITS
1854 && (i_shdrp->sh_flags & SHF_ALLOC)
1855 && (i_shdrp->sh_offset - i_shdrp->sh_addr) % get_elf_backend_data (abfd)->maxpagesize != 0)
1860 elf_tdata (abfd)->next_file_pos = off;
1861 map_program_segments (abfd);
1862 off = elf_tdata (abfd)->next_file_pos;
1864 /* Section headers. */
1865 off = align_file_position (off);
1866 i_ehdrp->e_shoff = off;
1867 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
1869 off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
1871 for (i = 0; i < i_ehdrp->e_shnum; i++)
1873 i_shdrp = i_shdrpp[i];
1874 if (i_shdrp->sh_offset + 1 == 0
1875 && i_shdrp->sh_type != SHT_REL
1876 && i_shdrp->sh_type != SHT_RELA)
1877 off = assign_file_position_for_section (i_shdrp, off);
1880 elf_tdata (abfd)->next_file_pos = off;
1887 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1888 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
1889 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1891 struct strtab *shstrtab;
1893 i_ehdrp = elf_elfheader (abfd);
1894 i_shdrp = elf_elfsections (abfd);
1896 shstrtab = bfd_new_strtab (abfd);
1897 elf_shstrtab (abfd) = shstrtab;
1899 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
1900 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
1901 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
1902 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
1904 i_ehdrp->e_ident[EI_CLASS] = ELFCLASS;
1905 i_ehdrp->e_ident[EI_DATA] =
1906 abfd->xvec->byteorder_big_p ? ELFDATA2MSB : ELFDATA2LSB;
1907 i_ehdrp->e_ident[EI_VERSION] = EV_CURRENT;
1909 for (count = EI_PAD; count < EI_NIDENT; count++)
1910 i_ehdrp->e_ident[count] = 0;
1912 i_ehdrp->e_type = (abfd->flags & EXEC_P) ? ET_EXEC : ET_REL;
1913 switch (bfd_get_arch (abfd))
1915 case bfd_arch_unknown:
1916 i_ehdrp->e_machine = EM_NONE;
1918 case bfd_arch_sparc:
1919 i_ehdrp->e_machine = EM_SPARC;
1920 /* start-sanitize-v9 */
1922 i_ehdrp->e_machine = EM_SPARC64;
1924 /* end-sanitize-v9 */
1927 i_ehdrp->e_machine = EM_386;
1930 i_ehdrp->e_machine = EM_68K;
1933 i_ehdrp->e_machine = EM_88K;
1936 i_ehdrp->e_machine = EM_860;
1938 case bfd_arch_mips: /* MIPS Rxxxx */
1939 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
1942 i_ehdrp->e_machine = EM_HPPA;
1944 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
1946 i_ehdrp->e_machine = EM_NONE;
1948 i_ehdrp->e_version = EV_CURRENT;
1949 i_ehdrp->e_ehsize = sizeof (Elf_External_Ehdr);
1951 /* no program header, for now. */
1952 i_ehdrp->e_phoff = 0;
1953 i_ehdrp->e_phentsize = 0;
1954 i_ehdrp->e_phnum = 0;
1956 /* each bfd section is section header entry */
1957 i_ehdrp->e_entry = bfd_get_start_address (abfd);
1958 i_ehdrp->e_shentsize = sizeof (Elf_External_Shdr);
1960 /* if we're building an executable, we'll need a program header table */
1961 if (abfd->flags & EXEC_P)
1963 /* it all happens later */
1965 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
1967 /* elf_build_phdrs() returns a (NULL-terminated) array of
1968 Elf_Internal_Phdrs */
1969 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
1970 i_ehdrp->e_phoff = outbase;
1971 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
1976 i_ehdrp->e_phentsize = 0;
1978 i_ehdrp->e_phoff = 0;
1981 elf_tdata (abfd)->symtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
1983 elf_tdata (abfd)->strtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
1985 elf_tdata (abfd)->shstrtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
1991 swap_out_syms (abfd)
1994 elf_map_symbols (abfd);
1996 /* Dump out the symtabs. */
1998 int symcount = bfd_get_symcount (abfd);
1999 asymbol **syms = bfd_get_outsymbols (abfd);
2000 struct strtab *stt = bfd_new_strtab (abfd);
2001 Elf_Internal_Shdr *symtab_hdr;
2002 Elf_Internal_Shdr *symstrtab_hdr;
2003 Elf_External_Sym *outbound_syms;
2006 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2007 symtab_hdr->sh_type = SHT_SYMTAB;
2008 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
2009 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
2010 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
2012 /* see assert in elf_fake_sections that supports this: */
2013 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2014 symstrtab_hdr->sh_type = SHT_STRTAB;
2016 outbound_syms = (Elf_External_Sym *)
2017 bfd_alloc (abfd, (1 + symcount) * sizeof (Elf_External_Sym));
2018 /* now generate the data (for "contents") */
2020 /* Fill in zeroth symbol and swap it out. */
2021 Elf_Internal_Sym sym;
2027 sym.st_shndx = SHN_UNDEF;
2028 elf_swap_symbol_out (abfd, &sym, outbound_syms);
2030 for (idx = 0; idx < symcount; idx++)
2032 Elf_Internal_Sym sym;
2033 bfd_vma value = syms[idx]->value;
2035 if (syms[idx]->flags & BSF_SECTION_SYM)
2036 /* Section symbols have no names. */
2039 sym.st_name = bfd_add_to_strtab (abfd, stt, syms[idx]->name);
2041 if (bfd_is_com_section (syms[idx]->section))
2043 /* ELF common symbols put the alignment into the `value' field,
2044 and the size into the `size' field. This is backwards from
2045 how BFD handles it, so reverse it here. */
2046 sym.st_size = value;
2047 /* Should retrieve this from somewhere... */
2049 sym.st_shndx = SHN_COMMON;
2053 asection *sec = syms[idx]->section;
2054 elf_symbol_type *type_ptr;
2057 if (sec->output_section)
2059 value += sec->output_offset;
2060 sec = sec->output_section;
2063 sym.st_value = value;
2064 type_ptr = elf_symbol_from (abfd, syms[idx]);
2065 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
2066 sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec);
2070 /* Writing this would be a hell of a lot easier if we had
2071 some decent documentation on bfd, and knew what to expect
2072 of the library, and what to demand of applications. For
2073 example, it appears that `objcopy' might not set the
2074 section of a symbol to be a section that is actually in
2076 sec2 = bfd_get_section_by_name (abfd, sec->name);
2078 sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec2);
2079 assert (shndx != -1);
2083 if (bfd_is_com_section (syms[idx]->section))
2084 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_NOTYPE);
2085 else if (syms[idx]->section == &bfd_und_section)
2086 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_NOTYPE);
2087 else if (syms[idx]->flags & BSF_SECTION_SYM)
2088 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2089 else if (syms[idx]->flags & BSF_FILE)
2090 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
2093 int bind = STB_LOCAL;
2094 int type = STT_OBJECT;
2095 unsigned int flags = syms[idx]->flags;
2097 if (flags & BSF_LOCAL)
2099 else if (flags & BSF_WEAK)
2101 else if (flags & BSF_GLOBAL)
2104 if (flags & BSF_FUNCTION)
2107 sym.st_info = ELF_ST_INFO (bind, type);
2111 elf_swap_symbol_out (abfd, &sym,
2113 + elf_sym_extra (abfd)[idx].elf_sym_num));
2116 symtab_hdr->contents = (PTR) outbound_syms;
2117 symstrtab_hdr->contents = (PTR) stt->tab;
2118 symstrtab_hdr->sh_size = stt->length;
2119 symstrtab_hdr->sh_type = SHT_STRTAB;
2121 symstrtab_hdr->sh_flags = 0;
2122 symstrtab_hdr->sh_addr = 0;
2123 symstrtab_hdr->sh_entsize = 0;
2124 symstrtab_hdr->sh_link = 0;
2125 symstrtab_hdr->sh_info = 0;
2126 symstrtab_hdr->sh_addralign = 0;
2127 symstrtab_hdr->size = 0;
2130 /* put the strtab out too... */
2132 Elf_Internal_Shdr *this_hdr;
2134 this_hdr = &elf_tdata(abfd)->shstrtab_hdr;
2135 this_hdr->contents = (PTR) elf_shstrtab (abfd)->tab;
2136 this_hdr->sh_size = elf_shstrtab (abfd)->length;
2137 this_hdr->sh_type = SHT_STRTAB;
2138 this_hdr->sh_flags = 0;
2139 this_hdr->sh_addr = 0;
2140 this_hdr->sh_entsize = 0;
2141 this_hdr->sh_addralign = 0;
2147 write_shdrs_and_ehdr (abfd)
2150 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
2151 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
2152 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
2153 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
2155 struct strtab *shstrtab;
2157 i_ehdrp = elf_elfheader (abfd);
2158 i_shdrp = elf_elfsections (abfd);
2159 shstrtab = elf_shstrtab (abfd);
2161 /* swap the header before spitting it out... */
2164 elf_debug_file (i_ehdrp);
2166 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
2167 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
2168 bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd);
2170 /* at this point we've concocted all the ELF sections... */
2171 x_shdrp = (Elf_External_Shdr *)
2172 bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
2175 bfd_error = no_memory;
2179 for (count = 0; count < i_ehdrp->e_shnum; count++)
2182 elf_debug_section (shstrtab->tab + i_shdrp[count]->sh_name, count,
2185 elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
2187 bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET);
2188 bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd);
2189 /* need to dump the string table too... */
2195 assign_file_positions_for_relocs (abfd)
2198 file_ptr off = elf_tdata(abfd)->next_file_pos;
2200 Elf_Internal_Shdr **shdrpp = elf_elfsections (abfd);
2201 Elf_Internal_Shdr *shdrp;
2202 for (i = 0; i < elf_elfheader(abfd)->e_shnum; i++)
2205 if (shdrp->sh_type != SHT_REL && shdrp->sh_type != SHT_RELA)
2207 off = align_file_position (off);
2208 off = assign_file_position_for_section (shdrp, off);
2210 elf_tdata(abfd)->next_file_pos = off;
2214 DEFUN (NAME(bfd_elf,write_object_contents), (abfd), bfd * abfd)
2216 Elf_Internal_Ehdr *i_ehdrp;
2217 Elf_Internal_Shdr **i_shdrp;
2220 if (abfd->output_has_begun == false)
2222 prep_headers (abfd);
2223 elf_compute_section_file_positions (abfd);
2224 abfd->output_has_begun = true;
2227 i_shdrp = elf_elfsections (abfd);
2228 i_ehdrp = elf_elfheader (abfd);
2230 bfd_map_over_sections (abfd, write_relocs, (PTR) 0);
2231 assign_file_positions_for_relocs (abfd);
2233 /* After writing the headers, we need to write the sections too... */
2234 for (count = 0; count < i_ehdrp->e_shnum; count++)
2236 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2238 if (bed->elf_backend_section_processing)
2239 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
2240 if (i_shdrp[count]->contents)
2242 bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET);
2243 bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size, 1,
2247 return write_shdrs_and_ehdr (abfd);
2250 /* Given an index of a section, retrieve a pointer to it. Note
2251 that for our purposes, sections are indexed by {1, 2, ...} with
2252 0 being an illegal index. */
2254 /* In the original, each ELF section went into exactly one BFD
2255 section. This doesn't really make sense, so we need a real mapping.
2256 The mapping has to hide in the Elf_Internal_Shdr since asection
2257 doesn't have anything like a tdata field... */
2260 DEFUN (section_from_elf_index, (abfd, index),
2264 /* @@ Is bfd_com_section really correct in all the places it could
2265 be returned from this routine? */
2267 if (index == SHN_ABS)
2268 return &bfd_com_section; /* not abs? */
2269 if (index == SHN_COMMON)
2270 return &bfd_com_section;
2272 if (index > elf_elfheader (abfd)->e_shnum)
2276 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[index];
2278 switch (hdr->sh_type)
2280 /* ELF sections that map to BFD sections */
2284 bfd_section_from_shdr (abfd, index);
2285 return (struct sec *) hdr->rawdata;
2288 return (struct sec *) &bfd_abs_section;
2293 /* given a section, search the header to find them... */
2295 DEFUN (elf_section_from_bfd_section, (abfd, asect),
2299 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
2301 Elf_Internal_Shdr *hdr;
2302 int maxindex = elf_elfheader (abfd)->e_shnum;
2304 if (asect == &bfd_abs_section)
2306 if (asect == &bfd_com_section)
2308 if (asect == &bfd_und_section)
2311 for (index = 0; index < maxindex; index++)
2313 hdr = i_shdrp[index];
2314 switch (hdr->sh_type)
2316 /* ELF sections that map to BFD sections */
2322 if (((struct sec *) (hdr->rawdata)) == asect)
2328 /* fix_up_strtabs will generate STRTAB sections with names
2330 if (!strncmp (asect->name, ".stab", 5)
2331 && !strcmp ("str", asect->name + strlen (asect->name) - 3))
2335 if (((struct sec *) (hdr->rawdata)) == asect)
2343 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2345 if (bed->elf_backend_section_from_bfd_section)
2350 if ((*bed->elf_backend_section_from_bfd_section)
2351 (abfd, hdr, asect, &retval))
2361 /* given a symbol, return the bfd index for that symbol. */
2363 DEFUN (elf_symbol_from_bfd_symbol, (abfd, asym_ptr_ptr),
2365 struct symbol_cache_entry **asym_ptr_ptr)
2367 struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
2369 flagword flags = asym_ptr->flags;
2371 /* When gas creates relocations against local labels, it creates its
2372 own symbol for the section, but does put the symbol into the
2373 symbol chain, so udata is 0. When the linker is generating
2374 relocatable output, this section symbol may be for one of the
2375 input sections rather than the output section. */
2376 if (asym_ptr->udata == (PTR) 0
2377 && (flags & BSF_SECTION_SYM)
2378 && asym_ptr->section)
2382 if (asym_ptr->section->output_section != NULL)
2383 indx = asym_ptr->section->output_section->index;
2385 indx = asym_ptr->section->index;
2386 if (elf_section_syms (abfd)[indx])
2387 asym_ptr->udata = elf_section_syms (abfd)[indx]->udata;
2390 if (asym_ptr->udata)
2391 idx = ((Elf_Sym_Extra *)asym_ptr->udata)->elf_sym_num;
2401 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2402 (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
2411 DEFUN (elf_slurp_symbol_table, (abfd, symptrs),
2413 asymbol ** symptrs) /* Buffer for generated bfd symbols */
2415 Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
2416 int symcount; /* Number of external ELF symbols */
2418 elf_symbol_type *sym; /* Pointer to current bfd symbol */
2419 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
2420 Elf_Internal_Sym i_sym;
2421 Elf_External_Sym *x_symp;
2423 /* this is only valid because there is only one symtab... */
2424 /* FIXME: This is incorrect, there may also be a dynamic symbol
2425 table which is a subset of the full symbol table. We either need
2426 to be prepared to read both (and merge them) or ensure that we
2427 only read the full symbol table. Currently we only get called to
2428 read the full symbol table. -fnf */
2429 if (bfd_get_outsymbols (abfd) != NULL)
2434 /* Read each raw ELF symbol, converting from external ELF form to
2435 internal ELF form, and then using the information to create a
2436 canonical bfd symbol table entry.
2438 Note that we allocate the initial bfd canonical symbol buffer
2439 based on a one-to-one mapping of the ELF symbols to canonical
2440 symbols. We actually use all the ELF symbols, so there will be no
2441 space left over at the end. When we have all the symbols, we
2442 build the caller's pointer vector. */
2444 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
2446 bfd_error = system_call_error;
2450 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2451 symbase = (elf_symbol_type *) bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type));
2454 /* Temporarily allocate room for the raw ELF symbols. */
2455 x_symp = (Elf_External_Sym *) bfd_xmalloc (symcount * sizeof (Elf_External_Sym));
2457 if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
2458 != symcount * sizeof (Elf_External_Sym))
2460 free ((PTR) x_symp);
2461 bfd_error = system_call_error;
2464 /* Skip first symbol, which is a null dummy. */
2465 for (i = 1; i < symcount; i++)
2467 elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
2468 memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
2469 #ifdef ELF_KEEP_EXTSYM
2470 memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
2472 sym->symbol.the_bfd = abfd;
2474 sym->symbol.name = elf_string_from_elf_section (abfd, hdr->sh_link,
2477 sym->symbol.value = i_sym.st_value;
2479 if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERV)
2481 sym->symbol.section = section_from_elf_index (abfd, i_sym.st_shndx);
2483 else if (i_sym.st_shndx == SHN_ABS)
2485 sym->symbol.section = &bfd_abs_section;
2487 else if (i_sym.st_shndx == SHN_COMMON)
2489 sym->symbol.section = &bfd_com_section;
2490 /* Elf puts the alignment into the `value' field, and the size
2491 into the `size' field. BFD wants to see the size in the
2492 value field, and doesn't care (at the moment) about the
2494 sym->symbol.value = i_sym.st_size;
2496 else if (i_sym.st_shndx == SHN_UNDEF)
2498 sym->symbol.section = &bfd_und_section;
2501 sym->symbol.section = &bfd_abs_section;
2503 sym->symbol.value -= sym->symbol.section->vma;
2505 switch (ELF_ST_BIND (i_sym.st_info))
2508 sym->symbol.flags |= BSF_LOCAL;
2511 sym->symbol.flags |= BSF_GLOBAL;
2514 sym->symbol.flags |= BSF_WEAK;
2518 switch (ELF_ST_TYPE (i_sym.st_info))
2521 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
2524 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
2527 sym->symbol.flags |= BSF_FUNCTION;
2531 /* Do some backend-specific processing on this symbol. */
2533 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2534 if (ebd->elf_backend_symbol_processing)
2535 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
2541 /* Do some backend-specific processing on this symbol table. */
2543 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2544 if (ebd->elf_backend_symbol_table_processing)
2545 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
2548 /* We rely on the zalloc to clear out the final symbol entry. */
2550 bfd_get_symcount (abfd) = symcount = sym - symbase;
2552 /* Fill in the user's symbol pointer vector if needed. */
2556 while (symcount-- > 0)
2558 *symptrs++ = &sym->symbol;
2561 *symptrs = 0; /* Final null pointer */
2567 /* Return the number of bytes required to hold the symtab vector.
2569 Note that we base it on the count plus 1, since we will null terminate
2570 the vector allocated based on this size. However, the ELF symbol table
2571 always has a dummy entry as symbol #0, so it ends up even. */
2574 DEFUN (elf_get_symtab_upper_bound, (abfd), bfd * abfd)
2576 unsigned int symcount;
2577 unsigned int symtab_size = 0;
2579 Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
2580 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2581 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol));
2587 This function return the number of bytes required to store the
2588 relocation information associated with section <<sect>>
2589 attached to bfd <<abfd>>
2593 elf_get_reloc_upper_bound (abfd, asect)
2597 if (asect->flags & SEC_RELOC)
2599 /* either rel or rela */
2600 return elf_section_data(asect)->rel_hdr.sh_size;
2607 DEFUN (elf_slurp_reloca_table, (abfd, asect, symbols),
2612 Elf_External_Rela *native_relocs;
2613 arelent *reloc_cache;
2618 if (asect->relocation)
2620 if (asect->reloc_count == 0)
2622 if (asect->flags & SEC_CONSTRUCTOR)
2625 bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
2626 native_relocs = (Elf_External_Rela *)
2627 bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rela));
2628 bfd_read ((PTR) native_relocs,
2629 sizeof (Elf_External_Rela), asect->reloc_count, abfd);
2631 reloc_cache = (arelent *)
2632 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2636 bfd_error = no_memory;
2640 for (idx = 0; idx < asect->reloc_count; idx++)
2642 Elf_Internal_Rela dst;
2643 Elf_External_Rela *src;
2645 cache_ptr = reloc_cache + idx;
2646 src = native_relocs + idx;
2647 elf_swap_reloca_in (abfd, src, &dst);
2649 #ifdef RELOC_PROCESSING
2650 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2652 if (asect->flags & SEC_RELOC)
2654 /* relocatable, so the offset is off of the section */
2655 cache_ptr->address = dst.r_offset + asect->vma;
2659 /* non-relocatable, so the offset a virtual address */
2660 cache_ptr->address = dst.r_offset;
2662 /* ELF_R_SYM(dst.r_info) is the symbol table offset; subtract 1
2663 because the first entry is NULL. */
2664 cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
2666 /* Is it an ELF section symbol? If so, translate it into a
2667 BFD section symbol. */
2668 asymbol *s = *(cache_ptr->sym_ptr_ptr);
2669 if (s->flags & BSF_SECTION_SYM)
2671 cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2672 s = *cache_ptr->sym_ptr_ptr;
2673 if (s->name == 0 || s->name[0] == 0)
2677 cache_ptr->addend = dst.r_addend;
2679 /* Fill in the cache_ptr->howto field from dst.r_type */
2681 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2682 (*ebd->elf_info_to_howto) (abfd, cache_ptr, &dst);
2687 asect->relocation = reloc_cache;
2693 elf_debug_section (str, num, hdr)
2696 Elf_Internal_Shdr *hdr;
2698 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, str, (long) hdr);
2700 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2701 (long) hdr->sh_name,
2702 (long) hdr->sh_type,
2703 (long) hdr->sh_flags);
2705 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2706 (long) hdr->sh_addr,
2707 (long) hdr->sh_offset,
2708 (long) hdr->sh_size);
2710 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2711 (long) hdr->sh_link,
2712 (long) hdr->sh_info,
2713 (long) hdr->sh_addralign);
2714 fprintf (stderr, "sh_entsize = %ld\n",
2715 (long) hdr->sh_entsize);
2716 fprintf (stderr, "rawdata = 0x%.8lx\n", (long) hdr->rawdata);
2717 fprintf (stderr, "contents = 0x%.8lx\n", (long) hdr->contents);
2718 fprintf (stderr, "size = %ld\n", (long) hdr->size);
2723 elf_debug_file (ehdrp)
2724 Elf_Internal_Ehdr *ehdrp;
2726 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
2727 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
2728 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
2729 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
2730 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
2731 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
2732 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
2737 DEFUN (elf_slurp_reloc_table, (abfd, asect, symbols),
2742 Elf_External_Rel *native_relocs;
2743 arelent *reloc_cache;
2745 Elf_Internal_Shdr *data_hdr;
2746 ElfNAME (Off) data_off;
2747 ElfNAME (Word) data_max;
2748 char buf[4]; /* FIXME -- might be elf64 */
2752 if (asect->relocation)
2754 if (asect->reloc_count == 0)
2756 if (asect->flags & SEC_CONSTRUCTOR)
2759 bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
2760 native_relocs = (Elf_External_Rel *)
2761 bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rel));
2762 bfd_read ((PTR) native_relocs,
2763 sizeof (Elf_External_Rel), asect->reloc_count, abfd);
2765 reloc_cache = (arelent *)
2766 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2770 bfd_error = no_memory;
2774 /* Get the offset of the start of the segment we are relocating to read in
2775 the implicit addend. */
2776 data_hdr = &elf_section_data(asect)->this_hdr;
2777 data_off = data_hdr->sh_offset;
2778 data_max = data_hdr->sh_size - sizeof (buf) + 1;
2781 elf_debug_section ("data section", -1, data_hdr);
2784 for (idx = 0; idx < asect->reloc_count; idx++)
2786 #ifdef RELOC_PROCESSING
2787 Elf_Internal_Rel dst;
2788 Elf_External_Rel *src;
2790 cache_ptr = reloc_cache + idx;
2791 src = native_relocs + idx;
2792 elf_swap_reloc_in (abfd, src, &dst);
2794 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2796 Elf_Internal_Rel dst;
2797 Elf_External_Rel *src;
2799 cache_ptr = reloc_cache + idx;
2800 src = native_relocs + idx;
2802 elf_swap_reloc_in (abfd, src, &dst);
2804 if (asect->flags & SEC_RELOC)
2806 /* relocatable, so the offset is off of the section */
2807 cache_ptr->address = dst.r_offset + asect->vma;
2811 /* non-relocatable, so the offset a virtual address */
2812 cache_ptr->address = dst.r_offset;
2814 /* ELF_R_SYM(dst.r_info) is the symbol table offset...
2815 -1 is to skip the dummy symbol table entry */
2816 cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
2818 /* Is it an ELF section symbol? If so, translate it into a
2819 BFD section symbol. */
2820 asymbol *s = *(cache_ptr->sym_ptr_ptr);
2821 if (s->flags & BSF_SECTION_SYM)
2823 cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2824 s = *cache_ptr->sym_ptr_ptr;
2825 if (s->name == 0 || s->name[0] == 0)
2829 BFD_ASSERT (dst.r_offset <= data_max);
2830 cache_ptr->addend = 0;
2832 /* Fill in the cache_ptr->howto field from dst.r_type */
2834 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2835 (*ebd->elf_info_to_howto_rel) (abfd, cache_ptr, &dst);
2840 asect->relocation = reloc_cache;
2845 elf_canonicalize_reloc (abfd, section, relptr, symbols)
2851 arelent *tblptr = section->relocation;
2852 unsigned int count = 0;
2853 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
2855 /* snarfed from coffcode.h */
2857 elf_slurp_reloca_table (abfd, section, symbols);
2859 elf_slurp_reloc_table (abfd, section, symbols);
2861 tblptr = section->relocation;
2865 for (; count++ < section->reloc_count;)
2866 *relptr++ = tblptr++;
2869 return section->reloc_count;
2873 DEFUN (elf_get_symtab, (abfd, alocation),
2875 asymbol ** alocation)
2878 if (!elf_slurp_symbol_table (abfd, alocation))
2881 return bfd_get_symcount (abfd);
2885 DEFUN (elf_make_empty_symbol, (abfd),
2888 elf_symbol_type *newsym;
2890 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
2893 bfd_error = no_memory;
2898 newsym->symbol.the_bfd = abfd;
2899 return &newsym->symbol;
2904 DEFUN (elf_get_symbol_info, (ignore_abfd, symbol, ret),
2905 bfd * ignore_abfd AND
2906 asymbol * symbol AND
2909 bfd_symbol_info (symbol, ret);
2913 DEFUN (elf_print_symbol, (ignore_abfd, filep, symbol, how),
2914 bfd * ignore_abfd AND
2916 asymbol * symbol AND
2917 bfd_print_symbol_type how)
2919 FILE *file = (FILE *) filep;
2922 case bfd_print_symbol_name:
2923 fprintf (file, "%s", symbol->name);
2925 case bfd_print_symbol_more:
2926 fprintf (file, "elf ");
2927 fprintf_vma (file, symbol->value);
2928 fprintf (file, " %lx", (long) symbol->flags);
2930 case bfd_print_symbol_all:
2932 CONST char *section_name;
2933 section_name = symbol->section ? symbol->section->name : "(*none*)";
2934 bfd_print_symbol_vandf ((PTR) file, symbol);
2935 fprintf (file, " %s\t%s",
2945 DEFUN (elf_get_lineno, (ignore_abfd, symbol),
2946 bfd * ignore_abfd AND
2949 fprintf (stderr, "elf_get_lineno unimplemented\n");
2956 DEFUN (elf_set_arch_mach, (abfd, arch, machine),
2958 enum bfd_architecture arch AND
2959 unsigned long machine)
2961 /* Allow any architecture to be supported by the elf backend */
2964 case bfd_arch_unknown: /* EM_NONE */
2965 case bfd_arch_sparc: /* EM_SPARC */
2966 case bfd_arch_i386: /* EM_386 */
2967 case bfd_arch_m68k: /* EM_68K */
2968 case bfd_arch_m88k: /* EM_88K */
2969 case bfd_arch_i860: /* EM_860 */
2970 case bfd_arch_mips: /* EM_MIPS (MIPS R3000) */
2971 case bfd_arch_hppa: /* EM_HPPA (HP PA_RISC) */
2972 return bfd_default_set_arch_mach (abfd, arch, machine);
2979 DEFUN (elf_find_nearest_line, (abfd,
2987 asection * section AND
2988 asymbol ** symbols AND
2990 CONST char **filename_ptr AND
2991 CONST char **functionname_ptr AND
2992 unsigned int *line_ptr)
2998 DEFUN (elf_sizeof_headers, (abfd, reloc),
3002 fprintf (stderr, "elf_sizeof_headers unimplemented\n");
3009 DEFUN (elf_set_section_contents, (abfd, section, location, offset, count),
3014 bfd_size_type count)
3016 Elf_Internal_Shdr *hdr;
3018 if (abfd->output_has_begun == false) /* set by bfd.c handler? */
3020 /* do setup calculations (FIXME) */
3021 prep_headers (abfd);
3022 elf_compute_section_file_positions (abfd);
3023 abfd->output_has_begun = true;
3026 hdr = &elf_section_data(section)->this_hdr;
3028 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
3030 if (bfd_write (location, 1, count, abfd) != count)
3037 DEFUN (elf_no_info_to_howto, (abfd, cache_ptr, dst),
3039 arelent * cache_ptr AND
3040 Elf_Internal_Rela * dst)
3042 fprintf (stderr, "elf RELA relocation support for target machine unimplemented\n");
3048 DEFUN (elf_no_info_to_howto_rel, (abfd, cache_ptr, dst),
3050 arelent * cache_ptr AND
3051 Elf_Internal_Rel * dst)
3053 fprintf (stderr, "elf REL relocation support for target machine unimplemented\n");
3059 /* Core file support */
3061 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3062 #include <sys/procfs.h>
3064 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3065 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3066 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3072 DEFUN (bfd_prstatus, (abfd, descdata, descsz, filepos),
3079 prstatus_t *status = (prstatus_t *) 0;
3081 if (descsz == sizeof (prstatus_t))
3083 newsect = bfd_make_section (abfd, ".reg");
3084 newsect->_raw_size = sizeof (status->pr_reg);
3085 newsect->filepos = filepos + (long) &status->pr_reg;
3086 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3087 newsect->alignment_power = 2;
3088 if ((core_prstatus (abfd) = bfd_alloc (abfd, descsz)) != NULL)
3090 memcpy (core_prstatus (abfd), descdata, descsz);
3095 /* Stash a copy of the prpsinfo structure away for future use. */
3098 DEFUN (bfd_prpsinfo, (abfd, descdata, descsz, filepos),
3106 if (descsz == sizeof (prpsinfo_t))
3108 if ((core_prpsinfo (abfd) = bfd_alloc (abfd, descsz)) != NULL)
3110 memcpy (core_prpsinfo (abfd), descdata, descsz);
3116 DEFUN (bfd_fpregset, (abfd, descdata, descsz, filepos),
3124 newsect = bfd_make_section (abfd, ".reg2");
3125 newsect->_raw_size = descsz;
3126 newsect->filepos = filepos;
3127 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3128 newsect->alignment_power = 2;
3131 #endif /* HAVE_PROCFS */
3133 /* Return a pointer to the args (including the command name) that were
3134 seen by the program that generated the core dump. Note that for
3135 some reason, a spurious space is tacked onto the end of the args
3136 in some (at least one anyway) implementations, so strip it off if
3140 DEFUN (elf_core_file_failing_command, (abfd),
3144 if (core_prpsinfo (abfd))
3146 prpsinfo_t *p = core_prpsinfo (abfd);
3147 char *scan = p->pr_psargs;
3152 if ((scan > p->pr_psargs) && (*scan == ' '))
3156 return p->pr_psargs;
3162 /* Return the number of the signal that caused the core dump. Presumably,
3163 since we have a core file, we got a signal of some kind, so don't bother
3164 checking the other process status fields, just return the signal number.
3168 DEFUN (elf_core_file_failing_signal, (abfd),
3172 if (core_prstatus (abfd))
3174 return ((prstatus_t *) (core_prstatus (abfd)))->pr_cursig;
3180 /* Check to see if the core file could reasonably be expected to have
3181 come for the current executable file. Note that by default we return
3182 true unless we find something that indicates that there might be a
3187 DEFUN (elf_core_file_matches_executable_p, (core_bfd, exec_bfd),
3196 /* First, xvecs must match since both are ELF files for the same target. */
3198 if (core_bfd->xvec != exec_bfd->xvec)
3200 bfd_error = system_call_error;
3206 /* If no prpsinfo, just return true. Otherwise, grab the last component
3207 of the exec'd pathname from the prpsinfo. */
3209 if (core_prpsinfo (core_bfd))
3211 corename = (((struct prpsinfo *) core_prpsinfo (core_bfd))->pr_fname);
3218 /* Find the last component of the executable pathname. */
3220 if ((execname = strrchr (exec_bfd->filename, '/')) != NULL)
3226 execname = (char *) exec_bfd->filename;
3229 /* See if they match */
3231 return strcmp (execname, corename) ? false : true;
3237 #endif /* HAVE_PROCFS */
3240 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3241 the information that would normally be available from the /proc interface
3242 for the process, at the time the process dumped core. Currently this
3243 includes copies of the prstatus, prpsinfo, and fpregset structures.
3245 Since these structures are potentially machine dependent in size and
3246 ordering, bfd provides two levels of support for them. The first level,
3247 available on all machines since it does not require that the host
3248 have /proc support or the relevant include files, is to create a bfd
3249 section for each of the prstatus, prpsinfo, and fpregset structures,
3250 without any interpretation of their contents. With just this support,
3251 the bfd client will have to interpret the structures itself. Even with
3252 /proc support, it might want these full structures for it's own reasons.
3254 In the second level of support, where HAVE_PROCFS is defined, bfd will
3255 pick apart the structures to gather some additional information that
3256 clients may want, such as the general register set, the name of the
3257 exec'ed file and its arguments, the signal (if any) that caused the
3263 DEFUN (elf_corefile_note, (abfd, hdr),
3265 Elf_Internal_Phdr * hdr)
3267 Elf_External_Note *x_note_p; /* Elf note, external form */
3268 Elf_Internal_Note i_note; /* Elf note, internal form */
3269 char *buf = NULL; /* Entire note segment contents */
3270 char *namedata; /* Name portion of the note */
3271 char *descdata; /* Descriptor portion of the note */
3272 char *sectname; /* Name to use for new section */
3273 long filepos; /* File offset to descriptor data */
3276 if (hdr->p_filesz > 0
3277 && (buf = (char *) bfd_xmalloc (hdr->p_filesz)) != NULL
3278 && bfd_seek (abfd, hdr->p_offset, SEEK_SET) != -1
3279 && bfd_read ((PTR) buf, hdr->p_filesz, 1, abfd) == hdr->p_filesz)
3281 x_note_p = (Elf_External_Note *) buf;
3282 while ((char *) x_note_p < (buf + hdr->p_filesz))
3284 i_note.namesz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->namesz);
3285 i_note.descsz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->descsz);
3286 i_note.type = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->type);
3287 namedata = x_note_p->name;
3288 descdata = namedata + BFD_ALIGN (i_note.namesz, 4);
3289 filepos = hdr->p_offset + (descdata - buf);
3290 switch (i_note.type)
3293 /* process descdata as prstatus info */
3294 bfd_prstatus (abfd, descdata, i_note.descsz, filepos);
3295 sectname = ".prstatus";
3298 /* process descdata as fpregset info */
3299 bfd_fpregset (abfd, descdata, i_note.descsz, filepos);
3300 sectname = ".fpregset";
3303 /* process descdata as prpsinfo */
3304 bfd_prpsinfo (abfd, descdata, i_note.descsz, filepos);
3305 sectname = ".prpsinfo";
3308 /* Unknown descriptor, just ignore it. */
3312 if (sectname != NULL)
3314 newsect = bfd_make_section (abfd, sectname);
3315 newsect->_raw_size = i_note.descsz;
3316 newsect->filepos = filepos;
3317 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3318 newsect->alignment_power = 2;
3320 x_note_p = (Elf_External_Note *)
3321 (descdata + BFD_ALIGN (i_note.descsz, 4));
3332 /* Core files are simply standard ELF formatted files that partition
3333 the file using the execution view of the file (program header table)
3334 rather than the linking view. In fact, there is no section header
3335 table in a core file.
3337 The process status information (including the contents of the general
3338 register set) and the floating point register set are stored in a
3339 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3340 that allow standard bfd access to the general registers (.reg) and the
3341 floating point registers (.reg2).
3346 DEFUN (elf_core_file_p, (abfd), bfd * abfd)
3348 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
3349 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3350 Elf_External_Phdr x_phdr; /* Program header table entry, external form */
3351 Elf_Internal_Phdr *i_phdrp; /* Program header table, internal form */
3352 unsigned int phindex;
3354 /* Read in the ELF header in external format. */
3356 if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
3358 bfd_error = system_call_error;
3362 /* Now check to see if we have a valid ELF file, and one that BFD can
3363 make use of. The magic number must match, the address size ('class')
3364 and byte-swapping must match our XVEC entry, and it must have a
3365 program header table (FIXME: See comments re segments at top of this
3368 if (elf_file_p (&x_ehdr) == false)
3371 bfd_error = wrong_format;
3375 /* FIXME, Check EI_VERSION here ! */
3379 int desired_address_size = ELFCLASS32;
3382 int desired_address_size = ELFCLASS64;
3385 if (x_ehdr.e_ident[EI_CLASS] != desired_address_size)
3389 /* Switch xvec to match the specified byte order. */
3390 switch (x_ehdr.e_ident[EI_DATA])
3392 case ELFDATA2MSB: /* Big-endian */
3393 if (abfd->xvec->byteorder_big_p == false)
3396 case ELFDATA2LSB: /* Little-endian */
3397 if (abfd->xvec->byteorder_big_p == true)
3400 case ELFDATANONE: /* No data encoding specified */
3401 default: /* Unknown data encoding specified */
3405 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3406 the tdata pointer in the bfd. */
3409 (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
3410 if (elf_tdata (abfd) == NULL)
3412 bfd_error = no_memory;
3416 /* FIXME, `wrong' returns from this point onward, leak memory. */
3418 /* Now that we know the byte order, swap in the rest of the header */
3419 i_ehdrp = elf_elfheader (abfd);
3420 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
3422 elf_debug_file (i_ehdrp);
3425 /* If there is no program header, or the type is not a core file, then
3427 if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
3430 /* Allocate space for a copy of the program header table in
3431 internal form, seek to the program header table in the file,
3432 read it in, and convert it to internal form. As a simple sanity
3433 check, verify that the what BFD thinks is the size of each program
3434 header table entry actually matches the size recorded in the file. */
3436 if (i_ehdrp->e_phentsize != sizeof (x_phdr))
3438 i_phdrp = (Elf_Internal_Phdr *)
3439 bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
3442 bfd_error = no_memory;
3445 if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
3447 bfd_error = system_call_error;
3450 for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3452 if (bfd_read ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd)
3455 bfd_error = system_call_error;
3458 elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
3461 /* Once all of the program headers have been read and converted, we
3462 can start processing them. */
3464 for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3466 bfd_section_from_phdr (abfd, i_phdrp + phindex, phindex);
3467 if ((i_phdrp + phindex)->p_type == PT_NOTE)
3469 elf_corefile_note (abfd, i_phdrp + phindex);
3473 /* Remember the entry point specified in the ELF file header. */
3475 bfd_get_start_address (abfd) = i_ehdrp->e_entry;