1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994 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
62 #include <string.h> /* For strrchr and friends */
68 /* Renaming structures, typedefs, macros and functions to be size-specific. */
69 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
70 #define Elf_External_Sym NAME(Elf,External_Sym)
71 #define Elf_External_Shdr NAME(Elf,External_Shdr)
72 #define Elf_External_Phdr NAME(Elf,External_Phdr)
73 #define Elf_External_Rel NAME(Elf,External_Rel)
74 #define Elf_External_Rela NAME(Elf,External_Rela)
76 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
77 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
78 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
79 #define elf_object_p NAME(bfd_elf,object_p)
80 #define elf_core_file_p NAME(bfd_elf,core_file_p)
81 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
82 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
83 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
84 #define elf_get_symtab NAME(bfd_elf,get_symtab)
85 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
86 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
87 #define elf_print_symbol NAME(bfd_elf,print_symbol)
88 #define elf_get_lineno NAME(bfd_elf,get_lineno)
89 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
90 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
91 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
92 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
93 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
94 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
95 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
96 #define write_relocs NAME(bfd_elf,_write_relocs)
97 #define elf_find_section NAME(bfd_elf,find_section)
100 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
101 #define ELF_R_SYM(X) ELF64_R_SYM(X)
102 #define ELFCLASS ELFCLASS64
106 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
107 #define ELF_R_SYM(X) ELF32_R_SYM(X)
108 #define ELFCLASS ELFCLASS32
112 static int shstrtab_length_fixed;
114 struct elf_sect_data {
119 /* Forward declarations of static functions */
121 static struct sec * section_from_elf_index PARAMS ((bfd *, unsigned int));
123 static int elf_section_from_bfd_section PARAMS ((bfd *, struct sec *));
125 static boolean elf_slurp_symbol_table PARAMS ((bfd *, asymbol **));
127 static int elf_symbol_from_bfd_symbol PARAMS ((bfd *,
128 struct symbol_cache_entry **));
130 static boolean elf_map_symbols PARAMS ((bfd *));
131 static boolean swap_out_syms PARAMS ((bfd *));
134 static void elf_debug_section PARAMS ((char *, int, Elf_Internal_Shdr *));
135 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
138 #define elf_string_from_elf_strtab(abfd,strindex) \
139 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
142 /* Structure swapping routines */
144 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
145 can be handled by explicitly specifying 32 bits or "the long type". */
147 #define put_word bfd_h_put_64
148 #define get_word bfd_h_get_64
151 #define put_word bfd_h_put_32
152 #define get_word bfd_h_get_32
155 /* Translate an ELF symbol in external format into an ELF symbol in internal
159 DEFUN (elf_swap_symbol_in, (abfd, src, dst),
161 Elf_External_Sym * src AND
162 Elf_Internal_Sym * dst)
164 dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
165 dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
166 dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
167 dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
168 dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
169 dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
172 /* Translate an ELF symbol in internal format into an ELF symbol in external
176 DEFUN (elf_swap_symbol_out, (abfd, src, dst),
178 Elf_Internal_Sym * src AND
179 Elf_External_Sym * dst)
181 bfd_h_put_32 (abfd, src->st_name, dst->st_name);
182 put_word (abfd, src->st_value, dst->st_value);
183 put_word (abfd, src->st_size, dst->st_size);
184 bfd_h_put_8 (abfd, src->st_info, dst->st_info);
185 bfd_h_put_8 (abfd, src->st_other, dst->st_other);
186 bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
190 /* Translate an ELF file header in external format into an ELF file header in
194 DEFUN (elf_swap_ehdr_in, (abfd, src, dst),
196 Elf_External_Ehdr * src AND
197 Elf_Internal_Ehdr * dst)
199 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
200 dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
201 dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
202 dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
203 dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
204 dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
205 dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
206 dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
207 dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
208 dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
209 dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
210 dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
211 dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
212 dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
215 /* Translate an ELF file header in internal format into an ELF file header in
219 DEFUN (elf_swap_ehdr_out, (abfd, src, dst),
221 Elf_Internal_Ehdr * src AND
222 Elf_External_Ehdr * dst)
224 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
225 /* note that all elements of dst are *arrays of unsigned char* already... */
226 bfd_h_put_16 (abfd, src->e_type, dst->e_type);
227 bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
228 bfd_h_put_32 (abfd, src->e_version, dst->e_version);
229 put_word (abfd, src->e_entry, dst->e_entry);
230 put_word (abfd, src->e_phoff, dst->e_phoff);
231 put_word (abfd, src->e_shoff, dst->e_shoff);
232 bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
233 bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
234 bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
235 bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
236 bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
237 bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
238 bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
242 /* Translate an ELF section header table entry in external format into an
243 ELF section header table entry in internal format. */
246 DEFUN (elf_swap_shdr_in, (abfd, src, dst),
248 Elf_External_Shdr * src AND
249 Elf_Internal_Shdr * dst)
251 dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
252 dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
253 dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
254 dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
255 dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
256 dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
257 dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
258 dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
259 dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
260 dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
261 /* we haven't done any processing on it yet, so... */
262 dst->rawdata = (void *) 0;
265 /* Translate an ELF section header table entry in internal format into an
266 ELF section header table entry in external format. */
269 DEFUN (elf_swap_shdr_out, (abfd, src, dst),
271 Elf_Internal_Shdr * src AND
272 Elf_External_Shdr * dst)
274 /* note that all elements of dst are *arrays of unsigned char* already... */
275 bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
276 bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
277 put_word (abfd, src->sh_flags, dst->sh_flags);
278 put_word (abfd, src->sh_addr, dst->sh_addr);
279 put_word (abfd, src->sh_offset, dst->sh_offset);
280 put_word (abfd, src->sh_size, dst->sh_size);
281 bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
282 bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
283 put_word (abfd, src->sh_addralign, dst->sh_addralign);
284 put_word (abfd, src->sh_entsize, dst->sh_entsize);
288 /* Translate an ELF program header table entry in external format into an
289 ELF program header table entry in internal format. */
292 DEFUN (elf_swap_phdr_in, (abfd, src, dst),
294 Elf_External_Phdr * src AND
295 Elf_Internal_Phdr * dst)
297 dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
298 dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
299 dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
300 dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
301 dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
302 dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
303 dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
304 dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
308 DEFUN (elf_swap_phdr_out, (abfd, src, dst),
310 Elf_Internal_Phdr * src AND
311 Elf_External_Phdr * dst)
313 /* note that all elements of dst are *arrays of unsigned char* already... */
314 bfd_h_put_32 (abfd, src->p_type, dst->p_type);
315 put_word (abfd, src->p_offset, dst->p_offset);
316 put_word (abfd, src->p_vaddr, dst->p_vaddr);
317 put_word (abfd, src->p_paddr, dst->p_paddr);
318 put_word (abfd, src->p_filesz, dst->p_filesz);
319 put_word (abfd, src->p_memsz, dst->p_memsz);
320 bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
321 put_word (abfd, src->p_align, dst->p_align);
324 /* Translate an ELF reloc from external format to internal format. */
326 DEFUN (elf_swap_reloc_in, (abfd, src, dst),
328 Elf_External_Rel * src AND
329 Elf_Internal_Rel * dst)
331 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
332 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
336 DEFUN (elf_swap_reloca_in, (abfd, src, dst),
338 Elf_External_Rela * src AND
339 Elf_Internal_Rela * dst)
341 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
342 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
343 dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
346 /* Translate an ELF reloc from internal format to external format. */
348 DEFUN (elf_swap_reloc_out, (abfd, src, dst),
350 Elf_Internal_Rel * src AND
351 Elf_External_Rel * dst)
353 put_word (abfd, src->r_offset, dst->r_offset);
354 put_word (abfd, src->r_info, dst->r_info);
358 DEFUN (elf_swap_reloca_out, (abfd, src, dst),
360 Elf_Internal_Rela * src AND
361 Elf_External_Rela * dst)
363 put_word (abfd, src->r_offset, dst->r_offset);
364 put_word (abfd, src->r_info, dst->r_info);
365 put_word (abfd, src->r_addend, dst->r_addend);
370 /* String table creation/manipulation routines */
372 static struct strtab *
373 DEFUN (bfd_new_strtab, (abfd),
378 ss = (struct strtab *) malloc (sizeof (struct strtab));
381 bfd_set_error (bfd_error_no_memory);
384 ss->tab = malloc (1);
387 bfd_set_error (bfd_error_no_memory);
398 DEFUN (bfd_add_to_strtab, (abfd, ss, str),
400 struct strtab *ss AND
403 /* should search first, but for now: */
404 /* include the trailing NUL */
405 int ln = strlen (str) + 1;
407 /* should this be using obstacks? */
408 ss->tab = realloc (ss->tab, ss->length + ln);
410 BFD_ASSERT (ss->tab != 0); /* FIXME */
411 strcpy (ss->tab + ss->length, str);
415 return ss->length - ln;
419 DEFUN (bfd_add_2_to_strtab, (abfd, ss, str, str2),
421 struct strtab *ss AND
425 /* should search first, but for now: */
426 /* include the trailing NUL */
427 int ln = strlen (str) + strlen (str2) + 1;
429 /* should this be using obstacks? */
431 ss->tab = realloc (ss->tab, ss->length + ln);
433 ss->tab = malloc (ln);
435 BFD_ASSERT (ss->tab != 0); /* FIXME */
436 strcpy (ss->tab + ss->length, str);
437 strcpy (ss->tab + ss->length + strlen (str), str2);
441 return ss->length - ln;
445 /* ELF .o/exec file reading */
447 /* Create a new bfd section from an ELF section header. */
450 DEFUN (bfd_section_from_shdr, (abfd, shindex),
452 unsigned int shindex)
454 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
455 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
459 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
461 switch (hdr->sh_type)
465 /* inactive section. Throw it away. */
470 /* Bits that get saved. This one is real. */
473 newsect = bfd_make_section (abfd, name);
476 newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
477 newsect->flags |= SEC_HAS_CONTENTS;
478 newsect->vma = hdr->sh_addr;
479 newsect->_raw_size = hdr->sh_size;
480 newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
482 if (hdr->sh_flags & SHF_ALLOC)
484 newsect->flags |= SEC_ALLOC;
485 newsect->flags |= SEC_LOAD;
488 if (!(hdr->sh_flags & SHF_WRITE))
489 newsect->flags |= SEC_READONLY;
491 if (hdr->sh_flags & SHF_EXECINSTR)
492 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
493 else if (newsect->flags & SEC_ALLOC)
494 newsect->flags |= SEC_DATA;
496 /* The debugging sections appear to recognized only by
498 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
499 || strncmp (name, ".line", sizeof ".line" - 1) == 0
500 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
501 newsect->flags |= SEC_DEBUGGING;
503 hdr->rawdata = (void *) newsect;
506 hdr->rawdata = (void *) bfd_get_section_by_name (abfd, name);
511 /* Bits that get saved. This one is real. */
514 newsect = bfd_make_section (abfd, name);
517 newsect->vma = hdr->sh_addr;
518 newsect->_raw_size = hdr->sh_size;
519 newsect->filepos = hdr->sh_offset; /* fake */
520 newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
521 if (hdr->sh_flags & SHF_ALLOC)
522 newsect->flags |= SEC_ALLOC;
524 if (!(hdr->sh_flags & SHF_WRITE))
525 newsect->flags |= SEC_READONLY;
527 /* FIXME: This section is empty. Does it really make
528 sense to set SEC_CODE for it? */
529 if (hdr->sh_flags & SHF_EXECINSTR)
530 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
532 hdr->rawdata = (void *) newsect;
537 case SHT_SYMTAB: /* A symbol table */
538 if (elf_onesymtab (abfd) == shindex)
541 BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym));
542 BFD_ASSERT (elf_onesymtab (abfd) == 0);
543 elf_onesymtab (abfd) = shindex;
544 elf_tdata(abfd)->symtab_hdr = *hdr;
545 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->symtab_hdr;
546 abfd->flags |= HAS_SYMS;
549 case SHT_STRTAB: /* A string table */
552 if (ehdr->e_shstrndx == shindex)
554 elf_tdata(abfd)->shstrtab_hdr = *hdr;
555 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->shstrtab_hdr;
556 hdr->rawdata = (PTR) &elf_tdata(abfd)->shstrtab_hdr;
562 for (i = 1; i < ehdr->e_shnum; i++)
564 Elf_Internal_Shdr *hdr2 = elf_elfsections(abfd)[i];
565 if (hdr2->sh_link == shindex)
567 bfd_section_from_shdr (abfd, i);
568 if (elf_onesymtab (abfd) == i)
570 elf_tdata(abfd)->strtab_hdr = *hdr;
571 elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->strtab_hdr;
574 #if 0 /* Not handling other string tables specially right now. */
575 hdr2 = elf_elfsections(abfd)[i]; /* in case it moved */
576 /* We have a strtab for some random other section. */
577 newsect = (asection *) hdr2->rawdata;
580 hdr->rawdata = (PTR) newsect;
581 hdr2 = &elf_section_data (newsect)->str_hdr;
583 elf_elfsections(abfd)[shindex] = hdr2;
589 newsect = bfd_make_section (abfd, name);
592 newsect->flags = SEC_HAS_CONTENTS;
593 hdr->rawdata = (PTR) newsect;
594 newsect->_raw_size = hdr->sh_size;
595 newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
596 newsect->vma = hdr->sh_addr;
597 newsect->filepos = hdr->sh_offset;
599 if (hdr->sh_flags & SHF_ALLOC)
600 newsect->flags |= SEC_ALLOC|SEC_LOAD;
601 if (!(hdr->sh_flags & SHF_WRITE))
602 newsect->flags |= SEC_READONLY;
603 if (hdr->sh_flags & SHF_EXECINSTR)
604 newsect->flags |= SEC_CODE;
605 else if (newsect->flags & SEC_ALLOC)
606 newsect->flags |= SEC_DATA;
608 /* Check for debugging string tables. */
609 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
610 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
611 newsect->flags |= SEC_DEBUGGING;
618 /* *These* do a lot of work -- but build no sections!
619 The spec says there can be multiple strtabs, but only one symtab,
620 but there can be lots of REL* sections. */
621 /* FIXME: The above statement is wrong! There are typically at least
622 two symbol tables in a dynamically linked executable, ".dynsym"
623 which is the dynamic linkage symbol table and ".symtab", which is
624 the "traditional" symbol table. -fnf */
627 asection *target_sect;
628 Elf_Internal_Shdr *hdr2;
629 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
631 /* Don't allow REL relocations on a machine that uses RELA and
633 /* @@ Actually, the generic ABI does suggest that both might be
634 used in one file. But the four ABI Processor Supplements I
635 have access to right now all specify that only one is used on
636 each of those architectures. It's conceivable that, e.g., a
637 bunch of absolute 32-bit relocs might be more compact in REL
638 form even on a RELA machine... */
639 BFD_ASSERT (!(use_rela_p && (hdr->sh_type == SHT_REL)));
640 BFD_ASSERT (!(!use_rela_p && (hdr->sh_type == SHT_RELA)));
641 BFD_ASSERT (hdr->sh_entsize ==
643 ? sizeof (Elf_External_Rela)
644 : sizeof (Elf_External_Rel)));
646 bfd_section_from_shdr (abfd, hdr->sh_info); /* target */
647 bfd_section_from_shdr (abfd, hdr->sh_link); /* symbol table */
648 target_sect = section_from_elf_index (abfd, hdr->sh_info);
649 if (target_sect == NULL
650 || elf_section_data (target_sect) == NULL)
653 hdr2 = &elf_section_data (target_sect)->rel_hdr;
655 elf_elfsections(abfd)[shindex] = hdr2;
656 target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
657 target_sect->flags |= SEC_RELOC;
658 target_sect->relocation = 0;
659 target_sect->rel_filepos = hdr->sh_offset;
660 abfd->flags |= HAS_RELOC;
666 case SHT_DYNSYM: /* could treat this like symtab... */
668 fprintf (stderr, "Dynamic Linking sections not yet supported.\n");
675 fprintf (stderr, "Note Sections not yet supported.\n");
682 fprintf (stderr, "SHLIB Sections not supported (and non conforming.)\n");
687 /* Check for any processor-specific section types. */
689 struct elf_backend_data *bed = get_elf_backend_data (abfd);
691 if (bed->elf_backend_section_from_shdr)
692 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
701 DEFUN (elf_new_section_hook, (abfd, sec),
705 struct bfd_elf_section_data *sdata;
707 sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
710 bfd_set_error (bfd_error_no_memory);
713 sec->used_by_bfd = (PTR) sdata;
714 memset (sdata, 0, sizeof (*sdata));
718 /* Create a new bfd section from an ELF program header.
720 Since program segments have no names, we generate a synthetic name
721 of the form segment<NUM>, where NUM is generally the index in the
722 program header table. For segments that are split (see below) we
723 generate the names segment<NUM>a and segment<NUM>b.
725 Note that some program segments may have a file size that is different than
726 (less than) the memory size. All this means is that at execution the
727 system must allocate the amount of memory specified by the memory size,
728 but only initialize it with the first "file size" bytes read from the
729 file. This would occur for example, with program segments consisting
730 of combined data+bss.
732 To handle the above situation, this routine generates TWO bfd sections
733 for the single program segment. The first has the length specified by
734 the file size of the segment, and the second has the length specified
735 by the difference between the two sizes. In effect, the segment is split
736 into it's initialized and uninitialized parts.
741 DEFUN (bfd_section_from_phdr, (abfd, hdr, index),
743 Elf_Internal_Phdr * hdr AND
751 split = ((hdr->p_memsz > 0) &&
752 (hdr->p_filesz > 0) &&
753 (hdr->p_memsz > hdr->p_filesz));
754 sprintf (namebuf, split ? "segment%da" : "segment%d", index);
755 name = bfd_alloc (abfd, strlen (namebuf) + 1);
758 bfd_set_error (bfd_error_no_memory);
761 strcpy (name, namebuf);
762 newsect = bfd_make_section (abfd, name);
763 newsect->vma = hdr->p_vaddr;
764 newsect->_raw_size = hdr->p_filesz;
765 newsect->filepos = hdr->p_offset;
766 newsect->flags |= SEC_HAS_CONTENTS;
767 if (hdr->p_type == PT_LOAD)
769 newsect->flags |= SEC_ALLOC;
770 newsect->flags |= SEC_LOAD;
771 if (hdr->p_flags & PF_X)
773 /* FIXME: all we known is that it has execute PERMISSION,
775 newsect->flags |= SEC_CODE;
778 if (!(hdr->p_flags & PF_W))
780 newsect->flags |= SEC_READONLY;
785 sprintf (namebuf, "segment%db", index);
786 name = bfd_alloc (abfd, strlen (namebuf) + 1);
789 bfd_set_error (bfd_error_no_memory);
792 strcpy (name, namebuf);
793 newsect = bfd_make_section (abfd, name);
794 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
795 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
796 if (hdr->p_type == PT_LOAD)
798 newsect->flags |= SEC_ALLOC;
799 if (hdr->p_flags & PF_X)
800 newsect->flags |= SEC_CODE;
802 if (!(hdr->p_flags & PF_W))
803 newsect->flags |= SEC_READONLY;
809 /* Begin processing a given object.
811 First we validate the file by reading in the ELF header and checking
814 static INLINE boolean
815 DEFUN (elf_file_p, (x_ehdrp), Elf_External_Ehdr * x_ehdrp)
817 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
818 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
819 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
820 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
823 /* Check to see if the file associated with ABFD matches the target vector
826 Note that we may be called several times with the same ABFD, but different
827 target vectors, most of which will not match. We have to avoid leaving
828 any side effects in ABFD, or any data it points to (like tdata), if the
829 file does not match the target vector.
831 FIXME: There is memory leak if we are called more than once with the same
832 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
833 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
834 much we can do about this except possibly rewrite the code. There are
835 also other bfd_allocs that may be the source of memory leaks as well. */
838 DEFUN (elf_object_p, (abfd), bfd * abfd)
840 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
841 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
842 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
843 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
844 unsigned int shindex;
845 char *shstrtab; /* Internal copy of section header stringtab */
846 struct elf_backend_data *ebd;
847 struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
849 /* Read in the ELF header in external format. */
851 if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
852 goto got_system_call;
854 /* Now check to see if we have a valid ELF file, and one that BFD can
855 make use of. The magic number must match, the address size ('class')
856 and byte-swapping must match our XVEC entry, and it must have a
857 section header table (FIXME: See comments re sections at top of this
860 if ((elf_file_p (&x_ehdr) == false) ||
861 (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
862 (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
863 goto got_wrong_format_error;
865 /* Check that file's byte order matches xvec's */
866 switch (x_ehdr.e_ident[EI_DATA])
868 case ELFDATA2MSB: /* Big-endian */
869 if (!abfd->xvec->header_byteorder_big_p)
870 goto got_wrong_format_error;
872 case ELFDATA2LSB: /* Little-endian */
873 if (abfd->xvec->header_byteorder_big_p)
874 goto got_wrong_format_error;
876 case ELFDATANONE: /* No data encoding specified */
877 default: /* Unknown data encoding specified */
878 goto got_wrong_format_error;
881 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
882 the tdata pointer in the bfd. FIXME: memory leak, see above. */
885 (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
886 if (elf_tdata (abfd) == NULL)
887 goto got_no_memory_error;
889 /* Now that we know the byte order, swap in the rest of the header */
890 i_ehdrp = elf_elfheader (abfd);
891 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
893 elf_debug_file (i_ehdrp);
896 /* If there is no section header table, we're hosed. */
897 if (i_ehdrp->e_shoff == 0)
898 goto got_wrong_format_error;
900 /* As a simple sanity check, verify that the what BFD thinks is the
901 size of each section header table entry actually matches the size
902 recorded in the file. */
903 if (i_ehdrp->e_shentsize != sizeof (x_shdr))
904 goto got_wrong_format_error;
906 ebd = get_elf_backend_data (abfd);
908 /* Check that the ELF e_machine field matches what this particular
909 BFD format expects. */
910 if (ebd->elf_machine_code != i_ehdrp->e_machine)
912 bfd_target **target_ptr;
914 if (ebd->elf_machine_code != EM_NONE)
915 goto got_wrong_format_error;
917 /* This is the generic ELF target. Let it match any ELF target
918 for which we do not have a specific backend. */
919 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
921 struct elf_backend_data *back;
923 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
925 back = (struct elf_backend_data *) (*target_ptr)->backend_data;
926 if (back->elf_machine_code == i_ehdrp->e_machine)
928 /* target_ptr is an ELF backend which matches this
929 object file, so reject the generic ELF target. */
930 goto got_wrong_format_error;
936 /* Set the flags and architecture before calling the backend so that
937 it can override them. */
938 if (i_ehdrp->e_type == ET_EXEC)
939 abfd->flags |= EXEC_P;
940 else if (i_ehdrp->e_type == ET_DYN)
941 abfd->flags |= DYNAMIC;
943 bfd_default_set_arch_mach (abfd, ebd->arch, 0);
945 /* Remember the entry point specified in the ELF file header. */
946 bfd_get_start_address (abfd) = i_ehdrp->e_entry;
948 /* Let the backend double check the format and override global
950 if (ebd->elf_backend_object_p)
952 if ((*ebd->elf_backend_object_p) (abfd) == false)
953 goto got_wrong_format_error;
956 /* Allocate space for a copy of the section header table in
957 internal form, seek to the section header table in the file,
958 read it in, and convert it to internal form. */
959 i_shdrp = (Elf_Internal_Shdr *)
960 bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum);
961 elf_elfsections (abfd) =
962 (Elf_Internal_Shdr **) bfd_alloc (abfd, sizeof (i_shdrp) * i_ehdrp->e_shnum);
963 if (!i_shdrp || !elf_elfsections(abfd))
964 goto got_no_memory_error;
965 if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1)
966 goto got_system_call;
967 for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
969 if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
970 goto got_system_call;
971 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
972 elf_elfsections(abfd)[shindex] = i_shdrp + shindex;
974 /* If this is a .dynamic section, mark the object file as being
975 dynamically linked. */
976 if (i_shdrp[shindex].sh_type == SHT_DYNAMIC)
977 abfd->flags |= DYNAMIC;
979 if (i_ehdrp->e_shstrndx)
981 bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx);
984 /* Read in the string table containing the names of the sections. We
985 will need the base pointer to this table later. */
986 /* We read this inline now, so that we don't have to go through
987 bfd_section_from_shdr with it (since this particular strtab is
988 used to find all of the ELF section names.) */
990 shstrtab = elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
992 goto got_wrong_format_error;
994 /* Once all of the section headers have been read and converted, we
995 can start processing them. Note that the first section header is
996 a dummy placeholder entry, so we ignore it.
998 We also watch for the symbol table section and remember the file
999 offset and section size for both the symbol table section and the
1000 associated string table section. */
1002 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
1004 bfd_section_from_shdr (abfd, shindex);
1007 return (abfd->xvec);
1009 /* If we are going to use goto's to avoid duplicating error setting
1010 and return(NULL) code, then this at least makes it more maintainable. */
1013 bfd_set_error (bfd_error_system_call);
1015 got_wrong_format_error:
1016 bfd_set_error (bfd_error_wrong_format);
1018 got_no_memory_error:
1019 bfd_set_error (bfd_error_no_memory);
1022 elf_tdata (abfd) = preserved_tdata;
1027 /* ELF .o/exec file writing */
1029 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1030 of the symbol if there is one. */
1031 static INLINE elf_symbol_type *
1032 DEFUN (elf_symbol_from, (ignore_abfd, symbol),
1033 bfd * ignore_abfd AND
1036 if (symbol->the_bfd->xvec->flavour != bfd_target_elf_flavour)
1039 if (symbol->the_bfd->tdata.elf_obj_data == (struct elf_obj_tdata *) NULL)
1042 return (elf_symbol_type *) symbol;
1045 /* Create ELF output from BFD sections.
1047 Essentially, just create the section header and forget about the program
1051 DEFUN (elf_make_sections, (abfd, asect, obj),
1053 asection * asect AND
1056 /* most of what is in bfd_shdr_from_section goes in here... */
1057 /* and all of these sections generate at *least* one ELF section. */
1058 Elf_Internal_Shdr *this_hdr;
1059 this_hdr = &elf_section_data (asect)->this_hdr;
1061 this_hdr->sh_addr = asect->vma;
1062 this_hdr->sh_size = asect->_raw_size;
1063 /* contents already set by elf_set_section_contents */
1065 if (asect->flags & SEC_RELOC)
1067 /* emit a reloc section, and thus strtab and symtab... */
1068 Elf_Internal_Shdr *rela_hdr;
1069 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1071 rela_hdr = &elf_section_data (asect)->rel_hdr;
1073 /* orelocation has the data, reloc_count has the count... */
1076 rela_hdr->sh_type = SHT_RELA;
1077 rela_hdr->sh_entsize = sizeof (Elf_External_Rela);
1080 /* REL relocations */
1082 rela_hdr->sh_type = SHT_REL;
1083 rela_hdr->sh_entsize = sizeof (Elf_External_Rel);
1085 rela_hdr->sh_flags = 0;
1086 rela_hdr->sh_addr = 0;
1087 rela_hdr->sh_offset = 0;
1089 /* FIXME: Systems I've checked use an alignment of 4, but it is
1090 possible that some systems use a different alignment. */
1091 rela_hdr->sh_addralign = 4;
1095 if (asect->flags & SEC_ALLOC)
1097 this_hdr->sh_flags |= SHF_ALLOC;
1098 if (asect->flags & SEC_LOAD)
1100 /* @@ Do something with sh_type? */
1105 /* If this section is not part of the program image during
1106 execution, leave the address fields at 0. */
1107 this_hdr->sh_addr = 0;
1110 if (!(asect->flags & SEC_READONLY))
1111 this_hdr->sh_flags |= SHF_WRITE;
1113 if (asect->flags & SEC_CODE)
1114 this_hdr->sh_flags |= SHF_EXECINSTR;
1118 write_relocs (abfd, sec, xxx)
1123 Elf_Internal_Shdr *rela_hdr;
1124 Elf_External_Rela *outbound_relocas;
1125 Elf_External_Rel *outbound_relocs;
1127 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1128 asymbol *last_sym = 0;
1129 int last_sym_idx = 9999999; /* should always be written before use */
1131 if ((sec->flags & SEC_RELOC) == 0)
1133 /* Flags are sometimes inconsistent. */
1134 if (sec->reloc_count == 0)
1137 rela_hdr = &elf_section_data (sec)->rel_hdr;
1139 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
1140 rela_hdr->contents = (void *) bfd_alloc (abfd, rela_hdr->sh_size);
1141 if (!rela_hdr->contents)
1143 bfd_set_error (bfd_error_no_memory);
1144 abort(); /* FIXME */
1147 /* orelocation has the data, reloc_count has the count... */
1150 outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
1152 for (idx = 0; idx < sec->reloc_count; idx++)
1154 Elf_Internal_Rela dst_rela;
1155 Elf_External_Rela *src_rela;
1160 ptr = sec->orelocation[idx];
1161 src_rela = outbound_relocas + idx;
1162 if (!(abfd->flags & EXEC_P))
1163 dst_rela.r_offset = ptr->address - sec->vma;
1165 dst_rela.r_offset = ptr->address;
1167 sym = *ptr->sym_ptr_ptr;
1168 if (sym == last_sym)
1173 last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1175 dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1177 dst_rela.r_addend = ptr->addend;
1178 elf_swap_reloca_out (abfd, &dst_rela, src_rela);
1182 /* REL relocations */
1184 outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
1186 for (idx = 0; idx < sec->reloc_count; idx++)
1188 Elf_Internal_Rel dst_rel;
1189 Elf_External_Rel *src_rel;
1194 ptr = sec->orelocation[idx];
1195 sym = *ptr->sym_ptr_ptr;
1196 src_rel = outbound_relocs + idx;
1197 if (!(abfd->flags & EXEC_P))
1198 dst_rel.r_offset = ptr->address - sec->vma;
1200 dst_rel.r_offset = ptr->address;
1202 if (sym == last_sym)
1207 last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1209 dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
1211 elf_swap_reloc_out (abfd, &dst_rel, src_rel);
1217 fix_up_strtabs (abfd, asect, obj)
1222 Elf_Internal_Shdr *this_hdr = &elf_section_data (asect)->this_hdr;
1223 int this_idx = elf_section_data(asect)->this_idx;
1225 /* @@ Check flags! */
1226 if (!strncmp (asect->name, ".stab", 5)
1227 && !strcmp ("str", asect->name + strlen (asect->name) - 3))
1229 size_t len = strlen (asect->name) + 1;
1230 char *s = (char *) alloca (len);
1231 strcpy (s, asect->name);
1233 asect = bfd_get_section_by_name (abfd, s);
1236 elf_section_data(asect)->this_hdr.sh_link = this_idx;
1237 /* @@ Assuming 32 bits! */
1238 elf_section_data(asect)->this_hdr.sh_entsize = 0xc;
1240 this_hdr->sh_type = SHT_STRTAB;
1245 DEFUN (elf_fake_sections, (abfd, asect, obj),
1247 asection * asect AND
1250 /* most of what is in bfd_shdr_from_section goes in here... */
1251 /* and all of these sections generate at *least* one ELF section. */
1253 Elf_Internal_Shdr *this_hdr;
1254 this_hdr = &elf_section_data (asect)->this_hdr;
1256 bfd_add_to_strtab (abfd, elf_shstrtab (abfd), asect->name);
1257 /* We need to log the type *now* so that elf_section_from_bfd_section
1258 can find us... have to set rawdata too. */
1259 this_hdr->rawdata = (void *) asect;
1260 this_hdr->sh_addralign = 1 << asect->alignment_power;
1261 if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD))
1262 this_hdr->sh_type = SHT_PROGBITS;
1263 else if ((asect->flags & SEC_ALLOC) && ((asect->flags & SEC_LOAD) == 0))
1265 BFD_ASSERT (strcmp (asect->name, ".bss") == 0
1266 || strcmp (asect->name, ".sbss") == 0);
1267 this_hdr->sh_type = SHT_NOBITS;
1269 /* FIXME I am not sure how to detect a .note section from the flags
1270 word of an `asection'. */
1271 else if (!strcmp (asect->name, ".note"))
1272 this_hdr->sh_type = SHT_NOTE;
1274 this_hdr->sh_type = SHT_PROGBITS;
1276 this_hdr->sh_flags = 0;
1277 this_hdr->sh_addr = 0;
1278 this_hdr->sh_size = 0;
1279 this_hdr->sh_entsize = 0;
1280 this_hdr->sh_info = 0;
1281 this_hdr->sh_link = 0;
1282 this_hdr->sh_offset = 0;
1285 /* Now, check for processor-specific section types. */
1287 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1289 if (bed->elf_backend_fake_sections)
1290 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1294 /* Emit a strtab and symtab, and possibly a reloc section. */
1295 Elf_Internal_Shdr *rela_hdr;
1297 /* Note that only one symtab is used, so just remember it
1300 if (asect->flags & SEC_RELOC)
1302 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1304 rela_hdr = &elf_section_data (asect)->rel_hdr;
1306 bfd_add_2_to_strtab (abfd, elf_shstrtab (abfd),
1307 use_rela_p ? ".rela" : ".rel",
1309 rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1310 rela_hdr->sh_entsize = (use_rela_p
1311 ? sizeof (Elf_External_Rela)
1312 : sizeof (Elf_External_Rel));
1314 rela_hdr->sh_flags = 0;
1315 rela_hdr->sh_addr = 0;
1316 rela_hdr->sh_size = 0;
1317 rela_hdr->sh_offset = 0;
1319 /* FIXME: Systems I've checked use an alignment of 4, but some
1320 systems may use a different alignment. */
1321 rela_hdr->sh_addralign = 4;
1326 if (asect->flags & SEC_ALLOC)
1328 this_hdr->sh_flags |= SHF_ALLOC;
1329 if (asect->flags & SEC_LOAD)
1331 /* @@ Do something with sh_type? */
1334 if (!(asect->flags & SEC_READONLY))
1335 this_hdr->sh_flags |= SHF_WRITE;
1336 if (asect->flags & SEC_CODE)
1337 this_hdr->sh_flags |= SHF_EXECINSTR;
1340 /* Map symbol from it's internal number to the external number, moving
1341 all local symbols to be at the head of the list. */
1344 sym_is_global (abfd, sym)
1348 /* If the backend has a special mapping, use it. */
1349 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1350 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1353 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
1355 if (sym->flags & BSF_LOCAL)
1359 if (sym->section == 0)
1361 /* Is this valid? */
1366 if (sym->section == &bfd_und_section)
1368 if (bfd_is_com_section (sym->section))
1370 if (sym->flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE))
1376 DEFUN (elf_map_symbols, (abfd), bfd * abfd)
1378 int symcount = bfd_get_symcount (abfd);
1379 asymbol **syms = bfd_get_outsymbols (abfd);
1380 asymbol **sect_syms;
1382 int num_globals = 0;
1383 int num_locals2 = 0;
1384 int num_globals2 = 0;
1386 int num_sections = 0;
1387 Elf_Sym_Extra *sym_extra;
1392 fprintf (stderr, "elf_map_symbols\n");
1396 /* Add local symbols for each section for which there are relocs.
1397 FIXME: How can we tell which sections have relocs at this point?
1398 Will reloc_count always be accurate? Actually, I think most ELF
1399 targets create section symbols for all sections anyhow. */
1400 for (asect = abfd->sections; asect; asect = asect->next)
1402 if (max_index < asect->index)
1403 max_index = asect->index;
1407 elf_num_section_syms (abfd) = max_index;
1408 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1409 elf_section_syms (abfd) = sect_syms;
1413 bfd_set_error (bfd_error_no_memory);
1417 for (asect = abfd->sections; asect; asect = asect->next)
1419 asymbol *sym = bfd_make_empty_symbol (abfd);
1422 bfd_set_error (bfd_error_no_memory);
1425 sym->the_bfd = abfd;
1426 sym->name = asect->name;
1427 sym->value = asect->vma;
1428 sym->flags = BSF_SECTION_SYM;
1429 sym->section = asect;
1430 sect_syms[asect->index] = sym;
1434 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1435 asect->name, (long) asect->vma, asect->index, (long) asect);
1442 syms = (asymbol **) bfd_realloc (abfd, syms,
1443 ((symcount + num_sections + 1)
1444 * sizeof (asymbol *)));
1446 syms = (asymbol **) bfd_alloc (abfd,
1447 (num_sections + 1) * sizeof (asymbol *));
1450 bfd_set_error (bfd_error_no_memory);
1454 for (asect = abfd->sections; asect; asect = asect->next)
1456 if (sect_syms[asect->index])
1457 syms[symcount++] = sect_syms[asect->index];
1460 syms[symcount] = (asymbol *) 0;
1461 bfd_set_symtab (abfd, syms, symcount);
1464 elf_sym_extra (abfd) = sym_extra
1465 = (Elf_Sym_Extra *) bfd_alloc (abfd, symcount * sizeof (Elf_Sym_Extra));
1468 bfd_set_error (bfd_error_no_memory);
1472 /* Identify and classify all of the symbols. */
1473 for (idx = 0; idx < symcount; idx++)
1475 if (!sym_is_global (abfd, syms[idx]))
1481 /* Now provide mapping information. Add +1 for skipping over the
1483 for (idx = 0; idx < symcount; idx++)
1485 syms[idx]->udata = (PTR) &sym_extra[idx];
1486 if (!sym_is_global (abfd, syms[idx]))
1487 sym_extra[idx].elf_sym_num = 1 + num_locals2++;
1489 sym_extra[idx].elf_sym_num = 1 + num_locals + num_globals2++;
1492 elf_num_locals (abfd) = num_locals;
1493 elf_num_globals (abfd) = num_globals;
1497 static boolean assign_section_numbers ();
1498 static boolean assign_file_positions_except_relocs ();
1501 DEFUN (elf_compute_section_file_positions, (abfd), bfd * abfd)
1503 bfd_map_over_sections (abfd, elf_fake_sections, 0);
1505 if (!assign_section_numbers (abfd))
1508 bfd_map_over_sections (abfd, elf_make_sections, 0);
1510 bfd_map_over_sections (abfd, fix_up_strtabs, 0); /* .stab/.stabstr &c */
1512 if (swap_out_syms (abfd) == false)
1515 if (!assign_file_positions_except_relocs (abfd))
1522 DEFUN (elf_write_phdrs, (abfd, i_ehdrp, i_phdrp, phdr_cnt),
1524 Elf_Internal_Ehdr * i_ehdrp AND
1525 Elf_Internal_Phdr * i_phdrp AND
1526 unsigned short phdr_cnt)
1528 /* first program header entry goes after the file header */
1529 int outbase = i_ehdrp->e_phoff;
1531 Elf_External_Phdr x_phdr;
1533 for (i = 0; i < phdr_cnt; i++)
1535 elf_swap_phdr_out (abfd, i_phdrp + i, &x_phdr);
1536 bfd_seek (abfd, outbase, SEEK_SET);
1537 bfd_write ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd);
1538 outbase += sizeof (x_phdr);
1544 static const Elf_Internal_Shdr null_shdr;
1546 /* Assign all ELF section numbers. The dummy first section is handled here
1547 too. The link/info pointers for the standard section types are filled
1548 in here too, while we're at it. (Link pointers for .stab sections are
1549 not filled in here.) */
1551 assign_section_numbers (abfd)
1554 struct elf_obj_tdata *t = elf_tdata (abfd);
1556 int section_number = 1;
1558 Elf_Internal_Shdr **i_shdrp;
1560 t->shstrtab_hdr.sh_size = elf_shstrtab(abfd)->length;
1561 t->shstrtab_hdr.contents = (void *) elf_shstrtab(abfd)->tab;
1562 shstrtab_length_fixed = 1;
1564 t->shstrtab_section = section_number++;
1565 elf_elfheader(abfd)->e_shstrndx = t->shstrtab_section;
1568 t->symtab_section = section_number++;
1569 t->strtab_section = section_number++;
1570 t->symtab_hdr.sh_link = t->strtab_section;
1572 for (sec = abfd->sections; sec; sec = sec->next)
1574 struct bfd_elf_section_data *d = elf_section_data (sec);
1575 d->this_idx = section_number++;
1576 if (sec->flags & SEC_RELOC)
1578 d->rel_idx = section_number++;
1579 d->rel_hdr.sh_link = t->symtab_section;
1580 d->rel_hdr.sh_info = d->this_idx;
1584 /* No handling for per-section string tables currently. */
1586 elf_elfheader(abfd)->e_shnum = section_number;
1588 /* Set up the list of section header pointers, in agreement with the
1590 i_shdrp = (Elf_Internal_Shdr **)
1591 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *));
1594 bfd_set_error (bfd_error_no_memory);
1597 elf_elfsections(abfd) = i_shdrp;
1598 for (i = 0; i < section_number; i++)
1601 i_shdrp[0] = (Elf_Internal_Shdr *) &null_shdr;
1602 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1605 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1606 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1608 for (sec = abfd->sections; sec; sec = sec->next)
1610 struct bfd_elf_section_data *d = elf_section_data (sec);
1611 i_shdrp[d->this_idx] = &d->this_hdr;
1613 i_shdrp[d->rel_idx] = &d->rel_hdr;
1615 /* Make sure we got everything.... */
1616 for (i = 0; i < section_number; i++)
1617 if (i_shdrp[i] == 0)
1622 static INLINE file_ptr
1623 assign_file_position_for_section (i_shdrp, offset)
1624 Elf_Internal_Shdr *i_shdrp;
1629 if (i_shdrp->sh_addralign != 0)
1630 align = i_shdrp->sh_addralign;
1633 i_shdrp->sh_offset = offset = BFD_ALIGN (offset, align);
1634 if (i_shdrp->rawdata != NULL)
1635 ((asection *) i_shdrp->rawdata)->filepos = offset;
1636 if (i_shdrp->sh_type != SHT_NOBITS)
1637 offset += i_shdrp->sh_size;
1641 static INLINE file_ptr
1642 align_file_position (off)
1645 return (off + FILE_ALIGN - 1) & ~(FILE_ALIGN - 1);
1648 static INLINE file_ptr
1649 assign_file_positions_for_symtab_and_strtabs (abfd, off)
1653 struct elf_obj_tdata *t = elf_tdata (abfd);
1655 off = align_file_position (off);
1656 off = assign_file_position_for_section (&t->symtab_hdr, off);
1657 off = assign_file_position_for_section (&t->shstrtab_hdr, off);
1658 off = assign_file_position_for_section (&t->strtab_hdr, off);
1663 bfd_vma low, mem_size;
1667 struct seg_info *next;
1671 map_program_segments (abfd)
1674 Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
1675 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1676 Elf_Internal_Shdr *i_shdrp;
1677 Elf_Internal_Phdr *phdr;
1679 unsigned int i, n_left = 0;
1680 file_ptr lowest_offset = 0;
1681 struct seg_info *seg = NULL;
1683 done = (char *) alloca (i_ehdrp->e_shnum);
1684 memset (done, 0, i_ehdrp->e_shnum);
1685 for (i = 1; i < i_ehdrp->e_shnum; i++)
1687 i_shdrp = i_shdrpp[i];
1688 /* If it's going to be mapped in, it's been assigned a position. */
1689 if (i_shdrp->sh_offset + 1 == 0)
1691 /* Well, not really, but we won't process it here. */
1695 if (i_shdrp->sh_offset < lowest_offset
1696 || lowest_offset == 0)
1697 lowest_offset = i_shdrp->sh_offset;
1698 /* Only interested in PROGBITS or NOBITS for generating segments. */
1699 switch (i_shdrp->sh_type)
1712 bfd_vma lowest_vma = -1, high;
1716 struct seg_info *snew;
1717 struct seg_info **s_ptr;
1719 for (i = 1; i < i_ehdrp->e_shnum; i++)
1721 i_shdrp = i_shdrpp[i];
1722 if (!done[i] && i_shdrp->sh_addr < lowest_vma)
1724 lowest_vma = i_shdrp->sh_addr;
1730 /* So now we know the lowest vma of any unassigned sections; start
1732 snew = (struct seg_info *) bfd_alloc (abfd, sizeof (struct seg_info));
1735 bfd_set_error (bfd_error_no_memory);
1739 while (*s_ptr != (struct seg_info *) NULL)
1740 s_ptr = &(*s_ptr)->next;
1743 snew->low = lowest_vma;
1744 i_shdrp = i_shdrpp[low_sec];
1745 snew->start_pos = i_shdrp->sh_offset;
1746 snew->sh_flags = i_shdrp->sh_flags;
1747 done[low_sec] = 1, n_left--;
1748 mem_size = i_shdrp->sh_size;
1749 high = lowest_vma + i_shdrp->sh_size;
1751 if (i_shdrp->sh_type == SHT_PROGBITS)
1752 file_size = i_shdrp->sh_size;
1754 for (i = 1; i < i_ehdrp->e_shnum; i++)
1760 i_shdrp = i_shdrpp[i];
1761 /* position of next byte on disk */
1762 f1 = snew->start_pos + file_size;
1763 if (i_shdrp->sh_type == SHT_PROGBITS)
1765 if (i_shdrp->sh_offset - f1 != i_shdrp->sh_addr - high)
1767 if (file_size != mem_size)
1770 else /* sh_type == NOBITS */
1772 /* If the section in question has no contents in the disk
1773 file, we really don't care where it supposedly starts.
1774 But we don't want to bother merging it into this segment
1775 if it doesn't start on this memory page. */
1776 bfd_vma page1, page2;
1777 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1779 /* page number in address space of current end of snew */
1780 page1 = (high - 1 + maxpagesize - 1) / maxpagesize;
1781 /* page number in address space of start of this section */
1782 page2 = (i_shdrp->sh_addr + maxpagesize - 1) / maxpagesize;
1787 done[i] = 1, n_left--;
1788 if (i_shdrp->sh_type == SHT_PROGBITS)
1789 file_size = i_shdrp->sh_offset + i_shdrp->sh_size - snew->start_pos;
1790 mem_size = i_shdrp->sh_addr + i_shdrp->sh_size - snew->low;
1791 high = i_shdrp->sh_addr + i_shdrp->sh_size;
1794 snew->file_size = file_size;
1795 snew->mem_size = mem_size;
1797 /* Now do something with the list of segments we've built up. */
1799 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1804 for (s = seg; s; s = s->next)
1808 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
1809 sz = sizeof (Elf_External_Phdr) * n_segs;
1810 if (align_file_position (i_ehdrp->e_ehsize) + sz <= lowest_offset)
1811 i_ehdrp->e_phoff = align_file_position (i_ehdrp->e_ehsize);
1814 i_ehdrp->e_phoff = align_file_position (elf_tdata (abfd)->next_file_pos);
1815 elf_tdata (abfd)->next_file_pos = i_ehdrp->e_phoff + sz;
1817 phdr = (Elf_Internal_Phdr*) bfd_alloc (abfd,
1818 n_segs * sizeof (Elf_Internal_Phdr));
1821 bfd_set_error (bfd_error_no_memory);
1822 abort(); /* FIXME */
1824 elf_tdata (abfd)->phdr = phdr;
1827 phdr->p_type = PT_LOAD; /* only type we really support so far */
1828 phdr->p_offset = seg->start_pos;
1829 phdr->p_vaddr = seg->low;
1831 phdr->p_filesz = seg->file_size;
1832 phdr->p_memsz = seg->mem_size;
1833 phdr->p_flags = PF_R;
1834 phdr->p_align = maxpagesize; /* ? */
1835 if (seg->sh_flags & SHF_WRITE)
1836 /* SysVr4 ELF docs say "data segments normally have read, write,
1837 and execute permissions." */
1838 phdr->p_flags |= (PF_W | PF_X);
1839 if (seg->sh_flags & SHF_EXECINSTR)
1840 phdr->p_flags |= PF_X;
1844 i_ehdrp->e_phnum = n_segs;
1846 elf_write_phdrs (abfd, i_ehdrp, elf_tdata (abfd)->phdr, i_ehdrp->e_phnum);
1851 assign_file_positions_except_relocs (abfd)
1854 /* For now, we ignore the possibility of having program segments, which
1855 may require some alignment in the file. That'll require padding, and
1856 some interesting calculations to optimize file space usage.
1858 Also, since the application may change the list of relocations for
1859 a given section, we don't figure them in here. We'll put them at the
1860 end of the file, at positions computed during bfd_close.
1862 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1863 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1865 struct elf_obj_tdata *t = elf_tdata (abfd);
1868 Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
1869 Elf_Internal_Shdr *i_shdrp;
1870 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1871 int exec_p = (abfd->flags & EXEC_P) != 0;
1872 bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1874 /* Everything starts after the ELF file header. */
1875 off = i_ehdrp->e_ehsize;
1879 /* Section headers. */
1880 off = align_file_position (off);
1881 i_ehdrp->e_shoff = off;
1882 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
1883 off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
1885 for (i = 1; i < i_ehdrp->e_shnum; i++)
1887 /* The symtab and strtab sections are placed by
1888 assign_file_positions_for_symtab_and_strtabs. */
1889 if (i == t->symtab_section
1890 || i == t->strtab_section
1891 || i == t->shstrtab_section)
1894 i_shdrp = i_shdrpp[i];
1895 if (i_shdrp->sh_type == SHT_REL || i_shdrp->sh_type == SHT_RELA)
1897 i_shdrp->sh_offset = -1;
1902 if (maxpagesize == 0)
1903 maxpagesize = 1; /* make the arithmetic work */
1904 /* This isn't necessarily going to give the best packing, if the
1905 segments require padding between them, but since that isn't
1906 usually the case, this'll do. */
1907 if ((i_shdrp->sh_flags & SHF_ALLOC) == 0)
1909 i_shdrp->sh_offset = -1;
1912 /* Blindly assume that the segments are ordered optimally. With
1913 the default LD script, they will be. */
1914 if (i_shdrp->sh_type != SHT_NOBITS)
1916 /* need big unsigned type */
1918 addtl_off = i_shdrp->sh_addr - off;
1919 addtl_off = addtl_off % maxpagesize;
1926 off = assign_file_position_for_section (i_shdrp, off);
1929 && i_shdrp->sh_type == SHT_NOBITS
1930 && (i == i_ehdrp->e_shnum
1931 || i_shdrpp[i + 1]->sh_type != SHT_NOBITS))
1933 /* Skip to the next page to ensure that when the file is
1934 loaded the bss section is loaded with zeroes. I don't
1935 know if this is required on all platforms, but it
1936 shouldn't really hurt. */
1937 off = BFD_ALIGN (off, maxpagesize);
1941 && get_elf_backend_data(abfd)->maxpagesize > 1
1942 && i_shdrp->sh_type == SHT_PROGBITS
1943 && (i_shdrp->sh_flags & SHF_ALLOC)
1944 && (i_shdrp->sh_offset - i_shdrp->sh_addr) % get_elf_backend_data (abfd)->maxpagesize != 0)
1949 elf_tdata (abfd)->next_file_pos = off;
1950 if (!map_program_segments (abfd))
1952 off = elf_tdata (abfd)->next_file_pos;
1954 /* Section headers. */
1955 off = align_file_position (off);
1956 i_ehdrp->e_shoff = off;
1957 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
1959 off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
1961 for (i = 1; i < i_ehdrp->e_shnum; i++)
1963 i_shdrp = i_shdrpp[i];
1964 if (i_shdrp->sh_offset + 1 == 0
1965 && i_shdrp->sh_type != SHT_REL
1966 && i_shdrp->sh_type != SHT_RELA)
1967 off = assign_file_position_for_section (i_shdrp, off);
1970 elf_tdata (abfd)->next_file_pos = off;
1978 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1979 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
1980 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1982 struct strtab *shstrtab;
1984 i_ehdrp = elf_elfheader (abfd);
1985 i_shdrp = elf_elfsections (abfd);
1987 shstrtab = bfd_new_strtab (abfd);
1991 elf_shstrtab (abfd) = shstrtab;
1993 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
1994 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
1995 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
1996 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
1998 i_ehdrp->e_ident[EI_CLASS] = ELFCLASS;
1999 i_ehdrp->e_ident[EI_DATA] =
2000 abfd->xvec->byteorder_big_p ? ELFDATA2MSB : ELFDATA2LSB;
2001 i_ehdrp->e_ident[EI_VERSION] = EV_CURRENT;
2003 for (count = EI_PAD; count < EI_NIDENT; count++)
2004 i_ehdrp->e_ident[count] = 0;
2006 i_ehdrp->e_type = (abfd->flags & EXEC_P) ? ET_EXEC : ET_REL;
2007 switch (bfd_get_arch (abfd))
2009 case bfd_arch_unknown:
2010 i_ehdrp->e_machine = EM_NONE;
2012 case bfd_arch_sparc:
2013 i_ehdrp->e_machine = EM_SPARC;
2014 /* start-sanitize-v9 */
2016 i_ehdrp->e_machine = EM_SPARC64;
2018 /* end-sanitize-v9 */
2021 i_ehdrp->e_machine = EM_386;
2024 i_ehdrp->e_machine = EM_68K;
2027 i_ehdrp->e_machine = EM_88K;
2030 i_ehdrp->e_machine = EM_860;
2032 case bfd_arch_mips: /* MIPS Rxxxx */
2033 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
2036 i_ehdrp->e_machine = EM_HPPA;
2038 case bfd_arch_powerpc:
2039 i_ehdrp->e_machine = EM_CYGNUS_POWERPC;
2041 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2043 i_ehdrp->e_machine = EM_NONE;
2045 i_ehdrp->e_version = EV_CURRENT;
2046 i_ehdrp->e_ehsize = sizeof (Elf_External_Ehdr);
2048 /* no program header, for now. */
2049 i_ehdrp->e_phoff = 0;
2050 i_ehdrp->e_phentsize = 0;
2051 i_ehdrp->e_phnum = 0;
2053 /* each bfd section is section header entry */
2054 i_ehdrp->e_entry = bfd_get_start_address (abfd);
2055 i_ehdrp->e_shentsize = sizeof (Elf_External_Shdr);
2057 /* if we're building an executable, we'll need a program header table */
2058 if (abfd->flags & EXEC_P)
2060 /* it all happens later */
2062 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
2064 /* elf_build_phdrs() returns a (NULL-terminated) array of
2065 Elf_Internal_Phdrs */
2066 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
2067 i_ehdrp->e_phoff = outbase;
2068 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
2073 i_ehdrp->e_phentsize = 0;
2075 i_ehdrp->e_phoff = 0;
2078 elf_tdata (abfd)->symtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
2080 elf_tdata (abfd)->strtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
2082 elf_tdata (abfd)->shstrtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
2088 swap_out_syms (abfd)
2091 if (!elf_map_symbols (abfd))
2094 /* Dump out the symtabs. */
2096 int symcount = bfd_get_symcount (abfd);
2097 asymbol **syms = bfd_get_outsymbols (abfd);
2098 struct strtab *stt = bfd_new_strtab (abfd);
2099 Elf_Internal_Shdr *symtab_hdr;
2100 Elf_Internal_Shdr *symstrtab_hdr;
2101 Elf_External_Sym *outbound_syms;
2106 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2107 symtab_hdr->sh_type = SHT_SYMTAB;
2108 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
2109 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
2110 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
2112 /* FIXME: Systems I've checked use 4 byte alignment for .symtab,
2113 but it is possible that there are systems which use a different
2115 symtab_hdr->sh_addralign = 4;
2117 /* see assert in elf_fake_sections that supports this: */
2118 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2119 symstrtab_hdr->sh_type = SHT_STRTAB;
2121 outbound_syms = (Elf_External_Sym *)
2122 bfd_alloc (abfd, (1 + symcount) * sizeof (Elf_External_Sym));
2125 bfd_set_error (bfd_error_no_memory);
2128 /* now generate the data (for "contents") */
2130 /* Fill in zeroth symbol and swap it out. */
2131 Elf_Internal_Sym sym;
2137 sym.st_shndx = SHN_UNDEF;
2138 elf_swap_symbol_out (abfd, &sym, outbound_syms);
2140 for (idx = 0; idx < symcount; idx++)
2142 Elf_Internal_Sym sym;
2143 bfd_vma value = syms[idx]->value;
2145 if (syms[idx]->flags & BSF_SECTION_SYM)
2146 /* Section symbols have no names. */
2149 sym.st_name = bfd_add_to_strtab (abfd, stt, syms[idx]->name);
2151 if (bfd_is_com_section (syms[idx]->section))
2153 /* ELF common symbols put the alignment into the `value' field,
2154 and the size into the `size' field. This is backwards from
2155 how BFD handles it, so reverse it here. */
2156 sym.st_size = value;
2157 /* Should retrieve this from somewhere... */
2159 sym.st_shndx = elf_section_from_bfd_section (abfd,
2160 syms[idx]->section);
2164 asection *sec = syms[idx]->section;
2165 elf_symbol_type *type_ptr;
2168 if (sec->output_section)
2170 value += sec->output_offset;
2171 sec = sec->output_section;
2174 sym.st_value = value;
2175 type_ptr = elf_symbol_from (abfd, syms[idx]);
2176 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
2177 sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec);
2181 /* Writing this would be a hell of a lot easier if we had
2182 some decent documentation on bfd, and knew what to expect
2183 of the library, and what to demand of applications. For
2184 example, it appears that `objcopy' might not set the
2185 section of a symbol to be a section that is actually in
2187 sec2 = bfd_get_section_by_name (abfd, sec->name);
2188 BFD_ASSERT (sec2 != 0);
2189 sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec2);
2190 BFD_ASSERT (shndx != -1);
2194 if (bfd_is_com_section (syms[idx]->section))
2195 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_OBJECT);
2196 else if (syms[idx]->section == &bfd_und_section)
2197 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_NOTYPE);
2198 else if (syms[idx]->flags & BSF_SECTION_SYM)
2199 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2200 else if (syms[idx]->flags & BSF_FILE)
2201 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
2204 int bind = STB_LOCAL;
2205 int type = STT_OBJECT;
2206 unsigned int flags = syms[idx]->flags;
2208 if (flags & BSF_LOCAL)
2210 else if (flags & BSF_WEAK)
2212 else if (flags & BSF_GLOBAL)
2215 if (flags & BSF_FUNCTION)
2218 sym.st_info = ELF_ST_INFO (bind, type);
2222 elf_swap_symbol_out (abfd, &sym,
2224 + elf_sym_extra (abfd)[idx].elf_sym_num));
2227 symtab_hdr->contents = (PTR) outbound_syms;
2228 symstrtab_hdr->contents = (PTR) stt->tab;
2229 symstrtab_hdr->sh_size = stt->length;
2230 symstrtab_hdr->sh_type = SHT_STRTAB;
2232 symstrtab_hdr->sh_flags = 0;
2233 symstrtab_hdr->sh_addr = 0;
2234 symstrtab_hdr->sh_entsize = 0;
2235 symstrtab_hdr->sh_link = 0;
2236 symstrtab_hdr->sh_info = 0;
2237 symstrtab_hdr->sh_addralign = 1;
2238 symstrtab_hdr->size = 0;
2241 /* put the strtab out too... */
2243 Elf_Internal_Shdr *this_hdr;
2245 this_hdr = &elf_tdata(abfd)->shstrtab_hdr;
2246 this_hdr->contents = (PTR) elf_shstrtab (abfd)->tab;
2247 this_hdr->sh_size = elf_shstrtab (abfd)->length;
2248 this_hdr->sh_type = SHT_STRTAB;
2249 this_hdr->sh_flags = 0;
2250 this_hdr->sh_addr = 0;
2251 this_hdr->sh_entsize = 0;
2252 this_hdr->sh_addralign = 1;
2259 write_shdrs_and_ehdr (abfd)
2262 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
2263 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
2264 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
2265 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
2267 struct strtab *shstrtab;
2269 i_ehdrp = elf_elfheader (abfd);
2270 i_shdrp = elf_elfsections (abfd);
2271 shstrtab = elf_shstrtab (abfd);
2273 /* swap the header before spitting it out... */
2276 elf_debug_file (i_ehdrp);
2278 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
2279 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
2280 bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd);
2282 /* at this point we've concocted all the ELF sections... */
2283 x_shdrp = (Elf_External_Shdr *)
2284 bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
2287 bfd_set_error (bfd_error_no_memory);
2291 for (count = 0; count < i_ehdrp->e_shnum; count++)
2294 elf_debug_section (shstrtab->tab + i_shdrp[count]->sh_name, count,
2297 elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
2299 bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET);
2300 bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd);
2301 /* need to dump the string table too... */
2307 assign_file_positions_for_relocs (abfd)
2310 file_ptr off = elf_tdata(abfd)->next_file_pos;
2312 Elf_Internal_Shdr **shdrpp = elf_elfsections (abfd);
2313 Elf_Internal_Shdr *shdrp;
2314 for (i = 1; i < elf_elfheader(abfd)->e_shnum; i++)
2317 if (shdrp->sh_type != SHT_REL && shdrp->sh_type != SHT_RELA)
2319 off = align_file_position (off);
2320 off = assign_file_position_for_section (shdrp, off);
2322 elf_tdata(abfd)->next_file_pos = off;
2326 DEFUN (NAME(bfd_elf,write_object_contents), (abfd), bfd * abfd)
2328 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2329 Elf_Internal_Ehdr *i_ehdrp;
2330 Elf_Internal_Shdr **i_shdrp;
2333 /* We don't know how to write dynamic objects. Specifically, we
2334 don't know how to construct the program header. */
2335 if ((abfd->flags & DYNAMIC) != 0)
2337 fprintf (stderr, "Writing ELF dynamic objects is not supported\n");
2338 bfd_set_error (bfd_error_wrong_format);
2342 if (abfd->output_has_begun == false)
2344 if (prep_headers (abfd) == false)
2346 if (elf_compute_section_file_positions (abfd) == false)
2348 abfd->output_has_begun = true;
2351 i_shdrp = elf_elfsections (abfd);
2352 i_ehdrp = elf_elfheader (abfd);
2354 bfd_map_over_sections (abfd, write_relocs, (PTR) 0);
2355 assign_file_positions_for_relocs (abfd);
2357 /* After writing the headers, we need to write the sections too... */
2358 for (count = 1; count < i_ehdrp->e_shnum; count++)
2360 if (bed->elf_backend_section_processing)
2361 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
2362 if (i_shdrp[count]->contents)
2364 bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET);
2365 bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size, 1,
2370 if (bed->elf_backend_final_write_processing)
2371 (*bed->elf_backend_final_write_processing) (abfd);
2373 return write_shdrs_and_ehdr (abfd);
2376 /* Given an index of a section, retrieve a pointer to it. Note
2377 that for our purposes, sections are indexed by {1, 2, ...} with
2378 0 being an illegal index. */
2380 /* In the original, each ELF section went into exactly one BFD
2381 section. This doesn't really make sense, so we need a real mapping.
2382 The mapping has to hide in the Elf_Internal_Shdr since asection
2383 doesn't have anything like a tdata field... */
2386 DEFUN (section_from_elf_index, (abfd, index),
2390 /* @@ Is bfd_com_section really correct in all the places it could
2391 be returned from this routine? */
2393 if (index == SHN_ABS)
2394 return &bfd_com_section; /* not abs? */
2395 if (index == SHN_COMMON)
2396 return &bfd_com_section;
2398 if (index > elf_elfheader (abfd)->e_shnum)
2402 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[index];
2404 switch (hdr->sh_type)
2406 /* ELF sections that map to BFD sections */
2410 bfd_section_from_shdr (abfd, index);
2411 return (struct sec *) hdr->rawdata;
2414 return (struct sec *) &bfd_abs_section;
2419 /* given a section, search the header to find them... */
2421 DEFUN (elf_section_from_bfd_section, (abfd, asect),
2425 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
2427 Elf_Internal_Shdr *hdr;
2428 int maxindex = elf_elfheader (abfd)->e_shnum;
2430 if (asect == &bfd_abs_section)
2432 if (asect == &bfd_com_section)
2434 if (asect == &bfd_und_section)
2437 for (index = 0; index < maxindex; index++)
2439 hdr = i_shdrp[index];
2440 switch (hdr->sh_type)
2442 /* ELF sections that map to BFD sections */
2448 if (((struct sec *) (hdr->rawdata)) == asect)
2454 /* fix_up_strtabs will generate STRTAB sections with names
2456 if (!strncmp (asect->name, ".stab", 5)
2457 && !strcmp ("str", asect->name + strlen (asect->name) - 3))
2461 if (((struct sec *) (hdr->rawdata)) == asect)
2469 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2471 if (bed->elf_backend_section_from_bfd_section)
2476 if ((*bed->elf_backend_section_from_bfd_section)
2477 (abfd, hdr, asect, &retval))
2487 /* given a symbol, return the bfd index for that symbol. */
2489 DEFUN (elf_symbol_from_bfd_symbol, (abfd, asym_ptr_ptr),
2491 struct symbol_cache_entry **asym_ptr_ptr)
2493 struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
2495 flagword flags = asym_ptr->flags;
2497 /* When gas creates relocations against local labels, it creates its
2498 own symbol for the section, but does put the symbol into the
2499 symbol chain, so udata is 0. When the linker is generating
2500 relocatable output, this section symbol may be for one of the
2501 input sections rather than the output section. */
2502 if (asym_ptr->udata == (PTR) 0
2503 && (flags & BSF_SECTION_SYM)
2504 && asym_ptr->section)
2508 if (asym_ptr->section->output_section != NULL)
2509 indx = asym_ptr->section->output_section->index;
2511 indx = asym_ptr->section->index;
2512 if (elf_section_syms (abfd)[indx])
2513 asym_ptr->udata = elf_section_syms (abfd)[indx]->udata;
2516 if (asym_ptr->udata)
2517 idx = ((Elf_Sym_Extra *)asym_ptr->udata)->elf_sym_num;
2527 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2528 (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
2537 DEFUN (elf_slurp_symbol_table, (abfd, symptrs),
2539 asymbol ** symptrs) /* Buffer for generated bfd symbols */
2541 Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
2542 long symcount; /* Number of external ELF symbols */
2543 elf_symbol_type *sym; /* Pointer to current bfd symbol */
2544 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
2545 Elf_Internal_Sym i_sym;
2546 Elf_External_Sym *x_symp;
2548 /* this is only valid because there is only one symtab... */
2549 /* FIXME: This is incorrect, there may also be a dynamic symbol
2550 table which is a subset of the full symbol table. We either need
2551 to be prepared to read both (and merge them) or ensure that we
2552 only read the full symbol table. Currently we only get called to
2553 read the full symbol table. -fnf */
2555 /* Read each raw ELF symbol, converting from external ELF form to
2556 internal ELF form, and then using the information to create a
2557 canonical bfd symbol table entry.
2559 Note that we allocate the initial bfd canonical symbol buffer
2560 based on a one-to-one mapping of the ELF symbols to canonical
2561 symbols. We actually use all the ELF symbols, so there will be no
2562 space left over at the end. When we have all the symbols, we
2563 build the caller's pointer vector. */
2565 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
2567 bfd_set_error (bfd_error_system_call);
2571 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2574 sym = symbase = NULL;
2579 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
2581 bfd_set_error (bfd_error_system_call);
2585 symbase = ((elf_symbol_type *)
2586 bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
2587 if (symbase == (elf_symbol_type *) NULL)
2589 bfd_set_error (bfd_error_no_memory);
2594 /* Temporarily allocate room for the raw ELF symbols. */
2595 x_symp = ((Elf_External_Sym *)
2596 alloca (symcount * sizeof (Elf_External_Sym)));
2598 if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
2599 != symcount * sizeof (Elf_External_Sym))
2601 bfd_set_error (bfd_error_system_call);
2604 /* Skip first symbol, which is a null dummy. */
2605 for (i = 1; i < symcount; i++)
2607 elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
2608 memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
2609 #ifdef ELF_KEEP_EXTSYM
2610 memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
2612 sym->symbol.the_bfd = abfd;
2614 sym->symbol.name = elf_string_from_elf_section (abfd, hdr->sh_link,
2617 sym->symbol.value = i_sym.st_value;
2619 if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERV)
2621 sym->symbol.section = section_from_elf_index (abfd,
2624 else if (i_sym.st_shndx == SHN_ABS)
2626 sym->symbol.section = &bfd_abs_section;
2628 else if (i_sym.st_shndx == SHN_COMMON)
2630 sym->symbol.section = &bfd_com_section;
2631 /* Elf puts the alignment into the `value' field, and
2632 the size into the `size' field. BFD wants to see the
2633 size in the value field, and doesn't care (at the
2634 moment) about the alignment. */
2635 sym->symbol.value = i_sym.st_size;
2637 else if (i_sym.st_shndx == SHN_UNDEF)
2639 sym->symbol.section = &bfd_und_section;
2642 sym->symbol.section = &bfd_abs_section;
2644 sym->symbol.value -= sym->symbol.section->vma;
2646 switch (ELF_ST_BIND (i_sym.st_info))
2649 sym->symbol.flags |= BSF_LOCAL;
2652 sym->symbol.flags |= BSF_GLOBAL;
2655 sym->symbol.flags |= BSF_WEAK;
2659 switch (ELF_ST_TYPE (i_sym.st_info))
2662 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
2665 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
2668 sym->symbol.flags |= BSF_FUNCTION;
2672 /* Do some backend-specific processing on this symbol. */
2674 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2675 if (ebd->elf_backend_symbol_processing)
2676 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
2683 /* Do some backend-specific processing on this symbol table. */
2685 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2686 if (ebd->elf_backend_symbol_table_processing)
2687 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
2690 /* We rely on the zalloc to clear out the final symbol entry. */
2692 bfd_get_symcount (abfd) = symcount = sym - symbase;
2694 /* Fill in the user's symbol pointer vector if needed. */
2698 while (symcount-- > 0)
2700 *symptrs++ = &sym->symbol;
2703 *symptrs = 0; /* Final null pointer */
2709 /* Return the number of bytes required to hold the symtab vector.
2711 Note that we base it on the count plus 1, since we will null terminate
2712 the vector allocated based on this size. However, the ELF symbol table
2713 always has a dummy entry as symbol #0, so it ends up even. */
2716 DEFUN (elf_get_symtab_upper_bound, (abfd), bfd * abfd)
2718 unsigned int symcount;
2719 unsigned int symtab_size = 0;
2721 Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
2722 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2723 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
2729 This function return the number of bytes required to store the
2730 relocation information associated with section <<sect>>
2731 attached to bfd <<abfd>>
2735 elf_get_reloc_upper_bound (abfd, asect)
2739 if (asect->flags & SEC_RELOC)
2741 /* either rel or rela */
2742 return elf_section_data(asect)->rel_hdr.sh_size;
2749 DEFUN (elf_slurp_reloca_table, (abfd, asect, symbols),
2754 Elf_External_Rela *native_relocs;
2755 arelent *reloc_cache;
2760 if (asect->relocation)
2762 if (asect->reloc_count == 0)
2764 if (asect->flags & SEC_CONSTRUCTOR)
2767 bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
2768 native_relocs = (Elf_External_Rela *)
2769 bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rela));
2772 bfd_set_error (bfd_error_no_memory);
2775 bfd_read ((PTR) native_relocs,
2776 sizeof (Elf_External_Rela), asect->reloc_count, abfd);
2778 reloc_cache = (arelent *)
2779 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2783 bfd_set_error (bfd_error_no_memory);
2787 for (idx = 0; idx < asect->reloc_count; idx++)
2789 Elf_Internal_Rela dst;
2790 Elf_External_Rela *src;
2792 cache_ptr = reloc_cache + idx;
2793 src = native_relocs + idx;
2794 elf_swap_reloca_in (abfd, src, &dst);
2796 #ifdef RELOC_PROCESSING
2797 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2799 if (asect->flags & SEC_RELOC)
2801 /* relocatable, so the offset is off of the section */
2802 cache_ptr->address = dst.r_offset + asect->vma;
2806 /* non-relocatable, so the offset a virtual address */
2807 cache_ptr->address = dst.r_offset;
2810 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2811 of zero points to the dummy symbol, which was not read into
2812 the symbol table SYMBOLS. */
2813 if (ELF_R_SYM (dst.r_info) == 0)
2814 cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
2819 cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
2821 /* Translate any ELF section symbol into a BFD section
2823 s = *(cache_ptr->sym_ptr_ptr);
2824 if (s->flags & BSF_SECTION_SYM)
2826 cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2827 s = *cache_ptr->sym_ptr_ptr;
2828 if (s->name == 0 || s->name[0] == 0)
2832 cache_ptr->addend = dst.r_addend;
2834 /* Fill in the cache_ptr->howto field from dst.r_type */
2836 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2837 (*ebd->elf_info_to_howto) (abfd, cache_ptr, &dst);
2842 asect->relocation = reloc_cache;
2848 elf_debug_section (str, num, hdr)
2851 Elf_Internal_Shdr *hdr;
2853 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, str, (long) hdr);
2855 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2856 (long) hdr->sh_name,
2857 (long) hdr->sh_type,
2858 (long) hdr->sh_flags);
2860 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2861 (long) hdr->sh_addr,
2862 (long) hdr->sh_offset,
2863 (long) hdr->sh_size);
2865 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2866 (long) hdr->sh_link,
2867 (long) hdr->sh_info,
2868 (long) hdr->sh_addralign);
2869 fprintf (stderr, "sh_entsize = %ld\n",
2870 (long) hdr->sh_entsize);
2871 fprintf (stderr, "rawdata = 0x%.8lx\n", (long) hdr->rawdata);
2872 fprintf (stderr, "contents = 0x%.8lx\n", (long) hdr->contents);
2873 fprintf (stderr, "size = %ld\n", (long) hdr->size);
2878 elf_debug_file (ehdrp)
2879 Elf_Internal_Ehdr *ehdrp;
2881 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
2882 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
2883 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
2884 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
2885 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
2886 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
2887 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
2892 DEFUN (elf_slurp_reloc_table, (abfd, asect, symbols),
2897 Elf_External_Rel *native_relocs;
2898 arelent *reloc_cache;
2900 Elf_Internal_Shdr *data_hdr;
2902 unsigned long data_max;
2903 char buf[4]; /* FIXME -- might be elf64 */
2907 if (asect->relocation)
2909 if (asect->reloc_count == 0)
2911 if (asect->flags & SEC_CONSTRUCTOR)
2914 bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
2915 native_relocs = (Elf_External_Rel *)
2916 bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rel));
2919 bfd_set_error (bfd_error_no_memory);
2922 bfd_read ((PTR) native_relocs,
2923 sizeof (Elf_External_Rel), asect->reloc_count, abfd);
2925 reloc_cache = (arelent *)
2926 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2930 bfd_set_error (bfd_error_no_memory);
2934 /* Get the offset of the start of the segment we are relocating to read in
2935 the implicit addend. */
2936 data_hdr = &elf_section_data(asect)->this_hdr;
2937 data_off = data_hdr->sh_offset;
2938 data_max = data_hdr->sh_size - sizeof (buf) + 1;
2941 elf_debug_section ("data section", -1, data_hdr);
2944 for (idx = 0; idx < asect->reloc_count; idx++)
2946 #ifdef RELOC_PROCESSING
2947 Elf_Internal_Rel dst;
2948 Elf_External_Rel *src;
2950 cache_ptr = reloc_cache + idx;
2951 src = native_relocs + idx;
2952 elf_swap_reloc_in (abfd, src, &dst);
2954 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2956 Elf_Internal_Rel dst;
2957 Elf_External_Rel *src;
2959 cache_ptr = reloc_cache + idx;
2960 src = native_relocs + idx;
2962 elf_swap_reloc_in (abfd, src, &dst);
2964 if (asect->flags & SEC_RELOC)
2966 /* relocatable, so the offset is off of the section */
2967 cache_ptr->address = dst.r_offset + asect->vma;
2971 /* non-relocatable, so the offset a virtual address */
2972 cache_ptr->address = dst.r_offset;
2975 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2976 of zero points to the dummy symbol, which was not read into
2977 the symbol table SYMBOLS. */
2978 if (ELF_R_SYM (dst.r_info) == 0)
2979 cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
2984 cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
2986 /* Translate any ELF section symbol into a BFD section
2988 s = *(cache_ptr->sym_ptr_ptr);
2989 if (s->flags & BSF_SECTION_SYM)
2991 cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2992 s = *cache_ptr->sym_ptr_ptr;
2993 if (s->name == 0 || s->name[0] == 0)
2997 BFD_ASSERT (dst.r_offset <= data_max);
2998 cache_ptr->addend = 0;
3000 /* Fill in the cache_ptr->howto field from dst.r_type */
3002 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
3003 (*ebd->elf_info_to_howto_rel) (abfd, cache_ptr, &dst);
3008 asect->relocation = reloc_cache;
3013 elf_canonicalize_reloc (abfd, section, relptr, symbols)
3019 arelent *tblptr = section->relocation;
3020 unsigned int count = 0;
3021 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
3023 /* snarfed from coffcode.h */
3025 elf_slurp_reloca_table (abfd, section, symbols);
3027 elf_slurp_reloc_table (abfd, section, symbols);
3029 tblptr = section->relocation;
3033 for (; count++ < section->reloc_count;)
3034 *relptr++ = tblptr++;
3037 return section->reloc_count;
3041 DEFUN (elf_get_symtab, (abfd, alocation),
3043 asymbol ** alocation)
3046 if (!elf_slurp_symbol_table (abfd, alocation))
3049 return bfd_get_symcount (abfd);
3053 DEFUN (elf_make_empty_symbol, (abfd),
3056 elf_symbol_type *newsym;
3058 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
3061 bfd_set_error (bfd_error_no_memory);
3066 newsym->symbol.the_bfd = abfd;
3067 return &newsym->symbol;
3072 DEFUN (elf_get_symbol_info, (ignore_abfd, symbol, ret),
3073 bfd * ignore_abfd AND
3074 asymbol * symbol AND
3077 bfd_symbol_info (symbol, ret);
3081 DEFUN (elf_print_symbol, (ignore_abfd, filep, symbol, how),
3082 bfd * ignore_abfd AND
3084 asymbol * symbol AND
3085 bfd_print_symbol_type how)
3087 FILE *file = (FILE *) filep;
3090 case bfd_print_symbol_name:
3091 fprintf (file, "%s", symbol->name);
3093 case bfd_print_symbol_more:
3094 fprintf (file, "elf ");
3095 fprintf_vma (file, symbol->value);
3096 fprintf (file, " %lx", (long) symbol->flags);
3098 case bfd_print_symbol_all:
3100 CONST char *section_name;
3101 section_name = symbol->section ? symbol->section->name : "(*none*)";
3102 bfd_print_symbol_vandf ((PTR) file, symbol);
3103 fprintf (file, " %s\t%s",
3113 DEFUN (elf_get_lineno, (ignore_abfd, symbol),
3114 bfd * ignore_abfd AND
3117 fprintf (stderr, "elf_get_lineno unimplemented\n");
3124 DEFUN (elf_set_arch_mach, (abfd, arch, machine),
3126 enum bfd_architecture arch AND
3127 unsigned long machine)
3129 /* Allow any architecture to be supported by the elf backend */
3132 case bfd_arch_unknown: /* EM_NONE */
3133 case bfd_arch_sparc: /* EM_SPARC */
3134 case bfd_arch_i386: /* EM_386 */
3135 case bfd_arch_m68k: /* EM_68K */
3136 case bfd_arch_m88k: /* EM_88K */
3137 case bfd_arch_i860: /* EM_860 */
3138 case bfd_arch_mips: /* EM_MIPS (MIPS R3000) */
3139 case bfd_arch_hppa: /* EM_HPPA (HP PA_RISC) */
3140 case bfd_arch_powerpc: /* EM_CYGNUS_POWERPC */
3141 return bfd_default_set_arch_mach (abfd, arch, machine);
3148 DEFUN (elf_find_nearest_line, (abfd,
3156 asection * section AND
3157 asymbol ** symbols AND
3159 CONST char **filename_ptr AND
3160 CONST char **functionname_ptr AND
3161 unsigned int *line_ptr)
3167 DEFUN (elf_sizeof_headers, (abfd, reloc),
3171 fprintf (stderr, "elf_sizeof_headers unimplemented\n");
3178 DEFUN (elf_set_section_contents, (abfd, section, location, offset, count),
3183 bfd_size_type count)
3185 Elf_Internal_Shdr *hdr;
3187 if (abfd->output_has_begun == false) /* set by bfd.c handler? */
3189 /* do setup calculations (FIXME) */
3190 if (prep_headers (abfd) == false)
3192 if (elf_compute_section_file_positions (abfd) == false)
3194 abfd->output_has_begun = true;
3197 hdr = &elf_section_data(section)->this_hdr;
3199 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
3201 if (bfd_write (location, 1, count, abfd) != count)
3208 DEFUN (elf_no_info_to_howto, (abfd, cache_ptr, dst),
3210 arelent * cache_ptr AND
3211 Elf_Internal_Rela * dst)
3213 fprintf (stderr, "elf RELA relocation support for target machine unimplemented\n");
3219 DEFUN (elf_no_info_to_howto_rel, (abfd, cache_ptr, dst),
3221 arelent * cache_ptr AND
3222 Elf_Internal_Rel * dst)
3224 fprintf (stderr, "elf REL relocation support for target machine unimplemented\n");
3230 /* Core file support */
3232 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3233 #include <sys/procfs.h>
3235 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3236 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3237 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3243 DEFUN (bfd_prstatus, (abfd, descdata, descsz, filepos),
3250 prstatus_t *status = (prstatus_t *) 0;
3252 if (descsz == sizeof (prstatus_t))
3254 newsect = bfd_make_section (abfd, ".reg");
3255 newsect->_raw_size = sizeof (status->pr_reg);
3256 newsect->filepos = filepos + (long) &status->pr_reg;
3257 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3258 newsect->alignment_power = 2;
3259 if ((core_prstatus (abfd) = bfd_alloc (abfd, descsz)) != NULL)
3261 memcpy (core_prstatus (abfd), descdata, descsz);
3266 /* Stash a copy of the prpsinfo structure away for future use. */
3269 DEFUN (bfd_prpsinfo, (abfd, descdata, descsz, filepos),
3277 if (descsz == sizeof (prpsinfo_t))
3279 if ((core_prpsinfo (abfd) = bfd_alloc (abfd, descsz)) != NULL)
3281 memcpy (core_prpsinfo (abfd), descdata, descsz);
3287 DEFUN (bfd_fpregset, (abfd, descdata, descsz, filepos),
3295 newsect = bfd_make_section (abfd, ".reg2");
3296 newsect->_raw_size = descsz;
3297 newsect->filepos = filepos;
3298 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3299 newsect->alignment_power = 2;
3302 #endif /* HAVE_PROCFS */
3304 /* Return a pointer to the args (including the command name) that were
3305 seen by the program that generated the core dump. Note that for
3306 some reason, a spurious space is tacked onto the end of the args
3307 in some (at least one anyway) implementations, so strip it off if
3311 DEFUN (elf_core_file_failing_command, (abfd),
3315 if (core_prpsinfo (abfd))
3317 prpsinfo_t *p = core_prpsinfo (abfd);
3318 char *scan = p->pr_psargs;
3323 if ((scan > p->pr_psargs) && (*scan == ' '))
3327 return p->pr_psargs;
3333 /* Return the number of the signal that caused the core dump. Presumably,
3334 since we have a core file, we got a signal of some kind, so don't bother
3335 checking the other process status fields, just return the signal number.
3339 DEFUN (elf_core_file_failing_signal, (abfd),
3343 if (core_prstatus (abfd))
3345 return ((prstatus_t *) (core_prstatus (abfd)))->pr_cursig;
3351 /* Check to see if the core file could reasonably be expected to have
3352 come for the current executable file. Note that by default we return
3353 true unless we find something that indicates that there might be a
3358 DEFUN (elf_core_file_matches_executable_p, (core_bfd, exec_bfd),
3367 /* First, xvecs must match since both are ELF files for the same target. */
3369 if (core_bfd->xvec != exec_bfd->xvec)
3371 bfd_set_error (bfd_error_system_call);
3377 /* If no prpsinfo, just return true. Otherwise, grab the last component
3378 of the exec'd pathname from the prpsinfo. */
3380 if (core_prpsinfo (core_bfd))
3382 corename = (((struct prpsinfo *) core_prpsinfo (core_bfd))->pr_fname);
3389 /* Find the last component of the executable pathname. */
3391 if ((execname = strrchr (exec_bfd->filename, '/')) != NULL)
3397 execname = (char *) exec_bfd->filename;
3400 /* See if they match */
3402 return strcmp (execname, corename) ? false : true;
3408 #endif /* HAVE_PROCFS */
3411 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3412 the information that would normally be available from the /proc interface
3413 for the process, at the time the process dumped core. Currently this
3414 includes copies of the prstatus, prpsinfo, and fpregset structures.
3416 Since these structures are potentially machine dependent in size and
3417 ordering, bfd provides two levels of support for them. The first level,
3418 available on all machines since it does not require that the host
3419 have /proc support or the relevant include files, is to create a bfd
3420 section for each of the prstatus, prpsinfo, and fpregset structures,
3421 without any interpretation of their contents. With just this support,
3422 the bfd client will have to interpret the structures itself. Even with
3423 /proc support, it might want these full structures for it's own reasons.
3425 In the second level of support, where HAVE_PROCFS is defined, bfd will
3426 pick apart the structures to gather some additional information that
3427 clients may want, such as the general register set, the name of the
3428 exec'ed file and its arguments, the signal (if any) that caused the
3434 DEFUN (elf_corefile_note, (abfd, hdr),
3436 Elf_Internal_Phdr * hdr)
3438 Elf_External_Note *x_note_p; /* Elf note, external form */
3439 Elf_Internal_Note i_note; /* Elf note, internal form */
3440 char *buf = NULL; /* Entire note segment contents */
3441 char *namedata; /* Name portion of the note */
3442 char *descdata; /* Descriptor portion of the note */
3443 char *sectname; /* Name to use for new section */
3444 long filepos; /* File offset to descriptor data */
3447 if (hdr->p_filesz > 0
3448 && (buf = (char *) malloc (hdr->p_filesz)) != NULL
3449 && bfd_seek (abfd, hdr->p_offset, SEEK_SET) != -1
3450 && bfd_read ((PTR) buf, hdr->p_filesz, 1, abfd) == hdr->p_filesz)
3452 x_note_p = (Elf_External_Note *) buf;
3453 while ((char *) x_note_p < (buf + hdr->p_filesz))
3455 i_note.namesz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->namesz);
3456 i_note.descsz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->descsz);
3457 i_note.type = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->type);
3458 namedata = x_note_p->name;
3459 descdata = namedata + BFD_ALIGN (i_note.namesz, 4);
3460 filepos = hdr->p_offset + (descdata - buf);
3461 switch (i_note.type)
3464 /* process descdata as prstatus info */
3465 bfd_prstatus (abfd, descdata, i_note.descsz, filepos);
3466 sectname = ".prstatus";
3469 /* process descdata as fpregset info */
3470 bfd_fpregset (abfd, descdata, i_note.descsz, filepos);
3471 sectname = ".fpregset";
3474 /* process descdata as prpsinfo */
3475 bfd_prpsinfo (abfd, descdata, i_note.descsz, filepos);
3476 sectname = ".prpsinfo";
3479 /* Unknown descriptor, just ignore it. */
3483 if (sectname != NULL)
3485 newsect = bfd_make_section (abfd, sectname);
3486 newsect->_raw_size = i_note.descsz;
3487 newsect->filepos = filepos;
3488 newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3489 newsect->alignment_power = 2;
3491 x_note_p = (Elf_External_Note *)
3492 (descdata + BFD_ALIGN (i_note.descsz, 4));
3499 else if (hdr->p_filesz > 0)
3501 bfd_set_error (bfd_error_no_memory);
3508 /* Core files are simply standard ELF formatted files that partition
3509 the file using the execution view of the file (program header table)
3510 rather than the linking view. In fact, there is no section header
3511 table in a core file.
3513 The process status information (including the contents of the general
3514 register set) and the floating point register set are stored in a
3515 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3516 that allow standard bfd access to the general registers (.reg) and the
3517 floating point registers (.reg2).
3522 DEFUN (elf_core_file_p, (abfd), bfd * abfd)
3524 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
3525 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3526 Elf_External_Phdr x_phdr; /* Program header table entry, external form */
3527 Elf_Internal_Phdr *i_phdrp; /* Program header table, internal form */
3528 unsigned int phindex;
3529 struct elf_backend_data *ebd;
3531 /* Read in the ELF header in external format. */
3533 if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
3535 bfd_set_error (bfd_error_system_call);
3539 /* Now check to see if we have a valid ELF file, and one that BFD can
3540 make use of. The magic number must match, the address size ('class')
3541 and byte-swapping must match our XVEC entry, and it must have a
3542 program header table (FIXME: See comments re segments at top of this
3545 if (elf_file_p (&x_ehdr) == false)
3548 bfd_set_error (bfd_error_wrong_format);
3552 /* FIXME, Check EI_VERSION here ! */
3556 int desired_address_size = ELFCLASS32;
3559 int desired_address_size = ELFCLASS64;
3562 if (x_ehdr.e_ident[EI_CLASS] != desired_address_size)
3566 /* Switch xvec to match the specified byte order. */
3567 switch (x_ehdr.e_ident[EI_DATA])
3569 case ELFDATA2MSB: /* Big-endian */
3570 if (abfd->xvec->byteorder_big_p == false)
3573 case ELFDATA2LSB: /* Little-endian */
3574 if (abfd->xvec->byteorder_big_p == true)
3577 case ELFDATANONE: /* No data encoding specified */
3578 default: /* Unknown data encoding specified */
3582 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3583 the tdata pointer in the bfd. */
3586 (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
3587 if (elf_tdata (abfd) == NULL)
3589 bfd_set_error (bfd_error_no_memory);
3593 /* FIXME, `wrong' returns from this point onward, leak memory. */
3595 /* Now that we know the byte order, swap in the rest of the header */
3596 i_ehdrp = elf_elfheader (abfd);
3597 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
3599 elf_debug_file (i_ehdrp);
3602 ebd = get_elf_backend_data (abfd);
3604 /* Check that the ELF e_machine field matches what this particular
3605 BFD format expects. */
3606 if (ebd->elf_machine_code != i_ehdrp->e_machine)
3608 bfd_target **target_ptr;
3610 if (ebd->elf_machine_code != EM_NONE)
3613 /* This is the generic ELF target. Let it match any ELF target
3614 for which we do not have a specific backend. */
3615 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
3617 struct elf_backend_data *back;
3619 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
3621 back = (struct elf_backend_data *) (*target_ptr)->backend_data;
3622 if (back->elf_machine_code == i_ehdrp->e_machine)
3624 /* target_ptr is an ELF backend which matches this
3625 object file, so reject the generic ELF target. */
3631 /* If there is no program header, or the type is not a core file, then
3633 if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
3636 /* Allocate space for a copy of the program header table in
3637 internal form, seek to the program header table in the file,
3638 read it in, and convert it to internal form. As a simple sanity
3639 check, verify that the what BFD thinks is the size of each program
3640 header table entry actually matches the size recorded in the file. */
3642 if (i_ehdrp->e_phentsize != sizeof (x_phdr))
3644 i_phdrp = (Elf_Internal_Phdr *)
3645 bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
3648 bfd_set_error (bfd_error_no_memory);
3651 if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
3653 bfd_set_error (bfd_error_system_call);
3656 for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3658 if (bfd_read ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd)
3661 bfd_set_error (bfd_error_system_call);
3664 elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
3667 /* Once all of the program headers have been read and converted, we
3668 can start processing them. */
3670 for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3672 bfd_section_from_phdr (abfd, i_phdrp + phindex, phindex);
3673 if ((i_phdrp + phindex)->p_type == PT_NOTE)
3675 elf_corefile_note (abfd, i_phdrp + phindex);
3679 /* Remember the entry point specified in the ELF file header. */
3681 bfd_get_start_address (abfd) = i_ehdrp->e_entry;