1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995 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
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
98 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
99 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
100 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
101 #define elf_get_symtab NAME(bfd_elf,get_symtab)
102 #define elf_canonicalize_dynamic_symtab \
103 NAME(bfd_elf,canonicalize_dynamic_symtab)
104 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
105 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
106 #define elf_get_lineno NAME(bfd_elf,get_lineno)
107 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
108 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
109 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
110 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
111 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
112 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
113 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
114 #define elf_find_section NAME(bfd_elf,find_section)
115 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
116 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
117 #define elf_link_create_dynamic_sections \
118 NAME(bfd_elf,link_create_dynamic_sections)
119 #define elf_link_record_dynamic_symbol \
120 NAME(bfd_elf,link_record_dynamic_symbol)
121 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
124 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
125 #define ELF_R_SYM(X) ELF64_R_SYM(X)
126 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
127 #define ELFCLASS ELFCLASS64
129 #define LOG_FILE_ALIGN 3
132 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
133 #define ELF_R_SYM(X) ELF32_R_SYM(X)
134 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
135 #define ELFCLASS ELFCLASS32
137 #define LOG_FILE_ALIGN 2
140 /* Forward declarations of static functions */
142 static struct bfd_strtab_hash
*elf_stringtab_init
PARAMS ((void));
143 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
145 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
147 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
149 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
151 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
152 struct symbol_cache_entry
**));
154 static boolean elf_compute_section_file_positions
155 PARAMS ((bfd
*, struct bfd_link_info
*));
156 static boolean prep_headers
PARAMS ((bfd
*));
157 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
158 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
159 static boolean assign_section_numbers
PARAMS ((bfd
*));
160 static file_ptr align_file_position
PARAMS ((file_ptr
));
161 static file_ptr assign_file_position_for_section
162 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
163 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
164 static int elf_sort_hdrs
PARAMS ((const PTR
, const PTR
));
165 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
166 static bfd_size_type get_program_header_size
PARAMS ((bfd
*,
167 Elf_Internal_Shdr
**,
170 static file_ptr map_program_segments
171 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, Elf_Internal_Shdr
**,
174 static boolean elf_map_symbols
PARAMS ((bfd
*));
175 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
177 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
180 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
181 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
182 static char *elf_symbol_flags
PARAMS ((flagword
));
185 #define elf_string_from_elf_strtab(abfd,strindex) \
186 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
188 /* Structure swapping routines */
190 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
191 can be handled by explicitly specifying 32 bits or "the long type". */
193 #define put_word bfd_h_put_64
194 #define get_word bfd_h_get_64
197 #define put_word bfd_h_put_32
198 #define get_word bfd_h_get_32
201 /* Translate an ELF symbol in external format into an ELF symbol in internal
205 elf_swap_symbol_in (abfd
, src
, dst
)
207 Elf_External_Sym
*src
;
208 Elf_Internal_Sym
*dst
;
210 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
211 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
212 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
213 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
214 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
215 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
218 /* Translate an ELF symbol in internal format into an ELF symbol in external
222 elf_swap_symbol_out (abfd
, src
, dst
)
224 Elf_Internal_Sym
*src
;
225 Elf_External_Sym
*dst
;
227 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
228 put_word (abfd
, src
->st_value
, dst
->st_value
);
229 put_word (abfd
, src
->st_size
, dst
->st_size
);
230 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
231 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
232 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
236 /* Translate an ELF file header in external format into an ELF file header in
240 elf_swap_ehdr_in (abfd
, src
, dst
)
242 Elf_External_Ehdr
*src
;
243 Elf_Internal_Ehdr
*dst
;
245 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
246 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
247 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
248 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
249 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
250 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
251 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
252 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
253 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
254 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
255 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
256 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
257 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
258 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
261 /* Translate an ELF file header in internal format into an ELF file header in
265 elf_swap_ehdr_out (abfd
, src
, dst
)
267 Elf_Internal_Ehdr
*src
;
268 Elf_External_Ehdr
*dst
;
270 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
271 /* note that all elements of dst are *arrays of unsigned char* already... */
272 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
273 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
274 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
275 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
276 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
277 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
278 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
279 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
280 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
281 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
282 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
283 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
284 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
288 /* Translate an ELF section header table entry in external format into an
289 ELF section header table entry in internal format. */
292 elf_swap_shdr_in (abfd
, src
, dst
)
294 Elf_External_Shdr
*src
;
295 Elf_Internal_Shdr
*dst
;
297 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
298 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
299 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
300 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
301 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
302 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
303 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
304 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
305 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
306 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
307 dst
->bfd_section
= NULL
;
308 dst
->contents
= NULL
;
311 /* Translate an ELF section header table entry in internal format into an
312 ELF section header table entry in external format. */
315 elf_swap_shdr_out (abfd
, src
, dst
)
317 Elf_Internal_Shdr
*src
;
318 Elf_External_Shdr
*dst
;
320 /* note that all elements of dst are *arrays of unsigned char* already... */
321 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
322 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
323 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
324 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
325 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
326 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
327 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
328 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
329 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
330 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
334 /* Translate an ELF program header table entry in external format into an
335 ELF program header table entry in internal format. */
338 elf_swap_phdr_in (abfd
, src
, dst
)
340 Elf_External_Phdr
*src
;
341 Elf_Internal_Phdr
*dst
;
343 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
344 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
345 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
346 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
347 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
348 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
349 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
350 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
354 elf_swap_phdr_out (abfd
, src
, dst
)
356 Elf_Internal_Phdr
*src
;
357 Elf_External_Phdr
*dst
;
359 /* note that all elements of dst are *arrays of unsigned char* already... */
360 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
361 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
362 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
363 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
364 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
365 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
366 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
367 put_word (abfd
, src
->p_align
, dst
->p_align
);
370 /* Translate an ELF reloc from external format to internal format. */
372 elf_swap_reloc_in (abfd
, src
, dst
)
374 Elf_External_Rel
*src
;
375 Elf_Internal_Rel
*dst
;
377 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
378 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
382 elf_swap_reloca_in (abfd
, src
, dst
)
384 Elf_External_Rela
*src
;
385 Elf_Internal_Rela
*dst
;
387 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
388 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
389 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
392 /* Translate an ELF reloc from internal format to external format. */
394 elf_swap_reloc_out (abfd
, src
, dst
)
396 Elf_Internal_Rel
*src
;
397 Elf_External_Rel
*dst
;
399 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
400 put_word (abfd
, src
->r_info
, dst
->r_info
);
404 elf_swap_reloca_out (abfd
, src
, dst
)
406 Elf_Internal_Rela
*src
;
407 Elf_External_Rela
*dst
;
409 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
410 put_word (abfd
, src
->r_info
, dst
->r_info
);
411 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
415 elf_swap_dyn_in (abfd
, src
, dst
)
417 const Elf_External_Dyn
*src
;
418 Elf_Internal_Dyn
*dst
;
420 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
421 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
425 elf_swap_dyn_out (abfd
, src
, dst
)
427 const Elf_Internal_Dyn
*src
;
428 Elf_External_Dyn
*dst
;
430 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
431 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
434 /* Allocate an ELF string table--force the first byte to be zero. */
436 static struct bfd_strtab_hash
*
437 elf_stringtab_init ()
439 struct bfd_strtab_hash
*ret
;
441 ret
= _bfd_stringtab_init ();
446 loc
= _bfd_stringtab_add (ret
, "", true, false);
447 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
448 if (loc
== (bfd_size_type
) -1)
450 _bfd_stringtab_free (ret
);
457 /* ELF .o/exec file reading */
459 /* Create a new bfd section from an ELF section header. */
462 bfd_section_from_shdr (abfd
, shindex
)
464 unsigned int shindex
;
466 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
467 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
470 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
472 switch (hdr
->sh_type
)
475 /* Inactive section. Throw it away. */
478 case SHT_PROGBITS
: /* Normal section with contents. */
479 case SHT_DYNAMIC
: /* Dynamic linking information. */
480 case SHT_NOBITS
: /* .bss section. */
481 case SHT_HASH
: /* .hash section. */
482 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
484 case SHT_SYMTAB
: /* A symbol table */
485 if (elf_onesymtab (abfd
) == shindex
)
488 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
489 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
490 elf_onesymtab (abfd
) = shindex
;
491 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
492 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
493 abfd
->flags
|= HAS_SYMS
;
495 /* Sometimes a shared object will map in the symbol table. If
496 SHF_ALLOC is set, and this is a shared object, then we also
497 treat this section as a BFD section. We can not base the
498 decision purely on SHF_ALLOC, because that flag is sometimes
499 set in a relocateable object file, which would confuse the
501 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
502 && (abfd
->flags
& DYNAMIC
) != 0
503 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
508 case SHT_DYNSYM
: /* A dynamic symbol table */
509 if (elf_dynsymtab (abfd
) == shindex
)
512 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
513 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
514 elf_dynsymtab (abfd
) = shindex
;
515 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
516 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
517 abfd
->flags
|= HAS_SYMS
;
519 /* Besides being a symbol table, we also treat this as a regular
520 section, so that objcopy can handle it. */
521 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
523 case SHT_STRTAB
: /* A string table */
524 if (hdr
->bfd_section
!= NULL
)
526 if (ehdr
->e_shstrndx
== shindex
)
528 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
529 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
535 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
537 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
538 if (hdr2
->sh_link
== shindex
)
540 if (! bfd_section_from_shdr (abfd
, i
))
542 if (elf_onesymtab (abfd
) == i
)
544 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
545 elf_elfsections (abfd
)[shindex
] =
546 &elf_tdata (abfd
)->strtab_hdr
;
549 if (elf_dynsymtab (abfd
) == i
)
551 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
552 elf_elfsections (abfd
)[shindex
] =
553 &elf_tdata (abfd
)->dynstrtab_hdr
;
554 /* We also treat this as a regular section, so
555 that objcopy can handle it. */
558 #if 0 /* Not handling other string tables specially right now. */
559 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
560 /* We have a strtab for some random other section. */
561 newsect
= (asection
*) hdr2
->bfd_section
;
564 hdr
->bfd_section
= newsect
;
565 hdr2
= &elf_section_data (newsect
)->str_hdr
;
567 elf_elfsections (abfd
)[shindex
] = hdr2
;
573 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
577 /* *These* do a lot of work -- but build no sections! */
579 asection
*target_sect
;
580 Elf_Internal_Shdr
*hdr2
;
581 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
583 /* Get the symbol table. */
584 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
587 /* If this reloc section does not use the main symbol table we
588 don't treat it as a reloc section. BFD can't adequately
589 represent such a section, so at least for now, we don't
590 try. We just present it as a normal section. */
591 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
592 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
594 /* Don't allow REL relocations on a machine that uses RELA and
596 /* @@ Actually, the generic ABI does suggest that both might be
597 used in one file. But the four ABI Processor Supplements I
598 have access to right now all specify that only one is used on
599 each of those architectures. It's conceivable that, e.g., a
600 bunch of absolute 32-bit relocs might be more compact in REL
601 form even on a RELA machine... */
602 BFD_ASSERT (use_rela_p
603 ? (hdr
->sh_type
== SHT_RELA
604 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
605 : (hdr
->sh_type
== SHT_REL
606 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
608 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
610 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
611 if (target_sect
== NULL
)
614 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
616 elf_elfsections (abfd
)[shindex
] = hdr2
;
617 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
618 target_sect
->flags
|= SEC_RELOC
;
619 target_sect
->relocation
= NULL
;
620 target_sect
->rel_filepos
= hdr
->sh_offset
;
621 abfd
->flags
|= HAS_RELOC
;
628 fprintf (stderr
, "Note Sections not yet supported.\n");
635 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
640 /* Check for any processor-specific section types. */
642 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
644 if (bed
->elf_backend_section_from_shdr
)
645 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
654 elf_new_section_hook (abfd
, sec
)
659 struct bfd_elf_section_data
*sdata
;
661 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
664 bfd_set_error (bfd_error_no_memory
);
667 sec
->used_by_bfd
= (PTR
) sdata
;
668 memset (sdata
, 0, sizeof (*sdata
));
672 /* Create a new bfd section from an ELF program header.
674 Since program segments have no names, we generate a synthetic name
675 of the form segment<NUM>, where NUM is generally the index in the
676 program header table. For segments that are split (see below) we
677 generate the names segment<NUM>a and segment<NUM>b.
679 Note that some program segments may have a file size that is different than
680 (less than) the memory size. All this means is that at execution the
681 system must allocate the amount of memory specified by the memory size,
682 but only initialize it with the first "file size" bytes read from the
683 file. This would occur for example, with program segments consisting
684 of combined data+bss.
686 To handle the above situation, this routine generates TWO bfd sections
687 for the single program segment. The first has the length specified by
688 the file size of the segment, and the second has the length specified
689 by the difference between the two sizes. In effect, the segment is split
690 into it's initialized and uninitialized parts.
695 bfd_section_from_phdr (abfd
, hdr
, index
)
697 Elf_Internal_Phdr
*hdr
;
705 split
= ((hdr
->p_memsz
> 0) &&
706 (hdr
->p_filesz
> 0) &&
707 (hdr
->p_memsz
> hdr
->p_filesz
));
708 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
709 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
712 bfd_set_error (bfd_error_no_memory
);
715 strcpy (name
, namebuf
);
716 newsect
= bfd_make_section (abfd
, name
);
719 newsect
->vma
= hdr
->p_vaddr
;
720 newsect
->_raw_size
= hdr
->p_filesz
;
721 newsect
->filepos
= hdr
->p_offset
;
722 newsect
->flags
|= SEC_HAS_CONTENTS
;
723 if (hdr
->p_type
== PT_LOAD
)
725 newsect
->flags
|= SEC_ALLOC
;
726 newsect
->flags
|= SEC_LOAD
;
727 if (hdr
->p_flags
& PF_X
)
729 /* FIXME: all we known is that it has execute PERMISSION,
731 newsect
->flags
|= SEC_CODE
;
734 if (!(hdr
->p_flags
& PF_W
))
736 newsect
->flags
|= SEC_READONLY
;
741 sprintf (namebuf
, "segment%db", index
);
742 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
745 bfd_set_error (bfd_error_no_memory
);
748 strcpy (name
, namebuf
);
749 newsect
= bfd_make_section (abfd
, name
);
752 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
753 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
754 if (hdr
->p_type
== PT_LOAD
)
756 newsect
->flags
|= SEC_ALLOC
;
757 if (hdr
->p_flags
& PF_X
)
758 newsect
->flags
|= SEC_CODE
;
760 if (!(hdr
->p_flags
& PF_W
))
761 newsect
->flags
|= SEC_READONLY
;
767 /* Begin processing a given object.
769 First we validate the file by reading in the ELF header and checking
772 static INLINE boolean
774 Elf_External_Ehdr
*x_ehdrp
;
776 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
777 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
778 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
779 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
782 /* Check to see if the file associated with ABFD matches the target vector
785 Note that we may be called several times with the same ABFD, but different
786 target vectors, most of which will not match. We have to avoid leaving
787 any side effects in ABFD, or any data it points to (like tdata), if the
788 file does not match the target vector. */
794 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
795 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
796 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
797 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
798 unsigned int shindex
;
799 char *shstrtab
; /* Internal copy of section header stringtab */
800 struct elf_backend_data
*ebd
;
801 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
802 struct elf_obj_tdata
*new_tdata
= NULL
;
804 /* Read in the ELF header in external format. */
806 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
808 if (bfd_get_error () != bfd_error_system_call
)
809 goto got_wrong_format_error
;
814 /* Now check to see if we have a valid ELF file, and one that BFD can
815 make use of. The magic number must match, the address size ('class')
816 and byte-swapping must match our XVEC entry, and it must have a
817 section header table (FIXME: See comments re sections at top of this
820 if ((elf_file_p (&x_ehdr
) == false) ||
821 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
822 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
823 goto got_wrong_format_error
;
825 /* Check that file's byte order matches xvec's */
826 switch (x_ehdr
.e_ident
[EI_DATA
])
828 case ELFDATA2MSB
: /* Big-endian */
829 if (!abfd
->xvec
->header_byteorder_big_p
)
830 goto got_wrong_format_error
;
832 case ELFDATA2LSB
: /* Little-endian */
833 if (abfd
->xvec
->header_byteorder_big_p
)
834 goto got_wrong_format_error
;
836 case ELFDATANONE
: /* No data encoding specified */
837 default: /* Unknown data encoding specified */
838 goto got_wrong_format_error
;
841 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
842 the tdata pointer in the bfd. */
844 new_tdata
= ((struct elf_obj_tdata
*)
845 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
846 if (new_tdata
== NULL
)
847 goto got_no_memory_error
;
848 elf_tdata (abfd
) = new_tdata
;
850 /* Now that we know the byte order, swap in the rest of the header */
851 i_ehdrp
= elf_elfheader (abfd
);
852 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
854 elf_debug_file (i_ehdrp
);
857 /* If there is no section header table, we're hosed. */
858 if (i_ehdrp
->e_shoff
== 0)
859 goto got_wrong_format_error
;
861 /* As a simple sanity check, verify that the what BFD thinks is the
862 size of each section header table entry actually matches the size
863 recorded in the file. */
864 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
865 goto got_wrong_format_error
;
867 ebd
= get_elf_backend_data (abfd
);
869 /* Check that the ELF e_machine field matches what this particular
870 BFD format expects. */
871 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
872 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
873 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
875 const bfd_target
* const *target_ptr
;
877 if (ebd
->elf_machine_code
!= EM_NONE
)
878 goto got_wrong_format_error
;
880 /* This is the generic ELF target. Let it match any ELF target
881 for which we do not have a specific backend. */
882 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
884 struct elf_backend_data
*back
;
886 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
888 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
889 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
891 /* target_ptr is an ELF backend which matches this
892 object file, so reject the generic ELF target. */
893 goto got_wrong_format_error
;
898 if (i_ehdrp
->e_type
== ET_EXEC
)
899 abfd
->flags
|= EXEC_P
;
900 else if (i_ehdrp
->e_type
== ET_DYN
)
901 abfd
->flags
|= DYNAMIC
;
903 if (i_ehdrp
->e_phnum
> 0)
904 abfd
->flags
|= D_PAGED
;
906 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
909 /* Remember the entry point specified in the ELF file header. */
910 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
912 /* Allocate space for a copy of the section header table in
913 internal form, seek to the section header table in the file,
914 read it in, and convert it to internal form. */
915 i_shdrp
= ((Elf_Internal_Shdr
*)
916 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
917 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
919 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
920 if (!i_shdrp
|| !elf_elfsections (abfd
))
921 goto got_no_memory_error
;
922 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
924 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
926 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
928 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
929 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
931 if (i_ehdrp
->e_shstrndx
)
933 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
937 /* Read in the string table containing the names of the sections. We
938 will need the base pointer to this table later. */
939 /* We read this inline now, so that we don't have to go through
940 bfd_section_from_shdr with it (since this particular strtab is
941 used to find all of the ELF section names.) */
943 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
947 /* Once all of the section headers have been read and converted, we
948 can start processing them. Note that the first section header is
949 a dummy placeholder entry, so we ignore it. */
951 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
953 if (! bfd_section_from_shdr (abfd
, shindex
))
957 /* Let the backend double check the format and override global
959 if (ebd
->elf_backend_object_p
)
961 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
962 goto got_wrong_format_error
;
967 got_wrong_format_error
:
968 bfd_set_error (bfd_error_wrong_format
);
971 bfd_set_error (bfd_error_no_memory
);
974 if (new_tdata
!= NULL
975 && new_tdata
->elf_sect_ptr
!= NULL
)
976 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
978 bfd_release (abfd
, i_shdrp
);
979 if (new_tdata
!= NULL
)
980 bfd_release (abfd
, new_tdata
);
981 elf_tdata (abfd
) = preserved_tdata
;
986 /* ELF .o/exec file writing */
988 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
989 of the symbol if there is one. */
990 static INLINE elf_symbol_type
*
991 elf_symbol_from (ignore_abfd
, symbol
)
995 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
998 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1001 return (elf_symbol_type
*) symbol
;
1005 write_relocs (abfd
, sec
, data
)
1010 boolean
*failedp
= (boolean
*) data
;
1011 Elf_Internal_Shdr
*rela_hdr
;
1012 Elf_External_Rela
*outbound_relocas
;
1013 Elf_External_Rel
*outbound_relocs
;
1015 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1016 asymbol
*last_sym
= 0;
1017 int last_sym_idx
= 9999999; /* should always be written before use */
1019 /* If we have already failed, don't do anything. */
1023 if ((sec
->flags
& SEC_RELOC
) == 0)
1026 /* The linker backend writes the relocs out itself, and sets the
1027 reloc_count field to zero to inhibit writing them here. Also,
1028 sometimes the SEC_RELOC flag gets set even when there aren't any
1030 if (sec
->reloc_count
== 0)
1033 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1035 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1036 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1037 if (rela_hdr
->contents
== NULL
)
1039 bfd_set_error (bfd_error_no_memory
);
1044 /* orelocation has the data, reloc_count has the count... */
1047 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1049 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1051 Elf_Internal_Rela dst_rela
;
1052 Elf_External_Rela
*src_rela
;
1057 ptr
= sec
->orelocation
[idx
];
1058 src_rela
= outbound_relocas
+ idx
;
1060 /* The address of an ELF reloc is section relative for an object
1061 file, and absolute for an executable file or shared library.
1062 The address of a BFD reloc is always section relative. */
1063 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1064 dst_rela
.r_offset
= ptr
->address
;
1066 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
1068 sym
= *ptr
->sym_ptr_ptr
;
1069 if (sym
== last_sym
)
1074 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1076 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1078 dst_rela
.r_addend
= ptr
->addend
;
1079 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1083 /* REL relocations */
1085 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1087 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1089 Elf_Internal_Rel dst_rel
;
1090 Elf_External_Rel
*src_rel
;
1095 ptr
= sec
->orelocation
[idx
];
1096 sym
= *ptr
->sym_ptr_ptr
;
1097 src_rel
= outbound_relocs
+ idx
;
1099 /* The address of an ELF reloc is section relative for an object
1100 file, and absolute for an executable file or shared library.
1101 The address of a BFD reloc is always section relative. */
1102 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1103 dst_rel
.r_offset
= ptr
->address
;
1105 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1107 if (sym
== last_sym
)
1112 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1114 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1116 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1121 /* Set up an ELF internal section header for a section. */
1125 elf_fake_sections (abfd
, asect
, failedptrarg
)
1130 boolean
*failedptr
= (boolean
*) failedptrarg
;
1131 Elf_Internal_Shdr
*this_hdr
;
1135 /* We already failed; just get out of the bfd_map_over_sections
1140 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1142 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1145 if (this_hdr
->sh_name
== (unsigned long) -1)
1151 this_hdr
->sh_flags
= 0;
1152 if ((asect
->flags
& SEC_ALLOC
) != 0)
1153 this_hdr
->sh_addr
= asect
->vma
;
1155 this_hdr
->sh_addr
= 0;
1156 this_hdr
->sh_offset
= 0;
1157 this_hdr
->sh_size
= asect
->_raw_size
;
1158 this_hdr
->sh_link
= 0;
1159 this_hdr
->sh_info
= 0;
1160 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1161 this_hdr
->sh_entsize
= 0;
1163 this_hdr
->bfd_section
= asect
;
1164 this_hdr
->contents
= NULL
;
1166 /* FIXME: This should not be based on section names. */
1167 if (strcmp (asect
->name
, ".dynstr") == 0)
1168 this_hdr
->sh_type
= SHT_STRTAB
;
1169 else if (strcmp (asect
->name
, ".hash") == 0)
1171 this_hdr
->sh_type
= SHT_HASH
;
1172 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1174 else if (strcmp (asect
->name
, ".dynsym") == 0)
1176 this_hdr
->sh_type
= SHT_DYNSYM
;
1177 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1179 else if (strcmp (asect
->name
, ".dynamic") == 0)
1181 this_hdr
->sh_type
= SHT_DYNAMIC
;
1182 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1184 else if (strncmp (asect
->name
, ".rela", 5) == 0
1185 && get_elf_backend_data (abfd
)->use_rela_p
)
1187 this_hdr
->sh_type
= SHT_RELA
;
1188 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1190 else if (strncmp (asect
->name
, ".rel", 4) == 0
1191 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1193 this_hdr
->sh_type
= SHT_REL
;
1194 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1196 else if (strcmp (asect
->name
, ".note") == 0)
1197 this_hdr
->sh_type
= SHT_NOTE
;
1198 else if (strncmp (asect
->name
, ".stab", 5) == 0
1199 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1200 this_hdr
->sh_type
= SHT_STRTAB
;
1201 else if ((asect
->flags
& SEC_ALLOC
) != 0
1202 && (asect
->flags
& SEC_LOAD
) != 0)
1203 this_hdr
->sh_type
= SHT_PROGBITS
;
1204 else if ((asect
->flags
& SEC_ALLOC
) != 0
1205 && ((asect
->flags
& SEC_LOAD
) == 0))
1207 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1208 || strcmp (asect
->name
, ".sbss") == 0
1209 || strcmp (asect
->name
, ".scommon") == 0
1210 || strcmp (asect
->name
, "COMMON") == 0);
1211 this_hdr
->sh_type
= SHT_NOBITS
;
1216 this_hdr
->sh_type
= SHT_PROGBITS
;
1219 if ((asect
->flags
& SEC_ALLOC
) != 0)
1220 this_hdr
->sh_flags
|= SHF_ALLOC
;
1221 if ((asect
->flags
& SEC_READONLY
) == 0)
1222 this_hdr
->sh_flags
|= SHF_WRITE
;
1223 if ((asect
->flags
& SEC_CODE
) != 0)
1224 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1226 /* Check for processor-specific section types. */
1228 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1230 if (bed
->elf_backend_fake_sections
)
1231 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1234 /* If the section has relocs, set up a section header for the
1235 SHT_REL[A] section. */
1236 if ((asect
->flags
& SEC_RELOC
) != 0)
1238 Elf_Internal_Shdr
*rela_hdr
;
1239 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1242 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1243 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1246 bfd_set_error (bfd_error_no_memory
);
1250 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1252 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1254 if (rela_hdr
->sh_name
== (unsigned int) -1)
1259 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1260 rela_hdr
->sh_entsize
= (use_rela_p
1261 ? sizeof (Elf_External_Rela
)
1262 : sizeof (Elf_External_Rel
));
1263 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1264 rela_hdr
->sh_flags
= 0;
1265 rela_hdr
->sh_addr
= 0;
1266 rela_hdr
->sh_size
= 0;
1267 rela_hdr
->sh_offset
= 0;
1271 /* Assign all ELF section numbers. The dummy first section is handled here
1272 too. The link/info pointers for the standard section types are filled
1273 in here too, while we're at it. */
1276 assign_section_numbers (abfd
)
1279 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1281 unsigned int section_number
;
1282 Elf_Internal_Shdr
**i_shdrp
;
1286 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1288 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1290 d
->this_idx
= section_number
++;
1291 if ((sec
->flags
& SEC_RELOC
) == 0)
1294 d
->rel_idx
= section_number
++;
1297 t
->shstrtab_section
= section_number
++;
1298 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1299 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1301 if (abfd
->symcount
> 0)
1303 t
->symtab_section
= section_number
++;
1304 t
->strtab_section
= section_number
++;
1307 elf_elfheader (abfd
)->e_shnum
= section_number
;
1309 /* Set up the list of section header pointers, in agreement with the
1311 i_shdrp
= ((Elf_Internal_Shdr
**)
1312 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1313 if (i_shdrp
== NULL
)
1315 bfd_set_error (bfd_error_no_memory
);
1319 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1320 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1321 if (i_shdrp
[0] == NULL
)
1323 bfd_release (abfd
, i_shdrp
);
1324 bfd_set_error (bfd_error_no_memory
);
1327 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1329 elf_elfsections (abfd
) = i_shdrp
;
1331 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1332 if (abfd
->symcount
> 0)
1334 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1335 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1336 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1338 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1340 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1344 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1345 if (d
->rel_idx
!= 0)
1346 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1348 /* Fill in the sh_link and sh_info fields while we're at it. */
1350 /* sh_link of a reloc section is the section index of the symbol
1351 table. sh_info is the section index of the section to which
1352 the relocation entries apply. */
1353 if (d
->rel_idx
!= 0)
1355 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1356 d
->rel_hdr
.sh_info
= d
->this_idx
;
1359 switch (d
->this_hdr
.sh_type
)
1363 /* A reloc section which we are treating as a normal BFD
1364 section. sh_link is the section index of the symbol
1365 table. sh_info is the section index of the section to
1366 which the relocation entries apply. We assume that an
1367 allocated reloc section uses the dynamic symbol table.
1368 FIXME: How can we be sure? */
1369 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1371 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1373 /* We look up the section the relocs apply to by name. */
1375 if (d
->this_hdr
.sh_type
== SHT_REL
)
1379 s
= bfd_get_section_by_name (abfd
, name
);
1381 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1385 /* We assume that a section named .stab*str is a stabs
1386 string section. We look for a section with the same name
1387 but without the trailing ``str'', and set its sh_link
1388 field to point to this section. */
1389 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1390 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1395 len
= strlen (sec
->name
);
1396 alc
= (char *) malloc (len
- 2);
1399 bfd_set_error (bfd_error_no_memory
);
1402 strncpy (alc
, sec
->name
, len
- 3);
1403 alc
[len
- 3] = '\0';
1404 s
= bfd_get_section_by_name (abfd
, alc
);
1408 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1410 /* This is a .stab section. */
1411 elf_section_data (s
)->this_hdr
.sh_entsize
=
1412 4 + 2 * (ARCH_SIZE
/ 8);
1419 /* sh_link is the section header index of the string table
1420 used for the dynamic entries or symbol table. */
1421 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1423 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1427 /* sh_link is the section header index of the symbol table
1428 this hash table is for. */
1429 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1431 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1439 /* Map symbol from it's internal number to the external number, moving
1440 all local symbols to be at the head of the list. */
1443 sym_is_global (abfd
, sym
)
1447 /* If the backend has a special mapping, use it. */
1448 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1449 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1452 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1453 || bfd_is_und_section (bfd_get_section (sym
))
1454 || bfd_is_com_section (bfd_get_section (sym
)));
1458 elf_map_symbols (abfd
)
1461 int symcount
= bfd_get_symcount (abfd
);
1462 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1463 asymbol
**sect_syms
;
1465 int num_globals
= 0;
1466 int num_locals2
= 0;
1467 int num_globals2
= 0;
1469 int num_sections
= 0;
1475 fprintf (stderr
, "elf_map_symbols\n");
1479 /* Add a section symbol for each BFD section. FIXME: Is this really
1481 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1483 if (max_index
< asect
->index
)
1484 max_index
= asect
->index
;
1488 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1489 if (sect_syms
== NULL
)
1491 bfd_set_error (bfd_error_no_memory
);
1494 elf_section_syms (abfd
) = sect_syms
;
1496 for (idx
= 0; idx
< symcount
; idx
++)
1498 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1499 && syms
[idx
]->value
== 0)
1503 sec
= syms
[idx
]->section
;
1504 if (sec
->owner
!= NULL
)
1506 if (sec
->owner
!= abfd
)
1508 if (sec
->output_offset
!= 0)
1510 sec
= sec
->output_section
;
1511 BFD_ASSERT (sec
->owner
== abfd
);
1513 sect_syms
[sec
->index
] = syms
[idx
];
1518 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1522 if (sect_syms
[asect
->index
] != NULL
)
1525 sym
= bfd_make_empty_symbol (abfd
);
1528 sym
->the_bfd
= abfd
;
1529 sym
->name
= asect
->name
;
1531 /* Set the flags to 0 to indicate that this one was newly added. */
1533 sym
->section
= asect
;
1534 sect_syms
[asect
->index
] = sym
;
1538 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1539 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1543 /* Classify all of the symbols. */
1544 for (idx
= 0; idx
< symcount
; idx
++)
1546 if (!sym_is_global (abfd
, syms
[idx
]))
1551 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1553 if (sect_syms
[asect
->index
] != NULL
1554 && sect_syms
[asect
->index
]->flags
== 0)
1556 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1557 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1561 sect_syms
[asect
->index
]->flags
= 0;
1565 /* Now sort the symbols so the local symbols are first. */
1566 new_syms
= ((asymbol
**)
1568 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1569 if (new_syms
== NULL
)
1571 bfd_set_error (bfd_error_no_memory
);
1575 for (idx
= 0; idx
< symcount
; idx
++)
1577 asymbol
*sym
= syms
[idx
];
1580 if (!sym_is_global (abfd
, sym
))
1583 i
= num_locals
+ num_globals2
++;
1585 sym
->udata
.i
= i
+ 1;
1587 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1589 if (sect_syms
[asect
->index
] != NULL
1590 && sect_syms
[asect
->index
]->flags
== 0)
1592 asymbol
*sym
= sect_syms
[asect
->index
];
1595 sym
->flags
= BSF_SECTION_SYM
;
1596 if (!sym_is_global (abfd
, sym
))
1599 i
= num_locals
+ num_globals2
++;
1601 sym
->udata
.i
= i
+ 1;
1605 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1607 elf_num_locals (abfd
) = num_locals
;
1608 elf_num_globals (abfd
) = num_globals
;
1612 /* Compute the file positions we are going to put the sections at, and
1613 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1614 is not NULL, this is being called by the ELF backend linker. */
1617 elf_compute_section_file_positions (abfd
, link_info
)
1619 struct bfd_link_info
*link_info
;
1621 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1623 struct bfd_strtab_hash
*strtab
;
1624 Elf_Internal_Shdr
*shstrtab_hdr
;
1626 if (abfd
->output_has_begun
)
1629 /* Do any elf backend specific processing first. */
1630 if (bed
->elf_backend_begin_write_processing
)
1631 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1633 if (! prep_headers (abfd
))
1637 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1641 if (!assign_section_numbers (abfd
))
1644 /* The backend linker builds symbol table information itself. */
1645 if (link_info
== NULL
)
1647 if (! swap_out_syms (abfd
, &strtab
))
1651 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1652 /* sh_name was set in prep_headers. */
1653 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1654 shstrtab_hdr
->sh_flags
= 0;
1655 shstrtab_hdr
->sh_addr
= 0;
1656 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1657 shstrtab_hdr
->sh_entsize
= 0;
1658 shstrtab_hdr
->sh_link
= 0;
1659 shstrtab_hdr
->sh_info
= 0;
1660 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1661 shstrtab_hdr
->sh_addralign
= 1;
1663 if (!assign_file_positions_except_relocs (abfd
,
1664 link_info
== NULL
? true : false))
1667 if (link_info
== NULL
)
1669 /* Now that we know where the .strtab section goes, write it
1671 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1673 || ! _bfd_stringtab_emit (abfd
, strtab
))
1675 _bfd_stringtab_free (strtab
);
1678 abfd
->output_has_begun
= true;
1684 /* Align to the maximum file alignment that could be required for any
1685 ELF data structure. */
1687 static INLINE file_ptr
1688 align_file_position (off
)
1691 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1694 /* Assign a file position to a section, optionally aligning to the
1695 required section alignment. */
1697 static INLINE file_ptr
1698 assign_file_position_for_section (i_shdrp
, offset
, align
)
1699 Elf_Internal_Shdr
*i_shdrp
;
1707 al
= i_shdrp
->sh_addralign
;
1709 offset
= BFD_ALIGN (offset
, al
);
1711 i_shdrp
->sh_offset
= offset
;
1712 if (i_shdrp
->bfd_section
!= NULL
)
1713 i_shdrp
->bfd_section
->filepos
= offset
;
1714 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1715 offset
+= i_shdrp
->sh_size
;
1719 /* Get the size of the program header.
1721 SORTED_HDRS, if non-NULL, is an array of COUNT pointers to headers sorted
1722 by VMA. Non-allocated sections (!SHF_ALLOC) must appear last. All
1723 section VMAs and sizes are known so we can compute the correct value.
1724 (??? This may not be perfectly true. What cases do we miss?)
1726 If SORTED_HDRS is NULL we assume there are two segments: text and data
1727 (exclusive of .interp and .dynamic).
1729 If this is called by the linker before any of the section VMA's are set, it
1730 can't calculate the correct value for a strange memory layout. This only
1731 happens when SIZEOF_HEADERS is used in a linker script. In this case,
1732 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
1733 data segment (exclusive of .interp and .dynamic).
1735 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
1736 will be two segments. */
1738 static bfd_size_type
1739 get_program_header_size (abfd
, sorted_hdrs
, count
, maxpagesize
)
1741 Elf_Internal_Shdr
**sorted_hdrs
;
1743 bfd_vma maxpagesize
;
1748 /* We can't return a different result each time we're called. */
1749 if (elf_tdata (abfd
)->program_header_size
!= 0)
1750 return elf_tdata (abfd
)->program_header_size
;
1752 if (sorted_hdrs
!= NULL
)
1755 unsigned int last_type
;
1756 Elf_Internal_Shdr
**hdrpp
;
1757 /* What we think the current segment's offset is. */
1759 /* What we think the current segment's address is. */
1761 /* How big we think the current segment is. */
1763 /* What we think the current file offset is. */
1764 bfd_vma file_offset
;
1765 bfd_vma next_offset
;
1767 /* Scan the headers and compute the number of segments required. This
1768 code is intentionally similar to the code in map_program_segments.
1770 The `sh_offset' field isn't valid at this point, so we keep our own
1771 running total in `file_offset'.
1773 This works because section VMAs are already known. */
1776 /* Make sure the first section goes in the first segment. */
1777 file_offset
= p_offset
= sorted_hdrs
[0]->sh_addr
% maxpagesize
;
1778 p_vaddr
= sorted_hdrs
[0]->sh_addr
;
1780 last_type
= SHT_PROGBITS
;
1782 for (i
= 0, hdrpp
= sorted_hdrs
; i
< count
; i
++, hdrpp
++)
1784 Elf_Internal_Shdr
*hdr
;
1788 /* Ignore any section which will not be part of the process
1790 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1793 /* Keep track of where this and the next sections go.
1794 The section VMA must equal the file position modulo
1796 file_offset
+= (hdr
->sh_addr
- file_offset
) % maxpagesize
;
1797 next_offset
= file_offset
;
1798 if (hdr
->sh_type
!= SHT_NOBITS
)
1799 next_offset
= file_offset
+ hdr
->sh_size
;
1801 /* If this section fits in the segment we are constructing, add
1803 if ((file_offset
- (p_offset
+ p_memsz
)
1804 == hdr
->sh_addr
- (p_vaddr
+ p_memsz
))
1805 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1807 bfd_size_type adjust
;
1809 adjust
= hdr
->sh_addr
- (p_vaddr
+ p_memsz
);
1810 p_memsz
+= hdr
->sh_size
+ adjust
;
1811 file_offset
= next_offset
;
1812 last_type
= hdr
->sh_type
;
1816 /* The section won't fit, start a new segment. */
1819 /* Initialize the segment. */
1820 p_vaddr
= hdr
->sh_addr
;
1821 p_memsz
= hdr
->sh_size
;
1822 p_offset
= file_offset
;
1823 file_offset
= next_offset
;
1825 last_type
= hdr
->sh_type
;
1830 /* Assume we will need exactly two PT_LOAD segments: one for text
1831 and one for data. */
1835 s
= bfd_get_section_by_name (abfd
, ".interp");
1836 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1838 /* If we have a loadable interpreter section, we need a
1839 PT_INTERP segment. In this case, assume we also need a
1840 PT_PHDR segment, although that may not be true for all
1845 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1847 /* We need a PT_DYNAMIC segment. */
1851 elf_tdata (abfd
)->program_header_size
= segs
* sizeof (Elf_External_Phdr
);
1852 return elf_tdata (abfd
)->program_header_size
;
1855 /* Create the program header. OFF is the file offset where the
1856 program header should be written. FIRST is the first loadable ELF
1857 section. SORTED_HDRS is the ELF sections sorted by section
1858 address. PHDR_SIZE is the size of the program header as returned
1859 by get_program_header_size. */
1862 map_program_segments (abfd
, off
, first
, sorted_hdrs
, phdr_size
)
1865 Elf_Internal_Shdr
*first
;
1866 Elf_Internal_Shdr
**sorted_hdrs
;
1867 bfd_size_type phdr_size
;
1869 Elf_Internal_Phdr phdrs
[10];
1870 unsigned int phdr_count
;
1871 Elf_Internal_Phdr
*phdr
;
1872 int phdr_size_adjust
;
1874 Elf_Internal_Shdr
**hdrpp
;
1875 asection
*sinterp
, *sdyn
;
1876 unsigned int last_type
;
1877 Elf_Internal_Ehdr
*i_ehdrp
;
1879 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1880 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1881 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1886 phdr_size_adjust
= 0;
1888 /* If we have a loadable .interp section, we must create a PT_INTERP
1889 segment which must precede all PT_LOAD segments. We assume that
1890 we must also create a PT_PHDR segment, although that may not be
1891 true for all targets. */
1892 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1893 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1895 BFD_ASSERT (first
!= NULL
);
1897 phdr
->p_type
= PT_PHDR
;
1899 phdr
->p_offset
= off
;
1901 /* Account for any adjustment made because of the alignment of
1902 the first loadable section. */
1903 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1904 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1906 /* The program header precedes all loadable sections. This lets
1907 us compute its loadable address. This depends on the linker
1909 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1912 phdr
->p_filesz
= phdr_size
;
1913 phdr
->p_memsz
= phdr_size
;
1915 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1916 phdr
->p_flags
= PF_R
| PF_X
;
1918 phdr
->p_align
= FILE_ALIGN
;
1919 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1921 /* Include the ELF header in the first loadable segment. */
1922 phdr_size_adjust
+= off
;
1927 phdr
->p_type
= PT_INTERP
;
1928 phdr
->p_offset
= sinterp
->filepos
;
1929 phdr
->p_vaddr
= sinterp
->vma
;
1931 phdr
->p_filesz
= sinterp
->_raw_size
;
1932 phdr
->p_memsz
= sinterp
->_raw_size
;
1933 phdr
->p_flags
= PF_R
;
1934 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1940 /* Look through the sections to see how they will be divided into
1941 program segments. The sections must be arranged in order by
1942 sh_addr for this to work correctly. */
1943 phdr
->p_type
= PT_NULL
;
1944 last_type
= SHT_PROGBITS
;
1945 for (i
= 1, hdrpp
= sorted_hdrs
;
1946 i
< elf_elfheader (abfd
)->e_shnum
;
1949 Elf_Internal_Shdr
*hdr
;
1953 /* Ignore any section which will not be part of the process
1955 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1958 /* If this section fits in the segment we are constructing, add
1960 if (phdr
->p_type
!= PT_NULL
1961 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1962 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1963 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1965 bfd_size_type adjust
;
1967 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1968 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1969 if (hdr
->sh_type
!= SHT_NOBITS
)
1970 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1971 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1972 phdr
->p_flags
|= PF_W
;
1973 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1974 phdr
->p_flags
|= PF_X
;
1975 last_type
= hdr
->sh_type
;
1979 /* The section won't fit, start a new segment. If we're already in one,
1980 move to the next one. */
1981 if (phdr
->p_type
!= PT_NULL
)
1987 /* Initialize the segment. */
1988 phdr
->p_type
= PT_LOAD
;
1989 phdr
->p_offset
= hdr
->sh_offset
;
1990 phdr
->p_vaddr
= hdr
->sh_addr
;
1992 if (hdr
->sh_type
== SHT_NOBITS
)
1995 phdr
->p_filesz
= hdr
->sh_size
;
1996 phdr
->p_memsz
= hdr
->sh_size
;
1997 phdr
->p_flags
= PF_R
;
1998 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1999 phdr
->p_flags
|= PF_W
;
2000 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
2001 phdr
->p_flags
|= PF_X
;
2002 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
2006 && (sinterp
->flags
& SEC_LOAD
) != 0)
2008 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
2009 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
2010 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
2011 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
2014 last_type
= hdr
->sh_type
;
2017 if (phdr
->p_type
!= PT_NULL
)
2023 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
2024 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
2025 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
2027 phdr
->p_type
= PT_DYNAMIC
;
2028 phdr
->p_offset
= sdyn
->filepos
;
2029 phdr
->p_vaddr
= sdyn
->vma
;
2031 phdr
->p_filesz
= sdyn
->_raw_size
;
2032 phdr
->p_memsz
= sdyn
->_raw_size
;
2033 phdr
->p_flags
= PF_R
;
2034 if ((sdyn
->flags
& SEC_READONLY
) == 0)
2035 phdr
->p_flags
|= PF_W
;
2036 if ((sdyn
->flags
& SEC_CODE
) != 0)
2037 phdr
->p_flags
|= PF_X
;
2038 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
2044 /* Make sure the return value from get_program_header_size matches
2045 what we computed here. Actually, it's OK if we allocated too
2046 much space in the program header. */
2047 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
2049 ((*_bfd_error_handler
)
2050 ("%s: Not enough room for program headers (allocated %lu, need %u)",
2051 bfd_get_filename (abfd
),
2052 (unsigned long) (phdr_size
/ sizeof (Elf_External_Phdr
)),
2054 bfd_set_error (bfd_error_bad_value
);
2055 return (file_ptr
) -1;
2058 /* Set up program header information. */
2059 i_ehdrp
= elf_elfheader (abfd
);
2060 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2061 i_ehdrp
->e_phoff
= off
;
2062 i_ehdrp
->e_phnum
= phdr_count
;
2064 /* Save the program headers away. I don't think anybody uses this
2065 information right now. */
2066 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
2069 * sizeof (Elf_Internal_Phdr
))));
2070 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
2072 bfd_set_error (bfd_error_no_memory
);
2073 return (file_ptr
) -1;
2075 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
2076 phdr_count
* sizeof (Elf_Internal_Phdr
));
2078 /* Write out the program headers. */
2079 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
2080 return (file_ptr
) -1;
2082 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
2084 Elf_External_Phdr extphdr
;
2086 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
2087 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
2088 != sizeof (Elf_External_Phdr
))
2089 return (file_ptr
) -1;
2092 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
2095 /* Work out the file positions of all the sections. This is called by
2096 elf_compute_section_file_positions. All the section sizes and VMAs
2097 must be known before this is called.
2099 We do not consider reloc sections at this point, unless they form
2100 part of the loadable image. Reloc sections are assigned file
2101 positions in assign_file_positions_for_relocs, which is called by
2102 write_object_contents and final_link.
2104 If DOSYMS is false, we do not assign file positions for the symbol
2105 table or the string table. */
2108 assign_file_positions_except_relocs (abfd
, dosyms
)
2112 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2113 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2114 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2117 /* Start after the ELF header. */
2118 off
= i_ehdrp
->e_ehsize
;
2120 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2122 Elf_Internal_Shdr
**hdrpp
;
2125 /* We are not creating an executable, which means that we are
2126 not creating a program header, and that the actual order of
2127 the sections in the file is unimportant. */
2128 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2130 Elf_Internal_Shdr
*hdr
;
2133 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2135 hdr
->sh_offset
= -1;
2139 && (i
== tdata
->symtab_section
2140 || i
== tdata
->strtab_section
))
2142 hdr
->sh_offset
= -1;
2146 off
= assign_file_position_for_section (hdr
, off
, true);
2152 bfd_size_type phdr_size
;
2153 bfd_vma maxpagesize
;
2155 Elf_Internal_Shdr
**sorted_hdrs
;
2156 Elf_Internal_Shdr
**hdrpp
;
2158 Elf_Internal_Shdr
*first
;
2161 /* We are creating an executable. */
2163 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2164 if (maxpagesize
== 0)
2167 /* We must sort the sections. The GNU linker will always create
2168 the sections in an appropriate order, but the Irix 5 linker
2169 will not. We don't include the dummy first section in the
2170 sort. We sort sections which are not SHF_ALLOC to the end. */
2171 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2172 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2173 if (sorted_hdrs
== NULL
)
2175 bfd_set_error (bfd_error_no_memory
);
2179 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2180 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2183 /* We can't actually create the program header until we have set the
2184 file positions for the sections, and we can't do that until we know
2185 how big the header is going to be. */
2186 off
= align_file_position (off
);
2187 phdr_size
= get_program_header_size (abfd
,
2188 sorted_hdrs
, i_ehdrp
->e_shnum
- 1,
2190 if (phdr_size
== (file_ptr
) -1)
2193 /* Compute the file offsets of each section. */
2197 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2199 Elf_Internal_Shdr
*hdr
;
2202 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2204 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2206 hdr
->sh_offset
= -1;
2210 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2211 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2213 hdr
->sh_offset
= -1;
2222 /* The section VMA must equal the file position modulo
2223 the page size. This is required by the program
2225 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2228 off
= assign_file_position_for_section (hdr
, off
, false);
2231 /* Create the program header. */
2232 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, sorted_hdrs
,
2234 if (phdr_map
== (file_ptr
) -1)
2236 BFD_ASSERT ((bfd_size_type
) phdr_map
<= (bfd_size_type
) phdr_off
+ phdr_size
);
2241 /* Place the section headers. */
2242 off
= align_file_position (off
);
2243 i_ehdrp
->e_shoff
= off
;
2244 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2246 elf_tdata (abfd
)->next_file_pos
= off
;
2251 /* Sort the ELF headers by VMA. We sort headers which are not
2252 SHF_ALLOC to the end. */
2256 elf_sort_hdrs (arg1
, arg2
)
2261 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2262 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2264 #define TOEND(x) (((x)->sh_flags & SHF_ALLOC)==0)
2275 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2277 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2280 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2281 The main loop in map_program_segments requires this. */
2283 ret
= (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2287 if (hdr1
->sh_size
< hdr2
->sh_size
)
2289 if (hdr1
->sh_size
> hdr2
->sh_size
)
2300 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2301 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2302 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2304 struct bfd_strtab_hash
*shstrtab
;
2306 i_ehdrp
= elf_elfheader (abfd
);
2307 i_shdrp
= elf_elfsections (abfd
);
2309 shstrtab
= elf_stringtab_init ();
2310 if (shstrtab
== NULL
)
2313 elf_shstrtab (abfd
) = shstrtab
;
2315 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2316 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2317 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2318 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2320 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2321 i_ehdrp
->e_ident
[EI_DATA
] =
2322 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2323 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2325 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2326 i_ehdrp
->e_ident
[count
] = 0;
2328 if ((abfd
->flags
& DYNAMIC
) != 0)
2329 i_ehdrp
->e_type
= ET_DYN
;
2330 else if ((abfd
->flags
& EXEC_P
) != 0)
2331 i_ehdrp
->e_type
= ET_EXEC
;
2333 i_ehdrp
->e_type
= ET_REL
;
2335 switch (bfd_get_arch (abfd
))
2337 case bfd_arch_unknown
:
2338 i_ehdrp
->e_machine
= EM_NONE
;
2340 case bfd_arch_sparc
:
2342 i_ehdrp
->e_machine
= EM_SPARC64
;
2344 i_ehdrp
->e_machine
= EM_SPARC
;
2348 i_ehdrp
->e_machine
= EM_386
;
2351 i_ehdrp
->e_machine
= EM_68K
;
2354 i_ehdrp
->e_machine
= EM_88K
;
2357 i_ehdrp
->e_machine
= EM_860
;
2359 case bfd_arch_mips
: /* MIPS Rxxxx */
2360 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2363 i_ehdrp
->e_machine
= EM_PARISC
;
2365 case bfd_arch_powerpc
:
2366 i_ehdrp
->e_machine
= EM_PPC
;
2368 /* start-sanitize-arc */
2370 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2372 /* end-sanitize-arc */
2373 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2375 i_ehdrp
->e_machine
= EM_NONE
;
2377 i_ehdrp
->e_version
= EV_CURRENT
;
2378 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2380 /* no program header, for now. */
2381 i_ehdrp
->e_phoff
= 0;
2382 i_ehdrp
->e_phentsize
= 0;
2383 i_ehdrp
->e_phnum
= 0;
2385 /* each bfd section is section header entry */
2386 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2387 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2389 /* if we're building an executable, we'll need a program header table */
2390 if (abfd
->flags
& EXEC_P
)
2392 /* it all happens later */
2394 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2396 /* elf_build_phdrs() returns a (NULL-terminated) array of
2397 Elf_Internal_Phdrs */
2398 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2399 i_ehdrp
->e_phoff
= outbase
;
2400 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2405 i_ehdrp
->e_phentsize
= 0;
2407 i_ehdrp
->e_phoff
= 0;
2410 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2411 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2412 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2413 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2414 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2415 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2416 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2417 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2418 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2425 swap_out_syms (abfd
, sttp
)
2427 struct bfd_strtab_hash
**sttp
;
2429 if (!elf_map_symbols (abfd
))
2432 /* Dump out the symtabs. */
2434 int symcount
= bfd_get_symcount (abfd
);
2435 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2436 struct bfd_strtab_hash
*stt
;
2437 Elf_Internal_Shdr
*symtab_hdr
;
2438 Elf_Internal_Shdr
*symstrtab_hdr
;
2439 Elf_External_Sym
*outbound_syms
;
2442 stt
= elf_stringtab_init ();
2446 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2447 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2448 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2449 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2450 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2451 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2453 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2454 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2456 outbound_syms
= ((Elf_External_Sym
*)
2458 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2459 if (outbound_syms
== NULL
)
2461 bfd_set_error (bfd_error_no_memory
);
2464 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2466 /* now generate the data (for "contents") */
2468 /* Fill in zeroth symbol and swap it out. */
2469 Elf_Internal_Sym sym
;
2475 sym
.st_shndx
= SHN_UNDEF
;
2476 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2479 for (idx
= 0; idx
< symcount
; idx
++)
2481 Elf_Internal_Sym sym
;
2482 bfd_vma value
= syms
[idx
]->value
;
2483 elf_symbol_type
*type_ptr
;
2484 flagword flags
= syms
[idx
]->flags
;
2486 if (flags
& BSF_SECTION_SYM
)
2487 /* Section symbols have no names. */
2491 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2494 if (sym
.st_name
== (unsigned long) -1)
2498 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2500 if (bfd_is_com_section (syms
[idx
]->section
))
2502 /* ELF common symbols put the alignment into the `value' field,
2503 and the size into the `size' field. This is backwards from
2504 how BFD handles it, so reverse it here. */
2505 sym
.st_size
= value
;
2506 if (type_ptr
== NULL
2507 || type_ptr
->internal_elf_sym
.st_value
== 0)
2508 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2510 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2511 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2512 syms
[idx
]->section
);
2516 asection
*sec
= syms
[idx
]->section
;
2519 if (sec
->output_section
)
2521 value
+= sec
->output_offset
;
2522 sec
= sec
->output_section
;
2525 sym
.st_value
= value
;
2526 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2527 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2531 /* Writing this would be a hell of a lot easier if we had
2532 some decent documentation on bfd, and knew what to expect
2533 of the library, and what to demand of applications. For
2534 example, it appears that `objcopy' might not set the
2535 section of a symbol to be a section that is actually in
2537 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2538 BFD_ASSERT (sec2
!= 0);
2539 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2540 BFD_ASSERT (shndx
!= -1);
2544 if (bfd_is_com_section (syms
[idx
]->section
))
2545 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2546 else if (bfd_is_und_section (syms
[idx
]->section
))
2547 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
2550 ((flags
& BSF_FUNCTION
)
2553 else if (flags
& BSF_SECTION_SYM
)
2554 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2555 else if (flags
& BSF_FILE
)
2556 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2559 int bind
= STB_LOCAL
;
2560 int type
= STT_OBJECT
;
2562 if (flags
& BSF_LOCAL
)
2564 else if (flags
& BSF_WEAK
)
2566 else if (flags
& BSF_GLOBAL
)
2569 if (flags
& BSF_FUNCTION
)
2572 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2576 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2581 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2582 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2584 symstrtab_hdr
->sh_flags
= 0;
2585 symstrtab_hdr
->sh_addr
= 0;
2586 symstrtab_hdr
->sh_entsize
= 0;
2587 symstrtab_hdr
->sh_link
= 0;
2588 symstrtab_hdr
->sh_info
= 0;
2589 symstrtab_hdr
->sh_addralign
= 1;
2596 write_shdrs_and_ehdr (abfd
)
2599 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2600 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2601 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2602 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2605 i_ehdrp
= elf_elfheader (abfd
);
2606 i_shdrp
= elf_elfsections (abfd
);
2608 /* swap the header before spitting it out... */
2611 elf_debug_file (i_ehdrp
);
2613 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2614 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2615 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2616 != sizeof (x_ehdr
)))
2619 /* at this point we've concocted all the ELF sections... */
2620 x_shdrp
= (Elf_External_Shdr
*)
2621 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2624 bfd_set_error (bfd_error_no_memory
);
2628 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2631 elf_debug_section (count
, i_shdrp
[count
]);
2633 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2635 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2636 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2637 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2640 /* need to dump the string table too... */
2645 /* Assign file positions for all the reloc sections which are not part
2646 of the loadable file image. */
2649 assign_file_positions_for_relocs (abfd
)
2654 Elf_Internal_Shdr
**shdrpp
;
2656 off
= elf_tdata (abfd
)->next_file_pos
;
2658 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2659 i
< elf_elfheader (abfd
)->e_shnum
;
2662 Elf_Internal_Shdr
*shdrp
;
2665 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2666 && shdrp
->sh_offset
== -1)
2667 off
= assign_file_position_for_section (shdrp
, off
, true);
2670 elf_tdata (abfd
)->next_file_pos
= off
;
2674 NAME(bfd_elf
,write_object_contents
) (abfd
)
2677 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2678 Elf_Internal_Ehdr
*i_ehdrp
;
2679 Elf_Internal_Shdr
**i_shdrp
;
2683 if (! abfd
->output_has_begun
2684 && ! elf_compute_section_file_positions (abfd
,
2685 (struct bfd_link_info
*) NULL
))
2688 i_shdrp
= elf_elfsections (abfd
);
2689 i_ehdrp
= elf_elfheader (abfd
);
2692 bfd_map_over_sections (abfd
, write_relocs
, &failed
);
2695 assign_file_positions_for_relocs (abfd
);
2697 /* After writing the headers, we need to write the sections too... */
2698 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2700 if (bed
->elf_backend_section_processing
)
2701 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2702 if (i_shdrp
[count
]->contents
)
2704 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2705 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2707 != i_shdrp
[count
]->sh_size
))
2712 /* Write out the section header names. */
2713 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2714 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2717 if (bed
->elf_backend_final_write_processing
)
2718 (*bed
->elf_backend_final_write_processing
) (abfd
,
2719 elf_tdata (abfd
)->linker
);
2721 return write_shdrs_and_ehdr (abfd
);
2724 /* Given an ELF section number, retrieve the corresponding BFD
2728 section_from_elf_index (abfd
, index
)
2732 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2733 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2735 return elf_elfsections (abfd
)[index
]->bfd_section
;
2738 /* given a section, search the header to find them... */
2740 elf_section_from_bfd_section (abfd
, asect
)
2744 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2745 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2747 Elf_Internal_Shdr
*hdr
;
2748 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2750 for (index
= 0; index
< maxindex
; index
++)
2752 hdr
= i_shdrp
[index
];
2753 if (hdr
->bfd_section
== asect
)
2757 if (bed
->elf_backend_section_from_bfd_section
)
2759 for (index
= 0; index
< maxindex
; index
++)
2763 hdr
= i_shdrp
[index
];
2765 if ((*bed
->elf_backend_section_from_bfd_section
)
2766 (abfd
, hdr
, asect
, &retval
))
2771 if (bfd_is_abs_section (asect
))
2773 if (bfd_is_com_section (asect
))
2775 if (bfd_is_und_section (asect
))
2781 /* given a symbol, return the bfd index for that symbol. */
2783 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2785 struct symbol_cache_entry
**asym_ptr_ptr
;
2787 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2789 flagword flags
= asym_ptr
->flags
;
2791 /* When gas creates relocations against local labels, it creates its
2792 own symbol for the section, but does put the symbol into the
2793 symbol chain, so udata is 0. When the linker is generating
2794 relocatable output, this section symbol may be for one of the
2795 input sections rather than the output section. */
2796 if (asym_ptr
->udata
.i
== 0
2797 && (flags
& BSF_SECTION_SYM
)
2798 && asym_ptr
->section
)
2802 if (asym_ptr
->section
->output_section
!= NULL
)
2803 indx
= asym_ptr
->section
->output_section
->index
;
2805 indx
= asym_ptr
->section
->index
;
2806 if (elf_section_syms (abfd
)[indx
])
2807 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2810 idx
= asym_ptr
->udata
.i
;
2811 BFD_ASSERT (idx
!= 0);
2817 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2818 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2827 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2829 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2832 Elf_Internal_Shdr
*hdr
;
2833 long symcount
; /* Number of external ELF symbols */
2834 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2835 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2836 Elf_Internal_Sym i_sym
;
2837 Elf_External_Sym
*x_symp
= NULL
;
2839 /* Read each raw ELF symbol, converting from external ELF form to
2840 internal ELF form, and then using the information to create a
2841 canonical bfd symbol table entry.
2843 Note that we allocate the initial bfd canonical symbol buffer
2844 based on a one-to-one mapping of the ELF symbols to canonical
2845 symbols. We actually use all the ELF symbols, so there will be no
2846 space left over at the end. When we have all the symbols, we
2847 build the caller's pointer vector. */
2850 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2852 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2853 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2856 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2859 sym
= symbase
= NULL
;
2864 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2867 symbase
= ((elf_symbol_type
*)
2868 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2869 if (symbase
== (elf_symbol_type
*) NULL
)
2871 bfd_set_error (bfd_error_no_memory
);
2876 /* Temporarily allocate room for the raw ELF symbols. */
2877 x_symp
= ((Elf_External_Sym
*)
2878 malloc (symcount
* sizeof (Elf_External_Sym
)));
2879 if (x_symp
== NULL
&& symcount
!= 0)
2881 bfd_set_error (bfd_error_no_memory
);
2885 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2886 != symcount
* sizeof (Elf_External_Sym
))
2888 /* Skip first symbol, which is a null dummy. */
2889 for (i
= 1; i
< symcount
; i
++)
2891 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2892 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2893 #ifdef ELF_KEEP_EXTSYM
2894 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2896 sym
->symbol
.the_bfd
= abfd
;
2898 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2901 sym
->symbol
.value
= i_sym
.st_value
;
2903 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2905 sym
->symbol
.section
= section_from_elf_index (abfd
,
2907 if (sym
->symbol
.section
== NULL
)
2909 /* This symbol is in a section for which we did not
2910 create a BFD section. Just use bfd_abs_section,
2911 although it is wrong. FIXME. */
2912 sym
->symbol
.section
= bfd_abs_section_ptr
;
2915 else if (i_sym
.st_shndx
== SHN_ABS
)
2917 sym
->symbol
.section
= bfd_abs_section_ptr
;
2919 else if (i_sym
.st_shndx
== SHN_COMMON
)
2921 sym
->symbol
.section
= bfd_com_section_ptr
;
2922 /* Elf puts the alignment into the `value' field, and
2923 the size into the `size' field. BFD wants to see the
2924 size in the value field, and doesn't care (at the
2925 moment) about the alignment. */
2926 sym
->symbol
.value
= i_sym
.st_size
;
2928 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2930 sym
->symbol
.section
= bfd_und_section_ptr
;
2933 sym
->symbol
.section
= bfd_abs_section_ptr
;
2935 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2937 switch (ELF_ST_BIND (i_sym
.st_info
))
2940 sym
->symbol
.flags
|= BSF_LOCAL
;
2943 if (i_sym
.st_shndx
!= SHN_UNDEF
2944 && i_sym
.st_shndx
!= SHN_COMMON
)
2945 sym
->symbol
.flags
|= BSF_GLOBAL
;
2948 sym
->symbol
.flags
|= BSF_WEAK
;
2952 switch (ELF_ST_TYPE (i_sym
.st_info
))
2955 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2958 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2961 sym
->symbol
.flags
|= BSF_FUNCTION
;
2966 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2968 /* Do some backend-specific processing on this symbol. */
2970 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2971 if (ebd
->elf_backend_symbol_processing
)
2972 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2979 /* Do some backend-specific processing on this symbol table. */
2981 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2982 if (ebd
->elf_backend_symbol_table_processing
)
2983 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2986 /* We rely on the zalloc to clear out the final symbol entry. */
2988 symcount
= sym
- symbase
;
2990 /* Fill in the user's symbol pointer vector if needed. */
2998 *symptrs
++ = &sym
->symbol
;
3001 *symptrs
= 0; /* Final null pointer */
3013 /* Return the number of bytes required to hold the symtab vector.
3015 Note that we base it on the count plus 1, since we will null terminate
3016 the vector allocated based on this size. However, the ELF symbol table
3017 always has a dummy entry as symbol #0, so it ends up even. */
3020 elf_get_symtab_upper_bound (abfd
)
3025 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3027 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3028 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3034 elf_get_dynamic_symtab_upper_bound (abfd
)
3039 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3041 if (elf_dynsymtab (abfd
) == 0)
3043 bfd_set_error (bfd_error_invalid_operation
);
3047 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3048 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3054 elf_get_reloc_upper_bound (abfd
, asect
)
3058 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3061 /* Read in and swap the external relocs. */
3064 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3069 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
3070 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
3071 PTR allocated
= NULL
;
3072 bfd_byte
*native_relocs
;
3078 if (asect
->relocation
!= NULL
3079 || (asect
->flags
& SEC_RELOC
) == 0
3080 || asect
->reloc_count
== 0)
3083 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
3084 && (asect
->reloc_count
3085 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
3087 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
3088 if (allocated
== NULL
)
3090 bfd_set_error (bfd_error_no_memory
);
3094 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
3095 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
3096 != d
->rel_hdr
.sh_size
))
3099 native_relocs
= (bfd_byte
*) allocated
;
3101 relents
= ((arelent
*)
3102 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
3103 if (relents
== NULL
)
3105 bfd_set_error (bfd_error_no_memory
);
3109 entsize
= d
->rel_hdr
.sh_entsize
;
3110 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
3111 || entsize
== sizeof (Elf_External_Rela
));
3113 for (i
= 0, relent
= relents
;
3114 i
< asect
->reloc_count
;
3115 i
++, relent
++, native_relocs
+= entsize
)
3117 Elf_Internal_Rela rela
;
3118 Elf_Internal_Rel rel
;
3120 if (entsize
== sizeof (Elf_External_Rela
))
3121 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
3124 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
3125 rela
.r_offset
= rel
.r_offset
;
3126 rela
.r_info
= rel
.r_info
;
3130 /* The address of an ELF reloc is section relative for an object
3131 file, and absolute for an executable file or shared library.
3132 The address of a BFD reloc is always section relative. */
3133 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3134 relent
->address
= rela
.r_offset
;
3136 relent
->address
= rela
.r_offset
- asect
->vma
;
3138 if (ELF_R_SYM (rela
.r_info
) == 0)
3139 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3144 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3147 /* Canonicalize ELF section symbols. FIXME: Why? */
3148 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3149 relent
->sym_ptr_ptr
= ps
;
3151 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3154 relent
->addend
= rela
.r_addend
;
3156 if (entsize
== sizeof (Elf_External_Rela
))
3157 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3159 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3162 asect
->relocation
= relents
;
3164 if (allocated
!= NULL
)
3170 if (allocated
!= NULL
)
3177 elf_debug_section (num
, hdr
)
3179 Elf_Internal_Shdr
*hdr
;
3181 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3182 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
3185 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3186 (long) hdr
->sh_name
,
3187 (long) hdr
->sh_type
,
3188 (long) hdr
->sh_flags
);
3190 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3191 (long) hdr
->sh_addr
,
3192 (long) hdr
->sh_offset
,
3193 (long) hdr
->sh_size
);
3195 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3196 (long) hdr
->sh_link
,
3197 (long) hdr
->sh_info
,
3198 (long) hdr
->sh_addralign
);
3199 fprintf (stderr
, "sh_entsize = %ld\n",
3200 (long) hdr
->sh_entsize
);
3205 elf_debug_file (ehdrp
)
3206 Elf_Internal_Ehdr
*ehdrp
;
3208 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3209 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3210 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3211 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3212 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3213 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3214 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3218 elf_symbol_flags (flags
)
3221 static char buffer
[1024];
3224 if (flags
& BSF_LOCAL
)
3225 strcat (buffer
, " local");
3227 if (flags
& BSF_GLOBAL
)
3228 strcat (buffer
, " global");
3230 if (flags
& BSF_DEBUGGING
)
3231 strcat (buffer
, " debug");
3233 if (flags
& BSF_FUNCTION
)
3234 strcat (buffer
, " function");
3236 if (flags
& BSF_KEEP
)
3237 strcat (buffer
, " keep");
3239 if (flags
& BSF_KEEP_G
)
3240 strcat (buffer
, " keep_g");
3242 if (flags
& BSF_WEAK
)
3243 strcat (buffer
, " weak");
3245 if (flags
& BSF_SECTION_SYM
)
3246 strcat (buffer
, " section-sym");
3248 if (flags
& BSF_OLD_COMMON
)
3249 strcat (buffer
, " old-common");
3251 if (flags
& BSF_NOT_AT_END
)
3252 strcat (buffer
, " not-at-end");
3254 if (flags
& BSF_CONSTRUCTOR
)
3255 strcat (buffer
, " constructor");
3257 if (flags
& BSF_WARNING
)
3258 strcat (buffer
, " warning");
3260 if (flags
& BSF_INDIRECT
)
3261 strcat (buffer
, " indirect");
3263 if (flags
& BSF_FILE
)
3264 strcat (buffer
, " file");
3266 if (flags
& DYNAMIC
)
3267 strcat (buffer
, " dynamic");
3269 if (flags
& ~(BSF_LOCAL
3284 strcat (buffer
, " unknown-bits");
3290 /* Canonicalize the relocs. */
3293 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3302 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3305 tblptr
= section
->relocation
;
3306 for (i
= 0; i
< section
->reloc_count
; i
++)
3307 *relptr
++ = tblptr
++;
3311 return section
->reloc_count
;
3315 elf_get_symtab (abfd
, alocation
)
3317 asymbol
**alocation
;
3319 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3322 bfd_get_symcount (abfd
) = symcount
;
3327 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3329 asymbol
**alocation
;
3331 return elf_slurp_symbol_table (abfd
, alocation
, true);
3335 elf_make_empty_symbol (abfd
)
3338 elf_symbol_type
*newsym
;
3340 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3343 bfd_set_error (bfd_error_no_memory
);
3348 newsym
->symbol
.the_bfd
= abfd
;
3349 return &newsym
->symbol
;
3354 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3359 bfd_symbol_info (symbol
, ret
);
3363 elf_get_lineno (ignore_abfd
, symbol
)
3367 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3374 elf_set_arch_mach (abfd
, arch
, machine
)
3376 enum bfd_architecture arch
;
3377 unsigned long machine
;
3379 /* If this isn't the right architecture for this backend, and this
3380 isn't the generic backend, fail. */
3381 if (arch
!= get_elf_backend_data (abfd
)->arch
3382 && arch
!= bfd_arch_unknown
3383 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3386 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3390 elf_find_nearest_line (abfd
,
3401 CONST
char **filename_ptr
;
3402 CONST
char **functionname_ptr
;
3403 unsigned int *line_ptr
;
3409 elf_sizeof_headers (abfd
, reloc
)
3415 ret
= sizeof (Elf_External_Ehdr
);
3417 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
3423 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3428 bfd_size_type count
;
3430 Elf_Internal_Shdr
*hdr
;
3432 if (! abfd
->output_has_begun
3433 && ! elf_compute_section_file_positions (abfd
,
3434 (struct bfd_link_info
*) NULL
))
3437 hdr
= &elf_section_data (section
)->this_hdr
;
3439 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3441 if (bfd_write (location
, 1, count
, abfd
) != count
)
3448 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3451 Elf_Internal_Rela
*dst
;
3453 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3459 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3462 Elf_Internal_Rel
*dst
;
3464 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3470 /* Core file support */
3472 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3473 #include <sys/procfs.h>
3475 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3476 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3477 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3483 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3490 prstatus_t
*status
= (prstatus_t
*) 0;
3492 if (descsz
== sizeof (prstatus_t
))
3494 newsect
= bfd_make_section (abfd
, ".reg");
3495 if (newsect
== NULL
)
3497 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3498 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3499 newsect
->flags
= SEC_HAS_CONTENTS
;
3500 newsect
->alignment_power
= 2;
3501 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3503 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3509 /* Stash a copy of the prpsinfo structure away for future use. */
3512 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3518 if (descsz
== sizeof (prpsinfo_t
))
3520 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3522 bfd_set_error (bfd_error_no_memory
);
3525 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3531 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3539 newsect
= bfd_make_section (abfd
, ".reg2");
3540 if (newsect
== NULL
)
3542 newsect
->_raw_size
= descsz
;
3543 newsect
->filepos
= filepos
;
3544 newsect
->flags
= SEC_HAS_CONTENTS
;
3545 newsect
->alignment_power
= 2;
3549 #endif /* HAVE_PROCFS */
3551 /* Return a pointer to the args (including the command name) that were
3552 seen by the program that generated the core dump. Note that for
3553 some reason, a spurious space is tacked onto the end of the args
3554 in some (at least one anyway) implementations, so strip it off if
3558 elf_core_file_failing_command (abfd
)
3562 if (core_prpsinfo (abfd
))
3564 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3565 char *scan
= p
->pr_psargs
;
3570 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3574 return p
->pr_psargs
;
3580 /* Return the number of the signal that caused the core dump. Presumably,
3581 since we have a core file, we got a signal of some kind, so don't bother
3582 checking the other process status fields, just return the signal number.
3586 elf_core_file_failing_signal (abfd
)
3590 if (core_prstatus (abfd
))
3592 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3598 /* Check to see if the core file could reasonably be expected to have
3599 come for the current executable file. Note that by default we return
3600 true unless we find something that indicates that there might be a
3605 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3614 /* First, xvecs must match since both are ELF files for the same target. */
3616 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3618 bfd_set_error (bfd_error_system_call
);
3624 /* If no prpsinfo, just return true. Otherwise, grab the last component
3625 of the exec'd pathname from the prpsinfo. */
3627 if (core_prpsinfo (core_bfd
))
3629 corename
= (((prpsinfo_t
*) core_prpsinfo (core_bfd
))->pr_fname
);
3636 /* Find the last component of the executable pathname. */
3638 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3644 execname
= (char *) exec_bfd
->filename
;
3647 /* See if they match */
3649 return strcmp (execname
, corename
) ? false : true;
3655 #endif /* HAVE_PROCFS */
3658 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3659 the information that would normally be available from the /proc interface
3660 for the process, at the time the process dumped core. Currently this
3661 includes copies of the prstatus, prpsinfo, and fpregset structures.
3663 Since these structures are potentially machine dependent in size and
3664 ordering, bfd provides two levels of support for them. The first level,
3665 available on all machines since it does not require that the host
3666 have /proc support or the relevant include files, is to create a bfd
3667 section for each of the prstatus, prpsinfo, and fpregset structures,
3668 without any interpretation of their contents. With just this support,
3669 the bfd client will have to interpret the structures itself. Even with
3670 /proc support, it might want these full structures for it's own reasons.
3672 In the second level of support, where HAVE_PROCFS is defined, bfd will
3673 pick apart the structures to gather some additional information that
3674 clients may want, such as the general register set, the name of the
3675 exec'ed file and its arguments, the signal (if any) that caused the
3681 elf_corefile_note (abfd
, hdr
)
3683 Elf_Internal_Phdr
*hdr
;
3685 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3686 Elf_Internal_Note i_note
; /* Elf note, internal form */
3687 char *buf
= NULL
; /* Entire note segment contents */
3688 char *namedata
; /* Name portion of the note */
3689 char *descdata
; /* Descriptor portion of the note */
3690 char *sectname
; /* Name to use for new section */
3691 long filepos
; /* File offset to descriptor data */
3694 if (hdr
->p_filesz
> 0
3695 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3696 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3697 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3699 x_note_p
= (Elf_External_Note
*) buf
;
3700 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3702 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3703 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3704 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3705 namedata
= x_note_p
->name
;
3706 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3707 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3708 switch (i_note
.type
)
3711 /* process descdata as prstatus info */
3712 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3714 sectname
= ".prstatus";
3717 /* process descdata as fpregset info */
3718 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3720 sectname
= ".fpregset";
3723 /* process descdata as prpsinfo */
3724 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3726 sectname
= ".prpsinfo";
3729 /* Unknown descriptor, just ignore it. */
3733 if (sectname
!= NULL
)
3735 newsect
= bfd_make_section (abfd
, sectname
);
3736 if (newsect
== NULL
)
3738 newsect
->_raw_size
= i_note
.descsz
;
3739 newsect
->filepos
= filepos
;
3740 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3741 newsect
->alignment_power
= 2;
3743 x_note_p
= (Elf_External_Note
*)
3744 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3751 else if (hdr
->p_filesz
> 0)
3753 bfd_set_error (bfd_error_no_memory
);
3760 /* Core files are simply standard ELF formatted files that partition
3761 the file using the execution view of the file (program header table)
3762 rather than the linking view. In fact, there is no section header
3763 table in a core file.
3765 The process status information (including the contents of the general
3766 register set) and the floating point register set are stored in a
3767 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3768 that allow standard bfd access to the general registers (.reg) and the
3769 floating point registers (.reg2).
3774 elf_core_file_p (abfd
)
3777 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3778 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3779 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3780 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3781 unsigned int phindex
;
3782 struct elf_backend_data
*ebd
;
3784 /* Read in the ELF header in external format. */
3786 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3788 if (bfd_get_error () != bfd_error_system_call
)
3789 bfd_set_error (bfd_error_wrong_format
);
3793 /* Now check to see if we have a valid ELF file, and one that BFD can
3794 make use of. The magic number must match, the address size ('class')
3795 and byte-swapping must match our XVEC entry, and it must have a
3796 program header table (FIXME: See comments re segments at top of this
3799 if (elf_file_p (&x_ehdr
) == false)
3802 bfd_set_error (bfd_error_wrong_format
);
3806 /* FIXME, Check EI_VERSION here ! */
3810 int desired_address_size
= ELFCLASS32
;
3813 int desired_address_size
= ELFCLASS64
;
3816 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3820 /* Switch xvec to match the specified byte order. */
3821 switch (x_ehdr
.e_ident
[EI_DATA
])
3823 case ELFDATA2MSB
: /* Big-endian */
3824 if (abfd
->xvec
->byteorder_big_p
== false)
3827 case ELFDATA2LSB
: /* Little-endian */
3828 if (abfd
->xvec
->byteorder_big_p
== true)
3831 case ELFDATANONE
: /* No data encoding specified */
3832 default: /* Unknown data encoding specified */
3836 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3837 the tdata pointer in the bfd. */
3840 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3841 if (elf_tdata (abfd
) == NULL
)
3843 bfd_set_error (bfd_error_no_memory
);
3847 /* FIXME, `wrong' returns from this point onward, leak memory. */
3849 /* Now that we know the byte order, swap in the rest of the header */
3850 i_ehdrp
= elf_elfheader (abfd
);
3851 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3853 elf_debug_file (i_ehdrp
);
3856 ebd
= get_elf_backend_data (abfd
);
3858 /* Check that the ELF e_machine field matches what this particular
3859 BFD format expects. */
3860 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
3861 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
3862 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
3864 const bfd_target
* const *target_ptr
;
3866 if (ebd
->elf_machine_code
!= EM_NONE
)
3869 /* This is the generic ELF target. Let it match any ELF target
3870 for which we do not have a specific backend. */
3871 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3873 struct elf_backend_data
*back
;
3875 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3877 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3878 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3880 /* target_ptr is an ELF backend which matches this
3881 object file, so reject the generic ELF target. */
3887 /* If there is no program header, or the type is not a core file, then
3889 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3892 /* Allocate space for a copy of the program header table in
3893 internal form, seek to the program header table in the file,
3894 read it in, and convert it to internal form. As a simple sanity
3895 check, verify that the what BFD thinks is the size of each program
3896 header table entry actually matches the size recorded in the file. */
3898 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3900 i_phdrp
= (Elf_Internal_Phdr
*)
3901 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3904 bfd_set_error (bfd_error_no_memory
);
3907 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3909 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3911 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3914 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3917 /* Once all of the program headers have been read and converted, we
3918 can start processing them. */
3920 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3922 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3923 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3925 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3930 /* Remember the entry point specified in the ELF file header. */
3932 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3937 /* ELF linker code. */
3939 static boolean elf_link_add_object_symbols
3940 PARAMS ((bfd
*, struct bfd_link_info
*));
3941 static boolean elf_link_add_archive_symbols
3942 PARAMS ((bfd
*, struct bfd_link_info
*));
3943 static Elf_Internal_Rela
*elf_link_read_relocs
3944 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3945 static boolean elf_export_symbol
3946 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3947 static boolean elf_adjust_dynamic_symbol
3948 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3950 /* This struct is used to pass information to routines called via
3951 elf_link_hash_traverse which must return failure. */
3953 struct elf_info_failed
3956 struct bfd_link_info
*info
;
3959 /* Given an ELF BFD, add symbols to the global hash table as
3963 elf_bfd_link_add_symbols (abfd
, info
)
3965 struct bfd_link_info
*info
;
3969 switch (bfd_get_format (abfd
))
3972 return elf_link_add_object_symbols (abfd
, info
);
3974 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3977 /* It's OK to have an empty archive. */
3980 if (! bfd_check_format (first
, bfd_object
))
3982 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3984 /* On Linux, we may have an a.out archive which got
3985 recognized as an ELF archive. Therefore, we treat all
3986 archives as though they were actually of the flavour of
3987 their first element. */
3988 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3990 return elf_link_add_archive_symbols (abfd
, info
);
3992 bfd_set_error (bfd_error_wrong_format
);
3997 /* Add symbols from an ELF archive file to the linker hash table. We
3998 don't use _bfd_generic_link_add_archive_symbols because of a
3999 problem which arises on UnixWare. The UnixWare libc.so is an
4000 archive which includes an entry libc.so.1 which defines a bunch of
4001 symbols. The libc.so archive also includes a number of other
4002 object files, which also define symbols, some of which are the same
4003 as those defined in libc.so.1. Correct linking requires that we
4004 consider each object file in turn, and include it if it defines any
4005 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4006 this; it looks through the list of undefined symbols, and includes
4007 any object file which defines them. When this algorithm is used on
4008 UnixWare, it winds up pulling in libc.so.1 early and defining a
4009 bunch of symbols. This means that some of the other objects in the
4010 archive are not included in the link, which is incorrect since they
4011 precede libc.so.1 in the archive.
4013 Fortunately, ELF archive handling is simpler than that done by
4014 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4015 oddities. In ELF, if we find a symbol in the archive map, and the
4016 symbol is currently undefined, we know that we must pull in that
4019 Unfortunately, we do have to make multiple passes over the symbol
4020 table until nothing further is resolved. */
4023 elf_link_add_archive_symbols (abfd
, info
)
4025 struct bfd_link_info
*info
;
4028 boolean
*defined
= NULL
;
4029 boolean
*included
= NULL
;
4033 if (! bfd_has_map (abfd
))
4035 /* An empty archive is a special case. */
4036 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
4038 bfd_set_error (bfd_error_no_armap
);
4042 /* Keep track of all symbols we know to be already defined, and all
4043 files we know to be already included. This is to speed up the
4044 second and subsequent passes. */
4045 c
= bfd_ardata (abfd
)->symdef_count
;
4048 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
4049 included
= (boolean
*) malloc (c
* sizeof (boolean
));
4050 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
4052 bfd_set_error (bfd_error_no_memory
);
4055 memset (defined
, 0, c
* sizeof (boolean
));
4056 memset (included
, 0, c
* sizeof (boolean
));
4058 symdefs
= bfd_ardata (abfd
)->symdefs
;
4071 symdefend
= symdef
+ c
;
4072 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
4074 struct elf_link_hash_entry
*h
;
4076 struct bfd_link_hash_entry
*undefs_tail
;
4079 if (defined
[i
] || included
[i
])
4081 if (symdef
->file_offset
== last
)
4087 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
4088 false, false, false);
4089 if (h
== (struct elf_link_hash_entry
*) NULL
)
4091 if (h
->root
.type
!= bfd_link_hash_undefined
)
4097 /* We need to include this archive member. */
4099 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
4100 if (element
== (bfd
*) NULL
)
4103 if (! bfd_check_format (element
, bfd_object
))
4106 /* Doublecheck that we have not included this object
4107 already--it should be impossible, but there may be
4108 something wrong with the archive. */
4109 if (element
->archive_pass
!= 0)
4111 bfd_set_error (bfd_error_bad_value
);
4114 element
->archive_pass
= 1;
4116 undefs_tail
= info
->hash
->undefs_tail
;
4118 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4121 if (! elf_link_add_object_symbols (element
, info
))
4124 /* If there are any new undefined symbols, we need to make
4125 another pass through the archive in order to see whether
4126 they can be defined. FIXME: This isn't perfect, because
4127 common symbols wind up on undefs_tail and because an
4128 undefined symbol which is defined later on in this pass
4129 does not require another pass. This isn't a bug, but it
4130 does make the code less efficient than it could be. */
4131 if (undefs_tail
!= info
->hash
->undefs_tail
)
4134 /* Look backward to mark all symbols from this object file
4135 which we have already seen in this pass. */
4139 included
[mark
] = true;
4144 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4146 /* We mark subsequent symbols from this object file as we go
4147 on through the loop. */
4148 last
= symdef
->file_offset
;
4159 if (defined
!= (boolean
*) NULL
)
4161 if (included
!= (boolean
*) NULL
)
4166 /* Record a new dynamic symbol. We record the dynamic symbols as we
4167 read the input files, since we need to have a list of all of them
4168 before we can determine the final sizes of the output sections.
4169 Note that we may actually call this function even though we are not
4170 going to output any dynamic symbols; in some cases we know that a
4171 symbol should be in the dynamic symbol table, but only if there is
4175 elf_link_record_dynamic_symbol (info
, h
)
4176 struct bfd_link_info
*info
;
4177 struct elf_link_hash_entry
*h
;
4179 if (h
->dynindx
== -1)
4181 struct bfd_strtab_hash
*dynstr
;
4183 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4184 ++elf_hash_table (info
)->dynsymcount
;
4186 dynstr
= elf_hash_table (info
)->dynstr
;
4189 /* Create a strtab to hold the dynamic symbol names. */
4190 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
4195 h
->dynstr_index
= ((unsigned long)
4196 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
4198 if (h
->dynstr_index
== (unsigned long) -1)
4205 /* Add symbols from an ELF object file to the linker hash table. */
4208 elf_link_add_object_symbols (abfd
, info
)
4210 struct bfd_link_info
*info
;
4212 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4213 const Elf_Internal_Sym
*,
4214 const char **, flagword
*,
4215 asection
**, bfd_vma
*));
4216 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4217 asection
*, const Elf_Internal_Rela
*));
4219 Elf_Internal_Shdr
*hdr
;
4223 Elf_External_Sym
*buf
= NULL
;
4224 struct elf_link_hash_entry
**sym_hash
;
4226 Elf_External_Dyn
*dynbuf
= NULL
;
4227 struct elf_link_hash_entry
*weaks
;
4228 Elf_External_Sym
*esym
;
4229 Elf_External_Sym
*esymend
;
4231 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4232 collect
= get_elf_backend_data (abfd
)->collect
;
4234 /* A stripped shared library might only have a dynamic symbol table,
4235 not a regular symbol table. In that case we can still go ahead
4236 and link using the dynamic symbol table. */
4237 if (elf_onesymtab (abfd
) == 0
4238 && elf_dynsymtab (abfd
) != 0)
4240 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4241 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4244 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4245 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4247 /* The sh_info field of the symtab header tells us where the
4248 external symbols start. We don't care about the local symbols at
4250 if (elf_bad_symtab (abfd
))
4252 extsymcount
= symcount
;
4257 extsymcount
= symcount
- hdr
->sh_info
;
4258 extsymoff
= hdr
->sh_info
;
4261 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4262 if (buf
== NULL
&& extsymcount
!= 0)
4264 bfd_set_error (bfd_error_no_memory
);
4268 /* We store a pointer to the hash table entry for each external
4270 sym_hash
= ((struct elf_link_hash_entry
**)
4272 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4273 if (sym_hash
== NULL
)
4275 bfd_set_error (bfd_error_no_memory
);
4278 elf_sym_hashes (abfd
) = sym_hash
;
4280 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4284 /* If we are creating a shared library, create all the dynamic
4285 sections immediately. We need to attach them to something,
4286 so we attach them to this BFD, provided it is the right
4287 format. FIXME: If there are no input BFD's of the same
4288 format as the output, we can't make a shared library. */
4290 && ! elf_hash_table (info
)->dynamic_sections_created
4291 && abfd
->xvec
== info
->hash
->creator
)
4293 if (! elf_link_create_dynamic_sections (abfd
, info
))
4301 bfd_size_type oldsize
;
4302 bfd_size_type strindex
;
4306 /* You can't use -r against a dynamic object. Also, there's no
4307 hope of using a dynamic object which does not exactly match
4308 the format of the output file. */
4309 if (info
->relocateable
4310 || info
->hash
->creator
!= abfd
->xvec
)
4312 bfd_set_error (bfd_error_invalid_operation
);
4316 /* Find the name to use in a DT_NEEDED entry that refers to this
4317 object. If the object has a DT_SONAME entry, we use it.
4318 Otherwise, if the generic linker stuck something in
4319 elf_dt_needed_name, we use that. Otherwise, we just use the
4321 name
= bfd_get_filename (abfd
);
4322 if (elf_dt_needed_name (abfd
) != NULL
)
4323 name
= elf_dt_needed_name (abfd
);
4324 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4327 Elf_External_Dyn
*extdyn
;
4328 Elf_External_Dyn
*extdynend
;
4330 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4333 bfd_set_error (bfd_error_no_memory
);
4337 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4338 (file_ptr
) 0, s
->_raw_size
))
4342 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4343 for (; extdyn
< extdynend
; extdyn
++)
4345 Elf_Internal_Dyn dyn
;
4347 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4348 if (dyn
.d_tag
== DT_SONAME
)
4353 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4356 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4357 name
= elf_string_from_elf_section (abfd
, link
,
4362 if (dyn
.d_tag
== DT_NEEDED
)
4363 elf_hash_table (info
)->saw_needed
= true;
4370 /* We do not want to include any of the sections in a dynamic
4371 object in the output file. We hack by simply clobbering the
4372 list of sections in the BFD. This could be handled more
4373 cleanly by, say, a new section flag; the existing
4374 SEC_NEVER_LOAD flag is not the one we want, because that one
4375 still implies that the section takes up space in the output
4377 abfd
->sections
= NULL
;
4379 /* If this is the first dynamic object found in the link, create
4380 the special sections required for dynamic linking. */
4381 if (! elf_hash_table (info
)->dynamic_sections_created
)
4383 if (! elf_link_create_dynamic_sections (abfd
, info
))
4387 /* Add a DT_NEEDED entry for this dynamic object. */
4388 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4389 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4391 if (strindex
== (bfd_size_type
) -1)
4394 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
4397 Elf_External_Dyn
*dyncon
, *dynconend
;
4399 /* The hash table size did not change, which means that the
4400 dynamic object name was already entered. If we have
4401 already included this dynamic object in the link, just
4402 ignore it. There is no reason to include a particular
4403 dynamic object more than once. */
4404 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
4406 BFD_ASSERT (sdyn
!= NULL
);
4408 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
4409 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4410 for (; dyncon
< dynconend
; dyncon
++)
4412 Elf_Internal_Dyn dyn
;
4414 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
, &dyn
);
4415 if (dyn
.d_tag
== DT_NEEDED
4416 && dyn
.d_un
.d_val
== strindex
)
4425 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4430 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4432 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4433 != extsymcount
* sizeof (Elf_External_Sym
)))
4438 esymend
= buf
+ extsymcount
;
4439 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4441 Elf_Internal_Sym sym
;
4447 struct elf_link_hash_entry
*h
= NULL
;
4450 elf_swap_symbol_in (abfd
, esym
, &sym
);
4452 flags
= BSF_NO_FLAGS
;
4454 value
= sym
.st_value
;
4457 bind
= ELF_ST_BIND (sym
.st_info
);
4458 if (bind
== STB_LOCAL
)
4460 /* This should be impossible, since ELF requires that all
4461 global symbols follow all local symbols, and that sh_info
4462 point to the first global symbol. Unfortunatealy, Irix 5
4466 else if (bind
== STB_GLOBAL
)
4468 if (sym
.st_shndx
!= SHN_UNDEF
4469 && sym
.st_shndx
!= SHN_COMMON
)
4474 else if (bind
== STB_WEAK
)
4478 /* Leave it up to the processor backend. */
4481 if (sym
.st_shndx
== SHN_UNDEF
)
4482 sec
= bfd_und_section_ptr
;
4483 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4485 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4489 sec
= bfd_abs_section_ptr
;
4491 else if (sym
.st_shndx
== SHN_ABS
)
4492 sec
= bfd_abs_section_ptr
;
4493 else if (sym
.st_shndx
== SHN_COMMON
)
4495 sec
= bfd_com_section_ptr
;
4496 /* What ELF calls the size we call the value. What ELF
4497 calls the value we call the alignment. */
4498 value
= sym
.st_size
;
4502 /* Leave it up to the processor backend. */
4505 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4506 if (name
== (const char *) NULL
)
4509 if (add_symbol_hook
)
4511 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4515 /* The hook function sets the name to NULL if this symbol
4516 should be skipped for some reason. */
4517 if (name
== (const char *) NULL
)
4521 /* Sanity check that all possibilities were handled. */
4522 if (sec
== (asection
*) NULL
)
4524 bfd_set_error (bfd_error_bad_value
);
4528 if (bfd_is_und_section (sec
)
4529 || bfd_is_com_section (sec
))
4534 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4536 /* We need to look up the symbol now in order to get some of
4537 the dynamic object handling right. We pass the hash
4538 table entry in to _bfd_generic_link_add_one_symbol so
4539 that it does not have to look it up again. */
4540 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4541 true, false, false);
4546 /* If we are looking at a dynamic object, and this is a
4547 definition, we need to see if it has already been defined
4548 by some other object. If it has, we want to use the
4549 existing definition, and we do not want to report a
4550 multiple symbol definition error; we do this by
4551 clobbering sec to be bfd_und_section_ptr. */
4552 if (dynamic
&& definition
)
4554 if (h
->root
.type
== bfd_link_hash_defined
4555 || h
->root
.type
== bfd_link_hash_defweak
)
4556 sec
= bfd_und_section_ptr
;
4559 /* Similarly, if we are not looking at a dynamic object, and
4560 we have a definition, we want to override any definition
4561 we may have from a dynamic object. Symbols from regular
4562 files always take precedence over symbols from dynamic
4563 objects, even if they are defined after the dynamic
4564 object in the link. */
4567 && (h
->root
.type
== bfd_link_hash_defined
4568 || h
->root
.type
== bfd_link_hash_defweak
)
4569 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4570 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4571 == bfd_target_elf_flavour
)
4572 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4575 /* Change the hash table entry to undefined, and let
4576 _bfd_generic_link_add_one_symbol do the right thing
4577 with the new definition. */
4578 h
->root
.type
= bfd_link_hash_undefined
;
4579 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4583 if (! (_bfd_generic_link_add_one_symbol
4584 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4585 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4590 && (flags
& BSF_WEAK
) != 0
4591 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4592 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4593 && (*sym_hash
)->weakdef
== NULL
)
4595 /* Keep a list of all weak defined non function symbols from
4596 a dynamic object, using the weakdef field. Later in this
4597 function we will set the weakdef field to the correct
4598 value. We only put non-function symbols from dynamic
4599 objects on this list, because that happens to be the only
4600 time we need to know the normal symbol corresponding to a
4601 weak symbol, and the information is time consuming to
4602 figure out. If the weakdef field is not already NULL,
4603 then this symbol was already defined by some previous
4604 dynamic object, and we will be using that previous
4605 definition anyhow. */
4607 (*sym_hash
)->weakdef
= weaks
;
4611 /* Get the alignment of a common symbol. */
4612 if (sym
.st_shndx
== SHN_COMMON
4613 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4614 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
4616 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4622 /* Remember the symbol size and type. */
4623 if (sym
.st_size
!= 0)
4625 /* FIXME: We should probably somehow give a warning if
4626 the symbol size changes. */
4627 h
->size
= sym
.st_size
;
4629 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4631 /* FIXME: We should probably somehow give a warning if
4632 the symbol type changes. */
4633 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4636 /* Set a flag in the hash table entry indicating the type of
4637 reference or definition we just found. Keep a count of
4638 the number of dynamic symbols we find. A dynamic symbol
4639 is one which is referenced or defined by both a regular
4640 object and a shared object, or one which is referenced or
4641 defined by more than one shared object. */
4642 old_flags
= h
->elf_link_hash_flags
;
4647 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4649 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4651 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4652 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4658 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4660 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4661 if ((old_flags
& new_flag
) != 0
4662 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4663 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4667 h
->elf_link_hash_flags
|= new_flag
;
4668 if (dynsym
&& h
->dynindx
== -1)
4670 if (! elf_link_record_dynamic_symbol (info
, h
))
4676 /* Now set the weakdefs field correctly for all the weak defined
4677 symbols we found. The only way to do this is to search all the
4678 symbols. Since we only need the information for non functions in
4679 dynamic objects, that's the only time we actually put anything on
4680 the list WEAKS. We need this information so that if a regular
4681 object refers to a symbol defined weakly in a dynamic object, the
4682 real symbol in the dynamic object is also put in the dynamic
4683 symbols; we also must arrange for both symbols to point to the
4684 same memory location. We could handle the general case of symbol
4685 aliasing, but a general symbol alias can only be generated in
4686 assembler code, handling it correctly would be very time
4687 consuming, and other ELF linkers don't handle general aliasing
4689 while (weaks
!= NULL
)
4691 struct elf_link_hash_entry
*hlook
;
4694 struct elf_link_hash_entry
**hpp
;
4695 struct elf_link_hash_entry
**hppend
;
4698 weaks
= hlook
->weakdef
;
4699 hlook
->weakdef
= NULL
;
4701 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4702 || hlook
->root
.type
== bfd_link_hash_defweak
4703 || hlook
->root
.type
== bfd_link_hash_common
4704 || hlook
->root
.type
== bfd_link_hash_indirect
);
4705 slook
= hlook
->root
.u
.def
.section
;
4706 vlook
= hlook
->root
.u
.def
.value
;
4708 hpp
= elf_sym_hashes (abfd
);
4709 hppend
= hpp
+ extsymcount
;
4710 for (; hpp
< hppend
; hpp
++)
4712 struct elf_link_hash_entry
*h
;
4715 if (h
!= NULL
&& h
!= hlook
4716 && (h
->root
.type
== bfd_link_hash_defined
4717 || h
->root
.type
== bfd_link_hash_defweak
)
4718 && h
->root
.u
.def
.section
== slook
4719 && h
->root
.u
.def
.value
== vlook
)
4723 /* If the weak definition is in the list of dynamic
4724 symbols, make sure the real definition is put there
4726 if (hlook
->dynindx
!= -1
4727 && h
->dynindx
== -1)
4729 if (! elf_link_record_dynamic_symbol (info
, h
))
4744 /* If this object is the same format as the output object, and it is
4745 not a shared library, then let the backend look through the
4748 This is required to build global offset table entries and to
4749 arrange for dynamic relocs. It is not required for the
4750 particular common case of linking non PIC code, even when linking
4751 against shared libraries, but unfortunately there is no way of
4752 knowing whether an object file has been compiled PIC or not.
4753 Looking through the relocs is not particularly time consuming.
4754 The problem is that we must either (1) keep the relocs in memory,
4755 which causes the linker to require additional runtime memory or
4756 (2) read the relocs twice from the input file, which wastes time.
4757 This would be a good case for using mmap.
4759 I have no idea how to handle linking PIC code into a file of a
4760 different format. It probably can't be done. */
4761 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4763 && abfd
->xvec
== info
->hash
->creator
4764 && check_relocs
!= NULL
)
4768 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4770 Elf_Internal_Rela
*internal_relocs
;
4773 if ((o
->flags
& SEC_RELOC
) == 0
4774 || o
->reloc_count
== 0)
4777 /* I believe we can ignore the relocs for any section which
4778 does not form part of the final process image, such as a
4779 debugging section. */
4780 if ((o
->flags
& SEC_ALLOC
) == 0)
4783 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4784 (Elf_Internal_Rela
*) NULL
,
4786 if (internal_relocs
== NULL
)
4789 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4791 if (! info
->keep_memory
)
4792 free (internal_relocs
);
4809 /* Create some sections which will be filled in with dynamic linking
4810 information. ABFD is an input file which requires dynamic sections
4811 to be created. The dynamic sections take up virtual memory space
4812 when the final executable is run, so we need to create them before
4813 addresses are assigned to the output sections. We work out the
4814 actual contents and size of these sections later. */
4817 elf_link_create_dynamic_sections (abfd
, info
)
4819 struct bfd_link_info
*info
;
4822 register asection
*s
;
4823 struct elf_link_hash_entry
*h
;
4824 struct elf_backend_data
*bed
;
4826 if (elf_hash_table (info
)->dynamic_sections_created
)
4829 /* Make sure that all dynamic sections use the same input BFD. */
4830 if (elf_hash_table (info
)->dynobj
== NULL
)
4831 elf_hash_table (info
)->dynobj
= abfd
;
4833 abfd
= elf_hash_table (info
)->dynobj
;
4835 /* Note that we set the SEC_IN_MEMORY flag for all of these
4837 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4839 /* A dynamically linked executable has a .interp section, but a
4840 shared library does not. */
4843 s
= bfd_make_section (abfd
, ".interp");
4845 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4849 s
= bfd_make_section (abfd
, ".dynsym");
4851 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4852 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4855 s
= bfd_make_section (abfd
, ".dynstr");
4857 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4860 /* Create a strtab to hold the dynamic symbol names. */
4861 if (elf_hash_table (info
)->dynstr
== NULL
)
4863 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4864 if (elf_hash_table (info
)->dynstr
== NULL
)
4868 s
= bfd_make_section (abfd
, ".dynamic");
4870 || ! bfd_set_section_flags (abfd
, s
, flags
)
4871 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4874 /* The special symbol _DYNAMIC is always set to the start of the
4875 .dynamic section. This call occurs before we have processed the
4876 symbols for any dynamic object, so we don't have to worry about
4877 overriding a dynamic definition. We could set _DYNAMIC in a
4878 linker script, but we only want to define it if we are, in fact,
4879 creating a .dynamic section. We don't want to define it if there
4880 is no .dynamic section, since on some ELF platforms the start up
4881 code examines it to decide how to initialize the process. */
4883 if (! (_bfd_generic_link_add_one_symbol
4884 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4885 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4886 (struct bfd_link_hash_entry
**) &h
)))
4888 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4889 h
->type
= STT_OBJECT
;
4892 && ! elf_link_record_dynamic_symbol (info
, h
))
4895 s
= bfd_make_section (abfd
, ".hash");
4897 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4898 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4901 /* Let the backend create the rest of the sections. This lets the
4902 backend set the right flags. The backend will normally create
4903 the .got and .plt sections. */
4904 bed
= get_elf_backend_data (abfd
);
4905 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4908 elf_hash_table (info
)->dynamic_sections_created
= true;
4913 /* Add an entry to the .dynamic table. */
4916 elf_add_dynamic_entry (info
, tag
, val
)
4917 struct bfd_link_info
*info
;
4921 Elf_Internal_Dyn dyn
;
4925 bfd_byte
*newcontents
;
4927 dynobj
= elf_hash_table (info
)->dynobj
;
4929 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4930 BFD_ASSERT (s
!= NULL
);
4932 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4933 if (s
->contents
== NULL
)
4934 newcontents
= (bfd_byte
*) malloc (newsize
);
4936 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4937 if (newcontents
== NULL
)
4939 bfd_set_error (bfd_error_no_memory
);
4944 dyn
.d_un
.d_val
= val
;
4945 elf_swap_dyn_out (dynobj
, &dyn
,
4946 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4948 s
->_raw_size
= newsize
;
4949 s
->contents
= newcontents
;
4954 /* Read and swap the relocs for a section. They may have been cached.
4955 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4956 they are used as buffers to read into. They are known to be large
4957 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4958 value is allocated using either malloc or bfd_alloc, according to
4959 the KEEP_MEMORY argument. */
4961 static Elf_Internal_Rela
*
4962 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4965 PTR external_relocs
;
4966 Elf_Internal_Rela
*internal_relocs
;
4967 boolean keep_memory
;
4969 Elf_Internal_Shdr
*rel_hdr
;
4971 Elf_Internal_Rela
*alloc2
= NULL
;
4973 if (elf_section_data (o
)->relocs
!= NULL
)
4974 return elf_section_data (o
)->relocs
;
4976 if (o
->reloc_count
== 0)
4979 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4981 if (internal_relocs
== NULL
)
4985 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4987 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4989 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4990 if (internal_relocs
== NULL
)
4992 bfd_set_error (bfd_error_no_memory
);
4997 if (external_relocs
== NULL
)
4999 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
5002 bfd_set_error (bfd_error_no_memory
);
5005 external_relocs
= alloc1
;
5008 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
5009 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
5010 != rel_hdr
->sh_size
))
5013 /* Swap in the relocs. For convenience, we always produce an
5014 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
5016 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5018 Elf_External_Rel
*erel
;
5019 Elf_External_Rel
*erelend
;
5020 Elf_Internal_Rela
*irela
;
5022 erel
= (Elf_External_Rel
*) external_relocs
;
5023 erelend
= erel
+ o
->reloc_count
;
5024 irela
= internal_relocs
;
5025 for (; erel
< erelend
; erel
++, irela
++)
5027 Elf_Internal_Rel irel
;
5029 elf_swap_reloc_in (abfd
, erel
, &irel
);
5030 irela
->r_offset
= irel
.r_offset
;
5031 irela
->r_info
= irel
.r_info
;
5032 irela
->r_addend
= 0;
5037 Elf_External_Rela
*erela
;
5038 Elf_External_Rela
*erelaend
;
5039 Elf_Internal_Rela
*irela
;
5041 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
5043 erela
= (Elf_External_Rela
*) external_relocs
;
5044 erelaend
= erela
+ o
->reloc_count
;
5045 irela
= internal_relocs
;
5046 for (; erela
< erelaend
; erela
++, irela
++)
5047 elf_swap_reloca_in (abfd
, erela
, irela
);
5050 /* Cache the results for next time, if we can. */
5052 elf_section_data (o
)->relocs
= internal_relocs
;
5057 /* Don't free alloc2, since if it was allocated we are passing it
5058 back (under the name of internal_relocs). */
5060 return internal_relocs
;
5070 /* Record an assignment to a symbol made by a linker script. We need
5071 this in case some dynamic object refers to this symbol. */
5075 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
5077 struct bfd_link_info
*info
;
5080 struct elf_link_hash_entry
*h
;
5082 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5085 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
5089 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5090 h
->type
= STT_OBJECT
;
5092 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
5093 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
5095 && h
->dynindx
== -1)
5097 if (! elf_link_record_dynamic_symbol (info
, h
))
5100 /* If this is a weak defined symbol, and we know a corresponding
5101 real symbol from the same dynamic object, make sure the real
5102 symbol is also made into a dynamic symbol. */
5103 if (h
->weakdef
!= NULL
5104 && h
->weakdef
->dynindx
== -1)
5106 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
5114 /* Array used to determine the number of hash table buckets to use
5115 based on the number of symbols there are. If there are fewer than
5116 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5117 fewer than 37 we use 17 buckets, and so forth. We never use more
5118 than 521 buckets. */
5120 static const size_t elf_buckets
[] =
5122 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
5125 /* Set up the sizes and contents of the ELF dynamic sections. This is
5126 called by the ELF linker emulation before_allocation routine. We
5127 must set the sizes of the sections before the linker sets the
5128 addresses of the various sections. */
5131 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
5132 export_dynamic
, info
, sinterpptr
)
5136 boolean export_dynamic
;
5137 struct bfd_link_info
*info
;
5138 asection
**sinterpptr
;
5141 struct elf_backend_data
*bed
;
5145 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5148 dynobj
= elf_hash_table (info
)->dynobj
;
5150 /* If there were no dynamic objects in the link, there is nothing to
5155 /* If we are supposed to export all symbols into the dynamic symbol
5156 table (this is not the normal case), then do so. */
5159 struct elf_info_failed eif
;
5163 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5169 if (elf_hash_table (info
)->dynamic_sections_created
)
5171 struct elf_info_failed eif
;
5172 bfd_size_type strsize
;
5174 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5175 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5181 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5183 if (indx
== (bfd_size_type
) -1
5184 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5192 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5194 if (indx
== (bfd_size_type
) -1
5195 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5199 /* Find all symbols which were defined in a dynamic object and make
5200 the backend pick a reasonable value for them. */
5203 elf_link_hash_traverse (elf_hash_table (info
),
5204 elf_adjust_dynamic_symbol
,
5209 /* Add some entries to the .dynamic section. We fill in some of the
5210 values later, in elf_bfd_final_link, but we must add the entries
5211 now so that we know the final size of the .dynamic section. */
5212 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5213 false, false) != NULL
)
5215 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5218 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5219 false, false) != NULL
)
5221 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5224 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5225 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5226 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5227 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5228 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5229 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5230 sizeof (Elf_External_Sym
)))
5234 /* The backend must work out the sizes of all the other dynamic
5236 bed
= get_elf_backend_data (output_bfd
);
5237 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5240 if (elf_hash_table (info
)->dynamic_sections_created
)
5246 Elf_Internal_Sym isym
;
5248 /* Set the size of the .dynsym and .hash sections. We counted
5249 the number of dynamic symbols in elf_link_add_object_symbols.
5250 We will build the contents of .dynsym and .hash when we build
5251 the final symbol table, because until then we do not know the
5252 correct value to give the symbols. We built the .dynstr
5253 section as we went along in elf_link_add_object_symbols. */
5254 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5255 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5256 BFD_ASSERT (s
!= NULL
);
5257 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5258 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5259 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5261 bfd_set_error (bfd_error_no_memory
);
5265 /* The first entry in .dynsym is a dummy symbol. */
5272 elf_swap_symbol_out (output_bfd
, &isym
,
5273 (Elf_External_Sym
*) s
->contents
);
5275 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5277 bucketcount
= elf_buckets
[i
];
5278 if (dynsymcount
< elf_buckets
[i
+ 1])
5282 s
= bfd_get_section_by_name (dynobj
, ".hash");
5283 BFD_ASSERT (s
!= NULL
);
5284 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5285 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5286 if (s
->contents
== NULL
)
5288 bfd_set_error (bfd_error_no_memory
);
5291 memset (s
->contents
, 0, s
->_raw_size
);
5293 put_word (output_bfd
, bucketcount
, s
->contents
);
5294 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5296 elf_hash_table (info
)->bucketcount
= bucketcount
;
5298 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5299 BFD_ASSERT (s
!= NULL
);
5300 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5302 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5309 /* This routine is used to export all defined symbols into the dynamic
5310 symbol table. It is called via elf_link_hash_traverse. */
5313 elf_export_symbol (h
, data
)
5314 struct elf_link_hash_entry
*h
;
5317 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
5319 if (h
->dynindx
== -1
5320 && (h
->elf_link_hash_flags
5321 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5323 if (! elf_link_record_dynamic_symbol (eif
->info
, h
))
5333 /* Make the backend pick a good value for a dynamic symbol. This is
5334 called via elf_link_hash_traverse, and also calls itself
5338 elf_adjust_dynamic_symbol (h
, data
)
5339 struct elf_link_hash_entry
*h
;
5342 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
5344 struct elf_backend_data
*bed
;
5346 /* If this symbol does not require a PLT entry, and it is not
5347 defined by a dynamic object, or is not referenced by a regular
5348 object, ignore it. FIXME: Do we need to worry about symbols
5349 which are defined by one dynamic object and referenced by another
5351 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5352 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5353 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5354 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5357 /* If we've already adjusted this symbol, don't do it again. This
5358 can happen via a recursive call. */
5359 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5362 /* Don't look at this symbol again. Note that we must set this
5363 after checking the above conditions, because we may look at a
5364 symbol once, decide not to do anything, and then get called
5365 recursively later after REF_REGULAR is set below. */
5366 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5368 /* If this is a weak definition, and we know a real definition, and
5369 the real symbol is not itself defined by a regular object file,
5370 then get a good value for the real definition. We handle the
5371 real symbol first, for the convenience of the backend routine.
5373 Note that there is a confusing case here. If the real definition
5374 is defined by a regular object file, we don't get the real symbol
5375 from the dynamic object, but we do get the weak symbol. If the
5376 processor backend uses a COPY reloc, then if some routine in the
5377 dynamic object changes the real symbol, we will not see that
5378 change in the corresponding weak symbol. This is the way other
5379 ELF linkers work as well, and seems to be a result of the shared
5382 I will clarify this issue. Most SVR4 shared libraries define the
5383 variable _timezone and define timezone as a weak synonym. The
5384 tzset call changes _timezone. If you write
5385 extern int timezone;
5387 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5388 you might expect that, since timezone is a synonym for _timezone,
5389 the same number will print both times. However, if the processor
5390 backend uses a COPY reloc, then actually timezone will be copied
5391 into your process image, and, since you define _timezone
5392 yourself, _timezone will not. Thus timezone and _timezone will
5393 wind up at different memory locations. The tzset call will set
5394 _timezone, leaving timezone unchanged. */
5396 if (h
->weakdef
!= NULL
)
5398 struct elf_link_hash_entry
*weakdef
;
5400 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5401 || h
->root
.type
== bfd_link_hash_defweak
);
5402 weakdef
= h
->weakdef
;
5403 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5404 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5405 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5406 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5408 /* This symbol is defined by a regular object file, so we
5409 will not do anything special. Clear weakdef for the
5410 convenience of the processor backend. */
5415 /* There is an implicit reference by a regular object file
5416 via the weak symbol. */
5417 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5418 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
5423 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
5424 bed
= get_elf_backend_data (dynobj
);
5425 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
5434 /* Final phase of ELF linker. */
5436 /* A structure we use to avoid passing large numbers of arguments. */
5438 struct elf_final_link_info
5440 /* General link information. */
5441 struct bfd_link_info
*info
;
5444 /* Symbol string table. */
5445 struct bfd_strtab_hash
*symstrtab
;
5446 /* .dynsym section. */
5447 asection
*dynsym_sec
;
5448 /* .hash section. */
5450 /* Buffer large enough to hold contents of any section. */
5452 /* Buffer large enough to hold external relocs of any section. */
5453 PTR external_relocs
;
5454 /* Buffer large enough to hold internal relocs of any section. */
5455 Elf_Internal_Rela
*internal_relocs
;
5456 /* Buffer large enough to hold external local symbols of any input
5458 Elf_External_Sym
*external_syms
;
5459 /* Buffer large enough to hold internal local symbols of any input
5461 Elf_Internal_Sym
*internal_syms
;
5462 /* Array large enough to hold a symbol index for each local symbol
5463 of any input BFD. */
5465 /* Array large enough to hold a section pointer for each local
5466 symbol of any input BFD. */
5467 asection
**sections
;
5468 /* Buffer to hold swapped out symbols. */
5469 Elf_External_Sym
*symbuf
;
5470 /* Number of swapped out symbols in buffer. */
5471 size_t symbuf_count
;
5472 /* Number of symbols which fit in symbuf. */
5476 static boolean elf_link_output_sym
5477 PARAMS ((struct elf_final_link_info
*, const char *,
5478 Elf_Internal_Sym
*, asection
*));
5479 static boolean elf_link_flush_output_syms
5480 PARAMS ((struct elf_final_link_info
*));
5481 static boolean elf_link_output_extsym
5482 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5483 static boolean elf_link_input_bfd
5484 PARAMS ((struct elf_final_link_info
*, bfd
*));
5485 static boolean elf_reloc_link_order
5486 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5487 struct bfd_link_order
*));
5489 /* This struct is used to pass information to routines called via
5490 elf_link_hash_traverse which must return failure. */
5492 struct elf_finfo_failed
5495 struct elf_final_link_info
*finfo
;
5498 /* Do the final step of an ELF link. */
5501 elf_bfd_final_link (abfd
, info
)
5503 struct bfd_link_info
*info
;
5507 struct elf_final_link_info finfo
;
5508 register asection
*o
;
5509 register struct bfd_link_order
*p
;
5511 size_t max_contents_size
;
5512 size_t max_external_reloc_size
;
5513 size_t max_internal_reloc_count
;
5514 size_t max_sym_count
;
5516 Elf_Internal_Sym elfsym
;
5518 Elf_Internal_Shdr
*symtab_hdr
;
5519 Elf_Internal_Shdr
*symstrtab_hdr
;
5520 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5521 struct elf_finfo_failed eif
;
5524 abfd
->flags
|= DYNAMIC
;
5526 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5527 dynobj
= elf_hash_table (info
)->dynobj
;
5530 finfo
.output_bfd
= abfd
;
5531 finfo
.symstrtab
= elf_stringtab_init ();
5532 if (finfo
.symstrtab
== NULL
)
5536 finfo
.dynsym_sec
= NULL
;
5537 finfo
.hash_sec
= NULL
;
5541 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5542 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5543 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
5545 finfo
.contents
= NULL
;
5546 finfo
.external_relocs
= NULL
;
5547 finfo
.internal_relocs
= NULL
;
5548 finfo
.external_syms
= NULL
;
5549 finfo
.internal_syms
= NULL
;
5550 finfo
.indices
= NULL
;
5551 finfo
.sections
= NULL
;
5552 finfo
.symbuf
= NULL
;
5553 finfo
.symbuf_count
= 0;
5555 /* Count up the number of relocations we will output for each output
5556 section, so that we know the sizes of the reloc sections. We
5557 also figure out some maximum sizes. */
5558 max_contents_size
= 0;
5559 max_external_reloc_size
= 0;
5560 max_internal_reloc_count
= 0;
5562 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5566 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5568 if (p
->type
== bfd_section_reloc_link_order
5569 || p
->type
== bfd_symbol_reloc_link_order
)
5571 else if (p
->type
== bfd_indirect_link_order
)
5575 sec
= p
->u
.indirect
.section
;
5577 if (info
->relocateable
)
5578 o
->reloc_count
+= sec
->reloc_count
;
5580 if (sec
->_raw_size
> max_contents_size
)
5581 max_contents_size
= sec
->_raw_size
;
5582 if (sec
->_cooked_size
> max_contents_size
)
5583 max_contents_size
= sec
->_cooked_size
;
5585 /* We are interested in just local symbols, not all
5587 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5591 if (elf_bad_symtab (sec
->owner
))
5592 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5593 / sizeof (Elf_External_Sym
));
5595 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5597 if (sym_count
> max_sym_count
)
5598 max_sym_count
= sym_count
;
5600 if ((sec
->flags
& SEC_RELOC
) != 0)
5604 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5605 if (ext_size
> max_external_reloc_size
)
5606 max_external_reloc_size
= ext_size
;
5607 if (sec
->reloc_count
> max_internal_reloc_count
)
5608 max_internal_reloc_count
= sec
->reloc_count
;
5614 if (o
->reloc_count
> 0)
5615 o
->flags
|= SEC_RELOC
;
5618 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5619 set it (this is probably a bug) and if it is set
5620 assign_section_numbers will create a reloc section. */
5621 o
->flags
&=~ SEC_RELOC
;
5624 /* If the SEC_ALLOC flag is not set, force the section VMA to
5625 zero. This is done in elf_fake_sections as well, but forcing
5626 the VMA to 0 here will ensure that relocs against these
5627 sections are handled correctly. */
5628 if ((o
->flags
& SEC_ALLOC
) == 0)
5632 /* Figure out the file positions for everything but the symbol table
5633 and the relocs. We set symcount to force assign_section_numbers
5634 to create a symbol table. */
5635 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5636 BFD_ASSERT (! abfd
->output_has_begun
);
5637 if (! elf_compute_section_file_positions (abfd
, info
))
5640 /* That created the reloc sections. Set their sizes, and assign
5641 them file positions, and allocate some buffers. */
5642 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5644 if ((o
->flags
& SEC_RELOC
) != 0)
5646 Elf_Internal_Shdr
*rel_hdr
;
5647 register struct elf_link_hash_entry
**p
, **pend
;
5649 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5651 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5653 /* The contents field must last into write_object_contents,
5654 so we allocate it with bfd_alloc rather than malloc. */
5655 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5656 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5658 bfd_set_error (bfd_error_no_memory
);
5662 p
= ((struct elf_link_hash_entry
**)
5663 malloc (o
->reloc_count
5664 * sizeof (struct elf_link_hash_entry
*)));
5665 if (p
== NULL
&& o
->reloc_count
!= 0)
5667 bfd_set_error (bfd_error_no_memory
);
5670 elf_section_data (o
)->rel_hashes
= p
;
5671 pend
= p
+ o
->reloc_count
;
5672 for (; p
< pend
; p
++)
5675 /* Use the reloc_count field as an index when outputting the
5681 assign_file_positions_for_relocs (abfd
);
5683 /* We have now assigned file positions for all the sections except
5684 .symtab and .strtab. We start the .symtab section at the current
5685 file position, and write directly to it. We build the .strtab
5686 section in memory. When we add .dynsym support, we will build
5687 that in memory as well (.dynsym is smaller than .symtab). */
5689 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5690 /* sh_name is set in prep_headers. */
5691 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5692 symtab_hdr
->sh_flags
= 0;
5693 symtab_hdr
->sh_addr
= 0;
5694 symtab_hdr
->sh_size
= 0;
5695 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5696 /* sh_link is set in assign_section_numbers. */
5697 /* sh_info is set below. */
5698 /* sh_offset is set just below. */
5699 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5701 off
= elf_tdata (abfd
)->next_file_pos
;
5702 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5704 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5705 incorrect. We do not yet know the size of the .symtab section.
5706 We correct next_file_pos below, after we do know the size. */
5708 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5709 continuously seeking to the right position in the file. */
5710 if (! info
->keep_memory
|| max_sym_count
< 20)
5711 finfo
.symbuf_size
= 20;
5713 finfo
.symbuf_size
= max_sym_count
;
5714 finfo
.symbuf
= ((Elf_External_Sym
*)
5715 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5716 if (finfo
.symbuf
== NULL
)
5718 bfd_set_error (bfd_error_no_memory
);
5722 /* Start writing out the symbol table. The first symbol is always a
5724 elfsym
.st_value
= 0;
5727 elfsym
.st_other
= 0;
5728 elfsym
.st_shndx
= SHN_UNDEF
;
5729 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5730 &elfsym
, bfd_und_section_ptr
))
5734 /* Some standard ELF linkers do this, but we don't because it causes
5735 bootstrap comparison failures. */
5736 /* Output a file symbol for the output file as the second symbol.
5737 We output this even if we are discarding local symbols, although
5738 I'm not sure if this is correct. */
5739 elfsym
.st_value
= 0;
5741 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5742 elfsym
.st_other
= 0;
5743 elfsym
.st_shndx
= SHN_ABS
;
5744 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5745 &elfsym
, bfd_abs_section_ptr
))
5749 /* Output a symbol for each section. We output these even if we are
5750 discarding local symbols, since they are used for relocs. These
5751 symbols have no names. We store the index of each one in the
5752 index field of the section, so that we can find it again when
5753 outputting relocs. */
5754 elfsym
.st_value
= 0;
5756 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5757 elfsym
.st_other
= 0;
5758 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5760 o
= section_from_elf_index (abfd
, i
);
5762 o
->target_index
= abfd
->symcount
;
5763 elfsym
.st_shndx
= i
;
5764 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5769 /* Allocate some memory to hold information read in from the input
5771 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5772 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5773 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5774 malloc (max_internal_reloc_count
5775 * sizeof (Elf_Internal_Rela
)));
5776 finfo
.external_syms
= ((Elf_External_Sym
*)
5777 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5778 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5779 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5780 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5781 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5782 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5783 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5784 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5785 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5786 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5787 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5788 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5790 bfd_set_error (bfd_error_no_memory
);
5794 /* Since ELF permits relocations to be against local symbols, we
5795 must have the local symbols available when we do the relocations.
5796 Since we would rather only read the local symbols once, and we
5797 would rather not keep them in memory, we handle all the
5798 relocations for a single input file at the same time.
5800 Unfortunately, there is no way to know the total number of local
5801 symbols until we have seen all of them, and the local symbol
5802 indices precede the global symbol indices. This means that when
5803 we are generating relocateable output, and we see a reloc against
5804 a global symbol, we can not know the symbol index until we have
5805 finished examining all the local symbols to see which ones we are
5806 going to output. To deal with this, we keep the relocations in
5807 memory, and don't output them until the end of the link. This is
5808 an unfortunate waste of memory, but I don't see a good way around
5809 it. Fortunately, it only happens when performing a relocateable
5810 link, which is not the common case. FIXME: If keep_memory is set
5811 we could write the relocs out and then read them again; I don't
5812 know how bad the memory loss will be. */
5814 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5815 sub
->output_has_begun
= false;
5816 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5818 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5820 if (p
->type
== bfd_indirect_link_order
5821 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5822 == bfd_target_elf_flavour
))
5824 sub
= p
->u
.indirect
.section
->owner
;
5825 if (! sub
->output_has_begun
)
5827 if (! elf_link_input_bfd (&finfo
, sub
))
5829 sub
->output_has_begun
= true;
5832 else if (p
->type
== bfd_section_reloc_link_order
5833 || p
->type
== bfd_symbol_reloc_link_order
)
5835 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5840 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5846 /* That wrote out all the local symbols. Finish up the symbol table
5847 with the global symbols. */
5849 /* The sh_info field records the index of the first non local
5851 symtab_hdr
->sh_info
= abfd
->symcount
;
5853 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5855 /* We get the global symbols from the hash table. */
5858 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5863 /* Flush all symbols to the file. */
5864 if (! elf_link_flush_output_syms (&finfo
))
5867 /* Now we know the size of the symtab section. */
5868 off
+= symtab_hdr
->sh_size
;
5870 /* Finish up and write out the symbol string table (.strtab)
5872 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5873 /* sh_name was set in prep_headers. */
5874 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5875 symstrtab_hdr
->sh_flags
= 0;
5876 symstrtab_hdr
->sh_addr
= 0;
5877 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5878 symstrtab_hdr
->sh_entsize
= 0;
5879 symstrtab_hdr
->sh_link
= 0;
5880 symstrtab_hdr
->sh_info
= 0;
5881 /* sh_offset is set just below. */
5882 symstrtab_hdr
->sh_addralign
= 1;
5884 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5885 elf_tdata (abfd
)->next_file_pos
= off
;
5887 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5888 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5891 /* Adjust the relocs to have the correct symbol indices. */
5892 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5894 struct elf_link_hash_entry
**rel_hash
;
5895 Elf_Internal_Shdr
*rel_hdr
;
5897 if ((o
->flags
& SEC_RELOC
) == 0)
5900 rel_hash
= elf_section_data (o
)->rel_hashes
;
5901 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5902 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5904 if (*rel_hash
== NULL
)
5907 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5909 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5911 Elf_External_Rel
*erel
;
5912 Elf_Internal_Rel irel
;
5914 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5915 elf_swap_reloc_in (abfd
, erel
, &irel
);
5916 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5917 ELF_R_TYPE (irel
.r_info
));
5918 elf_swap_reloc_out (abfd
, &irel
, erel
);
5922 Elf_External_Rela
*erela
;
5923 Elf_Internal_Rela irela
;
5925 BFD_ASSERT (rel_hdr
->sh_entsize
5926 == sizeof (Elf_External_Rela
));
5928 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5929 elf_swap_reloca_in (abfd
, erela
, &irela
);
5930 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5931 ELF_R_TYPE (irela
.r_info
));
5932 elf_swap_reloca_out (abfd
, &irela
, erela
);
5936 /* Set the reloc_count field to 0 to prevent write_relocs from
5937 trying to swap the relocs out itself. */
5941 /* If we are linking against a dynamic object, or generating a
5942 shared library, finish up the dynamic linking information. */
5945 Elf_External_Dyn
*dyncon
, *dynconend
;
5947 /* Fix up .dynamic entries. */
5948 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5949 BFD_ASSERT (o
!= NULL
);
5951 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5952 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5953 for (; dyncon
< dynconend
; dyncon
++)
5955 Elf_Internal_Dyn dyn
;
5959 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5966 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5967 magic _init and _fini symbols. This is pretty ugly,
5968 but we are compatible. */
5976 struct elf_link_hash_entry
*h
;
5978 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5979 false, false, true);
5980 BFD_ASSERT (h
!= NULL
);
5981 if (h
->root
.type
== bfd_link_hash_defined
5982 || h
->root
.type
== bfd_link_hash_defweak
)
5984 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5985 o
= h
->root
.u
.def
.section
;
5986 if (o
->output_section
!= NULL
)
5987 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5988 + o
->output_offset
);
5990 /* The symbol is imported from another shared
5991 library and does not apply to this one. */
5994 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6007 o
= bfd_get_section_by_name (abfd
, name
);
6008 BFD_ASSERT (o
!= NULL
);
6009 dyn
.d_un
.d_ptr
= o
->vma
;
6010 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6017 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
6022 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
6024 Elf_Internal_Shdr
*hdr
;
6026 hdr
= elf_elfsections (abfd
)[i
];
6027 if (hdr
->sh_type
== type
6028 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
6030 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
6031 dyn
.d_un
.d_val
+= hdr
->sh_size
;
6034 if (dyn
.d_un
.d_val
== 0
6035 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
6036 dyn
.d_un
.d_val
= hdr
->sh_addr
;
6040 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6046 /* If we have created any dynamic sections, then output them. */
6049 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
6052 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
6054 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
6055 || o
->_raw_size
== 0)
6057 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
6059 /* At this point, we are only interested in sections
6060 created by elf_link_create_dynamic_sections. FIXME:
6061 This test is fragile. */
6064 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
6066 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
6068 if (! bfd_set_section_contents (abfd
, o
->output_section
,
6069 o
->contents
, o
->output_offset
,
6077 /* The contents of the .dynstr section are actually in a
6079 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
6080 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
6081 || ! _bfd_stringtab_emit (abfd
,
6082 elf_hash_table (info
)->dynstr
))
6088 if (finfo
.symstrtab
!= NULL
)
6089 _bfd_stringtab_free (finfo
.symstrtab
);
6090 if (finfo
.contents
!= NULL
)
6091 free (finfo
.contents
);
6092 if (finfo
.external_relocs
!= NULL
)
6093 free (finfo
.external_relocs
);
6094 if (finfo
.internal_relocs
!= NULL
)
6095 free (finfo
.internal_relocs
);
6096 if (finfo
.external_syms
!= NULL
)
6097 free (finfo
.external_syms
);
6098 if (finfo
.internal_syms
!= NULL
)
6099 free (finfo
.internal_syms
);
6100 if (finfo
.indices
!= NULL
)
6101 free (finfo
.indices
);
6102 if (finfo
.sections
!= NULL
)
6103 free (finfo
.sections
);
6104 if (finfo
.symbuf
!= NULL
)
6105 free (finfo
.symbuf
);
6106 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6108 if ((o
->flags
& SEC_RELOC
) != 0
6109 && elf_section_data (o
)->rel_hashes
!= NULL
)
6110 free (elf_section_data (o
)->rel_hashes
);
6113 elf_tdata (abfd
)->linker
= true;
6118 if (finfo
.symstrtab
!= NULL
)
6119 _bfd_stringtab_free (finfo
.symstrtab
);
6120 if (finfo
.contents
!= NULL
)
6121 free (finfo
.contents
);
6122 if (finfo
.external_relocs
!= NULL
)
6123 free (finfo
.external_relocs
);
6124 if (finfo
.internal_relocs
!= NULL
)
6125 free (finfo
.internal_relocs
);
6126 if (finfo
.external_syms
!= NULL
)
6127 free (finfo
.external_syms
);
6128 if (finfo
.internal_syms
!= NULL
)
6129 free (finfo
.internal_syms
);
6130 if (finfo
.indices
!= NULL
)
6131 free (finfo
.indices
);
6132 if (finfo
.sections
!= NULL
)
6133 free (finfo
.sections
);
6134 if (finfo
.symbuf
!= NULL
)
6135 free (finfo
.symbuf
);
6136 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6138 if ((o
->flags
& SEC_RELOC
) != 0
6139 && elf_section_data (o
)->rel_hashes
!= NULL
)
6140 free (elf_section_data (o
)->rel_hashes
);
6146 /* Add a symbol to the output symbol table. */
6149 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
6150 struct elf_final_link_info
*finfo
;
6152 Elf_Internal_Sym
*elfsym
;
6153 asection
*input_sec
;
6155 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
6156 struct bfd_link_info
*info
,
6161 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
6162 elf_backend_link_output_symbol_hook
;
6163 if (output_symbol_hook
!= NULL
)
6165 if (! ((*output_symbol_hook
)
6166 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
6170 if (name
== (const char *) NULL
|| *name
== '\0')
6171 elfsym
->st_name
= 0;
6174 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6177 if (elfsym
->st_name
== (unsigned long) -1)
6181 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6183 if (! elf_link_flush_output_syms (finfo
))
6187 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6188 finfo
->symbuf
+ finfo
->symbuf_count
);
6189 ++finfo
->symbuf_count
;
6191 ++finfo
->output_bfd
->symcount
;
6196 /* Flush the output symbols to the file. */
6199 elf_link_flush_output_syms (finfo
)
6200 struct elf_final_link_info
*finfo
;
6202 Elf_Internal_Shdr
*symtab
;
6204 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6206 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6208 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6209 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6210 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6213 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6215 finfo
->symbuf_count
= 0;
6220 /* Add an external symbol to the symbol table. This is called from
6221 the hash table traversal routine. */
6224 elf_link_output_extsym (h
, data
)
6225 struct elf_link_hash_entry
*h
;
6228 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
6229 struct elf_final_link_info
*finfo
= eif
->finfo
;
6231 Elf_Internal_Sym sym
;
6232 asection
*input_sec
;
6234 /* If we are not creating a shared library, and this symbol is
6235 referenced by a shared library but is not defined anywhere, then
6236 warn that it is undefined. If we do not do this, the runtime
6237 linker will complain that the symbol is undefined when the
6238 program is run. We don't have to worry about symbols that are
6239 referenced by regular files, because we will already have issued
6242 FIXME: If we are linking against an object which uses DT_NEEDED,
6243 we don't give this warning, because it might be the case that the
6244 needed dynamic object will define the symbols. Unfortunately,
6245 this makes this type of check much less useful, but the only way
6246 to fix it would be to locate the needed object and read its
6247 symbol table. That seems like a real waste of time just to give
6248 better error messages. */
6249 if (! finfo
->info
->relocateable
6250 && ! finfo
->info
->shared
6251 && ! elf_hash_table (finfo
->info
)->saw_needed
6252 && h
->root
.type
== bfd_link_hash_undefined
6253 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6254 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6256 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6257 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6258 (asection
*) NULL
, 0)))
6265 /* We don't want to output symbols that have never been mentioned by
6266 a regular file, or that we have been told to strip. However, if
6267 h->indx is set to -2, the symbol is used by a reloc and we must
6271 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6272 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6273 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6274 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6276 else if (finfo
->info
->strip
== strip_all
6277 || (finfo
->info
->strip
== strip_some
6278 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6279 h
->root
.root
.string
,
6280 false, false) == NULL
))
6285 /* If we're stripping it, and it's not a dynamic symbol, there's
6286 nothing else to do. */
6287 if (strip
&& h
->dynindx
== -1)
6291 sym
.st_size
= h
->size
;
6293 if (h
->root
.type
== bfd_link_hash_undefweak
6294 || h
->root
.type
== bfd_link_hash_defweak
)
6295 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6297 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6299 switch (h
->root
.type
)
6302 case bfd_link_hash_new
:
6306 case bfd_link_hash_undefined
:
6307 input_sec
= bfd_und_section_ptr
;
6308 sym
.st_shndx
= SHN_UNDEF
;
6311 case bfd_link_hash_undefweak
:
6312 input_sec
= bfd_und_section_ptr
;
6313 sym
.st_shndx
= SHN_UNDEF
;
6316 case bfd_link_hash_defined
:
6317 case bfd_link_hash_defweak
:
6319 input_sec
= h
->root
.u
.def
.section
;
6320 if (input_sec
->output_section
!= NULL
)
6323 elf_section_from_bfd_section (finfo
->output_bfd
,
6324 input_sec
->output_section
);
6325 if (sym
.st_shndx
== (unsigned short) -1)
6331 /* ELF symbols in relocateable files are section relative,
6332 but in nonrelocateable files they are virtual
6334 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6335 if (! finfo
->info
->relocateable
)
6336 sym
.st_value
+= input_sec
->output_section
->vma
;
6340 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6341 == bfd_target_elf_flavour
)
6342 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6343 sym
.st_shndx
= SHN_UNDEF
;
6344 input_sec
= bfd_und_section_ptr
;
6349 case bfd_link_hash_common
:
6350 input_sec
= bfd_com_section_ptr
;
6351 sym
.st_shndx
= SHN_COMMON
;
6352 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
6355 case bfd_link_hash_indirect
:
6356 case bfd_link_hash_warning
:
6357 /* I have no idea how these should be handled. */
6361 /* If this symbol should be put in the .dynsym section, then put it
6362 there now. We have already know the symbol index. We also fill
6363 in the entry in the .hash section. */
6364 if (h
->dynindx
!= -1
6365 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6367 struct elf_backend_data
*bed
;
6370 bfd_byte
*bucketpos
;
6373 sym
.st_name
= h
->dynstr_index
;
6375 /* Give the processor backend a chance to tweak the symbol
6376 value, and also to finish up anything that needs to be done
6378 bed
= get_elf_backend_data (finfo
->output_bfd
);
6379 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6380 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6386 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6387 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6390 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6391 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6393 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6394 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6395 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6396 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6397 put_word (finfo
->output_bfd
, chain
,
6398 ((bfd_byte
*) finfo
->hash_sec
->contents
6399 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6402 /* If we're stripping it, then it was just a dynamic symbol, and
6403 there's nothing else to do. */
6407 h
->indx
= finfo
->output_bfd
->symcount
;
6409 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6418 /* Link an input file into the linker output file. This function
6419 handles all the sections and relocations of the input file at once.
6420 This is so that we only have to read the local symbols once, and
6421 don't have to keep them in memory. */
6424 elf_link_input_bfd (finfo
, input_bfd
)
6425 struct elf_final_link_info
*finfo
;
6428 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6429 bfd
*, asection
*, bfd_byte
*,
6430 Elf_Internal_Rela
*,
6431 Elf_Internal_Sym
*, asection
**));
6433 Elf_Internal_Shdr
*symtab_hdr
;
6436 Elf_External_Sym
*esym
;
6437 Elf_External_Sym
*esymend
;
6438 Elf_Internal_Sym
*isym
;
6440 asection
**ppsection
;
6443 output_bfd
= finfo
->output_bfd
;
6445 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6447 /* If this is a dynamic object, we don't want to do anything here:
6448 we don't want the local symbols, and we don't want the section
6450 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6453 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6454 if (elf_bad_symtab (input_bfd
))
6456 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6461 locsymcount
= symtab_hdr
->sh_info
;
6462 extsymoff
= symtab_hdr
->sh_info
;
6465 /* Read the local symbols. */
6467 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6468 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6469 locsymcount
, input_bfd
)
6470 != locsymcount
* sizeof (Elf_External_Sym
))))
6473 /* Swap in the local symbols and write out the ones which we know
6474 are going into the output file. */
6475 esym
= finfo
->external_syms
;
6476 esymend
= esym
+ locsymcount
;
6477 isym
= finfo
->internal_syms
;
6478 pindex
= finfo
->indices
;
6479 ppsection
= finfo
->sections
;
6480 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6484 Elf_Internal_Sym osym
;
6486 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6489 if (elf_bad_symtab (input_bfd
))
6491 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6498 if (isym
->st_shndx
== SHN_UNDEF
)
6499 isec
= bfd_und_section_ptr
;
6500 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6501 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6502 else if (isym
->st_shndx
== SHN_ABS
)
6503 isec
= bfd_abs_section_ptr
;
6504 else if (isym
->st_shndx
== SHN_COMMON
)
6505 isec
= bfd_com_section_ptr
;
6514 /* Don't output the first, undefined, symbol. */
6515 if (esym
== finfo
->external_syms
)
6518 /* If we are stripping all symbols, we don't want to output this
6520 if (finfo
->info
->strip
== strip_all
)
6523 /* We never output section symbols. Instead, we use the section
6524 symbol of the corresponding section in the output file. */
6525 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6528 /* If we are discarding all local symbols, we don't want to
6529 output this one. If we are generating a relocateable output
6530 file, then some of the local symbols may be required by
6531 relocs; we output them below as we discover that they are
6533 if (finfo
->info
->discard
== discard_all
)
6536 /* Get the name of the symbol. */
6537 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6542 /* See if we are discarding symbols with this name. */
6543 if ((finfo
->info
->strip
== strip_some
6544 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6546 || (finfo
->info
->discard
== discard_l
6547 && strncmp (name
, finfo
->info
->lprefix
,
6548 finfo
->info
->lprefix_len
) == 0))
6551 /* If we get here, we are going to output this symbol. */
6555 /* Adjust the section index for the output file. */
6556 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6557 isec
->output_section
);
6558 if (osym
.st_shndx
== (unsigned short) -1)
6561 *pindex
= output_bfd
->symcount
;
6563 /* ELF symbols in relocateable files are section relative, but
6564 in executable files they are virtual addresses. Note that
6565 this code assumes that all ELF sections have an associated
6566 BFD section with a reasonable value for output_offset; below
6567 we assume that they also have a reasonable value for
6568 output_section. Any special sections must be set up to meet
6569 these requirements. */
6570 osym
.st_value
+= isec
->output_offset
;
6571 if (! finfo
->info
->relocateable
)
6572 osym
.st_value
+= isec
->output_section
->vma
;
6574 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6578 /* Relocate the contents of each section. */
6579 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6581 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6584 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6585 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6587 /* Section was created by elf_link_create_dynamic_sections.
6588 FIXME: This test is fragile. */
6592 /* Read the contents of the section. */
6593 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6594 (file_ptr
) 0, o
->_raw_size
))
6597 if ((o
->flags
& SEC_RELOC
) != 0)
6599 Elf_Internal_Rela
*internal_relocs
;
6601 /* Get the swapped relocs. */
6602 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6603 finfo
->external_relocs
,
6604 finfo
->internal_relocs
,
6606 if (internal_relocs
== NULL
6607 && o
->reloc_count
> 0)
6610 /* Relocate the section by invoking a back end routine.
6612 The back end routine is responsible for adjusting the
6613 section contents as necessary, and (if using Rela relocs
6614 and generating a relocateable output file) adjusting the
6615 reloc addend as necessary.
6617 The back end routine does not have to worry about setting
6618 the reloc address or the reloc symbol index.
6620 The back end routine is given a pointer to the swapped in
6621 internal symbols, and can access the hash table entries
6622 for the external symbols via elf_sym_hashes (input_bfd).
6624 When generating relocateable output, the back end routine
6625 must handle STB_LOCAL/STT_SECTION symbols specially. The
6626 output symbol is going to be a section symbol
6627 corresponding to the output section, which will require
6628 the addend to be adjusted. */
6630 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6634 finfo
->internal_syms
,
6638 if (finfo
->info
->relocateable
)
6640 Elf_Internal_Rela
*irela
;
6641 Elf_Internal_Rela
*irelaend
;
6642 struct elf_link_hash_entry
**rel_hash
;
6643 Elf_Internal_Shdr
*input_rel_hdr
;
6644 Elf_Internal_Shdr
*output_rel_hdr
;
6646 /* Adjust the reloc addresses and symbol indices. */
6648 irela
= internal_relocs
;
6649 irelaend
= irela
+ o
->reloc_count
;
6650 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6651 + o
->output_section
->reloc_count
);
6652 for (; irela
< irelaend
; irela
++, rel_hash
++)
6655 Elf_Internal_Sym
*isym
;
6658 irela
->r_offset
+= o
->output_offset
;
6660 r_symndx
= ELF_R_SYM (irela
->r_info
);
6665 if (r_symndx
>= locsymcount
6666 || (elf_bad_symtab (input_bfd
)
6667 && finfo
->sections
[r_symndx
] == NULL
))
6671 /* This is a reloc against a global symbol. We
6672 have not yet output all the local symbols, so
6673 we do not know the symbol index of any global
6674 symbol. We set the rel_hash entry for this
6675 reloc to point to the global hash table entry
6676 for this symbol. The symbol index is then
6677 set at the end of elf_bfd_final_link. */
6678 indx
= r_symndx
- extsymoff
;
6679 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6681 /* Setting the index to -2 tells
6682 elf_link_output_extsym that this symbol is
6684 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6685 (*rel_hash
)->indx
= -2;
6690 /* This is a reloc against a local symbol. */
6693 isym
= finfo
->internal_syms
+ r_symndx
;
6694 sec
= finfo
->sections
[r_symndx
];
6695 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6697 /* I suppose the backend ought to fill in the
6698 section of any STT_SECTION symbol against a
6699 processor specific section. */
6700 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6702 else if (sec
== NULL
|| sec
->owner
== NULL
)
6704 bfd_set_error (bfd_error_bad_value
);
6709 r_symndx
= sec
->output_section
->target_index
;
6710 BFD_ASSERT (r_symndx
!= 0);
6715 if (finfo
->indices
[r_symndx
] == -1)
6721 if (finfo
->info
->strip
== strip_all
)
6723 /* You can't do ld -r -s. */
6724 bfd_set_error (bfd_error_invalid_operation
);
6728 /* This symbol was skipped earlier, but
6729 since it is needed by a reloc, we
6730 must output it now. */
6731 link
= symtab_hdr
->sh_link
;
6732 name
= elf_string_from_elf_section (input_bfd
,
6738 osec
= sec
->output_section
;
6740 elf_section_from_bfd_section (output_bfd
,
6742 if (isym
->st_shndx
== (unsigned short) -1)
6745 isym
->st_value
+= sec
->output_offset
;
6746 if (! finfo
->info
->relocateable
)
6747 isym
->st_value
+= osec
->vma
;
6749 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6751 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6755 r_symndx
= finfo
->indices
[r_symndx
];
6758 irela
->r_info
= ELF_R_INFO (r_symndx
,
6759 ELF_R_TYPE (irela
->r_info
));
6762 /* Swap out the relocs. */
6763 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6764 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6765 BFD_ASSERT (output_rel_hdr
->sh_entsize
6766 == input_rel_hdr
->sh_entsize
);
6767 irela
= internal_relocs
;
6768 irelaend
= irela
+ o
->reloc_count
;
6769 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6771 Elf_External_Rel
*erel
;
6773 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6774 + o
->output_section
->reloc_count
);
6775 for (; irela
< irelaend
; irela
++, erel
++)
6777 Elf_Internal_Rel irel
;
6779 irel
.r_offset
= irela
->r_offset
;
6780 irel
.r_info
= irela
->r_info
;
6781 BFD_ASSERT (irela
->r_addend
== 0);
6782 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6787 Elf_External_Rela
*erela
;
6789 BFD_ASSERT (input_rel_hdr
->sh_entsize
6790 == sizeof (Elf_External_Rela
));
6791 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6792 + o
->output_section
->reloc_count
);
6793 for (; irela
< irelaend
; irela
++, erela
++)
6794 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6797 o
->output_section
->reloc_count
+= o
->reloc_count
;
6801 /* Write out the modified section contents. */
6802 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6803 finfo
->contents
, o
->output_offset
,
6804 (o
->_cooked_size
!= 0
6813 /* Generate a reloc when linking an ELF file. This is a reloc
6814 requested by the linker, and does come from any input file. This
6815 is used to build constructor and destructor tables when linking
6819 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6821 struct bfd_link_info
*info
;
6822 asection
*output_section
;
6823 struct bfd_link_order
*link_order
;
6825 reloc_howto_type
*howto
;
6828 struct elf_link_hash_entry
**rel_hash_ptr
;
6829 Elf_Internal_Shdr
*rel_hdr
;
6831 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6834 bfd_set_error (bfd_error_bad_value
);
6838 /* If this is an inplace reloc, we must write the addend into the
6840 if (howto
->partial_inplace
6841 && link_order
->u
.reloc
.p
->addend
!= 0)
6844 bfd_reloc_status_type rstat
;
6848 size
= bfd_get_reloc_size (howto
);
6849 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6850 if (buf
== (bfd_byte
*) NULL
)
6852 bfd_set_error (bfd_error_no_memory
);
6855 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6856 link_order
->u
.reloc
.p
->addend
, buf
);
6862 case bfd_reloc_outofrange
:
6864 case bfd_reloc_overflow
:
6865 if (! ((*info
->callbacks
->reloc_overflow
)
6867 (link_order
->type
== bfd_section_reloc_link_order
6868 ? bfd_section_name (output_bfd
,
6869 link_order
->u
.reloc
.p
->u
.section
)
6870 : link_order
->u
.reloc
.p
->u
.name
),
6871 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6872 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6879 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6880 (file_ptr
) link_order
->offset
, size
);
6886 /* Figure out the symbol index. */
6887 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6888 + output_section
->reloc_count
);
6889 if (link_order
->type
== bfd_section_reloc_link_order
)
6891 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6892 BFD_ASSERT (indx
!= 0);
6893 *rel_hash_ptr
= NULL
;
6897 struct elf_link_hash_entry
*h
;
6899 h
= elf_link_hash_lookup (elf_hash_table (info
),
6900 link_order
->u
.reloc
.p
->u
.name
,
6901 false, false, true);
6904 /* Setting the index to -2 tells elf_link_output_extsym that
6905 this symbol is used by a reloc. */
6912 if (! ((*info
->callbacks
->unattached_reloc
)
6913 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6914 (asection
*) NULL
, (bfd_vma
) 0)))
6920 /* The address of a reloc is relative to the section in a
6921 relocateable file, and is a virtual address in an executable
6923 offset
= link_order
->offset
;
6924 if (! info
->relocateable
)
6925 offset
+= output_section
->vma
;
6927 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6929 if (rel_hdr
->sh_type
== SHT_REL
)
6931 Elf_Internal_Rel irel
;
6932 Elf_External_Rel
*erel
;
6934 irel
.r_offset
= offset
;
6935 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6936 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6937 + output_section
->reloc_count
);
6938 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6942 Elf_Internal_Rela irela
;
6943 Elf_External_Rela
*erela
;
6945 irela
.r_offset
= offset
;
6946 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6947 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6948 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6949 + output_section
->reloc_count
);
6950 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6953 ++output_section
->reloc_count
;