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
))
4302 bfd_size_type oldsize
;
4303 bfd_size_type strindex
;
4307 /* You can't use -r against a dynamic object. Also, there's no
4308 hope of using a dynamic object which does not exactly match
4309 the format of the output file. */
4310 if (info
->relocateable
4311 || info
->hash
->creator
!= abfd
->xvec
)
4313 bfd_set_error (bfd_error_invalid_operation
);
4317 /* Find the name to use in a DT_NEEDED entry that refers to this
4318 object. If the object has a DT_SONAME entry, we use it.
4319 Otherwise, if the generic linker stuck something in
4320 elf_dt_needed_name, we use that. Otherwise, we just use the
4321 file name. If the generic linker put a null string into
4322 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
4323 even if there is a DT_SONAME entry. */
4325 name
= bfd_get_filename (abfd
);
4326 if (elf_dt_needed_name (abfd
) != NULL
)
4328 name
= elf_dt_needed_name (abfd
);
4332 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4335 Elf_External_Dyn
*extdyn
;
4336 Elf_External_Dyn
*extdynend
;
4340 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4343 bfd_set_error (bfd_error_no_memory
);
4347 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4348 (file_ptr
) 0, s
->_raw_size
))
4351 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4354 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4357 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4358 for (; extdyn
< extdynend
; extdyn
++)
4360 Elf_Internal_Dyn dyn
;
4362 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4363 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
4365 name
= elf_string_from_elf_section (abfd
, link
,
4370 if (dyn
.d_tag
== DT_NEEDED
)
4372 struct bfd_elf_link_needed_list
*n
, **pn
;
4375 n
= bfd_alloc (abfd
,
4376 sizeof (struct bfd_elf_link_needed_list
));
4377 fnm
= elf_string_from_elf_section (abfd
, link
,
4379 if (n
== NULL
|| fnm
== NULL
)
4381 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
4388 for (pn
= &elf_hash_table (info
)->needed
;
4400 /* We do not want to include any of the sections in a dynamic
4401 object in the output file. We hack by simply clobbering the
4402 list of sections in the BFD. This could be handled more
4403 cleanly by, say, a new section flag; the existing
4404 SEC_NEVER_LOAD flag is not the one we want, because that one
4405 still implies that the section takes up space in the output
4407 abfd
->sections
= NULL
;
4409 /* If this is the first dynamic object found in the link, create
4410 the special sections required for dynamic linking. */
4411 if (! elf_hash_table (info
)->dynamic_sections_created
)
4413 if (! elf_link_create_dynamic_sections (abfd
, info
))
4419 /* Add a DT_NEEDED entry for this dynamic object. */
4420 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4421 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4423 if (strindex
== (bfd_size_type
) -1)
4426 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
4429 Elf_External_Dyn
*dyncon
, *dynconend
;
4431 /* The hash table size did not change, which means that
4432 the dynamic object name was already entered. If we
4433 have already included this dynamic object in the
4434 link, just ignore it. There is no reason to include
4435 a particular dynamic object more than once. */
4436 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
4438 BFD_ASSERT (sdyn
!= NULL
);
4440 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
4441 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
4443 for (; dyncon
< dynconend
; dyncon
++)
4445 Elf_Internal_Dyn dyn
;
4447 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
4449 if (dyn
.d_tag
== DT_NEEDED
4450 && dyn
.d_un
.d_val
== strindex
)
4459 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4465 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4467 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4468 != extsymcount
* sizeof (Elf_External_Sym
)))
4473 esymend
= buf
+ extsymcount
;
4474 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4476 Elf_Internal_Sym sym
;
4482 struct elf_link_hash_entry
*h
= NULL
;
4485 elf_swap_symbol_in (abfd
, esym
, &sym
);
4487 flags
= BSF_NO_FLAGS
;
4489 value
= sym
.st_value
;
4492 bind
= ELF_ST_BIND (sym
.st_info
);
4493 if (bind
== STB_LOCAL
)
4495 /* This should be impossible, since ELF requires that all
4496 global symbols follow all local symbols, and that sh_info
4497 point to the first global symbol. Unfortunatealy, Irix 5
4501 else if (bind
== STB_GLOBAL
)
4503 if (sym
.st_shndx
!= SHN_UNDEF
4504 && sym
.st_shndx
!= SHN_COMMON
)
4509 else if (bind
== STB_WEAK
)
4513 /* Leave it up to the processor backend. */
4516 if (sym
.st_shndx
== SHN_UNDEF
)
4517 sec
= bfd_und_section_ptr
;
4518 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4520 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4524 sec
= bfd_abs_section_ptr
;
4526 else if (sym
.st_shndx
== SHN_ABS
)
4527 sec
= bfd_abs_section_ptr
;
4528 else if (sym
.st_shndx
== SHN_COMMON
)
4530 sec
= bfd_com_section_ptr
;
4531 /* What ELF calls the size we call the value. What ELF
4532 calls the value we call the alignment. */
4533 value
= sym
.st_size
;
4537 /* Leave it up to the processor backend. */
4540 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4541 if (name
== (const char *) NULL
)
4544 if (add_symbol_hook
)
4546 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4550 /* The hook function sets the name to NULL if this symbol
4551 should be skipped for some reason. */
4552 if (name
== (const char *) NULL
)
4556 /* Sanity check that all possibilities were handled. */
4557 if (sec
== (asection
*) NULL
)
4559 bfd_set_error (bfd_error_bad_value
);
4563 if (bfd_is_und_section (sec
)
4564 || bfd_is_com_section (sec
))
4569 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4571 /* We need to look up the symbol now in order to get some of
4572 the dynamic object handling right. We pass the hash
4573 table entry in to _bfd_generic_link_add_one_symbol so
4574 that it does not have to look it up again. */
4575 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4576 true, false, false);
4581 /* If we are looking at a dynamic object, and this is a
4582 definition, we need to see if it has already been defined
4583 by some other object. If it has, we want to use the
4584 existing definition, and we do not want to report a
4585 multiple symbol definition error; we do this by
4586 clobbering sec to be bfd_und_section_ptr. */
4587 if (dynamic
&& definition
)
4589 if (h
->root
.type
== bfd_link_hash_defined
4590 || h
->root
.type
== bfd_link_hash_defweak
)
4591 sec
= bfd_und_section_ptr
;
4594 /* Similarly, if we are not looking at a dynamic object, and
4595 we have a definition, we want to override any definition
4596 we may have from a dynamic object. Symbols from regular
4597 files always take precedence over symbols from dynamic
4598 objects, even if they are defined after the dynamic
4599 object in the link. */
4602 && (h
->root
.type
== bfd_link_hash_defined
4603 || h
->root
.type
== bfd_link_hash_defweak
)
4604 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4605 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4606 == bfd_target_elf_flavour
)
4607 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4610 /* Change the hash table entry to undefined, and let
4611 _bfd_generic_link_add_one_symbol do the right thing
4612 with the new definition. */
4613 h
->root
.type
= bfd_link_hash_undefined
;
4614 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4618 if (! (_bfd_generic_link_add_one_symbol
4619 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4620 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4625 && (flags
& BSF_WEAK
) != 0
4626 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4627 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4628 && (*sym_hash
)->weakdef
== NULL
)
4630 /* Keep a list of all weak defined non function symbols from
4631 a dynamic object, using the weakdef field. Later in this
4632 function we will set the weakdef field to the correct
4633 value. We only put non-function symbols from dynamic
4634 objects on this list, because that happens to be the only
4635 time we need to know the normal symbol corresponding to a
4636 weak symbol, and the information is time consuming to
4637 figure out. If the weakdef field is not already NULL,
4638 then this symbol was already defined by some previous
4639 dynamic object, and we will be using that previous
4640 definition anyhow. */
4642 (*sym_hash
)->weakdef
= weaks
;
4646 /* Get the alignment of a common symbol. */
4647 if (sym
.st_shndx
== SHN_COMMON
4648 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4649 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
4651 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4657 /* Remember the symbol size and type. */
4658 if (sym
.st_size
!= 0)
4660 /* FIXME: We should probably somehow give a warning if
4661 the symbol size changes. */
4662 h
->size
= sym
.st_size
;
4664 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4666 /* FIXME: We should probably somehow give a warning if
4667 the symbol type changes. */
4668 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4671 /* Set a flag in the hash table entry indicating the type of
4672 reference or definition we just found. Keep a count of
4673 the number of dynamic symbols we find. A dynamic symbol
4674 is one which is referenced or defined by both a regular
4675 object and a shared object, or one which is referenced or
4676 defined by more than one shared object. */
4677 old_flags
= h
->elf_link_hash_flags
;
4682 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4684 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4686 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4687 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4693 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4695 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4696 if ((old_flags
& new_flag
) != 0
4697 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4698 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4702 h
->elf_link_hash_flags
|= new_flag
;
4703 if (dynsym
&& h
->dynindx
== -1)
4705 if (! elf_link_record_dynamic_symbol (info
, h
))
4711 /* Now set the weakdefs field correctly for all the weak defined
4712 symbols we found. The only way to do this is to search all the
4713 symbols. Since we only need the information for non functions in
4714 dynamic objects, that's the only time we actually put anything on
4715 the list WEAKS. We need this information so that if a regular
4716 object refers to a symbol defined weakly in a dynamic object, the
4717 real symbol in the dynamic object is also put in the dynamic
4718 symbols; we also must arrange for both symbols to point to the
4719 same memory location. We could handle the general case of symbol
4720 aliasing, but a general symbol alias can only be generated in
4721 assembler code, handling it correctly would be very time
4722 consuming, and other ELF linkers don't handle general aliasing
4724 while (weaks
!= NULL
)
4726 struct elf_link_hash_entry
*hlook
;
4729 struct elf_link_hash_entry
**hpp
;
4730 struct elf_link_hash_entry
**hppend
;
4733 weaks
= hlook
->weakdef
;
4734 hlook
->weakdef
= NULL
;
4736 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4737 || hlook
->root
.type
== bfd_link_hash_defweak
4738 || hlook
->root
.type
== bfd_link_hash_common
4739 || hlook
->root
.type
== bfd_link_hash_indirect
);
4740 slook
= hlook
->root
.u
.def
.section
;
4741 vlook
= hlook
->root
.u
.def
.value
;
4743 hpp
= elf_sym_hashes (abfd
);
4744 hppend
= hpp
+ extsymcount
;
4745 for (; hpp
< hppend
; hpp
++)
4747 struct elf_link_hash_entry
*h
;
4750 if (h
!= NULL
&& h
!= hlook
4751 && (h
->root
.type
== bfd_link_hash_defined
4752 || h
->root
.type
== bfd_link_hash_defweak
)
4753 && h
->root
.u
.def
.section
== slook
4754 && h
->root
.u
.def
.value
== vlook
)
4758 /* If the weak definition is in the list of dynamic
4759 symbols, make sure the real definition is put there
4761 if (hlook
->dynindx
!= -1
4762 && h
->dynindx
== -1)
4764 if (! elf_link_record_dynamic_symbol (info
, h
))
4779 /* If this object is the same format as the output object, and it is
4780 not a shared library, then let the backend look through the
4783 This is required to build global offset table entries and to
4784 arrange for dynamic relocs. It is not required for the
4785 particular common case of linking non PIC code, even when linking
4786 against shared libraries, but unfortunately there is no way of
4787 knowing whether an object file has been compiled PIC or not.
4788 Looking through the relocs is not particularly time consuming.
4789 The problem is that we must either (1) keep the relocs in memory,
4790 which causes the linker to require additional runtime memory or
4791 (2) read the relocs twice from the input file, which wastes time.
4792 This would be a good case for using mmap.
4794 I have no idea how to handle linking PIC code into a file of a
4795 different format. It probably can't be done. */
4796 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4798 && abfd
->xvec
== info
->hash
->creator
4799 && check_relocs
!= NULL
)
4803 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4805 Elf_Internal_Rela
*internal_relocs
;
4808 if ((o
->flags
& SEC_RELOC
) == 0
4809 || o
->reloc_count
== 0)
4812 /* I believe we can ignore the relocs for any section which
4813 does not form part of the final process image, such as a
4814 debugging section. */
4815 if ((o
->flags
& SEC_ALLOC
) == 0)
4818 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4819 (Elf_Internal_Rela
*) NULL
,
4821 if (internal_relocs
== NULL
)
4824 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4826 if (! info
->keep_memory
)
4827 free (internal_relocs
);
4844 /* Create some sections which will be filled in with dynamic linking
4845 information. ABFD is an input file which requires dynamic sections
4846 to be created. The dynamic sections take up virtual memory space
4847 when the final executable is run, so we need to create them before
4848 addresses are assigned to the output sections. We work out the
4849 actual contents and size of these sections later. */
4852 elf_link_create_dynamic_sections (abfd
, info
)
4854 struct bfd_link_info
*info
;
4857 register asection
*s
;
4858 struct elf_link_hash_entry
*h
;
4859 struct elf_backend_data
*bed
;
4861 if (elf_hash_table (info
)->dynamic_sections_created
)
4864 /* Make sure that all dynamic sections use the same input BFD. */
4865 if (elf_hash_table (info
)->dynobj
== NULL
)
4866 elf_hash_table (info
)->dynobj
= abfd
;
4868 abfd
= elf_hash_table (info
)->dynobj
;
4870 /* Note that we set the SEC_IN_MEMORY flag for all of these
4872 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4874 /* A dynamically linked executable has a .interp section, but a
4875 shared library does not. */
4878 s
= bfd_make_section (abfd
, ".interp");
4880 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4884 s
= bfd_make_section (abfd
, ".dynsym");
4886 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4887 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4890 s
= bfd_make_section (abfd
, ".dynstr");
4892 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4895 /* Create a strtab to hold the dynamic symbol names. */
4896 if (elf_hash_table (info
)->dynstr
== NULL
)
4898 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4899 if (elf_hash_table (info
)->dynstr
== NULL
)
4903 s
= bfd_make_section (abfd
, ".dynamic");
4905 || ! bfd_set_section_flags (abfd
, s
, flags
)
4906 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4909 /* The special symbol _DYNAMIC is always set to the start of the
4910 .dynamic section. This call occurs before we have processed the
4911 symbols for any dynamic object, so we don't have to worry about
4912 overriding a dynamic definition. We could set _DYNAMIC in a
4913 linker script, but we only want to define it if we are, in fact,
4914 creating a .dynamic section. We don't want to define it if there
4915 is no .dynamic section, since on some ELF platforms the start up
4916 code examines it to decide how to initialize the process. */
4918 if (! (_bfd_generic_link_add_one_symbol
4919 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4920 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4921 (struct bfd_link_hash_entry
**) &h
)))
4923 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4924 h
->type
= STT_OBJECT
;
4927 && ! elf_link_record_dynamic_symbol (info
, h
))
4930 s
= bfd_make_section (abfd
, ".hash");
4932 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4933 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4936 /* Let the backend create the rest of the sections. This lets the
4937 backend set the right flags. The backend will normally create
4938 the .got and .plt sections. */
4939 bed
= get_elf_backend_data (abfd
);
4940 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4943 elf_hash_table (info
)->dynamic_sections_created
= true;
4948 /* Add an entry to the .dynamic table. */
4951 elf_add_dynamic_entry (info
, tag
, val
)
4952 struct bfd_link_info
*info
;
4956 Elf_Internal_Dyn dyn
;
4960 bfd_byte
*newcontents
;
4962 dynobj
= elf_hash_table (info
)->dynobj
;
4964 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4965 BFD_ASSERT (s
!= NULL
);
4967 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4968 if (s
->contents
== NULL
)
4969 newcontents
= (bfd_byte
*) malloc (newsize
);
4971 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4972 if (newcontents
== NULL
)
4974 bfd_set_error (bfd_error_no_memory
);
4979 dyn
.d_un
.d_val
= val
;
4980 elf_swap_dyn_out (dynobj
, &dyn
,
4981 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4983 s
->_raw_size
= newsize
;
4984 s
->contents
= newcontents
;
4989 /* Read and swap the relocs for a section. They may have been cached.
4990 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4991 they are used as buffers to read into. They are known to be large
4992 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4993 value is allocated using either malloc or bfd_alloc, according to
4994 the KEEP_MEMORY argument. */
4996 static Elf_Internal_Rela
*
4997 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
5000 PTR external_relocs
;
5001 Elf_Internal_Rela
*internal_relocs
;
5002 boolean keep_memory
;
5004 Elf_Internal_Shdr
*rel_hdr
;
5006 Elf_Internal_Rela
*alloc2
= NULL
;
5008 if (elf_section_data (o
)->relocs
!= NULL
)
5009 return elf_section_data (o
)->relocs
;
5011 if (o
->reloc_count
== 0)
5014 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5016 if (internal_relocs
== NULL
)
5020 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
5022 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
5024 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
5025 if (internal_relocs
== NULL
)
5027 bfd_set_error (bfd_error_no_memory
);
5032 if (external_relocs
== NULL
)
5034 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
5037 bfd_set_error (bfd_error_no_memory
);
5040 external_relocs
= alloc1
;
5043 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
5044 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
5045 != rel_hdr
->sh_size
))
5048 /* Swap in the relocs. For convenience, we always produce an
5049 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
5051 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5053 Elf_External_Rel
*erel
;
5054 Elf_External_Rel
*erelend
;
5055 Elf_Internal_Rela
*irela
;
5057 erel
= (Elf_External_Rel
*) external_relocs
;
5058 erelend
= erel
+ o
->reloc_count
;
5059 irela
= internal_relocs
;
5060 for (; erel
< erelend
; erel
++, irela
++)
5062 Elf_Internal_Rel irel
;
5064 elf_swap_reloc_in (abfd
, erel
, &irel
);
5065 irela
->r_offset
= irel
.r_offset
;
5066 irela
->r_info
= irel
.r_info
;
5067 irela
->r_addend
= 0;
5072 Elf_External_Rela
*erela
;
5073 Elf_External_Rela
*erelaend
;
5074 Elf_Internal_Rela
*irela
;
5076 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
5078 erela
= (Elf_External_Rela
*) external_relocs
;
5079 erelaend
= erela
+ o
->reloc_count
;
5080 irela
= internal_relocs
;
5081 for (; erela
< erelaend
; erela
++, irela
++)
5082 elf_swap_reloca_in (abfd
, erela
, irela
);
5085 /* Cache the results for next time, if we can. */
5087 elf_section_data (o
)->relocs
= internal_relocs
;
5092 /* Don't free alloc2, since if it was allocated we are passing it
5093 back (under the name of internal_relocs). */
5095 return internal_relocs
;
5105 /* Record an assignment to a symbol made by a linker script. We need
5106 this in case some dynamic object refers to this symbol. */
5110 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
5112 struct bfd_link_info
*info
;
5116 struct elf_link_hash_entry
*h
;
5118 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5121 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
5125 /* If this symbol is being provided by the linker script, and it is
5126 currently defined by a dynamic object, but not by a regular
5127 object, then mark it as undefined so that the generic linker will
5128 force the correct value. */
5130 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5131 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5132 h
->root
.type
= bfd_link_hash_undefined
;
5134 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5135 h
->type
= STT_OBJECT
;
5137 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
5138 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
5140 && h
->dynindx
== -1)
5142 if (! elf_link_record_dynamic_symbol (info
, h
))
5145 /* If this is a weak defined symbol, and we know a corresponding
5146 real symbol from the same dynamic object, make sure the real
5147 symbol is also made into a dynamic symbol. */
5148 if (h
->weakdef
!= NULL
5149 && h
->weakdef
->dynindx
== -1)
5151 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
5159 /* Array used to determine the number of hash table buckets to use
5160 based on the number of symbols there are. If there are fewer than
5161 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5162 fewer than 37 we use 17 buckets, and so forth. We never use more
5163 than 521 buckets. */
5165 static const size_t elf_buckets
[] =
5167 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
5170 /* Set up the sizes and contents of the ELF dynamic sections. This is
5171 called by the ELF linker emulation before_allocation routine. We
5172 must set the sizes of the sections before the linker sets the
5173 addresses of the various sections. */
5176 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
5177 export_dynamic
, info
, sinterpptr
)
5181 boolean export_dynamic
;
5182 struct bfd_link_info
*info
;
5183 asection
**sinterpptr
;
5186 struct elf_backend_data
*bed
;
5190 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5193 dynobj
= elf_hash_table (info
)->dynobj
;
5195 /* If there were no dynamic objects in the link, there is nothing to
5200 /* If we are supposed to export all symbols into the dynamic symbol
5201 table (this is not the normal case), then do so. */
5204 struct elf_info_failed eif
;
5208 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5214 if (elf_hash_table (info
)->dynamic_sections_created
)
5216 struct elf_info_failed eif
;
5217 bfd_size_type strsize
;
5219 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5220 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5226 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5228 if (indx
== (bfd_size_type
) -1
5229 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5237 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5239 if (indx
== (bfd_size_type
) -1
5240 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5244 /* Find all symbols which were defined in a dynamic object and make
5245 the backend pick a reasonable value for them. */
5248 elf_link_hash_traverse (elf_hash_table (info
),
5249 elf_adjust_dynamic_symbol
,
5254 /* Add some entries to the .dynamic section. We fill in some of the
5255 values later, in elf_bfd_final_link, but we must add the entries
5256 now so that we know the final size of the .dynamic section. */
5257 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5258 false, false) != NULL
)
5260 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5263 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5264 false, false) != NULL
)
5266 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5269 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5270 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5271 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5272 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5273 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5274 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5275 sizeof (Elf_External_Sym
)))
5279 /* The backend must work out the sizes of all the other dynamic
5281 bed
= get_elf_backend_data (output_bfd
);
5282 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5285 if (elf_hash_table (info
)->dynamic_sections_created
)
5291 Elf_Internal_Sym isym
;
5293 /* Set the size of the .dynsym and .hash sections. We counted
5294 the number of dynamic symbols in elf_link_add_object_symbols.
5295 We will build the contents of .dynsym and .hash when we build
5296 the final symbol table, because until then we do not know the
5297 correct value to give the symbols. We built the .dynstr
5298 section as we went along in elf_link_add_object_symbols. */
5299 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5300 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5301 BFD_ASSERT (s
!= NULL
);
5302 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5303 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5304 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5306 bfd_set_error (bfd_error_no_memory
);
5310 /* The first entry in .dynsym is a dummy symbol. */
5317 elf_swap_symbol_out (output_bfd
, &isym
,
5318 (Elf_External_Sym
*) s
->contents
);
5320 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5322 bucketcount
= elf_buckets
[i
];
5323 if (dynsymcount
< elf_buckets
[i
+ 1])
5327 s
= bfd_get_section_by_name (dynobj
, ".hash");
5328 BFD_ASSERT (s
!= NULL
);
5329 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5330 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5331 if (s
->contents
== NULL
)
5333 bfd_set_error (bfd_error_no_memory
);
5336 memset (s
->contents
, 0, s
->_raw_size
);
5338 put_word (output_bfd
, bucketcount
, s
->contents
);
5339 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5341 elf_hash_table (info
)->bucketcount
= bucketcount
;
5343 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5344 BFD_ASSERT (s
!= NULL
);
5345 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5347 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5354 /* This routine is used to export all defined symbols into the dynamic
5355 symbol table. It is called via elf_link_hash_traverse. */
5358 elf_export_symbol (h
, data
)
5359 struct elf_link_hash_entry
*h
;
5362 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
5364 if (h
->dynindx
== -1
5365 && (h
->elf_link_hash_flags
5366 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5368 if (! elf_link_record_dynamic_symbol (eif
->info
, h
))
5378 /* Make the backend pick a good value for a dynamic symbol. This is
5379 called via elf_link_hash_traverse, and also calls itself
5383 elf_adjust_dynamic_symbol (h
, data
)
5384 struct elf_link_hash_entry
*h
;
5387 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
5389 struct elf_backend_data
*bed
;
5391 /* If this symbol does not require a PLT entry, and it is not
5392 defined by a dynamic object, or is not referenced by a regular
5393 object, ignore it. FIXME: Do we need to worry about symbols
5394 which are defined by one dynamic object and referenced by another
5396 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5397 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5398 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5399 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5402 /* If we've already adjusted this symbol, don't do it again. This
5403 can happen via a recursive call. */
5404 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5407 /* Don't look at this symbol again. Note that we must set this
5408 after checking the above conditions, because we may look at a
5409 symbol once, decide not to do anything, and then get called
5410 recursively later after REF_REGULAR is set below. */
5411 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5413 /* If this is a weak definition, and we know a real definition, and
5414 the real symbol is not itself defined by a regular object file,
5415 then get a good value for the real definition. We handle the
5416 real symbol first, for the convenience of the backend routine.
5418 Note that there is a confusing case here. If the real definition
5419 is defined by a regular object file, we don't get the real symbol
5420 from the dynamic object, but we do get the weak symbol. If the
5421 processor backend uses a COPY reloc, then if some routine in the
5422 dynamic object changes the real symbol, we will not see that
5423 change in the corresponding weak symbol. This is the way other
5424 ELF linkers work as well, and seems to be a result of the shared
5427 I will clarify this issue. Most SVR4 shared libraries define the
5428 variable _timezone and define timezone as a weak synonym. The
5429 tzset call changes _timezone. If you write
5430 extern int timezone;
5432 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5433 you might expect that, since timezone is a synonym for _timezone,
5434 the same number will print both times. However, if the processor
5435 backend uses a COPY reloc, then actually timezone will be copied
5436 into your process image, and, since you define _timezone
5437 yourself, _timezone will not. Thus timezone and _timezone will
5438 wind up at different memory locations. The tzset call will set
5439 _timezone, leaving timezone unchanged. */
5441 if (h
->weakdef
!= NULL
)
5443 struct elf_link_hash_entry
*weakdef
;
5445 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5446 || h
->root
.type
== bfd_link_hash_defweak
);
5447 weakdef
= h
->weakdef
;
5448 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5449 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5450 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5451 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5453 /* This symbol is defined by a regular object file, so we
5454 will not do anything special. Clear weakdef for the
5455 convenience of the processor backend. */
5460 /* There is an implicit reference by a regular object file
5461 via the weak symbol. */
5462 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5463 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
5468 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
5469 bed
= get_elf_backend_data (dynobj
);
5470 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
5479 /* Final phase of ELF linker. */
5481 /* A structure we use to avoid passing large numbers of arguments. */
5483 struct elf_final_link_info
5485 /* General link information. */
5486 struct bfd_link_info
*info
;
5489 /* Symbol string table. */
5490 struct bfd_strtab_hash
*symstrtab
;
5491 /* .dynsym section. */
5492 asection
*dynsym_sec
;
5493 /* .hash section. */
5495 /* Buffer large enough to hold contents of any section. */
5497 /* Buffer large enough to hold external relocs of any section. */
5498 PTR external_relocs
;
5499 /* Buffer large enough to hold internal relocs of any section. */
5500 Elf_Internal_Rela
*internal_relocs
;
5501 /* Buffer large enough to hold external local symbols of any input
5503 Elf_External_Sym
*external_syms
;
5504 /* Buffer large enough to hold internal local symbols of any input
5506 Elf_Internal_Sym
*internal_syms
;
5507 /* Array large enough to hold a symbol index for each local symbol
5508 of any input BFD. */
5510 /* Array large enough to hold a section pointer for each local
5511 symbol of any input BFD. */
5512 asection
**sections
;
5513 /* Buffer to hold swapped out symbols. */
5514 Elf_External_Sym
*symbuf
;
5515 /* Number of swapped out symbols in buffer. */
5516 size_t symbuf_count
;
5517 /* Number of symbols which fit in symbuf. */
5521 static boolean elf_link_output_sym
5522 PARAMS ((struct elf_final_link_info
*, const char *,
5523 Elf_Internal_Sym
*, asection
*));
5524 static boolean elf_link_flush_output_syms
5525 PARAMS ((struct elf_final_link_info
*));
5526 static boolean elf_link_output_extsym
5527 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5528 static boolean elf_link_input_bfd
5529 PARAMS ((struct elf_final_link_info
*, bfd
*));
5530 static boolean elf_reloc_link_order
5531 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5532 struct bfd_link_order
*));
5534 /* This struct is used to pass information to routines called via
5535 elf_link_hash_traverse which must return failure. */
5537 struct elf_finfo_failed
5540 struct elf_final_link_info
*finfo
;
5543 /* Do the final step of an ELF link. */
5546 elf_bfd_final_link (abfd
, info
)
5548 struct bfd_link_info
*info
;
5552 struct elf_final_link_info finfo
;
5553 register asection
*o
;
5554 register struct bfd_link_order
*p
;
5556 size_t max_contents_size
;
5557 size_t max_external_reloc_size
;
5558 size_t max_internal_reloc_count
;
5559 size_t max_sym_count
;
5561 Elf_Internal_Sym elfsym
;
5563 Elf_Internal_Shdr
*symtab_hdr
;
5564 Elf_Internal_Shdr
*symstrtab_hdr
;
5565 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5566 struct elf_finfo_failed eif
;
5569 abfd
->flags
|= DYNAMIC
;
5571 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5572 dynobj
= elf_hash_table (info
)->dynobj
;
5575 finfo
.output_bfd
= abfd
;
5576 finfo
.symstrtab
= elf_stringtab_init ();
5577 if (finfo
.symstrtab
== NULL
)
5581 finfo
.dynsym_sec
= NULL
;
5582 finfo
.hash_sec
= NULL
;
5586 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5587 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5588 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
5590 finfo
.contents
= NULL
;
5591 finfo
.external_relocs
= NULL
;
5592 finfo
.internal_relocs
= NULL
;
5593 finfo
.external_syms
= NULL
;
5594 finfo
.internal_syms
= NULL
;
5595 finfo
.indices
= NULL
;
5596 finfo
.sections
= NULL
;
5597 finfo
.symbuf
= NULL
;
5598 finfo
.symbuf_count
= 0;
5600 /* Count up the number of relocations we will output for each output
5601 section, so that we know the sizes of the reloc sections. We
5602 also figure out some maximum sizes. */
5603 max_contents_size
= 0;
5604 max_external_reloc_size
= 0;
5605 max_internal_reloc_count
= 0;
5607 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5611 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5613 if (p
->type
== bfd_section_reloc_link_order
5614 || p
->type
== bfd_symbol_reloc_link_order
)
5616 else if (p
->type
== bfd_indirect_link_order
)
5620 sec
= p
->u
.indirect
.section
;
5622 if (info
->relocateable
)
5623 o
->reloc_count
+= sec
->reloc_count
;
5625 if (sec
->_raw_size
> max_contents_size
)
5626 max_contents_size
= sec
->_raw_size
;
5627 if (sec
->_cooked_size
> max_contents_size
)
5628 max_contents_size
= sec
->_cooked_size
;
5630 /* We are interested in just local symbols, not all
5632 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5636 if (elf_bad_symtab (sec
->owner
))
5637 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5638 / sizeof (Elf_External_Sym
));
5640 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5642 if (sym_count
> max_sym_count
)
5643 max_sym_count
= sym_count
;
5645 if ((sec
->flags
& SEC_RELOC
) != 0)
5649 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5650 if (ext_size
> max_external_reloc_size
)
5651 max_external_reloc_size
= ext_size
;
5652 if (sec
->reloc_count
> max_internal_reloc_count
)
5653 max_internal_reloc_count
= sec
->reloc_count
;
5659 if (o
->reloc_count
> 0)
5660 o
->flags
|= SEC_RELOC
;
5663 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5664 set it (this is probably a bug) and if it is set
5665 assign_section_numbers will create a reloc section. */
5666 o
->flags
&=~ SEC_RELOC
;
5669 /* If the SEC_ALLOC flag is not set, force the section VMA to
5670 zero. This is done in elf_fake_sections as well, but forcing
5671 the VMA to 0 here will ensure that relocs against these
5672 sections are handled correctly. */
5673 if ((o
->flags
& SEC_ALLOC
) == 0)
5677 /* Figure out the file positions for everything but the symbol table
5678 and the relocs. We set symcount to force assign_section_numbers
5679 to create a symbol table. */
5680 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5681 BFD_ASSERT (! abfd
->output_has_begun
);
5682 if (! elf_compute_section_file_positions (abfd
, info
))
5685 /* That created the reloc sections. Set their sizes, and assign
5686 them file positions, and allocate some buffers. */
5687 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5689 if ((o
->flags
& SEC_RELOC
) != 0)
5691 Elf_Internal_Shdr
*rel_hdr
;
5692 register struct elf_link_hash_entry
**p
, **pend
;
5694 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5696 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5698 /* The contents field must last into write_object_contents,
5699 so we allocate it with bfd_alloc rather than malloc. */
5700 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5701 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5703 bfd_set_error (bfd_error_no_memory
);
5707 p
= ((struct elf_link_hash_entry
**)
5708 malloc (o
->reloc_count
5709 * sizeof (struct elf_link_hash_entry
*)));
5710 if (p
== NULL
&& o
->reloc_count
!= 0)
5712 bfd_set_error (bfd_error_no_memory
);
5715 elf_section_data (o
)->rel_hashes
= p
;
5716 pend
= p
+ o
->reloc_count
;
5717 for (; p
< pend
; p
++)
5720 /* Use the reloc_count field as an index when outputting the
5726 assign_file_positions_for_relocs (abfd
);
5728 /* We have now assigned file positions for all the sections except
5729 .symtab and .strtab. We start the .symtab section at the current
5730 file position, and write directly to it. We build the .strtab
5731 section in memory. When we add .dynsym support, we will build
5732 that in memory as well (.dynsym is smaller than .symtab). */
5734 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5735 /* sh_name is set in prep_headers. */
5736 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5737 symtab_hdr
->sh_flags
= 0;
5738 symtab_hdr
->sh_addr
= 0;
5739 symtab_hdr
->sh_size
= 0;
5740 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5741 /* sh_link is set in assign_section_numbers. */
5742 /* sh_info is set below. */
5743 /* sh_offset is set just below. */
5744 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5746 off
= elf_tdata (abfd
)->next_file_pos
;
5747 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5749 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5750 incorrect. We do not yet know the size of the .symtab section.
5751 We correct next_file_pos below, after we do know the size. */
5753 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5754 continuously seeking to the right position in the file. */
5755 if (! info
->keep_memory
|| max_sym_count
< 20)
5756 finfo
.symbuf_size
= 20;
5758 finfo
.symbuf_size
= max_sym_count
;
5759 finfo
.symbuf
= ((Elf_External_Sym
*)
5760 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5761 if (finfo
.symbuf
== NULL
)
5763 bfd_set_error (bfd_error_no_memory
);
5767 /* Start writing out the symbol table. The first symbol is always a
5769 elfsym
.st_value
= 0;
5772 elfsym
.st_other
= 0;
5773 elfsym
.st_shndx
= SHN_UNDEF
;
5774 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5775 &elfsym
, bfd_und_section_ptr
))
5779 /* Some standard ELF linkers do this, but we don't because it causes
5780 bootstrap comparison failures. */
5781 /* Output a file symbol for the output file as the second symbol.
5782 We output this even if we are discarding local symbols, although
5783 I'm not sure if this is correct. */
5784 elfsym
.st_value
= 0;
5786 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5787 elfsym
.st_other
= 0;
5788 elfsym
.st_shndx
= SHN_ABS
;
5789 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5790 &elfsym
, bfd_abs_section_ptr
))
5794 /* Output a symbol for each section. We output these even if we are
5795 discarding local symbols, since they are used for relocs. These
5796 symbols have no names. We store the index of each one in the
5797 index field of the section, so that we can find it again when
5798 outputting relocs. */
5799 elfsym
.st_value
= 0;
5801 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5802 elfsym
.st_other
= 0;
5803 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5805 o
= section_from_elf_index (abfd
, i
);
5807 o
->target_index
= abfd
->symcount
;
5808 elfsym
.st_shndx
= i
;
5809 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5814 /* Allocate some memory to hold information read in from the input
5816 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5817 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5818 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5819 malloc (max_internal_reloc_count
5820 * sizeof (Elf_Internal_Rela
)));
5821 finfo
.external_syms
= ((Elf_External_Sym
*)
5822 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5823 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5824 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5825 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5826 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5827 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5828 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5829 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5830 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5831 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5832 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5833 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5835 bfd_set_error (bfd_error_no_memory
);
5839 /* Since ELF permits relocations to be against local symbols, we
5840 must have the local symbols available when we do the relocations.
5841 Since we would rather only read the local symbols once, and we
5842 would rather not keep them in memory, we handle all the
5843 relocations for a single input file at the same time.
5845 Unfortunately, there is no way to know the total number of local
5846 symbols until we have seen all of them, and the local symbol
5847 indices precede the global symbol indices. This means that when
5848 we are generating relocateable output, and we see a reloc against
5849 a global symbol, we can not know the symbol index until we have
5850 finished examining all the local symbols to see which ones we are
5851 going to output. To deal with this, we keep the relocations in
5852 memory, and don't output them until the end of the link. This is
5853 an unfortunate waste of memory, but I don't see a good way around
5854 it. Fortunately, it only happens when performing a relocateable
5855 link, which is not the common case. FIXME: If keep_memory is set
5856 we could write the relocs out and then read them again; I don't
5857 know how bad the memory loss will be. */
5859 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5860 sub
->output_has_begun
= false;
5861 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5863 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5865 if (p
->type
== bfd_indirect_link_order
5866 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5867 == bfd_target_elf_flavour
))
5869 sub
= p
->u
.indirect
.section
->owner
;
5870 if (! sub
->output_has_begun
)
5872 if (! elf_link_input_bfd (&finfo
, sub
))
5874 sub
->output_has_begun
= true;
5877 else if (p
->type
== bfd_section_reloc_link_order
5878 || p
->type
== bfd_symbol_reloc_link_order
)
5880 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5885 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5891 /* That wrote out all the local symbols. Finish up the symbol table
5892 with the global symbols. */
5894 /* The sh_info field records the index of the first non local
5896 symtab_hdr
->sh_info
= abfd
->symcount
;
5898 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5900 /* We get the global symbols from the hash table. */
5903 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5908 /* Flush all symbols to the file. */
5909 if (! elf_link_flush_output_syms (&finfo
))
5912 /* Now we know the size of the symtab section. */
5913 off
+= symtab_hdr
->sh_size
;
5915 /* Finish up and write out the symbol string table (.strtab)
5917 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5918 /* sh_name was set in prep_headers. */
5919 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5920 symstrtab_hdr
->sh_flags
= 0;
5921 symstrtab_hdr
->sh_addr
= 0;
5922 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5923 symstrtab_hdr
->sh_entsize
= 0;
5924 symstrtab_hdr
->sh_link
= 0;
5925 symstrtab_hdr
->sh_info
= 0;
5926 /* sh_offset is set just below. */
5927 symstrtab_hdr
->sh_addralign
= 1;
5929 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5930 elf_tdata (abfd
)->next_file_pos
= off
;
5932 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5933 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5936 /* Adjust the relocs to have the correct symbol indices. */
5937 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5939 struct elf_link_hash_entry
**rel_hash
;
5940 Elf_Internal_Shdr
*rel_hdr
;
5942 if ((o
->flags
& SEC_RELOC
) == 0)
5945 rel_hash
= elf_section_data (o
)->rel_hashes
;
5946 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5947 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5949 if (*rel_hash
== NULL
)
5952 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5954 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5956 Elf_External_Rel
*erel
;
5957 Elf_Internal_Rel irel
;
5959 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5960 elf_swap_reloc_in (abfd
, erel
, &irel
);
5961 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5962 ELF_R_TYPE (irel
.r_info
));
5963 elf_swap_reloc_out (abfd
, &irel
, erel
);
5967 Elf_External_Rela
*erela
;
5968 Elf_Internal_Rela irela
;
5970 BFD_ASSERT (rel_hdr
->sh_entsize
5971 == sizeof (Elf_External_Rela
));
5973 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5974 elf_swap_reloca_in (abfd
, erela
, &irela
);
5975 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5976 ELF_R_TYPE (irela
.r_info
));
5977 elf_swap_reloca_out (abfd
, &irela
, erela
);
5981 /* Set the reloc_count field to 0 to prevent write_relocs from
5982 trying to swap the relocs out itself. */
5986 /* If we are linking against a dynamic object, or generating a
5987 shared library, finish up the dynamic linking information. */
5990 Elf_External_Dyn
*dyncon
, *dynconend
;
5992 /* Fix up .dynamic entries. */
5993 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5994 BFD_ASSERT (o
!= NULL
);
5996 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5997 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5998 for (; dyncon
< dynconend
; dyncon
++)
6000 Elf_Internal_Dyn dyn
;
6004 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
6011 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
6012 magic _init and _fini symbols. This is pretty ugly,
6013 but we are compatible. */
6021 struct elf_link_hash_entry
*h
;
6023 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
6024 false, false, true);
6025 BFD_ASSERT (h
!= NULL
);
6026 if (h
->root
.type
== bfd_link_hash_defined
6027 || h
->root
.type
== bfd_link_hash_defweak
)
6029 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
6030 o
= h
->root
.u
.def
.section
;
6031 if (o
->output_section
!= NULL
)
6032 dyn
.d_un
.d_val
+= (o
->output_section
->vma
6033 + o
->output_offset
);
6035 /* The symbol is imported from another shared
6036 library and does not apply to this one. */
6039 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6052 o
= bfd_get_section_by_name (abfd
, name
);
6053 BFD_ASSERT (o
!= NULL
);
6054 dyn
.d_un
.d_ptr
= o
->vma
;
6055 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6062 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
6067 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
6069 Elf_Internal_Shdr
*hdr
;
6071 hdr
= elf_elfsections (abfd
)[i
];
6072 if (hdr
->sh_type
== type
6073 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
6075 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
6076 dyn
.d_un
.d_val
+= hdr
->sh_size
;
6079 if (dyn
.d_un
.d_val
== 0
6080 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
6081 dyn
.d_un
.d_val
= hdr
->sh_addr
;
6085 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
6091 /* If we have created any dynamic sections, then output them. */
6094 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
6097 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
6099 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
6100 || o
->_raw_size
== 0)
6102 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
6104 /* At this point, we are only interested in sections
6105 created by elf_link_create_dynamic_sections. FIXME:
6106 This test is fragile. */
6109 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
6111 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
6113 if (! bfd_set_section_contents (abfd
, o
->output_section
,
6114 o
->contents
, o
->output_offset
,
6122 /* The contents of the .dynstr section are actually in a
6124 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
6125 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
6126 || ! _bfd_stringtab_emit (abfd
,
6127 elf_hash_table (info
)->dynstr
))
6133 if (finfo
.symstrtab
!= NULL
)
6134 _bfd_stringtab_free (finfo
.symstrtab
);
6135 if (finfo
.contents
!= NULL
)
6136 free (finfo
.contents
);
6137 if (finfo
.external_relocs
!= NULL
)
6138 free (finfo
.external_relocs
);
6139 if (finfo
.internal_relocs
!= NULL
)
6140 free (finfo
.internal_relocs
);
6141 if (finfo
.external_syms
!= NULL
)
6142 free (finfo
.external_syms
);
6143 if (finfo
.internal_syms
!= NULL
)
6144 free (finfo
.internal_syms
);
6145 if (finfo
.indices
!= NULL
)
6146 free (finfo
.indices
);
6147 if (finfo
.sections
!= NULL
)
6148 free (finfo
.sections
);
6149 if (finfo
.symbuf
!= NULL
)
6150 free (finfo
.symbuf
);
6151 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6153 if ((o
->flags
& SEC_RELOC
) != 0
6154 && elf_section_data (o
)->rel_hashes
!= NULL
)
6155 free (elf_section_data (o
)->rel_hashes
);
6158 elf_tdata (abfd
)->linker
= true;
6163 if (finfo
.symstrtab
!= NULL
)
6164 _bfd_stringtab_free (finfo
.symstrtab
);
6165 if (finfo
.contents
!= NULL
)
6166 free (finfo
.contents
);
6167 if (finfo
.external_relocs
!= NULL
)
6168 free (finfo
.external_relocs
);
6169 if (finfo
.internal_relocs
!= NULL
)
6170 free (finfo
.internal_relocs
);
6171 if (finfo
.external_syms
!= NULL
)
6172 free (finfo
.external_syms
);
6173 if (finfo
.internal_syms
!= NULL
)
6174 free (finfo
.internal_syms
);
6175 if (finfo
.indices
!= NULL
)
6176 free (finfo
.indices
);
6177 if (finfo
.sections
!= NULL
)
6178 free (finfo
.sections
);
6179 if (finfo
.symbuf
!= NULL
)
6180 free (finfo
.symbuf
);
6181 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6183 if ((o
->flags
& SEC_RELOC
) != 0
6184 && elf_section_data (o
)->rel_hashes
!= NULL
)
6185 free (elf_section_data (o
)->rel_hashes
);
6191 /* Add a symbol to the output symbol table. */
6194 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
6195 struct elf_final_link_info
*finfo
;
6197 Elf_Internal_Sym
*elfsym
;
6198 asection
*input_sec
;
6200 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
6201 struct bfd_link_info
*info
,
6206 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
6207 elf_backend_link_output_symbol_hook
;
6208 if (output_symbol_hook
!= NULL
)
6210 if (! ((*output_symbol_hook
)
6211 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
6215 if (name
== (const char *) NULL
|| *name
== '\0')
6216 elfsym
->st_name
= 0;
6219 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6222 if (elfsym
->st_name
== (unsigned long) -1)
6226 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6228 if (! elf_link_flush_output_syms (finfo
))
6232 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6233 finfo
->symbuf
+ finfo
->symbuf_count
);
6234 ++finfo
->symbuf_count
;
6236 ++finfo
->output_bfd
->symcount
;
6241 /* Flush the output symbols to the file. */
6244 elf_link_flush_output_syms (finfo
)
6245 struct elf_final_link_info
*finfo
;
6247 Elf_Internal_Shdr
*symtab
;
6249 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6251 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6253 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6254 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6255 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6258 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6260 finfo
->symbuf_count
= 0;
6265 /* Add an external symbol to the symbol table. This is called from
6266 the hash table traversal routine. */
6269 elf_link_output_extsym (h
, data
)
6270 struct elf_link_hash_entry
*h
;
6273 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
6274 struct elf_final_link_info
*finfo
= eif
->finfo
;
6276 Elf_Internal_Sym sym
;
6277 asection
*input_sec
;
6279 /* If we are not creating a shared library, and this symbol is
6280 referenced by a shared library but is not defined anywhere, then
6281 warn that it is undefined. If we do not do this, the runtime
6282 linker will complain that the symbol is undefined when the
6283 program is run. We don't have to worry about symbols that are
6284 referenced by regular files, because we will already have issued
6285 warnings for them. */
6286 if (! finfo
->info
->relocateable
6287 && ! finfo
->info
->shared
6288 && h
->root
.type
== bfd_link_hash_undefined
6289 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6290 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6292 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6293 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6294 (asection
*) NULL
, 0)))
6301 /* We don't want to output symbols that have never been mentioned by
6302 a regular file, or that we have been told to strip. However, if
6303 h->indx is set to -2, the symbol is used by a reloc and we must
6307 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6308 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6309 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6310 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6312 else if (finfo
->info
->strip
== strip_all
6313 || (finfo
->info
->strip
== strip_some
6314 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6315 h
->root
.root
.string
,
6316 false, false) == NULL
))
6321 /* If we're stripping it, and it's not a dynamic symbol, there's
6322 nothing else to do. */
6323 if (strip
&& h
->dynindx
== -1)
6327 sym
.st_size
= h
->size
;
6329 if (h
->root
.type
== bfd_link_hash_undefweak
6330 || h
->root
.type
== bfd_link_hash_defweak
)
6331 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6333 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6335 switch (h
->root
.type
)
6338 case bfd_link_hash_new
:
6342 case bfd_link_hash_undefined
:
6343 input_sec
= bfd_und_section_ptr
;
6344 sym
.st_shndx
= SHN_UNDEF
;
6347 case bfd_link_hash_undefweak
:
6348 input_sec
= bfd_und_section_ptr
;
6349 sym
.st_shndx
= SHN_UNDEF
;
6352 case bfd_link_hash_defined
:
6353 case bfd_link_hash_defweak
:
6355 input_sec
= h
->root
.u
.def
.section
;
6356 if (input_sec
->output_section
!= NULL
)
6359 elf_section_from_bfd_section (finfo
->output_bfd
,
6360 input_sec
->output_section
);
6361 if (sym
.st_shndx
== (unsigned short) -1)
6367 /* ELF symbols in relocateable files are section relative,
6368 but in nonrelocateable files they are virtual
6370 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6371 if (! finfo
->info
->relocateable
)
6372 sym
.st_value
+= input_sec
->output_section
->vma
;
6376 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6377 == bfd_target_elf_flavour
)
6378 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6379 sym
.st_shndx
= SHN_UNDEF
;
6380 input_sec
= bfd_und_section_ptr
;
6385 case bfd_link_hash_common
:
6386 input_sec
= bfd_com_section_ptr
;
6387 sym
.st_shndx
= SHN_COMMON
;
6388 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
6391 case bfd_link_hash_indirect
:
6392 case bfd_link_hash_warning
:
6393 /* I have no idea how these should be handled. */
6397 /* If this symbol should be put in the .dynsym section, then put it
6398 there now. We have already know the symbol index. We also fill
6399 in the entry in the .hash section. */
6400 if (h
->dynindx
!= -1
6401 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6403 struct elf_backend_data
*bed
;
6406 bfd_byte
*bucketpos
;
6409 sym
.st_name
= h
->dynstr_index
;
6411 /* Give the processor backend a chance to tweak the symbol
6412 value, and also to finish up anything that needs to be done
6414 bed
= get_elf_backend_data (finfo
->output_bfd
);
6415 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6416 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6422 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6423 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6426 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6427 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6429 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6430 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6431 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6432 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6433 put_word (finfo
->output_bfd
, chain
,
6434 ((bfd_byte
*) finfo
->hash_sec
->contents
6435 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6438 /* If we're stripping it, then it was just a dynamic symbol, and
6439 there's nothing else to do. */
6443 h
->indx
= finfo
->output_bfd
->symcount
;
6445 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6454 /* Link an input file into the linker output file. This function
6455 handles all the sections and relocations of the input file at once.
6456 This is so that we only have to read the local symbols once, and
6457 don't have to keep them in memory. */
6460 elf_link_input_bfd (finfo
, input_bfd
)
6461 struct elf_final_link_info
*finfo
;
6464 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6465 bfd
*, asection
*, bfd_byte
*,
6466 Elf_Internal_Rela
*,
6467 Elf_Internal_Sym
*, asection
**));
6469 Elf_Internal_Shdr
*symtab_hdr
;
6472 Elf_External_Sym
*esym
;
6473 Elf_External_Sym
*esymend
;
6474 Elf_Internal_Sym
*isym
;
6476 asection
**ppsection
;
6479 output_bfd
= finfo
->output_bfd
;
6481 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6483 /* If this is a dynamic object, we don't want to do anything here:
6484 we don't want the local symbols, and we don't want the section
6486 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6489 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6490 if (elf_bad_symtab (input_bfd
))
6492 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6497 locsymcount
= symtab_hdr
->sh_info
;
6498 extsymoff
= symtab_hdr
->sh_info
;
6501 /* Read the local symbols. */
6503 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6504 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6505 locsymcount
, input_bfd
)
6506 != locsymcount
* sizeof (Elf_External_Sym
))))
6509 /* Swap in the local symbols and write out the ones which we know
6510 are going into the output file. */
6511 esym
= finfo
->external_syms
;
6512 esymend
= esym
+ locsymcount
;
6513 isym
= finfo
->internal_syms
;
6514 pindex
= finfo
->indices
;
6515 ppsection
= finfo
->sections
;
6516 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6520 Elf_Internal_Sym osym
;
6522 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6525 if (elf_bad_symtab (input_bfd
))
6527 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6534 if (isym
->st_shndx
== SHN_UNDEF
)
6535 isec
= bfd_und_section_ptr
;
6536 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6537 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6538 else if (isym
->st_shndx
== SHN_ABS
)
6539 isec
= bfd_abs_section_ptr
;
6540 else if (isym
->st_shndx
== SHN_COMMON
)
6541 isec
= bfd_com_section_ptr
;
6550 /* Don't output the first, undefined, symbol. */
6551 if (esym
== finfo
->external_syms
)
6554 /* If we are stripping all symbols, we don't want to output this
6556 if (finfo
->info
->strip
== strip_all
)
6559 /* We never output section symbols. Instead, we use the section
6560 symbol of the corresponding section in the output file. */
6561 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6564 /* If we are discarding all local symbols, we don't want to
6565 output this one. If we are generating a relocateable output
6566 file, then some of the local symbols may be required by
6567 relocs; we output them below as we discover that they are
6569 if (finfo
->info
->discard
== discard_all
)
6572 /* Get the name of the symbol. */
6573 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6578 /* See if we are discarding symbols with this name. */
6579 if ((finfo
->info
->strip
== strip_some
6580 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6582 || (finfo
->info
->discard
== discard_l
6583 && strncmp (name
, finfo
->info
->lprefix
,
6584 finfo
->info
->lprefix_len
) == 0))
6587 /* If we get here, we are going to output this symbol. */
6591 /* Adjust the section index for the output file. */
6592 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6593 isec
->output_section
);
6594 if (osym
.st_shndx
== (unsigned short) -1)
6597 *pindex
= output_bfd
->symcount
;
6599 /* ELF symbols in relocateable files are section relative, but
6600 in executable files they are virtual addresses. Note that
6601 this code assumes that all ELF sections have an associated
6602 BFD section with a reasonable value for output_offset; below
6603 we assume that they also have a reasonable value for
6604 output_section. Any special sections must be set up to meet
6605 these requirements. */
6606 osym
.st_value
+= isec
->output_offset
;
6607 if (! finfo
->info
->relocateable
)
6608 osym
.st_value
+= isec
->output_section
->vma
;
6610 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6614 /* Relocate the contents of each section. */
6615 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6617 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6620 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6621 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6623 /* Section was created by elf_link_create_dynamic_sections.
6624 FIXME: This test is fragile. */
6628 /* Read the contents of the section. */
6629 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6630 (file_ptr
) 0, o
->_raw_size
))
6633 if ((o
->flags
& SEC_RELOC
) != 0)
6635 Elf_Internal_Rela
*internal_relocs
;
6637 /* Get the swapped relocs. */
6638 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6639 finfo
->external_relocs
,
6640 finfo
->internal_relocs
,
6642 if (internal_relocs
== NULL
6643 && o
->reloc_count
> 0)
6646 /* Relocate the section by invoking a back end routine.
6648 The back end routine is responsible for adjusting the
6649 section contents as necessary, and (if using Rela relocs
6650 and generating a relocateable output file) adjusting the
6651 reloc addend as necessary.
6653 The back end routine does not have to worry about setting
6654 the reloc address or the reloc symbol index.
6656 The back end routine is given a pointer to the swapped in
6657 internal symbols, and can access the hash table entries
6658 for the external symbols via elf_sym_hashes (input_bfd).
6660 When generating relocateable output, the back end routine
6661 must handle STB_LOCAL/STT_SECTION symbols specially. The
6662 output symbol is going to be a section symbol
6663 corresponding to the output section, which will require
6664 the addend to be adjusted. */
6666 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6670 finfo
->internal_syms
,
6674 if (finfo
->info
->relocateable
)
6676 Elf_Internal_Rela
*irela
;
6677 Elf_Internal_Rela
*irelaend
;
6678 struct elf_link_hash_entry
**rel_hash
;
6679 Elf_Internal_Shdr
*input_rel_hdr
;
6680 Elf_Internal_Shdr
*output_rel_hdr
;
6682 /* Adjust the reloc addresses and symbol indices. */
6684 irela
= internal_relocs
;
6685 irelaend
= irela
+ o
->reloc_count
;
6686 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6687 + o
->output_section
->reloc_count
);
6688 for (; irela
< irelaend
; irela
++, rel_hash
++)
6691 Elf_Internal_Sym
*isym
;
6694 irela
->r_offset
+= o
->output_offset
;
6696 r_symndx
= ELF_R_SYM (irela
->r_info
);
6701 if (r_symndx
>= locsymcount
6702 || (elf_bad_symtab (input_bfd
)
6703 && finfo
->sections
[r_symndx
] == NULL
))
6707 /* This is a reloc against a global symbol. We
6708 have not yet output all the local symbols, so
6709 we do not know the symbol index of any global
6710 symbol. We set the rel_hash entry for this
6711 reloc to point to the global hash table entry
6712 for this symbol. The symbol index is then
6713 set at the end of elf_bfd_final_link. */
6714 indx
= r_symndx
- extsymoff
;
6715 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6717 /* Setting the index to -2 tells
6718 elf_link_output_extsym that this symbol is
6720 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6721 (*rel_hash
)->indx
= -2;
6726 /* This is a reloc against a local symbol. */
6729 isym
= finfo
->internal_syms
+ r_symndx
;
6730 sec
= finfo
->sections
[r_symndx
];
6731 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6733 /* I suppose the backend ought to fill in the
6734 section of any STT_SECTION symbol against a
6735 processor specific section. */
6736 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6738 else if (sec
== NULL
|| sec
->owner
== NULL
)
6740 bfd_set_error (bfd_error_bad_value
);
6745 r_symndx
= sec
->output_section
->target_index
;
6746 BFD_ASSERT (r_symndx
!= 0);
6751 if (finfo
->indices
[r_symndx
] == -1)
6757 if (finfo
->info
->strip
== strip_all
)
6759 /* You can't do ld -r -s. */
6760 bfd_set_error (bfd_error_invalid_operation
);
6764 /* This symbol was skipped earlier, but
6765 since it is needed by a reloc, we
6766 must output it now. */
6767 link
= symtab_hdr
->sh_link
;
6768 name
= elf_string_from_elf_section (input_bfd
,
6774 osec
= sec
->output_section
;
6776 elf_section_from_bfd_section (output_bfd
,
6778 if (isym
->st_shndx
== (unsigned short) -1)
6781 isym
->st_value
+= sec
->output_offset
;
6782 if (! finfo
->info
->relocateable
)
6783 isym
->st_value
+= osec
->vma
;
6785 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6787 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6791 r_symndx
= finfo
->indices
[r_symndx
];
6794 irela
->r_info
= ELF_R_INFO (r_symndx
,
6795 ELF_R_TYPE (irela
->r_info
));
6798 /* Swap out the relocs. */
6799 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6800 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6801 BFD_ASSERT (output_rel_hdr
->sh_entsize
6802 == input_rel_hdr
->sh_entsize
);
6803 irela
= internal_relocs
;
6804 irelaend
= irela
+ o
->reloc_count
;
6805 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6807 Elf_External_Rel
*erel
;
6809 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6810 + o
->output_section
->reloc_count
);
6811 for (; irela
< irelaend
; irela
++, erel
++)
6813 Elf_Internal_Rel irel
;
6815 irel
.r_offset
= irela
->r_offset
;
6816 irel
.r_info
= irela
->r_info
;
6817 BFD_ASSERT (irela
->r_addend
== 0);
6818 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6823 Elf_External_Rela
*erela
;
6825 BFD_ASSERT (input_rel_hdr
->sh_entsize
6826 == sizeof (Elf_External_Rela
));
6827 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6828 + o
->output_section
->reloc_count
);
6829 for (; irela
< irelaend
; irela
++, erela
++)
6830 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6833 o
->output_section
->reloc_count
+= o
->reloc_count
;
6837 /* Write out the modified section contents. */
6838 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6839 finfo
->contents
, o
->output_offset
,
6840 (o
->_cooked_size
!= 0
6849 /* Generate a reloc when linking an ELF file. This is a reloc
6850 requested by the linker, and does come from any input file. This
6851 is used to build constructor and destructor tables when linking
6855 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6857 struct bfd_link_info
*info
;
6858 asection
*output_section
;
6859 struct bfd_link_order
*link_order
;
6861 reloc_howto_type
*howto
;
6864 struct elf_link_hash_entry
**rel_hash_ptr
;
6865 Elf_Internal_Shdr
*rel_hdr
;
6867 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6870 bfd_set_error (bfd_error_bad_value
);
6874 /* If this is an inplace reloc, we must write the addend into the
6876 if (howto
->partial_inplace
6877 && link_order
->u
.reloc
.p
->addend
!= 0)
6880 bfd_reloc_status_type rstat
;
6884 size
= bfd_get_reloc_size (howto
);
6885 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6886 if (buf
== (bfd_byte
*) NULL
)
6888 bfd_set_error (bfd_error_no_memory
);
6891 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6892 link_order
->u
.reloc
.p
->addend
, buf
);
6898 case bfd_reloc_outofrange
:
6900 case bfd_reloc_overflow
:
6901 if (! ((*info
->callbacks
->reloc_overflow
)
6903 (link_order
->type
== bfd_section_reloc_link_order
6904 ? bfd_section_name (output_bfd
,
6905 link_order
->u
.reloc
.p
->u
.section
)
6906 : link_order
->u
.reloc
.p
->u
.name
),
6907 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6908 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6915 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6916 (file_ptr
) link_order
->offset
, size
);
6922 /* Figure out the symbol index. */
6923 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6924 + output_section
->reloc_count
);
6925 if (link_order
->type
== bfd_section_reloc_link_order
)
6927 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6928 BFD_ASSERT (indx
!= 0);
6929 *rel_hash_ptr
= NULL
;
6933 struct elf_link_hash_entry
*h
;
6935 h
= elf_link_hash_lookup (elf_hash_table (info
),
6936 link_order
->u
.reloc
.p
->u
.name
,
6937 false, false, true);
6940 /* Setting the index to -2 tells elf_link_output_extsym that
6941 this symbol is used by a reloc. */
6948 if (! ((*info
->callbacks
->unattached_reloc
)
6949 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6950 (asection
*) NULL
, (bfd_vma
) 0)))
6956 /* The address of a reloc is relative to the section in a
6957 relocateable file, and is a virtual address in an executable
6959 offset
= link_order
->offset
;
6960 if (! info
->relocateable
)
6961 offset
+= output_section
->vma
;
6963 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6965 if (rel_hdr
->sh_type
== SHT_REL
)
6967 Elf_Internal_Rel irel
;
6968 Elf_External_Rel
*erel
;
6970 irel
.r_offset
= offset
;
6971 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6972 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6973 + output_section
->reloc_count
);
6974 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6978 Elf_Internal_Rela irela
;
6979 Elf_External_Rela
*erela
;
6981 irela
.r_offset
= offset
;
6982 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6983 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6984 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6985 + output_section
->reloc_count
);
6986 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6989 ++output_section
->reloc_count
;