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 write_relocs NAME(bfd_elf,_write_relocs)
115 #define elf_find_section NAME(bfd_elf,find_section)
116 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
117 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
118 #define elf_link_create_dynamic_sections \
119 NAME(bfd_elf,link_create_dynamic_sections)
120 #define elf_link_record_dynamic_symbol \
121 NAME(bfd_elf,link_record_dynamic_symbol)
122 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
125 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
126 #define ELF_R_SYM(X) ELF64_R_SYM(X)
127 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
128 #define ELFCLASS ELFCLASS64
130 #define LOG_FILE_ALIGN 3
133 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
134 #define ELF_R_SYM(X) ELF32_R_SYM(X)
135 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
136 #define ELFCLASS ELFCLASS32
138 #define LOG_FILE_ALIGN 2
141 /* Forward declarations of static functions */
143 static struct bfd_strtab_hash
*elf_stringtab_init
PARAMS ((void));
144 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
146 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
148 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
150 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
152 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
153 struct symbol_cache_entry
**));
155 static boolean elf_compute_section_file_positions
156 PARAMS ((bfd
*, struct bfd_link_info
*));
157 static boolean prep_headers
PARAMS ((bfd
*));
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
*));
184 #define elf_string_from_elf_strtab(abfd,strindex) \
185 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
187 /* Structure swapping routines */
189 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
190 can be handled by explicitly specifying 32 bits or "the long type". */
192 #define put_word bfd_h_put_64
193 #define get_word bfd_h_get_64
196 #define put_word bfd_h_put_32
197 #define get_word bfd_h_get_32
200 /* Translate an ELF symbol in external format into an ELF symbol in internal
204 elf_swap_symbol_in (abfd
, src
, dst
)
206 Elf_External_Sym
*src
;
207 Elf_Internal_Sym
*dst
;
209 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
210 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
211 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
212 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
213 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
214 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
217 /* Translate an ELF symbol in internal format into an ELF symbol in external
221 elf_swap_symbol_out (abfd
, src
, dst
)
223 Elf_Internal_Sym
*src
;
224 Elf_External_Sym
*dst
;
226 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
227 put_word (abfd
, src
->st_value
, dst
->st_value
);
228 put_word (abfd
, src
->st_size
, dst
->st_size
);
229 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
230 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
231 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
235 /* Translate an ELF file header in external format into an ELF file header in
239 elf_swap_ehdr_in (abfd
, src
, dst
)
241 Elf_External_Ehdr
*src
;
242 Elf_Internal_Ehdr
*dst
;
244 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
245 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
246 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
247 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
248 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
249 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
250 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
251 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
252 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
253 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
254 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
255 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
256 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
257 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
260 /* Translate an ELF file header in internal format into an ELF file header in
264 elf_swap_ehdr_out (abfd
, src
, dst
)
266 Elf_Internal_Ehdr
*src
;
267 Elf_External_Ehdr
*dst
;
269 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
270 /* note that all elements of dst are *arrays of unsigned char* already... */
271 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
272 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
273 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
274 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
275 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
276 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
277 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
278 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
279 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
280 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
281 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
282 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
283 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
287 /* Translate an ELF section header table entry in external format into an
288 ELF section header table entry in internal format. */
291 elf_swap_shdr_in (abfd
, src
, dst
)
293 Elf_External_Shdr
*src
;
294 Elf_Internal_Shdr
*dst
;
296 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
297 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
298 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
299 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
300 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
301 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
302 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
303 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
304 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
305 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
306 dst
->bfd_section
= NULL
;
307 dst
->contents
= NULL
;
310 /* Translate an ELF section header table entry in internal format into an
311 ELF section header table entry in external format. */
314 elf_swap_shdr_out (abfd
, src
, dst
)
316 Elf_Internal_Shdr
*src
;
317 Elf_External_Shdr
*dst
;
319 /* note that all elements of dst are *arrays of unsigned char* already... */
320 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
321 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
322 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
323 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
324 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
325 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
326 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
327 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
328 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
329 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
333 /* Translate an ELF program header table entry in external format into an
334 ELF program header table entry in internal format. */
337 elf_swap_phdr_in (abfd
, src
, dst
)
339 Elf_External_Phdr
*src
;
340 Elf_Internal_Phdr
*dst
;
342 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
343 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
344 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
345 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
346 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
347 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
348 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
349 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
353 elf_swap_phdr_out (abfd
, src
, dst
)
355 Elf_Internal_Phdr
*src
;
356 Elf_External_Phdr
*dst
;
358 /* note that all elements of dst are *arrays of unsigned char* already... */
359 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
360 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
361 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
362 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
363 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
364 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
365 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
366 put_word (abfd
, src
->p_align
, dst
->p_align
);
369 /* Translate an ELF reloc from external format to internal format. */
371 elf_swap_reloc_in (abfd
, src
, dst
)
373 Elf_External_Rel
*src
;
374 Elf_Internal_Rel
*dst
;
376 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
377 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
381 elf_swap_reloca_in (abfd
, src
, dst
)
383 Elf_External_Rela
*src
;
384 Elf_Internal_Rela
*dst
;
386 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
387 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
388 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
391 /* Translate an ELF reloc from internal format to external format. */
393 elf_swap_reloc_out (abfd
, src
, dst
)
395 Elf_Internal_Rel
*src
;
396 Elf_External_Rel
*dst
;
398 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
399 put_word (abfd
, src
->r_info
, dst
->r_info
);
403 elf_swap_reloca_out (abfd
, src
, dst
)
405 Elf_Internal_Rela
*src
;
406 Elf_External_Rela
*dst
;
408 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
409 put_word (abfd
, src
->r_info
, dst
->r_info
);
410 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
414 elf_swap_dyn_in (abfd
, src
, dst
)
416 const Elf_External_Dyn
*src
;
417 Elf_Internal_Dyn
*dst
;
419 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
420 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
424 elf_swap_dyn_out (abfd
, src
, dst
)
426 const Elf_Internal_Dyn
*src
;
427 Elf_External_Dyn
*dst
;
429 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
430 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
433 /* Allocate an ELF string table--force the first byte to be zero. */
435 static struct bfd_strtab_hash
*
436 elf_stringtab_init ()
438 struct bfd_strtab_hash
*ret
;
440 ret
= _bfd_stringtab_init ();
445 loc
= _bfd_stringtab_add (ret
, "", true, false);
446 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
447 if (loc
== (bfd_size_type
) -1)
449 _bfd_stringtab_free (ret
);
456 /* ELF .o/exec file reading */
458 /* Create a new bfd section from an ELF section header. */
461 bfd_section_from_shdr (abfd
, shindex
)
463 unsigned int shindex
;
465 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
466 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
469 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
471 switch (hdr
->sh_type
)
474 /* Inactive section. Throw it away. */
477 case SHT_PROGBITS
: /* Normal section with contents. */
478 case SHT_DYNAMIC
: /* Dynamic linking information. */
479 case SHT_NOBITS
: /* .bss section. */
480 case SHT_HASH
: /* .hash section. */
481 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
483 case SHT_SYMTAB
: /* A symbol table */
484 if (elf_onesymtab (abfd
) == shindex
)
487 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
488 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
489 elf_onesymtab (abfd
) = shindex
;
490 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
491 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
492 abfd
->flags
|= HAS_SYMS
;
494 /* Sometimes a shared object will map in the symbol table. If
495 SHF_ALLOC is set, and this is a shared object, then we also
496 treat this section as a BFD section. We can not base the
497 decision purely on SHF_ALLOC, because that flag is sometimes
498 set in a relocateable object file, which would confuse the
500 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
501 && (abfd
->flags
& DYNAMIC
) != 0
502 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
507 case SHT_DYNSYM
: /* A dynamic symbol table */
508 if (elf_dynsymtab (abfd
) == shindex
)
511 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
512 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
513 elf_dynsymtab (abfd
) = shindex
;
514 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
515 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
516 abfd
->flags
|= HAS_SYMS
;
518 /* Besides being a symbol table, we also treat this as a regular
519 section, so that objcopy can handle it. */
520 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
522 case SHT_STRTAB
: /* A string table */
523 if (hdr
->bfd_section
!= NULL
)
525 if (ehdr
->e_shstrndx
== shindex
)
527 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
528 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
534 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
536 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
537 if (hdr2
->sh_link
== shindex
)
539 if (! bfd_section_from_shdr (abfd
, i
))
541 if (elf_onesymtab (abfd
) == i
)
543 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
544 elf_elfsections (abfd
)[shindex
] =
545 &elf_tdata (abfd
)->strtab_hdr
;
548 if (elf_dynsymtab (abfd
) == i
)
550 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
551 elf_elfsections (abfd
)[shindex
] =
552 &elf_tdata (abfd
)->dynstrtab_hdr
;
553 /* We also treat this as a regular section, so
554 that objcopy can handle it. */
557 #if 0 /* Not handling other string tables specially right now. */
558 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
559 /* We have a strtab for some random other section. */
560 newsect
= (asection
*) hdr2
->bfd_section
;
563 hdr
->bfd_section
= newsect
;
564 hdr2
= &elf_section_data (newsect
)->str_hdr
;
566 elf_elfsections (abfd
)[shindex
] = hdr2
;
572 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
576 /* *These* do a lot of work -- but build no sections! */
578 asection
*target_sect
;
579 Elf_Internal_Shdr
*hdr2
;
580 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
582 /* Get the symbol table. */
583 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
586 /* If this reloc section does not use the main symbol table we
587 don't treat it as a reloc section. BFD can't adequately
588 represent such a section, so at least for now, we don't
589 try. We just present it as a normal section. */
590 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
591 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
593 /* Don't allow REL relocations on a machine that uses RELA and
595 /* @@ Actually, the generic ABI does suggest that both might be
596 used in one file. But the four ABI Processor Supplements I
597 have access to right now all specify that only one is used on
598 each of those architectures. It's conceivable that, e.g., a
599 bunch of absolute 32-bit relocs might be more compact in REL
600 form even on a RELA machine... */
601 BFD_ASSERT (use_rela_p
602 ? (hdr
->sh_type
== SHT_RELA
603 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
604 : (hdr
->sh_type
== SHT_REL
605 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
607 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
609 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
610 if (target_sect
== NULL
)
613 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
615 elf_elfsections (abfd
)[shindex
] = hdr2
;
616 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
617 target_sect
->flags
|= SEC_RELOC
;
618 target_sect
->relocation
= NULL
;
619 target_sect
->rel_filepos
= hdr
->sh_offset
;
620 abfd
->flags
|= HAS_RELOC
;
627 fprintf (stderr
, "Note Sections not yet supported.\n");
634 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
639 /* Check for any processor-specific section types. */
641 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
643 if (bed
->elf_backend_section_from_shdr
)
644 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
653 elf_new_section_hook (abfd
, sec
)
658 struct bfd_elf_section_data
*sdata
;
660 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
663 bfd_set_error (bfd_error_no_memory
);
666 sec
->used_by_bfd
= (PTR
) sdata
;
667 memset (sdata
, 0, sizeof (*sdata
));
671 /* Create a new bfd section from an ELF program header.
673 Since program segments have no names, we generate a synthetic name
674 of the form segment<NUM>, where NUM is generally the index in the
675 program header table. For segments that are split (see below) we
676 generate the names segment<NUM>a and segment<NUM>b.
678 Note that some program segments may have a file size that is different than
679 (less than) the memory size. All this means is that at execution the
680 system must allocate the amount of memory specified by the memory size,
681 but only initialize it with the first "file size" bytes read from the
682 file. This would occur for example, with program segments consisting
683 of combined data+bss.
685 To handle the above situation, this routine generates TWO bfd sections
686 for the single program segment. The first has the length specified by
687 the file size of the segment, and the second has the length specified
688 by the difference between the two sizes. In effect, the segment is split
689 into it's initialized and uninitialized parts.
694 bfd_section_from_phdr (abfd
, hdr
, index
)
696 Elf_Internal_Phdr
*hdr
;
704 split
= ((hdr
->p_memsz
> 0) &&
705 (hdr
->p_filesz
> 0) &&
706 (hdr
->p_memsz
> hdr
->p_filesz
));
707 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
708 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
711 bfd_set_error (bfd_error_no_memory
);
714 strcpy (name
, namebuf
);
715 newsect
= bfd_make_section (abfd
, name
);
718 newsect
->vma
= hdr
->p_vaddr
;
719 newsect
->_raw_size
= hdr
->p_filesz
;
720 newsect
->filepos
= hdr
->p_offset
;
721 newsect
->flags
|= SEC_HAS_CONTENTS
;
722 if (hdr
->p_type
== PT_LOAD
)
724 newsect
->flags
|= SEC_ALLOC
;
725 newsect
->flags
|= SEC_LOAD
;
726 if (hdr
->p_flags
& PF_X
)
728 /* FIXME: all we known is that it has execute PERMISSION,
730 newsect
->flags
|= SEC_CODE
;
733 if (!(hdr
->p_flags
& PF_W
))
735 newsect
->flags
|= SEC_READONLY
;
740 sprintf (namebuf
, "segment%db", index
);
741 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
744 bfd_set_error (bfd_error_no_memory
);
747 strcpy (name
, namebuf
);
748 newsect
= bfd_make_section (abfd
, name
);
751 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
752 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
753 if (hdr
->p_type
== PT_LOAD
)
755 newsect
->flags
|= SEC_ALLOC
;
756 if (hdr
->p_flags
& PF_X
)
757 newsect
->flags
|= SEC_CODE
;
759 if (!(hdr
->p_flags
& PF_W
))
760 newsect
->flags
|= SEC_READONLY
;
766 /* Begin processing a given object.
768 First we validate the file by reading in the ELF header and checking
771 static INLINE boolean
773 Elf_External_Ehdr
*x_ehdrp
;
775 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
776 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
777 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
778 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
781 /* Check to see if the file associated with ABFD matches the target vector
784 Note that we may be called several times with the same ABFD, but different
785 target vectors, most of which will not match. We have to avoid leaving
786 any side effects in ABFD, or any data it points to (like tdata), if the
787 file does not match the target vector. */
793 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
794 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
795 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
796 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
797 unsigned int shindex
;
798 char *shstrtab
; /* Internal copy of section header stringtab */
799 struct elf_backend_data
*ebd
;
800 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
801 struct elf_obj_tdata
*new_tdata
= NULL
;
803 /* Read in the ELF header in external format. */
805 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
807 if (bfd_get_error () != bfd_error_system_call
)
808 goto got_wrong_format_error
;
813 /* Now check to see if we have a valid ELF file, and one that BFD can
814 make use of. The magic number must match, the address size ('class')
815 and byte-swapping must match our XVEC entry, and it must have a
816 section header table (FIXME: See comments re sections at top of this
819 if ((elf_file_p (&x_ehdr
) == false) ||
820 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
821 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
822 goto got_wrong_format_error
;
824 /* Check that file's byte order matches xvec's */
825 switch (x_ehdr
.e_ident
[EI_DATA
])
827 case ELFDATA2MSB
: /* Big-endian */
828 if (!abfd
->xvec
->header_byteorder_big_p
)
829 goto got_wrong_format_error
;
831 case ELFDATA2LSB
: /* Little-endian */
832 if (abfd
->xvec
->header_byteorder_big_p
)
833 goto got_wrong_format_error
;
835 case ELFDATANONE
: /* No data encoding specified */
836 default: /* Unknown data encoding specified */
837 goto got_wrong_format_error
;
840 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
841 the tdata pointer in the bfd. */
843 new_tdata
= ((struct elf_obj_tdata
*)
844 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
845 if (new_tdata
== NULL
)
846 goto got_no_memory_error
;
847 elf_tdata (abfd
) = new_tdata
;
849 /* Now that we know the byte order, swap in the rest of the header */
850 i_ehdrp
= elf_elfheader (abfd
);
851 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
853 elf_debug_file (i_ehdrp
);
856 /* If there is no section header table, we're hosed. */
857 if (i_ehdrp
->e_shoff
== 0)
858 goto got_wrong_format_error
;
860 /* As a simple sanity check, verify that the what BFD thinks is the
861 size of each section header table entry actually matches the size
862 recorded in the file. */
863 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
864 goto got_wrong_format_error
;
866 ebd
= get_elf_backend_data (abfd
);
868 /* Check that the ELF e_machine field matches what this particular
869 BFD format expects. */
870 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
871 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
872 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
874 const bfd_target
* const *target_ptr
;
876 if (ebd
->elf_machine_code
!= EM_NONE
)
877 goto got_wrong_format_error
;
879 /* This is the generic ELF target. Let it match any ELF target
880 for which we do not have a specific backend. */
881 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
883 struct elf_backend_data
*back
;
885 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
887 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
888 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
890 /* target_ptr is an ELF backend which matches this
891 object file, so reject the generic ELF target. */
892 goto got_wrong_format_error
;
897 if (i_ehdrp
->e_type
== ET_EXEC
)
898 abfd
->flags
|= EXEC_P
;
899 else if (i_ehdrp
->e_type
== ET_DYN
)
900 abfd
->flags
|= DYNAMIC
;
902 if (i_ehdrp
->e_phnum
> 0)
903 abfd
->flags
|= D_PAGED
;
905 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
908 /* Remember the entry point specified in the ELF file header. */
909 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
911 /* Allocate space for a copy of the section header table in
912 internal form, seek to the section header table in the file,
913 read it in, and convert it to internal form. */
914 i_shdrp
= ((Elf_Internal_Shdr
*)
915 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
916 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
918 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
919 if (!i_shdrp
|| !elf_elfsections (abfd
))
920 goto got_no_memory_error
;
921 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
923 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
925 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
927 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
928 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
930 if (i_ehdrp
->e_shstrndx
)
932 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
936 /* Read in the string table containing the names of the sections. We
937 will need the base pointer to this table later. */
938 /* We read this inline now, so that we don't have to go through
939 bfd_section_from_shdr with it (since this particular strtab is
940 used to find all of the ELF section names.) */
942 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
946 /* Once all of the section headers have been read and converted, we
947 can start processing them. Note that the first section header is
948 a dummy placeholder entry, so we ignore it. */
950 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
952 if (! bfd_section_from_shdr (abfd
, shindex
))
956 /* Let the backend double check the format and override global
958 if (ebd
->elf_backend_object_p
)
960 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
961 goto got_wrong_format_error
;
966 got_wrong_format_error
:
967 bfd_set_error (bfd_error_wrong_format
);
970 bfd_set_error (bfd_error_no_memory
);
973 if (new_tdata
!= NULL
974 && new_tdata
->elf_sect_ptr
!= NULL
)
975 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
977 bfd_release (abfd
, i_shdrp
);
978 if (new_tdata
!= NULL
)
979 bfd_release (abfd
, new_tdata
);
980 elf_tdata (abfd
) = preserved_tdata
;
985 /* ELF .o/exec file writing */
987 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
988 of the symbol if there is one. */
989 static INLINE elf_symbol_type
*
990 elf_symbol_from (ignore_abfd
, symbol
)
994 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
997 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1000 return (elf_symbol_type
*) symbol
;
1004 write_relocs (abfd
, sec
, xxx
)
1009 Elf_Internal_Shdr
*rela_hdr
;
1010 Elf_External_Rela
*outbound_relocas
;
1011 Elf_External_Rel
*outbound_relocs
;
1013 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1014 asymbol
*last_sym
= 0;
1015 int last_sym_idx
= 9999999; /* should always be written before use */
1017 if ((sec
->flags
& SEC_RELOC
) == 0)
1020 /* The linker backend writes the relocs out itself, and sets the
1021 reloc_count field to zero to inhibit writing them here. Also,
1022 sometimes the SEC_RELOC flag gets set even when there aren't any
1024 if (sec
->reloc_count
== 0)
1027 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1029 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1030 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1031 if (!rela_hdr
->contents
)
1033 bfd_set_error (bfd_error_no_memory
);
1034 abort (); /* FIXME */
1037 /* orelocation has the data, reloc_count has the count... */
1040 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1042 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1044 Elf_Internal_Rela dst_rela
;
1045 Elf_External_Rela
*src_rela
;
1050 ptr
= sec
->orelocation
[idx
];
1051 src_rela
= outbound_relocas
+ idx
;
1053 /* The address of an ELF reloc is section relative for an object
1054 file, and absolute for an executable file or shared library.
1055 The address of a BFD reloc is always section relative. */
1056 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1057 dst_rela
.r_offset
= ptr
->address
;
1059 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
1061 sym
= *ptr
->sym_ptr_ptr
;
1062 if (sym
== last_sym
)
1067 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1069 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1071 dst_rela
.r_addend
= ptr
->addend
;
1072 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1076 /* REL relocations */
1078 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1080 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1082 Elf_Internal_Rel dst_rel
;
1083 Elf_External_Rel
*src_rel
;
1088 ptr
= sec
->orelocation
[idx
];
1089 sym
= *ptr
->sym_ptr_ptr
;
1090 src_rel
= outbound_relocs
+ idx
;
1092 /* The address of an ELF reloc is section relative for an object
1093 file, and absolute for an executable file or shared library.
1094 The address of a BFD reloc is always section relative. */
1095 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1096 dst_rel
.r_offset
= ptr
->address
;
1098 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1100 if (sym
== last_sym
)
1105 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1107 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1109 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1114 /* Set up an ELF internal section header for a section. */
1118 elf_fake_sections (abfd
, asect
, failedptrarg
)
1123 boolean
*failedptr
= (boolean
*) failedptrarg
;
1124 Elf_Internal_Shdr
*this_hdr
;
1128 /* We already failed; just get out of the bfd_map_over_sections
1133 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1135 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1138 if (this_hdr
->sh_name
== (unsigned long) -1)
1144 this_hdr
->sh_flags
= 0;
1145 if ((asect
->flags
& SEC_ALLOC
) != 0)
1146 this_hdr
->sh_addr
= asect
->vma
;
1148 this_hdr
->sh_addr
= 0;
1149 this_hdr
->sh_offset
= 0;
1150 this_hdr
->sh_size
= asect
->_raw_size
;
1151 this_hdr
->sh_link
= 0;
1152 this_hdr
->sh_info
= 0;
1153 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1154 this_hdr
->sh_entsize
= 0;
1156 this_hdr
->bfd_section
= asect
;
1157 this_hdr
->contents
= NULL
;
1159 /* FIXME: This should not be based on section names. */
1160 if (strcmp (asect
->name
, ".dynstr") == 0)
1161 this_hdr
->sh_type
= SHT_STRTAB
;
1162 else if (strcmp (asect
->name
, ".hash") == 0)
1164 this_hdr
->sh_type
= SHT_HASH
;
1165 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1167 else if (strcmp (asect
->name
, ".dynsym") == 0)
1169 this_hdr
->sh_type
= SHT_DYNSYM
;
1170 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1172 else if (strcmp (asect
->name
, ".dynamic") == 0)
1174 this_hdr
->sh_type
= SHT_DYNAMIC
;
1175 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1177 else if (strncmp (asect
->name
, ".rela", 5) == 0
1178 && get_elf_backend_data (abfd
)->use_rela_p
)
1180 this_hdr
->sh_type
= SHT_RELA
;
1181 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1183 else if (strncmp (asect
->name
, ".rel", 4) == 0
1184 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1186 this_hdr
->sh_type
= SHT_REL
;
1187 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1189 else if (strcmp (asect
->name
, ".note") == 0)
1190 this_hdr
->sh_type
= SHT_NOTE
;
1191 else if (strncmp (asect
->name
, ".stab", 5) == 0
1192 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1193 this_hdr
->sh_type
= SHT_STRTAB
;
1194 else if ((asect
->flags
& SEC_ALLOC
) != 0
1195 && (asect
->flags
& SEC_LOAD
) != 0)
1196 this_hdr
->sh_type
= SHT_PROGBITS
;
1197 else if ((asect
->flags
& SEC_ALLOC
) != 0
1198 && ((asect
->flags
& SEC_LOAD
) == 0))
1200 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1201 || strcmp (asect
->name
, ".sbss") == 0);
1202 this_hdr
->sh_type
= SHT_NOBITS
;
1207 this_hdr
->sh_type
= SHT_PROGBITS
;
1210 if ((asect
->flags
& SEC_ALLOC
) != 0)
1211 this_hdr
->sh_flags
|= SHF_ALLOC
;
1212 if ((asect
->flags
& SEC_READONLY
) == 0)
1213 this_hdr
->sh_flags
|= SHF_WRITE
;
1214 if ((asect
->flags
& SEC_CODE
) != 0)
1215 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1217 /* Check for processor-specific section types. */
1219 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1221 if (bed
->elf_backend_fake_sections
)
1222 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1225 /* If the section has relocs, set up a section header for the
1226 SHT_REL[A] section. */
1227 if ((asect
->flags
& SEC_RELOC
) != 0)
1229 Elf_Internal_Shdr
*rela_hdr
;
1230 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1233 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1234 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1237 bfd_set_error (bfd_error_no_memory
);
1241 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1243 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1245 if (rela_hdr
->sh_name
== (unsigned int) -1)
1250 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1251 rela_hdr
->sh_entsize
= (use_rela_p
1252 ? sizeof (Elf_External_Rela
)
1253 : sizeof (Elf_External_Rel
));
1254 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1255 rela_hdr
->sh_flags
= 0;
1256 rela_hdr
->sh_addr
= 0;
1257 rela_hdr
->sh_size
= 0;
1258 rela_hdr
->sh_offset
= 0;
1262 /* Assign all ELF section numbers. The dummy first section is handled here
1263 too. The link/info pointers for the standard section types are filled
1264 in here too, while we're at it. */
1267 assign_section_numbers (abfd
)
1270 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1272 unsigned int section_number
;
1273 Elf_Internal_Shdr
**i_shdrp
;
1277 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1279 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1281 d
->this_idx
= section_number
++;
1282 if ((sec
->flags
& SEC_RELOC
) == 0)
1285 d
->rel_idx
= section_number
++;
1288 t
->shstrtab_section
= section_number
++;
1289 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1290 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1292 if (abfd
->symcount
> 0)
1294 t
->symtab_section
= section_number
++;
1295 t
->strtab_section
= section_number
++;
1298 elf_elfheader (abfd
)->e_shnum
= section_number
;
1300 /* Set up the list of section header pointers, in agreement with the
1302 i_shdrp
= ((Elf_Internal_Shdr
**)
1303 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1304 if (i_shdrp
== NULL
)
1306 bfd_set_error (bfd_error_no_memory
);
1310 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1311 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1312 if (i_shdrp
[0] == NULL
)
1314 bfd_release (abfd
, i_shdrp
);
1315 bfd_set_error (bfd_error_no_memory
);
1318 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1320 elf_elfsections (abfd
) = i_shdrp
;
1322 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1323 if (abfd
->symcount
> 0)
1325 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1326 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1327 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1329 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1331 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1335 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1336 if (d
->rel_idx
!= 0)
1337 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1339 /* Fill in the sh_link and sh_info fields while we're at it. */
1341 /* sh_link of a reloc section is the section index of the symbol
1342 table. sh_info is the section index of the section to which
1343 the relocation entries apply. */
1344 if (d
->rel_idx
!= 0)
1346 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1347 d
->rel_hdr
.sh_info
= d
->this_idx
;
1350 switch (d
->this_hdr
.sh_type
)
1354 /* A reloc section which we are treating as a normal BFD
1355 section. sh_link is the section index of the symbol
1356 table. sh_info is the section index of the section to
1357 which the relocation entries apply. We assume that an
1358 allocated reloc section uses the dynamic symbol table.
1359 FIXME: How can we be sure? */
1360 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1362 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1364 /* We look up the section the relocs apply to by name. */
1366 if (d
->this_hdr
.sh_type
== SHT_REL
)
1370 s
= bfd_get_section_by_name (abfd
, name
);
1372 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1376 /* We assume that a section named .stab*str is a stabs
1377 string section. We look for a section with the same name
1378 but without the trailing ``str'', and set its sh_link
1379 field to point to this section. */
1380 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1381 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1386 len
= strlen (sec
->name
);
1387 alc
= (char *) malloc (len
- 2);
1390 bfd_set_error (bfd_error_no_memory
);
1393 strncpy (alc
, sec
->name
, len
- 3);
1394 alc
[len
- 3] = '\0';
1395 s
= bfd_get_section_by_name (abfd
, alc
);
1399 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1401 /* This is a .stab section. */
1402 elf_section_data (s
)->this_hdr
.sh_entsize
=
1403 4 + 2 * (ARCH_SIZE
/ 8);
1410 /* sh_link is the section header index of the string table
1411 used for the dynamic entries or symbol table. */
1412 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1414 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1418 /* sh_link is the section header index of the symbol table
1419 this hash table is for. */
1420 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1422 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1430 /* Map symbol from it's internal number to the external number, moving
1431 all local symbols to be at the head of the list. */
1434 sym_is_global (abfd
, sym
)
1438 /* If the backend has a special mapping, use it. */
1439 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1440 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1443 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1445 if (sym
->flags
& BSF_LOCAL
)
1449 if (sym
->section
== 0)
1451 /* Is this valid? */
1456 if (bfd_is_und_section (sym
->section
))
1458 if (bfd_is_com_section (sym
->section
))
1460 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1466 elf_map_symbols (abfd
)
1469 int symcount
= bfd_get_symcount (abfd
);
1470 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1471 asymbol
**sect_syms
;
1473 int num_globals
= 0;
1474 int num_locals2
= 0;
1475 int num_globals2
= 0;
1477 int num_sections
= 0;
1483 fprintf (stderr
, "elf_map_symbols\n");
1487 /* Add a section symbol for each BFD section. FIXME: Is this really
1489 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1491 if (max_index
< asect
->index
)
1492 max_index
= asect
->index
;
1496 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1497 if (sect_syms
== NULL
)
1499 bfd_set_error (bfd_error_no_memory
);
1502 elf_section_syms (abfd
) = sect_syms
;
1504 for (idx
= 0; idx
< symcount
; idx
++)
1506 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1507 && syms
[idx
]->value
== 0)
1511 sec
= syms
[idx
]->section
;
1512 if (sec
->owner
!= NULL
)
1514 if (sec
->owner
!= abfd
)
1516 if (sec
->output_offset
!= 0)
1518 sec
= sec
->output_section
;
1519 BFD_ASSERT (sec
->owner
== abfd
);
1521 sect_syms
[sec
->index
] = syms
[idx
];
1526 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1530 if (sect_syms
[asect
->index
] != NULL
)
1533 sym
= bfd_make_empty_symbol (abfd
);
1536 sym
->the_bfd
= abfd
;
1537 sym
->name
= asect
->name
;
1539 /* Set the flags to 0 to indicate that this one was newly added. */
1541 sym
->section
= asect
;
1542 sect_syms
[asect
->index
] = sym
;
1546 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1547 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1551 /* Classify all of the symbols. */
1552 for (idx
= 0; idx
< symcount
; idx
++)
1554 if (!sym_is_global (abfd
, syms
[idx
]))
1559 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1561 if (sect_syms
[asect
->index
] != NULL
1562 && sect_syms
[asect
->index
]->flags
== 0)
1564 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1565 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1569 sect_syms
[asect
->index
]->flags
= 0;
1573 /* Now sort the symbols so the local symbols are first. */
1574 new_syms
= ((asymbol
**)
1576 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1577 if (new_syms
== NULL
)
1579 bfd_set_error (bfd_error_no_memory
);
1583 for (idx
= 0; idx
< symcount
; idx
++)
1585 asymbol
*sym
= syms
[idx
];
1588 if (!sym_is_global (abfd
, sym
))
1591 i
= num_locals
+ num_globals2
++;
1593 sym
->udata
.i
= i
+ 1;
1595 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1597 if (sect_syms
[asect
->index
] != NULL
1598 && sect_syms
[asect
->index
]->flags
== 0)
1600 asymbol
*sym
= sect_syms
[asect
->index
];
1603 sym
->flags
= BSF_SECTION_SYM
;
1604 if (!sym_is_global (abfd
, sym
))
1607 i
= num_locals
+ num_globals2
++;
1609 sym
->udata
.i
= i
+ 1;
1613 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1615 elf_num_locals (abfd
) = num_locals
;
1616 elf_num_globals (abfd
) = num_globals
;
1620 /* Compute the file positions we are going to put the sections at, and
1621 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1622 is not NULL, this is being called by the ELF backend linker. */
1625 elf_compute_section_file_positions (abfd
, link_info
)
1627 struct bfd_link_info
*link_info
;
1629 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1631 struct bfd_strtab_hash
*strtab
;
1632 Elf_Internal_Shdr
*shstrtab_hdr
;
1634 if (abfd
->output_has_begun
)
1637 /* Do any elf backend specific processing first. */
1638 if (bed
->elf_backend_begin_write_processing
)
1639 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1641 if (! prep_headers (abfd
))
1645 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1649 if (!assign_section_numbers (abfd
))
1652 /* The backend linker builds symbol table information itself. */
1653 if (link_info
== NULL
)
1655 if (! swap_out_syms (abfd
, &strtab
))
1659 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1660 /* sh_name was set in prep_headers. */
1661 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1662 shstrtab_hdr
->sh_flags
= 0;
1663 shstrtab_hdr
->sh_addr
= 0;
1664 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1665 shstrtab_hdr
->sh_entsize
= 0;
1666 shstrtab_hdr
->sh_link
= 0;
1667 shstrtab_hdr
->sh_info
= 0;
1668 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1669 shstrtab_hdr
->sh_addralign
= 1;
1671 if (!assign_file_positions_except_relocs (abfd
,
1672 link_info
== NULL
? true : false))
1675 if (link_info
== NULL
)
1677 /* Now that we know where the .strtab section goes, write it
1679 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1681 || ! _bfd_stringtab_emit (abfd
, strtab
))
1683 _bfd_stringtab_free (strtab
);
1686 abfd
->output_has_begun
= true;
1692 /* Align to the maximum file alignment that could be required for any
1693 ELF data structure. */
1695 static INLINE file_ptr
1696 align_file_position (off
)
1699 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1702 /* Assign a file position to a section, optionally aligning to the
1703 required section alignment. */
1705 static INLINE file_ptr
1706 assign_file_position_for_section (i_shdrp
, offset
, align
)
1707 Elf_Internal_Shdr
*i_shdrp
;
1715 al
= i_shdrp
->sh_addralign
;
1717 offset
= BFD_ALIGN (offset
, al
);
1719 i_shdrp
->sh_offset
= offset
;
1720 if (i_shdrp
->bfd_section
!= NULL
)
1721 i_shdrp
->bfd_section
->filepos
= offset
;
1722 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1723 offset
+= i_shdrp
->sh_size
;
1727 /* Get the size of the program header.
1729 SORTED_HDRS, if non-NULL, is an array of COUNT pointers to headers sorted
1730 by VMA. Non-allocated sections (!SHF_ALLOC) must appear last. All
1731 section VMAs and sizes are known so we can compute the correct value.
1732 (??? This may not be perfectly true. What cases do we miss?)
1734 If SORTED_HDRS is NULL we assume there are two segments: text and data
1735 (exclusive of .interp and .dynamic).
1737 If this is called by the linker before any of the section VMA's are set, it
1738 can't calculate the correct value for a strange memory layout. This only
1739 happens when SIZEOF_HEADERS is used in a linker script. In this case,
1740 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
1741 data segment (exclusive of .interp and .dynamic).
1743 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
1744 will be two segments. */
1746 static bfd_size_type
1747 get_program_header_size (abfd
, sorted_hdrs
, count
, maxpagesize
)
1749 Elf_Internal_Shdr
**sorted_hdrs
;
1751 bfd_vma maxpagesize
;
1756 /* We can't return a different result each time we're called. */
1757 if (elf_tdata (abfd
)->program_header_size
!= 0)
1758 return elf_tdata (abfd
)->program_header_size
;
1760 if (sorted_hdrs
!= NULL
)
1763 unsigned int last_type
;
1764 Elf_Internal_Shdr
**hdrpp
;
1765 /* What we think the current segment's offset is. */
1767 /* What we think the current segment's address is. */
1769 /* How big we think the current segment is. */
1771 /* What we think the current file offset is. */
1772 bfd_vma file_offset
;
1773 bfd_vma next_offset
;
1775 /* Scan the headers and compute the number of segments required. This
1776 code is intentionally similar to the code in map_program_segments.
1778 The `sh_offset' field isn't valid at this point, so we keep our own
1779 running total in `file_offset'.
1781 This works because section VMAs are already known. */
1784 /* Make sure the first section goes in the first segment. */
1785 file_offset
= p_offset
= sorted_hdrs
[0]->sh_addr
% maxpagesize
;
1786 p_vaddr
= sorted_hdrs
[0]->sh_addr
;
1788 last_type
= SHT_PROGBITS
;
1790 for (i
= 0, hdrpp
= sorted_hdrs
; i
< count
; i
++, hdrpp
++)
1792 Elf_Internal_Shdr
*hdr
;
1796 /* Ignore any section which will not be part of the process
1798 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1801 /* Keep track of where this and the next sections go.
1802 The section VMA must equal the file position modulo
1804 file_offset
+= (hdr
->sh_addr
- file_offset
) % maxpagesize
;
1805 next_offset
= file_offset
;
1806 if (hdr
->sh_type
!= SHT_NOBITS
)
1807 next_offset
= file_offset
+ hdr
->sh_size
;
1809 /* If this section fits in the segment we are constructing, add
1811 if ((file_offset
- (p_offset
+ p_memsz
)
1812 == hdr
->sh_addr
- (p_vaddr
+ p_memsz
))
1813 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1815 bfd_size_type adjust
;
1817 adjust
= hdr
->sh_addr
- (p_vaddr
+ p_memsz
);
1818 p_memsz
+= hdr
->sh_size
+ adjust
;
1819 file_offset
= next_offset
;
1820 last_type
= hdr
->sh_type
;
1824 /* The section won't fit, start a new segment. */
1827 /* Initialize the segment. */
1828 p_vaddr
= hdr
->sh_addr
;
1829 p_memsz
= hdr
->sh_size
;
1830 p_offset
= file_offset
;
1831 file_offset
= next_offset
;
1833 last_type
= hdr
->sh_type
;
1838 /* Assume we will need exactly two PT_LOAD segments: one for text
1839 and one for data. */
1843 s
= bfd_get_section_by_name (abfd
, ".interp");
1844 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1846 /* If we have a loadable interpreter section, we need a
1847 PT_INTERP segment. In this case, assume we also need a
1848 PT_PHDR segment, although that may not be true for all
1853 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1855 /* We need a PT_DYNAMIC segment. */
1859 elf_tdata (abfd
)->program_header_size
= segs
* sizeof (Elf_External_Phdr
);
1860 return elf_tdata (abfd
)->program_header_size
;
1863 /* Create the program header. OFF is the file offset where the
1864 program header should be written. FIRST is the first loadable ELF
1865 section. SORTED_HDRS is the ELF sections sorted by section
1866 address. PHDR_SIZE is the size of the program header as returned
1867 by get_program_header_size. */
1870 map_program_segments (abfd
, off
, first
, sorted_hdrs
, phdr_size
)
1873 Elf_Internal_Shdr
*first
;
1874 Elf_Internal_Shdr
**sorted_hdrs
;
1875 bfd_size_type phdr_size
;
1877 Elf_Internal_Phdr phdrs
[10];
1878 unsigned int phdr_count
;
1879 Elf_Internal_Phdr
*phdr
;
1880 int phdr_size_adjust
;
1882 Elf_Internal_Shdr
**hdrpp
;
1883 asection
*sinterp
, *sdyn
;
1884 unsigned int last_type
;
1885 Elf_Internal_Ehdr
*i_ehdrp
;
1887 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1888 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1889 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1894 phdr_size_adjust
= 0;
1896 /* If we have a loadable .interp section, we must create a PT_INTERP
1897 segment which must precede all PT_LOAD segments. We assume that
1898 we must also create a PT_PHDR segment, although that may not be
1899 true for all targets. */
1900 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1901 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1903 BFD_ASSERT (first
!= NULL
);
1905 phdr
->p_type
= PT_PHDR
;
1907 phdr
->p_offset
= off
;
1909 /* Account for any adjustment made because of the alignment of
1910 the first loadable section. */
1911 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1912 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1914 /* The program header precedes all loadable sections. This lets
1915 us compute its loadable address. This depends on the linker
1917 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1920 phdr
->p_filesz
= phdr_size
;
1921 phdr
->p_memsz
= phdr_size
;
1923 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1924 phdr
->p_flags
= PF_R
| PF_X
;
1926 phdr
->p_align
= FILE_ALIGN
;
1927 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1929 /* Include the ELF header in the first loadable segment. */
1930 phdr_size_adjust
+= off
;
1935 phdr
->p_type
= PT_INTERP
;
1936 phdr
->p_offset
= sinterp
->filepos
;
1937 phdr
->p_vaddr
= sinterp
->vma
;
1939 phdr
->p_filesz
= sinterp
->_raw_size
;
1940 phdr
->p_memsz
= sinterp
->_raw_size
;
1941 phdr
->p_flags
= PF_R
;
1942 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1948 /* Look through the sections to see how they will be divided into
1949 program segments. The sections must be arranged in order by
1950 sh_addr for this to work correctly. */
1951 phdr
->p_type
= PT_NULL
;
1952 last_type
= SHT_PROGBITS
;
1953 for (i
= 1, hdrpp
= sorted_hdrs
;
1954 i
< elf_elfheader (abfd
)->e_shnum
;
1957 Elf_Internal_Shdr
*hdr
;
1961 /* Ignore any section which will not be part of the process
1963 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1966 /* If this section fits in the segment we are constructing, add
1968 if (phdr
->p_type
!= PT_NULL
1969 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1970 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1971 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1973 bfd_size_type adjust
;
1975 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1976 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1977 if (hdr
->sh_type
!= SHT_NOBITS
)
1978 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1979 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1980 phdr
->p_flags
|= PF_W
;
1981 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1982 phdr
->p_flags
|= PF_X
;
1983 last_type
= hdr
->sh_type
;
1987 /* The section won't fit, start a new segment. If we're already in one,
1988 move to the next one. */
1989 if (phdr
->p_type
!= PT_NULL
)
1995 /* Initialize the segment. */
1996 phdr
->p_type
= PT_LOAD
;
1997 phdr
->p_offset
= hdr
->sh_offset
;
1998 phdr
->p_vaddr
= hdr
->sh_addr
;
2000 if (hdr
->sh_type
== SHT_NOBITS
)
2003 phdr
->p_filesz
= hdr
->sh_size
;
2004 phdr
->p_memsz
= hdr
->sh_size
;
2005 phdr
->p_flags
= PF_R
;
2006 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
2007 phdr
->p_flags
|= PF_W
;
2008 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
2009 phdr
->p_flags
|= PF_X
;
2010 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
2014 && (sinterp
->flags
& SEC_LOAD
) != 0)
2016 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
2017 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
2018 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
2019 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
2022 last_type
= hdr
->sh_type
;
2025 if (phdr
->p_type
!= PT_NULL
)
2031 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
2032 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
2033 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
2035 phdr
->p_type
= PT_DYNAMIC
;
2036 phdr
->p_offset
= sdyn
->filepos
;
2037 phdr
->p_vaddr
= sdyn
->vma
;
2039 phdr
->p_filesz
= sdyn
->_raw_size
;
2040 phdr
->p_memsz
= sdyn
->_raw_size
;
2041 phdr
->p_flags
= PF_R
;
2042 if ((sdyn
->flags
& SEC_READONLY
) == 0)
2043 phdr
->p_flags
|= PF_W
;
2044 if ((sdyn
->flags
& SEC_CODE
) != 0)
2045 phdr
->p_flags
|= PF_X
;
2046 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
2052 /* Make sure the return value from get_program_header_size matches
2053 what we computed here. Actually, it's OK if we allocated too
2054 much space in the program header. */
2055 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
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. */
2255 elf_sort_hdrs (arg1
, arg2
)
2259 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2260 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2262 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2264 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2266 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2268 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2270 if (hdr1
->sh_size
== 0)
2272 if (hdr2
->sh_size
== 0)
2274 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2275 The main loop in map_program_segments requires this. */
2276 return (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2281 else if (hdr2
->sh_size
== 0)
2283 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2284 The main loop in map_program_segments requires this. */
2285 return (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2289 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2299 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2300 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2301 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2303 struct bfd_strtab_hash
*shstrtab
;
2305 i_ehdrp
= elf_elfheader (abfd
);
2306 i_shdrp
= elf_elfsections (abfd
);
2308 shstrtab
= elf_stringtab_init ();
2309 if (shstrtab
== NULL
)
2312 elf_shstrtab (abfd
) = shstrtab
;
2314 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2315 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2316 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2317 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2319 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2320 i_ehdrp
->e_ident
[EI_DATA
] =
2321 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2322 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2324 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2325 i_ehdrp
->e_ident
[count
] = 0;
2327 if ((abfd
->flags
& DYNAMIC
) != 0)
2328 i_ehdrp
->e_type
= ET_DYN
;
2329 else if ((abfd
->flags
& EXEC_P
) != 0)
2330 i_ehdrp
->e_type
= ET_EXEC
;
2332 i_ehdrp
->e_type
= ET_REL
;
2334 switch (bfd_get_arch (abfd
))
2336 case bfd_arch_unknown
:
2337 i_ehdrp
->e_machine
= EM_NONE
;
2339 case bfd_arch_sparc
:
2341 i_ehdrp
->e_machine
= EM_SPARC64
;
2343 i_ehdrp
->e_machine
= EM_SPARC
;
2347 i_ehdrp
->e_machine
= EM_386
;
2350 i_ehdrp
->e_machine
= EM_68K
;
2353 i_ehdrp
->e_machine
= EM_88K
;
2356 i_ehdrp
->e_machine
= EM_860
;
2358 case bfd_arch_mips
: /* MIPS Rxxxx */
2359 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2362 i_ehdrp
->e_machine
= EM_PARISC
;
2364 case bfd_arch_powerpc
:
2365 i_ehdrp
->e_machine
= EM_PPC
;
2367 /* start-sanitize-arc */
2369 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2371 /* end-sanitize-arc */
2372 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2374 i_ehdrp
->e_machine
= EM_NONE
;
2376 i_ehdrp
->e_version
= EV_CURRENT
;
2377 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2379 /* no program header, for now. */
2380 i_ehdrp
->e_phoff
= 0;
2381 i_ehdrp
->e_phentsize
= 0;
2382 i_ehdrp
->e_phnum
= 0;
2384 /* each bfd section is section header entry */
2385 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2386 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2388 /* if we're building an executable, we'll need a program header table */
2389 if (abfd
->flags
& EXEC_P
)
2391 /* it all happens later */
2393 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2395 /* elf_build_phdrs() returns a (NULL-terminated) array of
2396 Elf_Internal_Phdrs */
2397 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2398 i_ehdrp
->e_phoff
= outbase
;
2399 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2404 i_ehdrp
->e_phentsize
= 0;
2406 i_ehdrp
->e_phoff
= 0;
2409 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2410 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2411 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2412 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2413 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2414 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2415 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2416 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2417 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2424 swap_out_syms (abfd
, sttp
)
2426 struct bfd_strtab_hash
**sttp
;
2428 if (!elf_map_symbols (abfd
))
2431 /* Dump out the symtabs. */
2433 int symcount
= bfd_get_symcount (abfd
);
2434 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2435 struct bfd_strtab_hash
*stt
;
2436 Elf_Internal_Shdr
*symtab_hdr
;
2437 Elf_Internal_Shdr
*symstrtab_hdr
;
2438 Elf_External_Sym
*outbound_syms
;
2441 stt
= elf_stringtab_init ();
2445 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2446 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2447 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2448 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2449 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2450 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2452 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2453 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2455 outbound_syms
= ((Elf_External_Sym
*)
2457 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2458 if (outbound_syms
== NULL
)
2460 bfd_set_error (bfd_error_no_memory
);
2463 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2465 /* now generate the data (for "contents") */
2467 /* Fill in zeroth symbol and swap it out. */
2468 Elf_Internal_Sym sym
;
2474 sym
.st_shndx
= SHN_UNDEF
;
2475 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2478 for (idx
= 0; idx
< symcount
; idx
++)
2480 Elf_Internal_Sym sym
;
2481 bfd_vma value
= syms
[idx
]->value
;
2482 elf_symbol_type
*type_ptr
;
2484 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2485 /* Section symbols have no names. */
2489 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2492 if (sym
.st_name
== (unsigned long) -1)
2496 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2498 if (bfd_is_com_section (syms
[idx
]->section
))
2500 /* ELF common symbols put the alignment into the `value' field,
2501 and the size into the `size' field. This is backwards from
2502 how BFD handles it, so reverse it here. */
2503 sym
.st_size
= value
;
2504 if (type_ptr
== NULL
2505 || type_ptr
->internal_elf_sym
.st_value
== 0)
2506 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2508 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2509 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2510 syms
[idx
]->section
);
2514 asection
*sec
= syms
[idx
]->section
;
2517 if (sec
->output_section
)
2519 value
+= sec
->output_offset
;
2520 sec
= sec
->output_section
;
2523 sym
.st_value
= value
;
2524 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2525 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2529 /* Writing this would be a hell of a lot easier if we had
2530 some decent documentation on bfd, and knew what to expect
2531 of the library, and what to demand of applications. For
2532 example, it appears that `objcopy' might not set the
2533 section of a symbol to be a section that is actually in
2535 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2536 BFD_ASSERT (sec2
!= 0);
2537 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2538 BFD_ASSERT (shndx
!= -1);
2542 if (bfd_is_com_section (syms
[idx
]->section
))
2543 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2544 else if (bfd_is_und_section (syms
[idx
]->section
))
2545 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2546 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2549 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2550 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2551 else if (syms
[idx
]->flags
& BSF_FILE
)
2552 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2555 int bind
= STB_LOCAL
;
2556 int type
= STT_OBJECT
;
2557 unsigned int flags
= syms
[idx
]->flags
;
2559 if (flags
& BSF_LOCAL
)
2561 else if (flags
& BSF_WEAK
)
2563 else if (flags
& BSF_GLOBAL
)
2566 if (flags
& BSF_FUNCTION
)
2569 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2573 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2578 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2579 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2581 symstrtab_hdr
->sh_flags
= 0;
2582 symstrtab_hdr
->sh_addr
= 0;
2583 symstrtab_hdr
->sh_entsize
= 0;
2584 symstrtab_hdr
->sh_link
= 0;
2585 symstrtab_hdr
->sh_info
= 0;
2586 symstrtab_hdr
->sh_addralign
= 1;
2593 write_shdrs_and_ehdr (abfd
)
2596 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2597 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2598 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2599 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2602 i_ehdrp
= elf_elfheader (abfd
);
2603 i_shdrp
= elf_elfsections (abfd
);
2605 /* swap the header before spitting it out... */
2608 elf_debug_file (i_ehdrp
);
2610 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2611 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2612 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2613 != sizeof (x_ehdr
)))
2616 /* at this point we've concocted all the ELF sections... */
2617 x_shdrp
= (Elf_External_Shdr
*)
2618 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2621 bfd_set_error (bfd_error_no_memory
);
2625 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2628 elf_debug_section (count
, i_shdrp
[count
]);
2630 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2632 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2633 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2634 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2637 /* need to dump the string table too... */
2642 /* Assign file positions for all the reloc sections which are not part
2643 of the loadable file image. */
2646 assign_file_positions_for_relocs (abfd
)
2651 Elf_Internal_Shdr
**shdrpp
;
2653 off
= elf_tdata (abfd
)->next_file_pos
;
2655 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2656 i
< elf_elfheader (abfd
)->e_shnum
;
2659 Elf_Internal_Shdr
*shdrp
;
2662 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2663 && shdrp
->sh_offset
== -1)
2664 off
= assign_file_position_for_section (shdrp
, off
, true);
2667 elf_tdata (abfd
)->next_file_pos
= off
;
2671 NAME(bfd_elf
,write_object_contents
) (abfd
)
2674 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2675 Elf_Internal_Ehdr
*i_ehdrp
;
2676 Elf_Internal_Shdr
**i_shdrp
;
2679 if (! abfd
->output_has_begun
2680 && ! elf_compute_section_file_positions (abfd
,
2681 (struct bfd_link_info
*) NULL
))
2684 i_shdrp
= elf_elfsections (abfd
);
2685 i_ehdrp
= elf_elfheader (abfd
);
2687 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2688 assign_file_positions_for_relocs (abfd
);
2690 /* After writing the headers, we need to write the sections too... */
2691 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2693 if (bed
->elf_backend_section_processing
)
2694 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2695 if (i_shdrp
[count
]->contents
)
2697 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2698 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2700 != i_shdrp
[count
]->sh_size
))
2705 /* Write out the section header names. */
2706 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2707 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2710 if (bed
->elf_backend_final_write_processing
)
2711 (*bed
->elf_backend_final_write_processing
) (abfd
,
2712 elf_tdata (abfd
)->linker
);
2714 return write_shdrs_and_ehdr (abfd
);
2717 /* Given an ELF section number, retrieve the corresponding BFD
2721 section_from_elf_index (abfd
, index
)
2725 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2726 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2728 return elf_elfsections (abfd
)[index
]->bfd_section
;
2731 /* given a section, search the header to find them... */
2733 elf_section_from_bfd_section (abfd
, asect
)
2737 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2738 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2740 Elf_Internal_Shdr
*hdr
;
2741 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2743 for (index
= 0; index
< maxindex
; index
++)
2745 hdr
= i_shdrp
[index
];
2746 if (hdr
->bfd_section
== asect
)
2750 if (bed
->elf_backend_section_from_bfd_section
)
2752 for (index
= 0; index
< maxindex
; index
++)
2756 hdr
= i_shdrp
[index
];
2758 if ((*bed
->elf_backend_section_from_bfd_section
)
2759 (abfd
, hdr
, asect
, &retval
))
2764 if (bfd_is_abs_section (asect
))
2766 if (bfd_is_com_section (asect
))
2768 if (bfd_is_und_section (asect
))
2774 /* given a symbol, return the bfd index for that symbol. */
2776 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2778 struct symbol_cache_entry
**asym_ptr_ptr
;
2780 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2782 flagword flags
= asym_ptr
->flags
;
2784 /* When gas creates relocations against local labels, it creates its
2785 own symbol for the section, but does put the symbol into the
2786 symbol chain, so udata is 0. When the linker is generating
2787 relocatable output, this section symbol may be for one of the
2788 input sections rather than the output section. */
2789 if (asym_ptr
->udata
.i
== 0
2790 && (flags
& BSF_SECTION_SYM
)
2791 && asym_ptr
->section
)
2795 if (asym_ptr
->section
->output_section
!= NULL
)
2796 indx
= asym_ptr
->section
->output_section
->index
;
2798 indx
= asym_ptr
->section
->index
;
2799 if (elf_section_syms (abfd
)[indx
])
2800 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2803 idx
= asym_ptr
->udata
.i
;
2811 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2812 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2821 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2823 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2826 Elf_Internal_Shdr
*hdr
;
2827 long symcount
; /* Number of external ELF symbols */
2828 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2829 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2830 Elf_Internal_Sym i_sym
;
2831 Elf_External_Sym
*x_symp
= NULL
;
2833 /* Read each raw ELF symbol, converting from external ELF form to
2834 internal ELF form, and then using the information to create a
2835 canonical bfd symbol table entry.
2837 Note that we allocate the initial bfd canonical symbol buffer
2838 based on a one-to-one mapping of the ELF symbols to canonical
2839 symbols. We actually use all the ELF symbols, so there will be no
2840 space left over at the end. When we have all the symbols, we
2841 build the caller's pointer vector. */
2844 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2846 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2847 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2850 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2853 sym
= symbase
= NULL
;
2858 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2861 symbase
= ((elf_symbol_type
*)
2862 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2863 if (symbase
== (elf_symbol_type
*) NULL
)
2865 bfd_set_error (bfd_error_no_memory
);
2870 /* Temporarily allocate room for the raw ELF symbols. */
2871 x_symp
= ((Elf_External_Sym
*)
2872 malloc (symcount
* sizeof (Elf_External_Sym
)));
2873 if (x_symp
== NULL
&& symcount
!= 0)
2875 bfd_set_error (bfd_error_no_memory
);
2879 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2880 != symcount
* sizeof (Elf_External_Sym
))
2882 /* Skip first symbol, which is a null dummy. */
2883 for (i
= 1; i
< symcount
; i
++)
2885 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2886 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2887 #ifdef ELF_KEEP_EXTSYM
2888 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2890 sym
->symbol
.the_bfd
= abfd
;
2892 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2895 sym
->symbol
.value
= i_sym
.st_value
;
2897 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2899 sym
->symbol
.section
= section_from_elf_index (abfd
,
2901 if (sym
->symbol
.section
== NULL
)
2903 /* This symbol is in a section for which we did not
2904 create a BFD section. Just use bfd_abs_section,
2905 although it is wrong. FIXME. */
2906 sym
->symbol
.section
= bfd_abs_section_ptr
;
2909 else if (i_sym
.st_shndx
== SHN_ABS
)
2911 sym
->symbol
.section
= bfd_abs_section_ptr
;
2913 else if (i_sym
.st_shndx
== SHN_COMMON
)
2915 sym
->symbol
.section
= bfd_com_section_ptr
;
2916 /* Elf puts the alignment into the `value' field, and
2917 the size into the `size' field. BFD wants to see the
2918 size in the value field, and doesn't care (at the
2919 moment) about the alignment. */
2920 sym
->symbol
.value
= i_sym
.st_size
;
2922 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2924 sym
->symbol
.section
= bfd_und_section_ptr
;
2927 sym
->symbol
.section
= bfd_abs_section_ptr
;
2929 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2931 switch (ELF_ST_BIND (i_sym
.st_info
))
2934 sym
->symbol
.flags
|= BSF_LOCAL
;
2937 if (i_sym
.st_shndx
!= SHN_UNDEF
2938 && i_sym
.st_shndx
!= SHN_COMMON
)
2939 sym
->symbol
.flags
|= BSF_GLOBAL
;
2942 sym
->symbol
.flags
|= BSF_WEAK
;
2946 switch (ELF_ST_TYPE (i_sym
.st_info
))
2949 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2952 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2955 sym
->symbol
.flags
|= BSF_FUNCTION
;
2960 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2962 /* Do some backend-specific processing on this symbol. */
2964 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2965 if (ebd
->elf_backend_symbol_processing
)
2966 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2973 /* Do some backend-specific processing on this symbol table. */
2975 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2976 if (ebd
->elf_backend_symbol_table_processing
)
2977 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2980 /* We rely on the zalloc to clear out the final symbol entry. */
2982 symcount
= sym
- symbase
;
2984 /* Fill in the user's symbol pointer vector if needed. */
2992 *symptrs
++ = &sym
->symbol
;
2995 *symptrs
= 0; /* Final null pointer */
3007 /* Return the number of bytes required to hold the symtab vector.
3009 Note that we base it on the count plus 1, since we will null terminate
3010 the vector allocated based on this size. However, the ELF symbol table
3011 always has a dummy entry as symbol #0, so it ends up even. */
3014 elf_get_symtab_upper_bound (abfd
)
3019 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3021 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3022 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3028 elf_get_dynamic_symtab_upper_bound (abfd
)
3033 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3035 if (elf_dynsymtab (abfd
) == 0)
3037 bfd_set_error (bfd_error_invalid_operation
);
3041 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3042 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3048 elf_get_reloc_upper_bound (abfd
, asect
)
3052 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3055 /* Read in and swap the external relocs. */
3058 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3063 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
3064 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
3065 PTR allocated
= NULL
;
3066 bfd_byte
*native_relocs
;
3072 if (asect
->relocation
!= NULL
3073 || (asect
->flags
& SEC_RELOC
) == 0
3074 || asect
->reloc_count
== 0)
3077 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
3078 && (asect
->reloc_count
3079 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
3081 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
3082 if (allocated
== NULL
)
3084 bfd_set_error (bfd_error_no_memory
);
3088 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
3089 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
3090 != d
->rel_hdr
.sh_size
))
3093 native_relocs
= (bfd_byte
*) allocated
;
3095 relents
= ((arelent
*)
3096 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
3097 if (relents
== NULL
)
3099 bfd_set_error (bfd_error_no_memory
);
3103 entsize
= d
->rel_hdr
.sh_entsize
;
3104 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
3105 || entsize
== sizeof (Elf_External_Rela
));
3107 for (i
= 0, relent
= relents
;
3108 i
< asect
->reloc_count
;
3109 i
++, relent
++, native_relocs
+= entsize
)
3111 Elf_Internal_Rela rela
;
3112 Elf_Internal_Rel rel
;
3114 if (entsize
== sizeof (Elf_External_Rela
))
3115 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
3118 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
3119 rela
.r_offset
= rel
.r_offset
;
3120 rela
.r_info
= rel
.r_info
;
3124 /* The address of an ELF reloc is section relative for an object
3125 file, and absolute for an executable file or shared library.
3126 The address of a BFD reloc is always section relative. */
3127 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3128 relent
->address
= rela
.r_offset
;
3130 relent
->address
= rela
.r_offset
- asect
->vma
;
3132 if (ELF_R_SYM (rela
.r_info
) == 0)
3133 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3138 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3141 /* Canonicalize ELF section symbols. FIXME: Why? */
3142 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3143 relent
->sym_ptr_ptr
= ps
;
3145 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3148 relent
->addend
= rela
.r_addend
;
3150 if (entsize
== sizeof (Elf_External_Rela
))
3151 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3153 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3156 asect
->relocation
= relents
;
3158 if (allocated
!= NULL
)
3164 if (allocated
!= NULL
)
3171 elf_debug_section (num
, hdr
)
3173 Elf_Internal_Shdr
*hdr
;
3175 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3176 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3179 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3180 (long) hdr
->sh_name
,
3181 (long) hdr
->sh_type
,
3182 (long) hdr
->sh_flags
);
3184 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3185 (long) hdr
->sh_addr
,
3186 (long) hdr
->sh_offset
,
3187 (long) hdr
->sh_size
);
3189 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3190 (long) hdr
->sh_link
,
3191 (long) hdr
->sh_info
,
3192 (long) hdr
->sh_addralign
);
3193 fprintf (stderr
, "sh_entsize = %ld\n",
3194 (long) hdr
->sh_entsize
);
3199 elf_debug_file (ehdrp
)
3200 Elf_Internal_Ehdr
*ehdrp
;
3202 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3203 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3204 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3205 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3206 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3207 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3208 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3212 /* Canonicalize the relocs. */
3215 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3224 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3227 tblptr
= section
->relocation
;
3228 for (i
= 0; i
< section
->reloc_count
; i
++)
3229 *relptr
++ = tblptr
++;
3233 return section
->reloc_count
;
3237 elf_get_symtab (abfd
, alocation
)
3239 asymbol
**alocation
;
3241 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3244 bfd_get_symcount (abfd
) = symcount
;
3249 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3251 asymbol
**alocation
;
3253 return elf_slurp_symbol_table (abfd
, alocation
, true);
3257 elf_make_empty_symbol (abfd
)
3260 elf_symbol_type
*newsym
;
3262 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3265 bfd_set_error (bfd_error_no_memory
);
3270 newsym
->symbol
.the_bfd
= abfd
;
3271 return &newsym
->symbol
;
3276 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3281 bfd_symbol_info (symbol
, ret
);
3285 elf_get_lineno (ignore_abfd
, symbol
)
3289 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3296 elf_set_arch_mach (abfd
, arch
, machine
)
3298 enum bfd_architecture arch
;
3299 unsigned long machine
;
3301 /* If this isn't the right architecture for this backend, and this
3302 isn't the generic backend, fail. */
3303 if (arch
!= get_elf_backend_data (abfd
)->arch
3304 && arch
!= bfd_arch_unknown
3305 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3308 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3312 elf_find_nearest_line (abfd
,
3323 CONST
char **filename_ptr
;
3324 CONST
char **functionname_ptr
;
3325 unsigned int *line_ptr
;
3331 elf_sizeof_headers (abfd
, reloc
)
3337 ret
= sizeof (Elf_External_Ehdr
);
3339 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
3345 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3350 bfd_size_type count
;
3352 Elf_Internal_Shdr
*hdr
;
3354 if (! abfd
->output_has_begun
3355 && ! elf_compute_section_file_positions (abfd
,
3356 (struct bfd_link_info
*) NULL
))
3359 hdr
= &elf_section_data (section
)->this_hdr
;
3361 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3363 if (bfd_write (location
, 1, count
, abfd
) != count
)
3370 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3373 Elf_Internal_Rela
*dst
;
3375 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3381 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3384 Elf_Internal_Rel
*dst
;
3386 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3392 /* Core file support */
3394 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3395 #include <sys/procfs.h>
3397 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3398 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3399 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3405 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3412 prstatus_t
*status
= (prstatus_t
*) 0;
3414 if (descsz
== sizeof (prstatus_t
))
3416 newsect
= bfd_make_section (abfd
, ".reg");
3417 if (newsect
== NULL
)
3419 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3420 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3421 newsect
->flags
= SEC_HAS_CONTENTS
;
3422 newsect
->alignment_power
= 2;
3423 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3425 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3431 /* Stash a copy of the prpsinfo structure away for future use. */
3434 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3440 if (descsz
== sizeof (prpsinfo_t
))
3442 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3444 bfd_set_error (bfd_error_no_memory
);
3447 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3453 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3461 newsect
= bfd_make_section (abfd
, ".reg2");
3462 if (newsect
== NULL
)
3464 newsect
->_raw_size
= descsz
;
3465 newsect
->filepos
= filepos
;
3466 newsect
->flags
= SEC_HAS_CONTENTS
;
3467 newsect
->alignment_power
= 2;
3471 #endif /* HAVE_PROCFS */
3473 /* Return a pointer to the args (including the command name) that were
3474 seen by the program that generated the core dump. Note that for
3475 some reason, a spurious space is tacked onto the end of the args
3476 in some (at least one anyway) implementations, so strip it off if
3480 elf_core_file_failing_command (abfd
)
3484 if (core_prpsinfo (abfd
))
3486 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3487 char *scan
= p
->pr_psargs
;
3492 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3496 return p
->pr_psargs
;
3502 /* Return the number of the signal that caused the core dump. Presumably,
3503 since we have a core file, we got a signal of some kind, so don't bother
3504 checking the other process status fields, just return the signal number.
3508 elf_core_file_failing_signal (abfd
)
3512 if (core_prstatus (abfd
))
3514 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3520 /* Check to see if the core file could reasonably be expected to have
3521 come for the current executable file. Note that by default we return
3522 true unless we find something that indicates that there might be a
3527 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3536 /* First, xvecs must match since both are ELF files for the same target. */
3538 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3540 bfd_set_error (bfd_error_system_call
);
3546 /* If no prpsinfo, just return true. Otherwise, grab the last component
3547 of the exec'd pathname from the prpsinfo. */
3549 if (core_prpsinfo (core_bfd
))
3551 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3558 /* Find the last component of the executable pathname. */
3560 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3566 execname
= (char *) exec_bfd
->filename
;
3569 /* See if they match */
3571 return strcmp (execname
, corename
) ? false : true;
3577 #endif /* HAVE_PROCFS */
3580 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3581 the information that would normally be available from the /proc interface
3582 for the process, at the time the process dumped core. Currently this
3583 includes copies of the prstatus, prpsinfo, and fpregset structures.
3585 Since these structures are potentially machine dependent in size and
3586 ordering, bfd provides two levels of support for them. The first level,
3587 available on all machines since it does not require that the host
3588 have /proc support or the relevant include files, is to create a bfd
3589 section for each of the prstatus, prpsinfo, and fpregset structures,
3590 without any interpretation of their contents. With just this support,
3591 the bfd client will have to interpret the structures itself. Even with
3592 /proc support, it might want these full structures for it's own reasons.
3594 In the second level of support, where HAVE_PROCFS is defined, bfd will
3595 pick apart the structures to gather some additional information that
3596 clients may want, such as the general register set, the name of the
3597 exec'ed file and its arguments, the signal (if any) that caused the
3603 elf_corefile_note (abfd
, hdr
)
3605 Elf_Internal_Phdr
*hdr
;
3607 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3608 Elf_Internal_Note i_note
; /* Elf note, internal form */
3609 char *buf
= NULL
; /* Entire note segment contents */
3610 char *namedata
; /* Name portion of the note */
3611 char *descdata
; /* Descriptor portion of the note */
3612 char *sectname
; /* Name to use for new section */
3613 long filepos
; /* File offset to descriptor data */
3616 if (hdr
->p_filesz
> 0
3617 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3618 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3619 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3621 x_note_p
= (Elf_External_Note
*) buf
;
3622 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3624 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3625 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3626 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3627 namedata
= x_note_p
->name
;
3628 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3629 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3630 switch (i_note
.type
)
3633 /* process descdata as prstatus info */
3634 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3636 sectname
= ".prstatus";
3639 /* process descdata as fpregset info */
3640 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3642 sectname
= ".fpregset";
3645 /* process descdata as prpsinfo */
3646 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3648 sectname
= ".prpsinfo";
3651 /* Unknown descriptor, just ignore it. */
3655 if (sectname
!= NULL
)
3657 newsect
= bfd_make_section (abfd
, sectname
);
3658 if (newsect
== NULL
)
3660 newsect
->_raw_size
= i_note
.descsz
;
3661 newsect
->filepos
= filepos
;
3662 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3663 newsect
->alignment_power
= 2;
3665 x_note_p
= (Elf_External_Note
*)
3666 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3673 else if (hdr
->p_filesz
> 0)
3675 bfd_set_error (bfd_error_no_memory
);
3682 /* Core files are simply standard ELF formatted files that partition
3683 the file using the execution view of the file (program header table)
3684 rather than the linking view. In fact, there is no section header
3685 table in a core file.
3687 The process status information (including the contents of the general
3688 register set) and the floating point register set are stored in a
3689 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3690 that allow standard bfd access to the general registers (.reg) and the
3691 floating point registers (.reg2).
3696 elf_core_file_p (abfd
)
3699 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3700 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3701 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3702 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3703 unsigned int phindex
;
3704 struct elf_backend_data
*ebd
;
3706 /* Read in the ELF header in external format. */
3708 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3710 if (bfd_get_error () != bfd_error_system_call
)
3711 bfd_set_error (bfd_error_wrong_format
);
3715 /* Now check to see if we have a valid ELF file, and one that BFD can
3716 make use of. The magic number must match, the address size ('class')
3717 and byte-swapping must match our XVEC entry, and it must have a
3718 program header table (FIXME: See comments re segments at top of this
3721 if (elf_file_p (&x_ehdr
) == false)
3724 bfd_set_error (bfd_error_wrong_format
);
3728 /* FIXME, Check EI_VERSION here ! */
3732 int desired_address_size
= ELFCLASS32
;
3735 int desired_address_size
= ELFCLASS64
;
3738 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3742 /* Switch xvec to match the specified byte order. */
3743 switch (x_ehdr
.e_ident
[EI_DATA
])
3745 case ELFDATA2MSB
: /* Big-endian */
3746 if (abfd
->xvec
->byteorder_big_p
== false)
3749 case ELFDATA2LSB
: /* Little-endian */
3750 if (abfd
->xvec
->byteorder_big_p
== true)
3753 case ELFDATANONE
: /* No data encoding specified */
3754 default: /* Unknown data encoding specified */
3758 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3759 the tdata pointer in the bfd. */
3762 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3763 if (elf_tdata (abfd
) == NULL
)
3765 bfd_set_error (bfd_error_no_memory
);
3769 /* FIXME, `wrong' returns from this point onward, leak memory. */
3771 /* Now that we know the byte order, swap in the rest of the header */
3772 i_ehdrp
= elf_elfheader (abfd
);
3773 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3775 elf_debug_file (i_ehdrp
);
3778 ebd
= get_elf_backend_data (abfd
);
3780 /* Check that the ELF e_machine field matches what this particular
3781 BFD format expects. */
3782 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
3783 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
3784 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
3786 const bfd_target
* const *target_ptr
;
3788 if (ebd
->elf_machine_code
!= EM_NONE
)
3791 /* This is the generic ELF target. Let it match any ELF target
3792 for which we do not have a specific backend. */
3793 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3795 struct elf_backend_data
*back
;
3797 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3799 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3800 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3802 /* target_ptr is an ELF backend which matches this
3803 object file, so reject the generic ELF target. */
3809 /* If there is no program header, or the type is not a core file, then
3811 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3814 /* Allocate space for a copy of the program header table in
3815 internal form, seek to the program header table in the file,
3816 read it in, and convert it to internal form. As a simple sanity
3817 check, verify that the what BFD thinks is the size of each program
3818 header table entry actually matches the size recorded in the file. */
3820 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3822 i_phdrp
= (Elf_Internal_Phdr
*)
3823 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3826 bfd_set_error (bfd_error_no_memory
);
3829 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3831 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3833 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3836 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3839 /* Once all of the program headers have been read and converted, we
3840 can start processing them. */
3842 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3844 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3845 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3847 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3852 /* Remember the entry point specified in the ELF file header. */
3854 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3859 /* ELF linker code. */
3861 static boolean elf_link_add_object_symbols
3862 PARAMS ((bfd
*, struct bfd_link_info
*));
3863 static boolean elf_link_add_archive_symbols
3864 PARAMS ((bfd
*, struct bfd_link_info
*));
3865 static Elf_Internal_Rela
*elf_link_read_relocs
3866 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3867 static boolean elf_export_symbol
3868 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3869 static boolean elf_adjust_dynamic_symbol
3870 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3872 /* Given an ELF BFD, add symbols to the global hash table as
3876 elf_bfd_link_add_symbols (abfd
, info
)
3878 struct bfd_link_info
*info
;
3882 switch (bfd_get_format (abfd
))
3885 return elf_link_add_object_symbols (abfd
, info
);
3887 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3890 if (! bfd_check_format (first
, bfd_object
))
3892 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3894 /* On Linux, we may have an a.out archive which got
3895 recognized as an ELF archive. Therefore, we treat all
3896 archives as though they were actually of the flavour of
3897 their first element. */
3898 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3900 return elf_link_add_archive_symbols (abfd
, info
);
3902 bfd_set_error (bfd_error_wrong_format
);
3907 /* Add symbols from an ELF archive file to the linker hash table. We
3908 don't use _bfd_generic_link_add_archive_symbols because of a
3909 problem which arises on UnixWare. The UnixWare libc.so is an
3910 archive which includes an entry libc.so.1 which defines a bunch of
3911 symbols. The libc.so archive also includes a number of other
3912 object files, which also define symbols, some of which are the same
3913 as those defined in libc.so.1. Correct linking requires that we
3914 consider each object file in turn, and include it if it defines any
3915 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3916 this; it looks through the list of undefined symbols, and includes
3917 any object file which defines them. When this algorithm is used on
3918 UnixWare, it winds up pulling in libc.so.1 early and defining a
3919 bunch of symbols. This means that some of the other objects in the
3920 archive are not included in the link, which is incorrect since they
3921 precede libc.so.1 in the archive.
3923 Fortunately, ELF archive handling is simpler than that done by
3924 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3925 oddities. In ELF, if we find a symbol in the archive map, and the
3926 symbol is currently undefined, we know that we must pull in that
3929 Unfortunately, we do have to make multiple passes over the symbol
3930 table until nothing further is resolved. */
3933 elf_link_add_archive_symbols (abfd
, info
)
3935 struct bfd_link_info
*info
;
3938 boolean
*defined
= NULL
;
3939 boolean
*included
= NULL
;
3943 if (! bfd_has_map (abfd
))
3945 /* An empty archive is a special case. */
3946 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3948 bfd_set_error (bfd_error_no_symbols
);
3952 /* Keep track of all symbols we know to be already defined, and all
3953 files we know to be already included. This is to speed up the
3954 second and subsequent passes. */
3955 c
= bfd_ardata (abfd
)->symdef_count
;
3958 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3959 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3960 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3962 bfd_set_error (bfd_error_no_memory
);
3965 memset (defined
, 0, c
* sizeof (boolean
));
3966 memset (included
, 0, c
* sizeof (boolean
));
3968 symdefs
= bfd_ardata (abfd
)->symdefs
;
3981 symdefend
= symdef
+ c
;
3982 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3984 struct elf_link_hash_entry
*h
;
3986 struct bfd_link_hash_entry
*undefs_tail
;
3989 if (defined
[i
] || included
[i
])
3991 if (symdef
->file_offset
== last
)
3997 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3998 false, false, false);
3999 if (h
== (struct elf_link_hash_entry
*) NULL
)
4001 if (h
->root
.type
!= bfd_link_hash_undefined
)
4007 /* We need to include this archive member. */
4009 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
4010 if (element
== (bfd
*) NULL
)
4013 if (! bfd_check_format (element
, bfd_object
))
4016 /* Doublecheck that we have not included this object
4017 already--it should be impossible, but there may be
4018 something wrong with the archive. */
4019 if (element
->archive_pass
!= 0)
4021 bfd_set_error (bfd_error_bad_value
);
4024 element
->archive_pass
= 1;
4026 undefs_tail
= info
->hash
->undefs_tail
;
4028 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4031 if (! elf_link_add_object_symbols (element
, info
))
4034 /* If there are any new undefined symbols, we need to make
4035 another pass through the archive in order to see whether
4036 they can be defined. FIXME: This isn't perfect, because
4037 common symbols wind up on undefs_tail and because an
4038 undefined symbol which is defined later on in this pass
4039 does not require another pass. This isn't a bug, but it
4040 does make the code less efficient than it could be. */
4041 if (undefs_tail
!= info
->hash
->undefs_tail
)
4044 /* Look backward to mark all symbols from this object file
4045 which we have already seen in this pass. */
4049 included
[mark
] = true;
4054 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4056 /* We mark subsequent symbols from this object file as we go
4057 on through the loop. */
4058 last
= symdef
->file_offset
;
4069 if (defined
!= (boolean
*) NULL
)
4071 if (included
!= (boolean
*) NULL
)
4076 /* Record a new dynamic symbol. We record the dynamic symbols as we
4077 read the input files, since we need to have a list of all of them
4078 before we can determine the final sizes of the output sections.
4079 Note that we may actually call this function even though we are not
4080 going to output any dynamic symbols; in some cases we know that a
4081 symbol should be in the dynamic symbol table, but only if there is
4085 elf_link_record_dynamic_symbol (info
, h
)
4086 struct bfd_link_info
*info
;
4087 struct elf_link_hash_entry
*h
;
4089 if (h
->dynindx
== -1)
4091 struct bfd_strtab_hash
*dynstr
;
4093 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4094 ++elf_hash_table (info
)->dynsymcount
;
4096 dynstr
= elf_hash_table (info
)->dynstr
;
4099 /* Create a strtab to hold the dynamic symbol names. */
4100 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
4105 h
->dynstr_index
= ((unsigned long)
4106 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
4108 if (h
->dynstr_index
== (unsigned long) -1)
4115 /* Add symbols from an ELF object file to the linker hash table. */
4118 elf_link_add_object_symbols (abfd
, info
)
4120 struct bfd_link_info
*info
;
4122 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4123 const Elf_Internal_Sym
*,
4124 const char **, flagword
*,
4125 asection
**, bfd_vma
*));
4126 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4127 asection
*, const Elf_Internal_Rela
*));
4129 Elf_Internal_Shdr
*hdr
;
4133 Elf_External_Sym
*buf
= NULL
;
4134 struct elf_link_hash_entry
**sym_hash
;
4136 Elf_External_Dyn
*dynbuf
= NULL
;
4137 struct elf_link_hash_entry
*weaks
;
4138 Elf_External_Sym
*esym
;
4139 Elf_External_Sym
*esymend
;
4141 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4142 collect
= get_elf_backend_data (abfd
)->collect
;
4144 /* A stripped shared library might only have a dynamic symbol table,
4145 not a regular symbol table. In that case we can still go ahead
4146 and link using the dynamic symbol table. */
4147 if (elf_onesymtab (abfd
) == 0
4148 && elf_dynsymtab (abfd
) != 0)
4150 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4151 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4154 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4155 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4157 /* The sh_info field of the symtab header tells us where the
4158 external symbols start. We don't care about the local symbols at
4160 if (elf_bad_symtab (abfd
))
4162 extsymcount
= symcount
;
4167 extsymcount
= symcount
- hdr
->sh_info
;
4168 extsymoff
= hdr
->sh_info
;
4171 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4172 if (buf
== NULL
&& extsymcount
!= 0)
4174 bfd_set_error (bfd_error_no_memory
);
4178 /* We store a pointer to the hash table entry for each external
4180 sym_hash
= ((struct elf_link_hash_entry
**)
4182 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4183 if (sym_hash
== NULL
)
4185 bfd_set_error (bfd_error_no_memory
);
4188 elf_sym_hashes (abfd
) = sym_hash
;
4190 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4194 /* If we are creating a shared library, create all the dynamic
4195 sections immediately. We need to attach them to something,
4196 so we attach them to this BFD, provided it is the right
4197 format. FIXME: If there are no input BFD's of the same
4198 format as the output, we can't make a shared library. */
4200 && ! elf_hash_table (info
)->dynamic_sections_created
4201 && abfd
->xvec
== info
->hash
->creator
)
4203 if (! elf_link_create_dynamic_sections (abfd
, info
))
4211 bfd_size_type strindex
;
4215 /* You can't use -r against a dynamic object. Also, there's no
4216 hope of using a dynamic object which does not exactly match
4217 the format of the output file. */
4218 if (info
->relocateable
4219 || info
->hash
->creator
!= abfd
->xvec
)
4221 bfd_set_error (bfd_error_invalid_operation
);
4225 /* Find the name to use in a DT_NEEDED entry that refers to this
4226 object. If the object has a DT_SONAME entry, we use it.
4227 Otherwise, if the generic linker stuck something in
4228 elf_dt_needed_name, we use that. Otherwise, we just use the
4230 name
= bfd_get_filename (abfd
);
4231 if (elf_dt_needed_name (abfd
) != NULL
)
4232 name
= elf_dt_needed_name (abfd
);
4233 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4236 Elf_External_Dyn
*extdyn
;
4237 Elf_External_Dyn
*extdynend
;
4239 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4242 bfd_set_error (bfd_error_no_memory
);
4246 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4247 (file_ptr
) 0, s
->_raw_size
))
4251 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4252 for (; extdyn
< extdynend
; extdyn
++)
4254 Elf_Internal_Dyn dyn
;
4256 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4257 if (dyn
.d_tag
== DT_SONAME
)
4262 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4265 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4266 name
= elf_string_from_elf_section (abfd
, link
,
4271 if (dyn
.d_tag
== DT_NEEDED
)
4272 elf_hash_table (info
)->saw_needed
= true;
4279 /* We do not want to include any of the sections in a dynamic
4280 object in the output file. We hack by simply clobbering the
4281 list of sections in the BFD. This could be handled more
4282 cleanly by, say, a new section flag; the existing
4283 SEC_NEVER_LOAD flag is not the one we want, because that one
4284 still implies that the section takes up space in the output
4286 abfd
->sections
= NULL
;
4288 /* If this is the first dynamic object found in the link, create
4289 the special sections required for dynamic linking. */
4290 if (! elf_hash_table (info
)->dynamic_sections_created
)
4292 if (! elf_link_create_dynamic_sections (abfd
, info
))
4296 /* Add a DT_NEEDED entry for this dynamic object. */
4297 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4299 if (strindex
== (bfd_size_type
) -1)
4301 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4306 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4308 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4309 != extsymcount
* sizeof (Elf_External_Sym
)))
4314 esymend
= buf
+ extsymcount
;
4315 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4317 Elf_Internal_Sym sym
;
4323 struct elf_link_hash_entry
*h
= NULL
;
4326 elf_swap_symbol_in (abfd
, esym
, &sym
);
4328 flags
= BSF_NO_FLAGS
;
4330 value
= sym
.st_value
;
4333 bind
= ELF_ST_BIND (sym
.st_info
);
4334 if (bind
== STB_LOCAL
)
4336 /* This should be impossible, since ELF requires that all
4337 global symbols follow all local symbols, and that sh_info
4338 point to the first global symbol. Unfortunatealy, Irix 5
4342 else if (bind
== STB_GLOBAL
)
4344 if (sym
.st_shndx
!= SHN_UNDEF
4345 && sym
.st_shndx
!= SHN_COMMON
)
4350 else if (bind
== STB_WEAK
)
4354 /* Leave it up to the processor backend. */
4357 if (sym
.st_shndx
== SHN_UNDEF
)
4358 sec
= bfd_und_section_ptr
;
4359 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4361 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4365 sec
= bfd_abs_section_ptr
;
4367 else if (sym
.st_shndx
== SHN_ABS
)
4368 sec
= bfd_abs_section_ptr
;
4369 else if (sym
.st_shndx
== SHN_COMMON
)
4371 sec
= bfd_com_section_ptr
;
4372 /* What ELF calls the size we call the value. What ELF
4373 calls the value we call the alignment. */
4374 value
= sym
.st_size
;
4378 /* Leave it up to the processor backend. */
4381 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4382 if (name
== (const char *) NULL
)
4385 if (add_symbol_hook
)
4387 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4391 /* The hook function sets the name to NULL if this symbol
4392 should be skipped for some reason. */
4393 if (name
== (const char *) NULL
)
4397 /* Sanity check that all possibilities were handled. */
4398 if (sec
== (asection
*) NULL
)
4400 bfd_set_error (bfd_error_bad_value
);
4404 if (bfd_is_und_section (sec
)
4405 || bfd_is_com_section (sec
))
4410 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4412 /* We need to look up the symbol now in order to get some of
4413 the dynamic object handling right. We pass the hash
4414 table entry in to _bfd_generic_link_add_one_symbol so
4415 that it does not have to look it up again. */
4416 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4417 true, false, false);
4422 /* If we are looking at a dynamic object, and this is a
4423 definition, we need to see if it has already been defined
4424 by some other object. If it has, we want to use the
4425 existing definition, and we do not want to report a
4426 multiple symbol definition error; we do this by
4427 clobbering sec to be bfd_und_section_ptr. */
4428 if (dynamic
&& definition
)
4430 if (h
->root
.type
== bfd_link_hash_defined
4431 || h
->root
.type
== bfd_link_hash_defweak
)
4432 sec
= bfd_und_section_ptr
;
4435 /* Similarly, if we are not looking at a dynamic object, and
4436 we have a definition, we want to override any definition
4437 we may have from a dynamic object. Symbols from regular
4438 files always take precedence over symbols from dynamic
4439 objects, even if they are defined after the dynamic
4440 object in the link. */
4443 && (h
->root
.type
== bfd_link_hash_defined
4444 || h
->root
.type
== bfd_link_hash_defweak
)
4445 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4446 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4447 == bfd_target_elf_flavour
)
4448 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4451 /* Change the hash table entry to undefined, and let
4452 _bfd_generic_link_add_one_symbol do the right thing
4453 with the new definition. */
4454 h
->root
.type
= bfd_link_hash_undefined
;
4455 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4459 if (! (_bfd_generic_link_add_one_symbol
4460 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4461 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4466 && (flags
& BSF_WEAK
) != 0
4467 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4468 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4469 && (*sym_hash
)->weakdef
== NULL
)
4471 /* Keep a list of all weak defined non function symbols from
4472 a dynamic object, using the weakdef field. Later in this
4473 function we will set the weakdef field to the correct
4474 value. We only put non-function symbols from dynamic
4475 objects on this list, because that happens to be the only
4476 time we need to know the normal symbol corresponding to a
4477 weak symbol, and the information is time consuming to
4478 figure out. If the weakdef field is not already NULL,
4479 then this symbol was already defined by some previous
4480 dynamic object, and we will be using that previous
4481 definition anyhow. */
4483 (*sym_hash
)->weakdef
= weaks
;
4487 /* Get the alignment of a common symbol. */
4488 if (sym
.st_shndx
== SHN_COMMON
4489 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4490 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
4492 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4498 /* Remember the symbol size and type. */
4499 if (sym
.st_size
!= 0)
4501 /* FIXME: We should probably somehow give a warning if
4502 the symbol size changes. */
4503 h
->size
= sym
.st_size
;
4505 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4507 /* FIXME: We should probably somehow give a warning if
4508 the symbol type changes. */
4509 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4512 /* Set a flag in the hash table entry indicating the type of
4513 reference or definition we just found. Keep a count of
4514 the number of dynamic symbols we find. A dynamic symbol
4515 is one which is referenced or defined by both a regular
4516 object and a shared object, or one which is referenced or
4517 defined by more than one shared object. */
4518 old_flags
= h
->elf_link_hash_flags
;
4523 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4525 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4527 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4528 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4534 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4536 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4537 if ((old_flags
& new_flag
) != 0
4538 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4539 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4543 h
->elf_link_hash_flags
|= new_flag
;
4544 if (dynsym
&& h
->dynindx
== -1)
4546 if (! elf_link_record_dynamic_symbol (info
, h
))
4552 /* Now set the weakdefs field correctly for all the weak defined
4553 symbols we found. The only way to do this is to search all the
4554 symbols. Since we only need the information for non functions in
4555 dynamic objects, that's the only time we actually put anything on
4556 the list WEAKS. We need this information so that if a regular
4557 object refers to a symbol defined weakly in a dynamic object, the
4558 real symbol in the dynamic object is also put in the dynamic
4559 symbols; we also must arrange for both symbols to point to the
4560 same memory location. We could handle the general case of symbol
4561 aliasing, but a general symbol alias can only be generated in
4562 assembler code, handling it correctly would be very time
4563 consuming, and other ELF linkers don't handle general aliasing
4565 while (weaks
!= NULL
)
4567 struct elf_link_hash_entry
*hlook
;
4570 struct elf_link_hash_entry
**hpp
;
4571 struct elf_link_hash_entry
**hppend
;
4574 weaks
= hlook
->weakdef
;
4575 hlook
->weakdef
= NULL
;
4577 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4578 || hlook
->root
.type
== bfd_link_hash_defweak
);
4579 slook
= hlook
->root
.u
.def
.section
;
4580 vlook
= hlook
->root
.u
.def
.value
;
4582 hpp
= elf_sym_hashes (abfd
);
4583 hppend
= hpp
+ extsymcount
;
4584 for (; hpp
< hppend
; hpp
++)
4586 struct elf_link_hash_entry
*h
;
4590 && (h
->root
.type
== bfd_link_hash_defined
4591 || h
->root
.type
== bfd_link_hash_defweak
)
4592 && h
->root
.u
.def
.section
== slook
4593 && h
->root
.u
.def
.value
== vlook
)
4597 /* If the weak definition is in the list of dynamic
4598 symbols, make sure the real definition is put there
4600 if (hlook
->dynindx
!= -1
4601 && h
->dynindx
== -1)
4603 if (! elf_link_record_dynamic_symbol (info
, h
))
4618 /* If this object is the same format as the output object, and it is
4619 not a shared library, then let the backend look through the
4622 This is required to build global offset table entries and to
4623 arrange for dynamic relocs. It is not required for the
4624 particular common case of linking non PIC code, even when linking
4625 against shared libraries, but unfortunately there is no way of
4626 knowing whether an object file has been compiled PIC or not.
4627 Looking through the relocs is not particularly time consuming.
4628 The problem is that we must either (1) keep the relocs in memory,
4629 which causes the linker to require additional runtime memory or
4630 (2) read the relocs twice from the input file, which wastes time.
4631 This would be a good case for using mmap.
4633 I have no idea how to handle linking PIC code into a file of a
4634 different format. It probably can't be done. */
4635 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4637 && abfd
->xvec
== info
->hash
->creator
4638 && check_relocs
!= NULL
)
4642 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4644 Elf_Internal_Rela
*internal_relocs
;
4647 if ((o
->flags
& SEC_RELOC
) == 0
4648 || o
->reloc_count
== 0)
4651 /* I believe we can ignore the relocs for any section which
4652 does not form part of the final process image, such as a
4653 debugging section. */
4654 if ((o
->flags
& SEC_ALLOC
) == 0)
4657 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4658 (Elf_Internal_Rela
*) NULL
,
4660 if (internal_relocs
== NULL
)
4663 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4665 if (! info
->keep_memory
)
4666 free (internal_relocs
);
4683 /* Create some sections which will be filled in with dynamic linking
4684 information. ABFD is an input file which requires dynamic sections
4685 to be created. The dynamic sections take up virtual memory space
4686 when the final executable is run, so we need to create them before
4687 addresses are assigned to the output sections. We work out the
4688 actual contents and size of these sections later. */
4691 elf_link_create_dynamic_sections (abfd
, info
)
4693 struct bfd_link_info
*info
;
4696 register asection
*s
;
4697 struct elf_link_hash_entry
*h
;
4698 struct elf_backend_data
*bed
;
4700 if (elf_hash_table (info
)->dynamic_sections_created
)
4703 /* Make sure that all dynamic sections use the same input BFD. */
4704 if (elf_hash_table (info
)->dynobj
== NULL
)
4705 elf_hash_table (info
)->dynobj
= abfd
;
4707 abfd
= elf_hash_table (info
)->dynobj
;
4709 /* Note that we set the SEC_IN_MEMORY flag for all of these
4711 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4713 /* A dynamically linked executable has a .interp section, but a
4714 shared library does not. */
4717 s
= bfd_make_section (abfd
, ".interp");
4719 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4723 s
= bfd_make_section (abfd
, ".dynsym");
4725 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4726 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4729 s
= bfd_make_section (abfd
, ".dynstr");
4731 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4734 /* Create a strtab to hold the dynamic symbol names. */
4735 if (elf_hash_table (info
)->dynstr
== NULL
)
4737 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4738 if (elf_hash_table (info
)->dynstr
== NULL
)
4742 s
= bfd_make_section (abfd
, ".dynamic");
4744 || ! bfd_set_section_flags (abfd
, s
, flags
)
4745 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4748 /* The special symbol _DYNAMIC is always set to the start of the
4749 .dynamic section. This call occurs before we have processed the
4750 symbols for any dynamic object, so we don't have to worry about
4751 overriding a dynamic definition. We could set _DYNAMIC in a
4752 linker script, but we only want to define it if we are, in fact,
4753 creating a .dynamic section. We don't want to define it if there
4754 is no .dynamic section, since on some ELF platforms the start up
4755 code examines it to decide how to initialize the process. */
4757 if (! (_bfd_generic_link_add_one_symbol
4758 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4759 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4760 (struct bfd_link_hash_entry
**) &h
)))
4762 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4763 h
->type
= STT_OBJECT
;
4766 && ! elf_link_record_dynamic_symbol (info
, h
))
4769 s
= bfd_make_section (abfd
, ".hash");
4771 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4772 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4775 /* Let the backend create the rest of the sections. This lets the
4776 backend set the right flags. The backend will normally create
4777 the .got and .plt sections. */
4778 bed
= get_elf_backend_data (abfd
);
4779 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4782 elf_hash_table (info
)->dynamic_sections_created
= true;
4787 /* Add an entry to the .dynamic table. */
4790 elf_add_dynamic_entry (info
, tag
, val
)
4791 struct bfd_link_info
*info
;
4795 Elf_Internal_Dyn dyn
;
4799 bfd_byte
*newcontents
;
4801 dynobj
= elf_hash_table (info
)->dynobj
;
4803 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4804 BFD_ASSERT (s
!= NULL
);
4806 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4807 if (s
->contents
== NULL
)
4808 newcontents
= (bfd_byte
*) malloc (newsize
);
4810 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4811 if (newcontents
== NULL
)
4813 bfd_set_error (bfd_error_no_memory
);
4818 dyn
.d_un
.d_val
= val
;
4819 elf_swap_dyn_out (dynobj
, &dyn
,
4820 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4822 s
->_raw_size
= newsize
;
4823 s
->contents
= newcontents
;
4828 /* Read and swap the relocs for a section. They may have been cached.
4829 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4830 they are used as buffers to read into. They are known to be large
4831 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4832 value is allocated using either malloc or bfd_alloc, according to
4833 the KEEP_MEMORY argument. */
4835 static Elf_Internal_Rela
*
4836 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4839 PTR external_relocs
;
4840 Elf_Internal_Rela
*internal_relocs
;
4841 boolean keep_memory
;
4843 Elf_Internal_Shdr
*rel_hdr
;
4845 Elf_Internal_Rela
*alloc2
= NULL
;
4847 if (elf_section_data (o
)->relocs
!= NULL
)
4848 return elf_section_data (o
)->relocs
;
4850 if (o
->reloc_count
== 0)
4853 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4855 if (internal_relocs
== NULL
)
4859 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4861 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4863 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4864 if (internal_relocs
== NULL
)
4866 bfd_set_error (bfd_error_no_memory
);
4871 if (external_relocs
== NULL
)
4873 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4876 bfd_set_error (bfd_error_no_memory
);
4879 external_relocs
= alloc1
;
4882 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4883 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4884 != rel_hdr
->sh_size
))
4887 /* Swap in the relocs. For convenience, we always produce an
4888 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4890 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4892 Elf_External_Rel
*erel
;
4893 Elf_External_Rel
*erelend
;
4894 Elf_Internal_Rela
*irela
;
4896 erel
= (Elf_External_Rel
*) external_relocs
;
4897 erelend
= erel
+ o
->reloc_count
;
4898 irela
= internal_relocs
;
4899 for (; erel
< erelend
; erel
++, irela
++)
4901 Elf_Internal_Rel irel
;
4903 elf_swap_reloc_in (abfd
, erel
, &irel
);
4904 irela
->r_offset
= irel
.r_offset
;
4905 irela
->r_info
= irel
.r_info
;
4906 irela
->r_addend
= 0;
4911 Elf_External_Rela
*erela
;
4912 Elf_External_Rela
*erelaend
;
4913 Elf_Internal_Rela
*irela
;
4915 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4917 erela
= (Elf_External_Rela
*) external_relocs
;
4918 erelaend
= erela
+ o
->reloc_count
;
4919 irela
= internal_relocs
;
4920 for (; erela
< erelaend
; erela
++, irela
++)
4921 elf_swap_reloca_in (abfd
, erela
, irela
);
4924 /* Cache the results for next time, if we can. */
4926 elf_section_data (o
)->relocs
= internal_relocs
;
4931 /* Don't free alloc2, since if it was allocated we are passing it
4932 back (under the name of internal_relocs). */
4934 return internal_relocs
;
4944 /* Record an assignment to a symbol made by a linker script. We need
4945 this in case some dynamic object refers to this symbol. */
4949 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4951 struct bfd_link_info
*info
;
4954 struct elf_link_hash_entry
*h
;
4956 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4959 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4963 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4964 h
->type
= STT_OBJECT
;
4966 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4967 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4969 && h
->dynindx
== -1)
4971 if (! elf_link_record_dynamic_symbol (info
, h
))
4974 /* If this is a weak defined symbol, and we know a corresponding
4975 real symbol from the same dynamic object, make sure the real
4976 symbol is also made into a dynamic symbol. */
4977 if (h
->weakdef
!= NULL
4978 && h
->weakdef
->dynindx
== -1)
4980 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4988 /* Array used to determine the number of hash table buckets to use
4989 based on the number of symbols there are. If there are fewer than
4990 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4991 fewer than 37 we use 17 buckets, and so forth. We never use more
4992 than 521 buckets. */
4994 static const size_t elf_buckets
[] =
4996 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4999 /* Set up the sizes and contents of the ELF dynamic sections. This is
5000 called by the ELF linker emulation before_allocation routine. We
5001 must set the sizes of the sections before the linker sets the
5002 addresses of the various sections. */
5005 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
5006 export_dynamic
, info
, sinterpptr
)
5010 boolean export_dynamic
;
5011 struct bfd_link_info
*info
;
5012 asection
**sinterpptr
;
5016 Elf_Internal_Sym isym
;
5019 struct elf_backend_data
*bed
;
5023 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5026 dynobj
= elf_hash_table (info
)->dynobj
;
5028 /* If there were no dynamic objects in the link, there is nothing to
5033 /* If we are supposed to export all symbols into the dynamic symbol
5034 table (this is not the normal case), then do so. */
5036 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5039 if (elf_hash_table (info
)->dynamic_sections_created
)
5041 bfd_size_type strsize
;
5043 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5044 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5050 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5052 if (indx
== (bfd_size_type
) -1
5053 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5061 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5063 if (indx
== (bfd_size_type
) -1
5064 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5068 /* Find all symbols which were defined in a dynamic object and make
5069 the backend pick a reasonable value for them. */
5070 elf_link_hash_traverse (elf_hash_table (info
),
5071 elf_adjust_dynamic_symbol
,
5074 /* Add some entries to the .dynamic section. We fill in some of the
5075 values later, in elf_bfd_final_link, but we must add the entries
5076 now so that we know the final size of the .dynamic section. */
5077 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5078 false, false) != NULL
)
5080 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5083 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5084 false, false) != NULL
)
5086 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5089 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5090 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5091 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5092 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5093 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5094 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5095 sizeof (Elf_External_Sym
)))
5099 /* The backend must work out the sizes of all the other dynamic
5101 bed
= get_elf_backend_data (output_bfd
);
5102 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5105 if (elf_hash_table (info
)->dynamic_sections_created
)
5109 /* Set the size of the .dynsym and .hash sections. We counted
5110 the number of dynamic symbols in elf_link_add_object_symbols.
5111 We will build the contents of .dynsym and .hash when we build
5112 the final symbol table, because until then we do not know the
5113 correct value to give the symbols. We built the .dynstr
5114 section as we went along in elf_link_add_object_symbols. */
5115 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5116 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5117 BFD_ASSERT (s
!= NULL
);
5118 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5119 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5120 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5122 bfd_set_error (bfd_error_no_memory
);
5126 /* The first entry in .dynsym is a dummy symbol. */
5133 elf_swap_symbol_out (output_bfd
, &isym
,
5134 (Elf_External_Sym
*) s
->contents
);
5136 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5138 bucketcount
= elf_buckets
[i
];
5139 if (dynsymcount
< elf_buckets
[i
+ 1])
5143 s
= bfd_get_section_by_name (dynobj
, ".hash");
5144 BFD_ASSERT (s
!= NULL
);
5145 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5146 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5147 if (s
->contents
== NULL
)
5149 bfd_set_error (bfd_error_no_memory
);
5152 memset (s
->contents
, 0, s
->_raw_size
);
5154 put_word (output_bfd
, bucketcount
, s
->contents
);
5155 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5157 elf_hash_table (info
)->bucketcount
= bucketcount
;
5159 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5160 BFD_ASSERT (s
!= NULL
);
5161 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5163 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5170 /* This routine is used to export all defined symbols into the dynamic
5171 symbol table. It is called via elf_link_hash_traverse. */
5174 elf_export_symbol (h
, data
)
5175 struct elf_link_hash_entry
*h
;
5178 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5180 if (h
->dynindx
== -1
5181 && (h
->elf_link_hash_flags
5182 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5184 if (! elf_link_record_dynamic_symbol (info
, h
))
5186 /* FIXME: No way to report error. */
5194 /* Make the backend pick a good value for a dynamic symbol. This is
5195 called via elf_link_hash_traverse, and also calls itself
5199 elf_adjust_dynamic_symbol (h
, data
)
5200 struct elf_link_hash_entry
*h
;
5203 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5205 struct elf_backend_data
*bed
;
5207 /* If this symbol does not require a PLT entry, and it is not
5208 defined by a dynamic object, or is not referenced by a regular
5209 object, ignore it. FIXME: Do we need to worry about symbols
5210 which are defined by one dynamic object and referenced by another
5212 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5213 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5214 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5215 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5218 /* If we've already adjusted this symbol, don't do it again. This
5219 can happen via a recursive call. */
5220 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5223 /* Don't look at this symbol again. Note that we must set this
5224 after checking the above conditions, because we may look at a
5225 symbol once, decide not to do anything, and then get called
5226 recursively later after REF_REGULAR is set below. */
5227 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5229 /* If this is a weak definition, and we know a real definition, and
5230 the real symbol is not itself defined by a regular object file,
5231 then get a good value for the real definition. We handle the
5232 real symbol first, for the convenience of the backend routine.
5234 Note that there is a confusing case here. If the real definition
5235 is defined by a regular object file, we don't get the real symbol
5236 from the dynamic object, but we do get the weak symbol. If the
5237 processor backend uses a COPY reloc, then if some routine in the
5238 dynamic object changes the real symbol, we will not see that
5239 change in the corresponding weak symbol. This is the way other
5240 ELF linkers work as well, and seems to be a result of the shared
5243 I will clarify this issue. Most SVR4 shared libraries define the
5244 variable _timezone and define timezone as a weak synonym. The
5245 tzset call changes _timezone. If you write
5246 extern int timezone;
5248 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5249 you might expect that, since timezone is a synonym for _timezone,
5250 the same number will print both times. However, if the processor
5251 backend uses a COPY reloc, then actually timezone will be copied
5252 into your process image, and, since you define _timezone
5253 yourself, _timezone will not. Thus timezone and _timezone will
5254 wind up at different memory locations. The tzset call will set
5255 _timezone, leaving timezone unchanged. */
5257 if (h
->weakdef
!= NULL
)
5259 struct elf_link_hash_entry
*weakdef
;
5261 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5262 || h
->root
.type
== bfd_link_hash_defweak
);
5263 weakdef
= h
->weakdef
;
5264 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5265 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5266 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5267 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5269 /* This symbol is defined by a regular object file, so we
5270 will not do anything special. Clear weakdef for the
5271 convenience of the processor backend. */
5276 /* There is an implicit reference by a regular object file
5277 via the weak symbol. */
5278 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5279 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5284 dynobj
= elf_hash_table (info
)->dynobj
;
5285 bed
= get_elf_backend_data (dynobj
);
5286 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5288 /* FIXME: No way to return error. */
5295 /* Final phase of ELF linker. */
5297 /* A structure we use to avoid passing large numbers of arguments. */
5299 struct elf_final_link_info
5301 /* General link information. */
5302 struct bfd_link_info
*info
;
5305 /* Symbol string table. */
5306 struct bfd_strtab_hash
*symstrtab
;
5307 /* .dynsym section. */
5308 asection
*dynsym_sec
;
5309 /* .hash section. */
5311 /* Buffer large enough to hold contents of any section. */
5313 /* Buffer large enough to hold external relocs of any section. */
5314 PTR external_relocs
;
5315 /* Buffer large enough to hold internal relocs of any section. */
5316 Elf_Internal_Rela
*internal_relocs
;
5317 /* Buffer large enough to hold external local symbols of any input
5319 Elf_External_Sym
*external_syms
;
5320 /* Buffer large enough to hold internal local symbols of any input
5322 Elf_Internal_Sym
*internal_syms
;
5323 /* Array large enough to hold a symbol index for each local symbol
5324 of any input BFD. */
5326 /* Array large enough to hold a section pointer for each local
5327 symbol of any input BFD. */
5328 asection
**sections
;
5329 /* Buffer to hold swapped out symbols. */
5330 Elf_External_Sym
*symbuf
;
5331 /* Number of swapped out symbols in buffer. */
5332 size_t symbuf_count
;
5333 /* Number of symbols which fit in symbuf. */
5337 static boolean elf_link_output_sym
5338 PARAMS ((struct elf_final_link_info
*, const char *,
5339 Elf_Internal_Sym
*, asection
*));
5340 static boolean elf_link_flush_output_syms
5341 PARAMS ((struct elf_final_link_info
*));
5342 static boolean elf_link_output_extsym
5343 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5344 static boolean elf_link_input_bfd
5345 PARAMS ((struct elf_final_link_info
*, bfd
*));
5346 static boolean elf_reloc_link_order
5347 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5348 struct bfd_link_order
*));
5350 /* Do the final step of an ELF link. */
5353 elf_bfd_final_link (abfd
, info
)
5355 struct bfd_link_info
*info
;
5359 struct elf_final_link_info finfo
;
5360 register asection
*o
;
5361 register struct bfd_link_order
*p
;
5363 size_t max_contents_size
;
5364 size_t max_external_reloc_size
;
5365 size_t max_internal_reloc_count
;
5366 size_t max_sym_count
;
5368 Elf_Internal_Sym elfsym
;
5370 Elf_Internal_Shdr
*symtab_hdr
;
5371 Elf_Internal_Shdr
*symstrtab_hdr
;
5372 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5375 abfd
->flags
|= DYNAMIC
;
5377 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5378 dynobj
= elf_hash_table (info
)->dynobj
;
5381 finfo
.output_bfd
= abfd
;
5382 finfo
.symstrtab
= elf_stringtab_init ();
5383 if (finfo
.symstrtab
== NULL
)
5387 finfo
.dynsym_sec
= NULL
;
5388 finfo
.hash_sec
= NULL
;
5392 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5393 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5394 if (finfo
.dynsym_sec
== NULL
5395 || finfo
.hash_sec
== NULL
)
5398 finfo
.contents
= NULL
;
5399 finfo
.external_relocs
= NULL
;
5400 finfo
.internal_relocs
= NULL
;
5401 finfo
.external_syms
= NULL
;
5402 finfo
.internal_syms
= NULL
;
5403 finfo
.indices
= NULL
;
5404 finfo
.sections
= NULL
;
5405 finfo
.symbuf
= NULL
;
5406 finfo
.symbuf_count
= 0;
5408 /* Count up the number of relocations we will output for each output
5409 section, so that we know the sizes of the reloc sections. We
5410 also figure out some maximum sizes. */
5411 max_contents_size
= 0;
5412 max_external_reloc_size
= 0;
5413 max_internal_reloc_count
= 0;
5415 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5419 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5421 if (p
->type
== bfd_section_reloc_link_order
5422 || p
->type
== bfd_symbol_reloc_link_order
)
5424 else if (p
->type
== bfd_indirect_link_order
)
5428 sec
= p
->u
.indirect
.section
;
5430 if (info
->relocateable
)
5431 o
->reloc_count
+= sec
->reloc_count
;
5433 if (sec
->_raw_size
> max_contents_size
)
5434 max_contents_size
= sec
->_raw_size
;
5435 if (sec
->_cooked_size
> max_contents_size
)
5436 max_contents_size
= sec
->_cooked_size
;
5438 /* We are interested in just local symbols, not all
5440 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5444 if (elf_bad_symtab (sec
->owner
))
5445 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5446 / sizeof (Elf_External_Sym
));
5448 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5450 if (sym_count
> max_sym_count
)
5451 max_sym_count
= sym_count
;
5453 if ((sec
->flags
& SEC_RELOC
) != 0)
5457 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5458 if (ext_size
> max_external_reloc_size
)
5459 max_external_reloc_size
= ext_size
;
5460 if (sec
->reloc_count
> max_internal_reloc_count
)
5461 max_internal_reloc_count
= sec
->reloc_count
;
5467 if (o
->reloc_count
> 0)
5468 o
->flags
|= SEC_RELOC
;
5471 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5472 set it (this is probably a bug) and if it is set
5473 assign_section_numbers will create a reloc section. */
5474 o
->flags
&=~ SEC_RELOC
;
5477 /* If the SEC_ALLOC flag is not set, force the section VMA to
5478 zero. This is done in elf_fake_sections as well, but forcing
5479 the VMA to 0 here will ensure that relocs against these
5480 sections are handled correctly. */
5481 if ((o
->flags
& SEC_ALLOC
) == 0)
5485 /* Figure out the file positions for everything but the symbol table
5486 and the relocs. We set symcount to force assign_section_numbers
5487 to create a symbol table. */
5488 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5489 BFD_ASSERT (! abfd
->output_has_begun
);
5490 if (! elf_compute_section_file_positions (abfd
, info
))
5493 /* That created the reloc sections. Set their sizes, and assign
5494 them file positions, and allocate some buffers. */
5495 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5497 if ((o
->flags
& SEC_RELOC
) != 0)
5499 Elf_Internal_Shdr
*rel_hdr
;
5500 register struct elf_link_hash_entry
**p
, **pend
;
5502 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5504 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5506 /* The contents field must last into write_object_contents,
5507 so we allocate it with bfd_alloc rather than malloc. */
5508 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5509 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5511 bfd_set_error (bfd_error_no_memory
);
5515 p
= ((struct elf_link_hash_entry
**)
5516 malloc (o
->reloc_count
5517 * sizeof (struct elf_link_hash_entry
*)));
5518 if (p
== NULL
&& o
->reloc_count
!= 0)
5520 bfd_set_error (bfd_error_no_memory
);
5523 elf_section_data (o
)->rel_hashes
= p
;
5524 pend
= p
+ o
->reloc_count
;
5525 for (; p
< pend
; p
++)
5528 /* Use the reloc_count field as an index when outputting the
5534 assign_file_positions_for_relocs (abfd
);
5536 /* We have now assigned file positions for all the sections except
5537 .symtab and .strtab. We start the .symtab section at the current
5538 file position, and write directly to it. We build the .strtab
5539 section in memory. When we add .dynsym support, we will build
5540 that in memory as well (.dynsym is smaller than .symtab). */
5542 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5543 /* sh_name is set in prep_headers. */
5544 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5545 symtab_hdr
->sh_flags
= 0;
5546 symtab_hdr
->sh_addr
= 0;
5547 symtab_hdr
->sh_size
= 0;
5548 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5549 /* sh_link is set in assign_section_numbers. */
5550 /* sh_info is set below. */
5551 /* sh_offset is set just below. */
5552 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5554 off
= elf_tdata (abfd
)->next_file_pos
;
5555 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5557 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5558 incorrect. We do not yet know the size of the .symtab section.
5559 We correct next_file_pos below, after we do know the size. */
5561 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5562 continuously seeking to the right position in the file. */
5563 if (! info
->keep_memory
|| max_sym_count
< 20)
5564 finfo
.symbuf_size
= 20;
5566 finfo
.symbuf_size
= max_sym_count
;
5567 finfo
.symbuf
= ((Elf_External_Sym
*)
5568 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5569 if (finfo
.symbuf
== NULL
)
5571 bfd_set_error (bfd_error_no_memory
);
5575 /* Start writing out the symbol table. The first symbol is always a
5577 elfsym
.st_value
= 0;
5580 elfsym
.st_other
= 0;
5581 elfsym
.st_shndx
= SHN_UNDEF
;
5582 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5583 &elfsym
, bfd_und_section_ptr
))
5587 /* Some standard ELF linkers do this, but we don't because it causes
5588 bootstrap comparison failures. */
5589 /* Output a file symbol for the output file as the second symbol.
5590 We output this even if we are discarding local symbols, although
5591 I'm not sure if this is correct. */
5592 elfsym
.st_value
= 0;
5594 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5595 elfsym
.st_other
= 0;
5596 elfsym
.st_shndx
= SHN_ABS
;
5597 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5598 &elfsym
, bfd_abs_section_ptr
))
5602 /* Output a symbol for each section. We output these even if we are
5603 discarding local symbols, since they are used for relocs. These
5604 symbols have no names. We store the index of each one in the
5605 index field of the section, so that we can find it again when
5606 outputting relocs. */
5607 elfsym
.st_value
= 0;
5609 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5610 elfsym
.st_other
= 0;
5611 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5613 o
= section_from_elf_index (abfd
, i
);
5615 o
->target_index
= abfd
->symcount
;
5616 elfsym
.st_shndx
= i
;
5617 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5622 /* Allocate some memory to hold information read in from the input
5624 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5625 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5626 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5627 malloc (max_internal_reloc_count
5628 * sizeof (Elf_Internal_Rela
)));
5629 finfo
.external_syms
= ((Elf_External_Sym
*)
5630 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5631 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5632 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5633 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5634 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5635 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5636 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5637 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5638 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5639 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5640 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5641 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5643 bfd_set_error (bfd_error_no_memory
);
5647 /* Since ELF permits relocations to be against local symbols, we
5648 must have the local symbols available when we do the relocations.
5649 Since we would rather only read the local symbols once, and we
5650 would rather not keep them in memory, we handle all the
5651 relocations for a single input file at the same time.
5653 Unfortunately, there is no way to know the total number of local
5654 symbols until we have seen all of them, and the local symbol
5655 indices precede the global symbol indices. This means that when
5656 we are generating relocateable output, and we see a reloc against
5657 a global symbol, we can not know the symbol index until we have
5658 finished examining all the local symbols to see which ones we are
5659 going to output. To deal with this, we keep the relocations in
5660 memory, and don't output them until the end of the link. This is
5661 an unfortunate waste of memory, but I don't see a good way around
5662 it. Fortunately, it only happens when performing a relocateable
5663 link, which is not the common case. FIXME: If keep_memory is set
5664 we could write the relocs out and then read them again; I don't
5665 know how bad the memory loss will be. */
5667 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5668 sub
->output_has_begun
= false;
5669 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5671 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5673 if (p
->type
== bfd_indirect_link_order
5674 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5675 == bfd_target_elf_flavour
))
5677 sub
= p
->u
.indirect
.section
->owner
;
5678 if (! sub
->output_has_begun
)
5680 if (! elf_link_input_bfd (&finfo
, sub
))
5682 sub
->output_has_begun
= true;
5685 else if (p
->type
== bfd_section_reloc_link_order
5686 || p
->type
== bfd_symbol_reloc_link_order
)
5688 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5693 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5699 /* That wrote out all the local symbols. Finish up the symbol table
5700 with the global symbols. */
5702 /* The sh_info field records the index of the first non local
5704 symtab_hdr
->sh_info
= abfd
->symcount
;
5706 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5708 /* We get the global symbols from the hash table. */
5709 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5712 /* Flush all symbols to the file. */
5713 if (! elf_link_flush_output_syms (&finfo
))
5716 /* Now we know the size of the symtab section. */
5717 off
+= symtab_hdr
->sh_size
;
5719 /* Finish up and write out the symbol string table (.strtab)
5721 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5722 /* sh_name was set in prep_headers. */
5723 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5724 symstrtab_hdr
->sh_flags
= 0;
5725 symstrtab_hdr
->sh_addr
= 0;
5726 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5727 symstrtab_hdr
->sh_entsize
= 0;
5728 symstrtab_hdr
->sh_link
= 0;
5729 symstrtab_hdr
->sh_info
= 0;
5730 /* sh_offset is set just below. */
5731 symstrtab_hdr
->sh_addralign
= 1;
5733 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5734 elf_tdata (abfd
)->next_file_pos
= off
;
5736 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5737 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5740 /* Adjust the relocs to have the correct symbol indices. */
5741 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5743 struct elf_link_hash_entry
**rel_hash
;
5744 Elf_Internal_Shdr
*rel_hdr
;
5746 if ((o
->flags
& SEC_RELOC
) == 0)
5749 rel_hash
= elf_section_data (o
)->rel_hashes
;
5750 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5751 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5753 if (*rel_hash
== NULL
)
5756 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5758 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5760 Elf_External_Rel
*erel
;
5761 Elf_Internal_Rel irel
;
5763 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5764 elf_swap_reloc_in (abfd
, erel
, &irel
);
5765 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5766 ELF_R_TYPE (irel
.r_info
));
5767 elf_swap_reloc_out (abfd
, &irel
, erel
);
5771 Elf_External_Rela
*erela
;
5772 Elf_Internal_Rela irela
;
5774 BFD_ASSERT (rel_hdr
->sh_entsize
5775 == sizeof (Elf_External_Rela
));
5777 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5778 elf_swap_reloca_in (abfd
, erela
, &irela
);
5779 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5780 ELF_R_TYPE (irela
.r_info
));
5781 elf_swap_reloca_out (abfd
, &irela
, erela
);
5785 /* Set the reloc_count field to 0 to prevent write_relocs from
5786 trying to swap the relocs out itself. */
5790 /* If we are linking against a dynamic object, or generating a
5791 shared library, finish up the dynamic linking information. */
5794 Elf_External_Dyn
*dyncon
, *dynconend
;
5796 /* Fix up .dynamic entries. */
5797 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5798 BFD_ASSERT (o
!= NULL
);
5800 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5801 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5802 for (; dyncon
< dynconend
; dyncon
++)
5804 Elf_Internal_Dyn dyn
;
5808 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5815 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5816 magic _init and _fini symbols. This is pretty ugly,
5817 but we are compatible. */
5825 struct elf_link_hash_entry
*h
;
5827 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5828 false, false, true);
5829 BFD_ASSERT (h
!= NULL
);
5830 if (h
->root
.type
== bfd_link_hash_defined
5831 || h
->root
.type
== bfd_link_hash_defweak
)
5833 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5834 o
= h
->root
.u
.def
.section
;
5835 if (o
->output_section
!= NULL
)
5836 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5837 + o
->output_offset
);
5839 dyn
.d_un
.d_val
+= o
->vma
;
5841 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5854 o
= bfd_get_section_by_name (abfd
, name
);
5855 BFD_ASSERT (o
!= NULL
);
5856 dyn
.d_un
.d_ptr
= o
->vma
;
5857 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5864 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5869 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5871 Elf_Internal_Shdr
*hdr
;
5873 hdr
= elf_elfsections (abfd
)[i
];
5874 if (hdr
->sh_type
== type
5875 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5877 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5878 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5881 if (dyn
.d_un
.d_val
== 0
5882 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5883 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5887 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5893 /* If we have created any dynamic sections, then output them. */
5896 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5899 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5901 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5902 || o
->_raw_size
== 0)
5904 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5906 /* At this point, we are only interested in sections
5907 created by elf_link_create_dynamic_sections. FIXME:
5908 This test is fragile. */
5911 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5913 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5915 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5916 o
->contents
, o
->output_offset
,
5924 /* The contents of the .dynstr section are actually in a
5926 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5927 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5928 || ! _bfd_stringtab_emit (abfd
,
5929 elf_hash_table (info
)->dynstr
))
5935 if (finfo
.symstrtab
!= NULL
)
5936 _bfd_stringtab_free (finfo
.symstrtab
);
5937 if (finfo
.contents
!= NULL
)
5938 free (finfo
.contents
);
5939 if (finfo
.external_relocs
!= NULL
)
5940 free (finfo
.external_relocs
);
5941 if (finfo
.internal_relocs
!= NULL
)
5942 free (finfo
.internal_relocs
);
5943 if (finfo
.external_syms
!= NULL
)
5944 free (finfo
.external_syms
);
5945 if (finfo
.internal_syms
!= NULL
)
5946 free (finfo
.internal_syms
);
5947 if (finfo
.indices
!= NULL
)
5948 free (finfo
.indices
);
5949 if (finfo
.sections
!= NULL
)
5950 free (finfo
.sections
);
5951 if (finfo
.symbuf
!= NULL
)
5952 free (finfo
.symbuf
);
5953 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5955 if ((o
->flags
& SEC_RELOC
) != 0
5956 && elf_section_data (o
)->rel_hashes
!= NULL
)
5957 free (elf_section_data (o
)->rel_hashes
);
5960 elf_tdata (abfd
)->linker
= true;
5965 if (finfo
.symstrtab
!= NULL
)
5966 _bfd_stringtab_free (finfo
.symstrtab
);
5967 if (finfo
.contents
!= NULL
)
5968 free (finfo
.contents
);
5969 if (finfo
.external_relocs
!= NULL
)
5970 free (finfo
.external_relocs
);
5971 if (finfo
.internal_relocs
!= NULL
)
5972 free (finfo
.internal_relocs
);
5973 if (finfo
.external_syms
!= NULL
)
5974 free (finfo
.external_syms
);
5975 if (finfo
.internal_syms
!= NULL
)
5976 free (finfo
.internal_syms
);
5977 if (finfo
.indices
!= NULL
)
5978 free (finfo
.indices
);
5979 if (finfo
.sections
!= NULL
)
5980 free (finfo
.sections
);
5981 if (finfo
.symbuf
!= NULL
)
5982 free (finfo
.symbuf
);
5983 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5985 if ((o
->flags
& SEC_RELOC
) != 0
5986 && elf_section_data (o
)->rel_hashes
!= NULL
)
5987 free (elf_section_data (o
)->rel_hashes
);
5993 /* Add a symbol to the output symbol table. */
5996 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5997 struct elf_final_link_info
*finfo
;
5999 Elf_Internal_Sym
*elfsym
;
6000 asection
*input_sec
;
6002 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
6003 struct bfd_link_info
*info
,
6008 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
6009 elf_backend_link_output_symbol_hook
;
6010 if (output_symbol_hook
!= NULL
)
6012 if (! ((*output_symbol_hook
)
6013 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
6017 if (name
== (const char *) NULL
|| *name
== '\0')
6018 elfsym
->st_name
= 0;
6021 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6024 if (elfsym
->st_name
== (unsigned long) -1)
6028 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6030 if (! elf_link_flush_output_syms (finfo
))
6034 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6035 finfo
->symbuf
+ finfo
->symbuf_count
);
6036 ++finfo
->symbuf_count
;
6038 ++finfo
->output_bfd
->symcount
;
6043 /* Flush the output symbols to the file. */
6046 elf_link_flush_output_syms (finfo
)
6047 struct elf_final_link_info
*finfo
;
6049 Elf_Internal_Shdr
*symtab
;
6051 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6053 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6055 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6056 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6057 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6060 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6062 finfo
->symbuf_count
= 0;
6067 /* Add an external symbol to the symbol table. This is called from
6068 the hash table traversal routine. */
6071 elf_link_output_extsym (h
, data
)
6072 struct elf_link_hash_entry
*h
;
6075 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
6077 Elf_Internal_Sym sym
;
6078 asection
*input_sec
;
6080 /* If we are not creating a shared library, and this symbol is
6081 referenced by a shared library but is not defined anywhere, then
6082 warn that it is undefined. If we do not do this, the runtime
6083 linker will complain that the symbol is undefined when the
6084 program is run. We don't have to worry about symbols that are
6085 referenced by regular files, because we will already have issued
6088 FIXME: If we are linking against an object which uses DT_NEEDED,
6089 we don't give this warning, because it might be the case that the
6090 needed dynamic object will define the symbols. Unfortunately,
6091 this makes this type of check much less useful, but the only way
6092 to fix it would be to locate the needed object and read its
6093 symbol table. That seems like a real waste of time just to give
6094 better error messages. */
6095 if (! finfo
->info
->relocateable
6096 && ! finfo
->info
->shared
6097 && ! elf_hash_table (finfo
->info
)->saw_needed
6098 && h
->root
.type
== bfd_link_hash_undefined
6099 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6100 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6102 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6103 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6104 (asection
*) NULL
, 0)))
6106 /* FIXME: No way to return error. */
6111 /* We don't want to output symbols that have never been mentioned by
6112 a regular file, or that we have been told to strip. However, if
6113 h->indx is set to -2, the symbol is used by a reloc and we must
6117 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6118 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6119 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6120 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6122 else if (finfo
->info
->strip
== strip_all
6123 || (finfo
->info
->strip
== strip_some
6124 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6125 h
->root
.root
.string
,
6126 false, false) == NULL
))
6131 /* If we're stripping it, and it's not a dynamic symbol, there's
6132 nothing else to do. */
6133 if (strip
&& h
->dynindx
== -1)
6137 sym
.st_size
= h
->size
;
6139 if (h
->root
.type
== bfd_link_hash_undefweak
6140 || h
->root
.type
== bfd_link_hash_defweak
)
6141 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6143 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6145 switch (h
->root
.type
)
6148 case bfd_link_hash_new
:
6152 case bfd_link_hash_undefined
:
6153 input_sec
= bfd_und_section_ptr
;
6154 sym
.st_shndx
= SHN_UNDEF
;
6157 case bfd_link_hash_undefweak
:
6158 input_sec
= bfd_und_section_ptr
;
6159 sym
.st_shndx
= SHN_UNDEF
;
6162 case bfd_link_hash_defined
:
6163 case bfd_link_hash_defweak
:
6165 input_sec
= h
->root
.u
.def
.section
;
6166 if (input_sec
->output_section
!= NULL
)
6169 elf_section_from_bfd_section (finfo
->output_bfd
,
6170 input_sec
->output_section
);
6171 if (sym
.st_shndx
== (unsigned short) -1)
6173 /* FIXME: No way to handle errors. */
6177 /* ELF symbols in relocateable files are section relative,
6178 but in nonrelocateable files they are virtual
6180 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6181 if (! finfo
->info
->relocateable
)
6182 sym
.st_value
+= input_sec
->output_section
->vma
;
6186 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6187 == bfd_target_elf_flavour
)
6188 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6189 sym
.st_shndx
= SHN_UNDEF
;
6190 input_sec
= bfd_und_section_ptr
;
6195 case bfd_link_hash_common
:
6196 input_sec
= bfd_com_section_ptr
;
6197 sym
.st_shndx
= SHN_COMMON
;
6198 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
6201 case bfd_link_hash_indirect
:
6202 case bfd_link_hash_warning
:
6203 /* I have no idea how these should be handled. */
6207 /* If this symbol should be put in the .dynsym section, then put it
6208 there now. We have already know the symbol index. We also fill
6209 in the entry in the .hash section. */
6210 if (h
->dynindx
!= -1
6211 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6213 struct elf_backend_data
*bed
;
6216 bfd_byte
*bucketpos
;
6219 sym
.st_name
= h
->dynstr_index
;
6221 /* Give the processor backend a chance to tweak the symbol
6222 value, and also to finish up anything that needs to be done
6224 bed
= get_elf_backend_data (finfo
->output_bfd
);
6225 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6226 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6228 /* FIXME: No way to return error. */
6232 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6233 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6236 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6237 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6239 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6240 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6241 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6242 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6243 put_word (finfo
->output_bfd
, chain
,
6244 ((bfd_byte
*) finfo
->hash_sec
->contents
6245 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6248 /* If we're stripping it, then it was just a dynamic symbol, and
6249 there's nothing else to do. */
6253 h
->indx
= finfo
->output_bfd
->symcount
;
6255 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6257 /* FIXME: No way to return error. */
6264 /* Link an input file into the linker output file. This function
6265 handles all the sections and relocations of the input file at once.
6266 This is so that we only have to read the local symbols once, and
6267 don't have to keep them in memory. */
6270 elf_link_input_bfd (finfo
, input_bfd
)
6271 struct elf_final_link_info
*finfo
;
6274 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6275 bfd
*, asection
*, bfd_byte
*,
6276 Elf_Internal_Rela
*,
6277 Elf_Internal_Sym
*, asection
**));
6279 Elf_Internal_Shdr
*symtab_hdr
;
6282 Elf_External_Sym
*esym
;
6283 Elf_External_Sym
*esymend
;
6284 Elf_Internal_Sym
*isym
;
6286 asection
**ppsection
;
6289 output_bfd
= finfo
->output_bfd
;
6291 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6293 /* If this is a dynamic object, we don't want to do anything here:
6294 we don't want the local symbols, and we don't want the section
6296 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6299 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6300 if (elf_bad_symtab (input_bfd
))
6302 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6307 locsymcount
= symtab_hdr
->sh_info
;
6308 extsymoff
= symtab_hdr
->sh_info
;
6311 /* Read the local symbols. */
6313 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6314 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6315 locsymcount
, input_bfd
)
6316 != locsymcount
* sizeof (Elf_External_Sym
))))
6319 /* Swap in the local symbols and write out the ones which we know
6320 are going into the output file. */
6321 esym
= finfo
->external_syms
;
6322 esymend
= esym
+ locsymcount
;
6323 isym
= finfo
->internal_syms
;
6324 pindex
= finfo
->indices
;
6325 ppsection
= finfo
->sections
;
6326 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6330 Elf_Internal_Sym osym
;
6332 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6335 if (elf_bad_symtab (input_bfd
))
6337 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6344 if (isym
->st_shndx
== SHN_UNDEF
)
6345 isec
= bfd_und_section_ptr
;
6346 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6347 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6348 else if (isym
->st_shndx
== SHN_ABS
)
6349 isec
= bfd_abs_section_ptr
;
6350 else if (isym
->st_shndx
== SHN_COMMON
)
6351 isec
= bfd_com_section_ptr
;
6360 /* Don't output the first, undefined, symbol. */
6361 if (esym
== finfo
->external_syms
)
6364 /* If we are stripping all symbols, we don't want to output this
6366 if (finfo
->info
->strip
== strip_all
)
6369 /* We never output section symbols. Instead, we use the section
6370 symbol of the corresponding section in the output file. */
6371 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6374 /* If we are discarding all local symbols, we don't want to
6375 output this one. If we are generating a relocateable output
6376 file, then some of the local symbols may be required by
6377 relocs; we output them below as we discover that they are
6379 if (finfo
->info
->discard
== discard_all
)
6382 /* Get the name of the symbol. */
6383 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6388 /* See if we are discarding symbols with this name. */
6389 if ((finfo
->info
->strip
== strip_some
6390 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6392 || (finfo
->info
->discard
== discard_l
6393 && strncmp (name
, finfo
->info
->lprefix
,
6394 finfo
->info
->lprefix_len
) == 0))
6397 /* If we get here, we are going to output this symbol. */
6401 /* Adjust the section index for the output file. */
6402 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6403 isec
->output_section
);
6404 if (osym
.st_shndx
== (unsigned short) -1)
6407 *pindex
= output_bfd
->symcount
;
6409 /* ELF symbols in relocateable files are section relative, but
6410 in executable files they are virtual addresses. Note that
6411 this code assumes that all ELF sections have an associated
6412 BFD section with a reasonable value for output_offset; below
6413 we assume that they also have a reasonable value for
6414 output_section. Any special sections must be set up to meet
6415 these requirements. */
6416 osym
.st_value
+= isec
->output_offset
;
6417 if (! finfo
->info
->relocateable
)
6418 osym
.st_value
+= isec
->output_section
->vma
;
6420 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6424 /* Relocate the contents of each section. */
6425 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6427 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6430 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6431 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6433 /* Section was created by elf_link_create_dynamic_sections.
6434 FIXME: This test is fragile. */
6438 /* Read the contents of the section. */
6439 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6440 (file_ptr
) 0, o
->_raw_size
))
6443 if ((o
->flags
& SEC_RELOC
) != 0)
6445 Elf_Internal_Rela
*internal_relocs
;
6447 /* Get the swapped relocs. */
6448 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6449 finfo
->external_relocs
,
6450 finfo
->internal_relocs
,
6452 if (internal_relocs
== NULL
6453 && o
->reloc_count
> 0)
6456 /* Relocate the section by invoking a back end routine.
6458 The back end routine is responsible for adjusting the
6459 section contents as necessary, and (if using Rela relocs
6460 and generating a relocateable output file) adjusting the
6461 reloc addend as necessary.
6463 The back end routine does not have to worry about setting
6464 the reloc address or the reloc symbol index.
6466 The back end routine is given a pointer to the swapped in
6467 internal symbols, and can access the hash table entries
6468 for the external symbols via elf_sym_hashes (input_bfd).
6470 When generating relocateable output, the back end routine
6471 must handle STB_LOCAL/STT_SECTION symbols specially. The
6472 output symbol is going to be a section symbol
6473 corresponding to the output section, which will require
6474 the addend to be adjusted. */
6476 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6480 finfo
->internal_syms
,
6484 if (finfo
->info
->relocateable
)
6486 Elf_Internal_Rela
*irela
;
6487 Elf_Internal_Rela
*irelaend
;
6488 struct elf_link_hash_entry
**rel_hash
;
6489 Elf_Internal_Shdr
*input_rel_hdr
;
6490 Elf_Internal_Shdr
*output_rel_hdr
;
6492 /* Adjust the reloc addresses and symbol indices. */
6494 irela
= internal_relocs
;
6495 irelaend
= irela
+ o
->reloc_count
;
6496 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6497 + o
->output_section
->reloc_count
);
6498 for (; irela
< irelaend
; irela
++, rel_hash
++)
6501 Elf_Internal_Sym
*isym
;
6504 irela
->r_offset
+= o
->output_offset
;
6506 r_symndx
= ELF_R_SYM (irela
->r_info
);
6511 if (r_symndx
>= locsymcount
6512 || (elf_bad_symtab (input_bfd
)
6513 && finfo
->sections
[r_symndx
] == NULL
))
6517 /* This is a reloc against a global symbol. We
6518 have not yet output all the local symbols, so
6519 we do not know the symbol index of any global
6520 symbol. We set the rel_hash entry for this
6521 reloc to point to the global hash table entry
6522 for this symbol. The symbol index is then
6523 set at the end of elf_bfd_final_link. */
6524 indx
= r_symndx
- extsymoff
;
6525 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6527 /* Setting the index to -2 tells
6528 elf_link_output_extsym that this symbol is
6530 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6531 (*rel_hash
)->indx
= -2;
6536 /* This is a reloc against a local symbol. */
6539 isym
= finfo
->internal_syms
+ r_symndx
;
6540 sec
= finfo
->sections
[r_symndx
];
6541 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6543 /* I suppose the backend ought to fill in the
6544 section of any STT_SECTION symbol against a
6545 processor specific section. */
6546 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6548 else if (sec
== NULL
|| sec
->owner
== NULL
)
6550 bfd_set_error (bfd_error_bad_value
);
6555 r_symndx
= sec
->output_section
->target_index
;
6562 if (finfo
->indices
[r_symndx
] == -1)
6568 if (finfo
->info
->strip
== strip_all
)
6570 /* You can't do ld -r -s. */
6571 bfd_set_error (bfd_error_invalid_operation
);
6575 /* This symbol was skipped earlier, but
6576 since it is needed by a reloc, we
6577 must output it now. */
6578 link
= symtab_hdr
->sh_link
;
6579 name
= elf_string_from_elf_section (input_bfd
,
6585 osec
= sec
->output_section
;
6587 elf_section_from_bfd_section (output_bfd
,
6589 if (isym
->st_shndx
== (unsigned short) -1)
6592 isym
->st_value
+= sec
->output_offset
;
6593 if (! finfo
->info
->relocateable
)
6594 isym
->st_value
+= osec
->vma
;
6596 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6598 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6602 r_symndx
= finfo
->indices
[r_symndx
];
6605 irela
->r_info
= ELF_R_INFO (r_symndx
,
6606 ELF_R_TYPE (irela
->r_info
));
6609 /* Swap out the relocs. */
6610 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6611 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6612 BFD_ASSERT (output_rel_hdr
->sh_entsize
6613 == input_rel_hdr
->sh_entsize
);
6614 irela
= internal_relocs
;
6615 irelaend
= irela
+ o
->reloc_count
;
6616 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6618 Elf_External_Rel
*erel
;
6620 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6621 + o
->output_section
->reloc_count
);
6622 for (; irela
< irelaend
; irela
++, erel
++)
6624 Elf_Internal_Rel irel
;
6626 irel
.r_offset
= irela
->r_offset
;
6627 irel
.r_info
= irela
->r_info
;
6628 BFD_ASSERT (irela
->r_addend
== 0);
6629 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6634 Elf_External_Rela
*erela
;
6636 BFD_ASSERT (input_rel_hdr
->sh_entsize
6637 == sizeof (Elf_External_Rela
));
6638 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6639 + o
->output_section
->reloc_count
);
6640 for (; irela
< irelaend
; irela
++, erela
++)
6641 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6644 o
->output_section
->reloc_count
+= o
->reloc_count
;
6648 /* Write out the modified section contents. */
6649 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6650 finfo
->contents
, o
->output_offset
,
6651 (o
->_cooked_size
!= 0
6660 /* Generate a reloc when linking an ELF file. This is a reloc
6661 requested by the linker, and does come from any input file. This
6662 is used to build constructor and destructor tables when linking
6666 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6668 struct bfd_link_info
*info
;
6669 asection
*output_section
;
6670 struct bfd_link_order
*link_order
;
6672 reloc_howto_type
*howto
;
6675 struct elf_link_hash_entry
**rel_hash_ptr
;
6676 Elf_Internal_Shdr
*rel_hdr
;
6678 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6681 bfd_set_error (bfd_error_bad_value
);
6685 /* If this is an inplace reloc, we must write the addend into the
6687 if (howto
->partial_inplace
6688 && link_order
->u
.reloc
.p
->addend
!= 0)
6691 bfd_reloc_status_type rstat
;
6695 size
= bfd_get_reloc_size (howto
);
6696 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6697 if (buf
== (bfd_byte
*) NULL
)
6699 bfd_set_error (bfd_error_no_memory
);
6702 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6703 link_order
->u
.reloc
.p
->addend
, buf
);
6709 case bfd_reloc_outofrange
:
6711 case bfd_reloc_overflow
:
6712 if (! ((*info
->callbacks
->reloc_overflow
)
6714 (link_order
->type
== bfd_section_reloc_link_order
6715 ? bfd_section_name (output_bfd
,
6716 link_order
->u
.reloc
.p
->u
.section
)
6717 : link_order
->u
.reloc
.p
->u
.name
),
6718 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6719 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6726 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6727 (file_ptr
) link_order
->offset
, size
);
6733 /* Figure out the symbol index. */
6734 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6735 + output_section
->reloc_count
);
6736 if (link_order
->type
== bfd_section_reloc_link_order
)
6738 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6741 *rel_hash_ptr
= NULL
;
6745 struct elf_link_hash_entry
*h
;
6747 h
= elf_link_hash_lookup (elf_hash_table (info
),
6748 link_order
->u
.reloc
.p
->u
.name
,
6749 false, false, true);
6752 /* Setting the index to -2 tells elf_link_output_extsym that
6753 this symbol is used by a reloc. */
6760 if (! ((*info
->callbacks
->unattached_reloc
)
6761 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6762 (asection
*) NULL
, (bfd_vma
) 0)))
6768 /* The address of a reloc is relative to the section in a
6769 relocateable file, and is a virtual address in an executable
6771 offset
= link_order
->offset
;
6772 if (! info
->relocateable
)
6773 offset
+= output_section
->vma
;
6775 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6777 if (rel_hdr
->sh_type
== SHT_REL
)
6779 Elf_Internal_Rel irel
;
6780 Elf_External_Rel
*erel
;
6782 irel
.r_offset
= offset
;
6783 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6784 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6785 + output_section
->reloc_count
);
6786 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6790 Elf_Internal_Rela irela
;
6791 Elf_External_Rela
*erela
;
6793 irela
.r_offset
= offset
;
6794 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6795 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6796 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6797 + output_section
->reloc_count
);
6798 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6801 ++output_section
->reloc_count
;