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)
2266 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2268 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2270 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2272 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2273 The main loop in map_program_segments requires this. */
2274 ret
= (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2277 if (hdr1
->sh_size
== 0)
2279 else if (hdr2
->sh_size
== 0)
2285 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2295 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2296 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2297 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2299 struct bfd_strtab_hash
*shstrtab
;
2301 i_ehdrp
= elf_elfheader (abfd
);
2302 i_shdrp
= elf_elfsections (abfd
);
2304 shstrtab
= elf_stringtab_init ();
2305 if (shstrtab
== NULL
)
2308 elf_shstrtab (abfd
) = shstrtab
;
2310 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2311 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2312 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2313 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2315 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2316 i_ehdrp
->e_ident
[EI_DATA
] =
2317 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2318 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2320 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2321 i_ehdrp
->e_ident
[count
] = 0;
2323 if ((abfd
->flags
& DYNAMIC
) != 0)
2324 i_ehdrp
->e_type
= ET_DYN
;
2325 else if ((abfd
->flags
& EXEC_P
) != 0)
2326 i_ehdrp
->e_type
= ET_EXEC
;
2328 i_ehdrp
->e_type
= ET_REL
;
2330 switch (bfd_get_arch (abfd
))
2332 case bfd_arch_unknown
:
2333 i_ehdrp
->e_machine
= EM_NONE
;
2335 case bfd_arch_sparc
:
2337 i_ehdrp
->e_machine
= EM_SPARC64
;
2339 i_ehdrp
->e_machine
= EM_SPARC
;
2343 i_ehdrp
->e_machine
= EM_386
;
2346 i_ehdrp
->e_machine
= EM_68K
;
2349 i_ehdrp
->e_machine
= EM_88K
;
2352 i_ehdrp
->e_machine
= EM_860
;
2354 case bfd_arch_mips
: /* MIPS Rxxxx */
2355 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2358 i_ehdrp
->e_machine
= EM_PARISC
;
2360 case bfd_arch_powerpc
:
2361 i_ehdrp
->e_machine
= EM_PPC
;
2363 /* start-sanitize-arc */
2365 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2367 /* end-sanitize-arc */
2368 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2370 i_ehdrp
->e_machine
= EM_NONE
;
2372 i_ehdrp
->e_version
= EV_CURRENT
;
2373 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2375 /* no program header, for now. */
2376 i_ehdrp
->e_phoff
= 0;
2377 i_ehdrp
->e_phentsize
= 0;
2378 i_ehdrp
->e_phnum
= 0;
2380 /* each bfd section is section header entry */
2381 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2382 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2384 /* if we're building an executable, we'll need a program header table */
2385 if (abfd
->flags
& EXEC_P
)
2387 /* it all happens later */
2389 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2391 /* elf_build_phdrs() returns a (NULL-terminated) array of
2392 Elf_Internal_Phdrs */
2393 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2394 i_ehdrp
->e_phoff
= outbase
;
2395 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2400 i_ehdrp
->e_phentsize
= 0;
2402 i_ehdrp
->e_phoff
= 0;
2405 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2406 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2407 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2408 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2409 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2410 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2411 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2412 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2413 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2420 swap_out_syms (abfd
, sttp
)
2422 struct bfd_strtab_hash
**sttp
;
2424 if (!elf_map_symbols (abfd
))
2427 /* Dump out the symtabs. */
2429 int symcount
= bfd_get_symcount (abfd
);
2430 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2431 struct bfd_strtab_hash
*stt
;
2432 Elf_Internal_Shdr
*symtab_hdr
;
2433 Elf_Internal_Shdr
*symstrtab_hdr
;
2434 Elf_External_Sym
*outbound_syms
;
2437 stt
= elf_stringtab_init ();
2441 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2442 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2443 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2444 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2445 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2446 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2448 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2449 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2451 outbound_syms
= ((Elf_External_Sym
*)
2453 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2454 if (outbound_syms
== NULL
)
2456 bfd_set_error (bfd_error_no_memory
);
2459 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2461 /* now generate the data (for "contents") */
2463 /* Fill in zeroth symbol and swap it out. */
2464 Elf_Internal_Sym sym
;
2470 sym
.st_shndx
= SHN_UNDEF
;
2471 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2474 for (idx
= 0; idx
< symcount
; idx
++)
2476 Elf_Internal_Sym sym
;
2477 bfd_vma value
= syms
[idx
]->value
;
2478 elf_symbol_type
*type_ptr
;
2480 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2481 /* Section symbols have no names. */
2485 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2488 if (sym
.st_name
== (unsigned long) -1)
2492 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2494 if (bfd_is_com_section (syms
[idx
]->section
))
2496 /* ELF common symbols put the alignment into the `value' field,
2497 and the size into the `size' field. This is backwards from
2498 how BFD handles it, so reverse it here. */
2499 sym
.st_size
= value
;
2500 if (type_ptr
== NULL
2501 || type_ptr
->internal_elf_sym
.st_value
== 0)
2502 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2504 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2505 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2506 syms
[idx
]->section
);
2510 asection
*sec
= syms
[idx
]->section
;
2513 if (sec
->output_section
)
2515 value
+= sec
->output_offset
;
2516 sec
= sec
->output_section
;
2519 sym
.st_value
= value
;
2520 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2521 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2525 /* Writing this would be a hell of a lot easier if we had
2526 some decent documentation on bfd, and knew what to expect
2527 of the library, and what to demand of applications. For
2528 example, it appears that `objcopy' might not set the
2529 section of a symbol to be a section that is actually in
2531 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2532 BFD_ASSERT (sec2
!= 0);
2533 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2534 BFD_ASSERT (shndx
!= -1);
2538 if (bfd_is_com_section (syms
[idx
]->section
))
2539 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2540 else if (bfd_is_und_section (syms
[idx
]->section
))
2541 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2542 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2545 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2546 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2547 else if (syms
[idx
]->flags
& BSF_FILE
)
2548 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2551 int bind
= STB_LOCAL
;
2552 int type
= STT_OBJECT
;
2553 unsigned int flags
= syms
[idx
]->flags
;
2555 if (flags
& BSF_LOCAL
)
2557 else if (flags
& BSF_WEAK
)
2559 else if (flags
& BSF_GLOBAL
)
2562 if (flags
& BSF_FUNCTION
)
2565 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2569 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2574 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2575 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2577 symstrtab_hdr
->sh_flags
= 0;
2578 symstrtab_hdr
->sh_addr
= 0;
2579 symstrtab_hdr
->sh_entsize
= 0;
2580 symstrtab_hdr
->sh_link
= 0;
2581 symstrtab_hdr
->sh_info
= 0;
2582 symstrtab_hdr
->sh_addralign
= 1;
2589 write_shdrs_and_ehdr (abfd
)
2592 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2593 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2594 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2595 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2598 i_ehdrp
= elf_elfheader (abfd
);
2599 i_shdrp
= elf_elfsections (abfd
);
2601 /* swap the header before spitting it out... */
2604 elf_debug_file (i_ehdrp
);
2606 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2607 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2608 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2609 != sizeof (x_ehdr
)))
2612 /* at this point we've concocted all the ELF sections... */
2613 x_shdrp
= (Elf_External_Shdr
*)
2614 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2617 bfd_set_error (bfd_error_no_memory
);
2621 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2624 elf_debug_section (count
, i_shdrp
[count
]);
2626 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2628 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2629 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2630 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2633 /* need to dump the string table too... */
2638 /* Assign file positions for all the reloc sections which are not part
2639 of the loadable file image. */
2642 assign_file_positions_for_relocs (abfd
)
2647 Elf_Internal_Shdr
**shdrpp
;
2649 off
= elf_tdata (abfd
)->next_file_pos
;
2651 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2652 i
< elf_elfheader (abfd
)->e_shnum
;
2655 Elf_Internal_Shdr
*shdrp
;
2658 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2659 && shdrp
->sh_offset
== -1)
2660 off
= assign_file_position_for_section (shdrp
, off
, true);
2663 elf_tdata (abfd
)->next_file_pos
= off
;
2667 NAME(bfd_elf
,write_object_contents
) (abfd
)
2670 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2671 Elf_Internal_Ehdr
*i_ehdrp
;
2672 Elf_Internal_Shdr
**i_shdrp
;
2675 if (! abfd
->output_has_begun
2676 && ! elf_compute_section_file_positions (abfd
,
2677 (struct bfd_link_info
*) NULL
))
2680 i_shdrp
= elf_elfsections (abfd
);
2681 i_ehdrp
= elf_elfheader (abfd
);
2683 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2684 assign_file_positions_for_relocs (abfd
);
2686 /* After writing the headers, we need to write the sections too... */
2687 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2689 if (bed
->elf_backend_section_processing
)
2690 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2691 if (i_shdrp
[count
]->contents
)
2693 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2694 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2696 != i_shdrp
[count
]->sh_size
))
2701 /* Write out the section header names. */
2702 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2703 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2706 if (bed
->elf_backend_final_write_processing
)
2707 (*bed
->elf_backend_final_write_processing
) (abfd
,
2708 elf_tdata (abfd
)->linker
);
2710 return write_shdrs_and_ehdr (abfd
);
2713 /* Given an ELF section number, retrieve the corresponding BFD
2717 section_from_elf_index (abfd
, index
)
2721 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2722 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2724 return elf_elfsections (abfd
)[index
]->bfd_section
;
2727 /* given a section, search the header to find them... */
2729 elf_section_from_bfd_section (abfd
, asect
)
2733 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2734 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2736 Elf_Internal_Shdr
*hdr
;
2737 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2739 for (index
= 0; index
< maxindex
; index
++)
2741 hdr
= i_shdrp
[index
];
2742 if (hdr
->bfd_section
== asect
)
2746 if (bed
->elf_backend_section_from_bfd_section
)
2748 for (index
= 0; index
< maxindex
; index
++)
2752 hdr
= i_shdrp
[index
];
2754 if ((*bed
->elf_backend_section_from_bfd_section
)
2755 (abfd
, hdr
, asect
, &retval
))
2760 if (bfd_is_abs_section (asect
))
2762 if (bfd_is_com_section (asect
))
2764 if (bfd_is_und_section (asect
))
2770 /* given a symbol, return the bfd index for that symbol. */
2772 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2774 struct symbol_cache_entry
**asym_ptr_ptr
;
2776 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2778 flagword flags
= asym_ptr
->flags
;
2780 /* When gas creates relocations against local labels, it creates its
2781 own symbol for the section, but does put the symbol into the
2782 symbol chain, so udata is 0. When the linker is generating
2783 relocatable output, this section symbol may be for one of the
2784 input sections rather than the output section. */
2785 if (asym_ptr
->udata
.i
== 0
2786 && (flags
& BSF_SECTION_SYM
)
2787 && asym_ptr
->section
)
2791 if (asym_ptr
->section
->output_section
!= NULL
)
2792 indx
= asym_ptr
->section
->output_section
->index
;
2794 indx
= asym_ptr
->section
->index
;
2795 if (elf_section_syms (abfd
)[indx
])
2796 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2799 idx
= asym_ptr
->udata
.i
;
2807 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2808 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2817 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2819 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2822 Elf_Internal_Shdr
*hdr
;
2823 long symcount
; /* Number of external ELF symbols */
2824 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2825 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2826 Elf_Internal_Sym i_sym
;
2827 Elf_External_Sym
*x_symp
= NULL
;
2829 /* Read each raw ELF symbol, converting from external ELF form to
2830 internal ELF form, and then using the information to create a
2831 canonical bfd symbol table entry.
2833 Note that we allocate the initial bfd canonical symbol buffer
2834 based on a one-to-one mapping of the ELF symbols to canonical
2835 symbols. We actually use all the ELF symbols, so there will be no
2836 space left over at the end. When we have all the symbols, we
2837 build the caller's pointer vector. */
2840 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2842 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2843 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2846 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2849 sym
= symbase
= NULL
;
2854 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2857 symbase
= ((elf_symbol_type
*)
2858 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2859 if (symbase
== (elf_symbol_type
*) NULL
)
2861 bfd_set_error (bfd_error_no_memory
);
2866 /* Temporarily allocate room for the raw ELF symbols. */
2867 x_symp
= ((Elf_External_Sym
*)
2868 malloc (symcount
* sizeof (Elf_External_Sym
)));
2869 if (x_symp
== NULL
&& symcount
!= 0)
2871 bfd_set_error (bfd_error_no_memory
);
2875 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2876 != symcount
* sizeof (Elf_External_Sym
))
2878 /* Skip first symbol, which is a null dummy. */
2879 for (i
= 1; i
< symcount
; i
++)
2881 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2882 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2883 #ifdef ELF_KEEP_EXTSYM
2884 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2886 sym
->symbol
.the_bfd
= abfd
;
2888 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2891 sym
->symbol
.value
= i_sym
.st_value
;
2893 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2895 sym
->symbol
.section
= section_from_elf_index (abfd
,
2897 if (sym
->symbol
.section
== NULL
)
2899 /* This symbol is in a section for which we did not
2900 create a BFD section. Just use bfd_abs_section,
2901 although it is wrong. FIXME. */
2902 sym
->symbol
.section
= bfd_abs_section_ptr
;
2905 else if (i_sym
.st_shndx
== SHN_ABS
)
2907 sym
->symbol
.section
= bfd_abs_section_ptr
;
2909 else if (i_sym
.st_shndx
== SHN_COMMON
)
2911 sym
->symbol
.section
= bfd_com_section_ptr
;
2912 /* Elf puts the alignment into the `value' field, and
2913 the size into the `size' field. BFD wants to see the
2914 size in the value field, and doesn't care (at the
2915 moment) about the alignment. */
2916 sym
->symbol
.value
= i_sym
.st_size
;
2918 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2920 sym
->symbol
.section
= bfd_und_section_ptr
;
2923 sym
->symbol
.section
= bfd_abs_section_ptr
;
2925 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2927 switch (ELF_ST_BIND (i_sym
.st_info
))
2930 sym
->symbol
.flags
|= BSF_LOCAL
;
2933 if (i_sym
.st_shndx
!= SHN_UNDEF
2934 && i_sym
.st_shndx
!= SHN_COMMON
)
2935 sym
->symbol
.flags
|= BSF_GLOBAL
;
2938 sym
->symbol
.flags
|= BSF_WEAK
;
2942 switch (ELF_ST_TYPE (i_sym
.st_info
))
2945 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2948 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2951 sym
->symbol
.flags
|= BSF_FUNCTION
;
2956 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2958 /* Do some backend-specific processing on this symbol. */
2960 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2961 if (ebd
->elf_backend_symbol_processing
)
2962 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2969 /* Do some backend-specific processing on this symbol table. */
2971 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2972 if (ebd
->elf_backend_symbol_table_processing
)
2973 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2976 /* We rely on the zalloc to clear out the final symbol entry. */
2978 symcount
= sym
- symbase
;
2980 /* Fill in the user's symbol pointer vector if needed. */
2988 *symptrs
++ = &sym
->symbol
;
2991 *symptrs
= 0; /* Final null pointer */
3003 /* Return the number of bytes required to hold the symtab vector.
3005 Note that we base it on the count plus 1, since we will null terminate
3006 the vector allocated based on this size. However, the ELF symbol table
3007 always has a dummy entry as symbol #0, so it ends up even. */
3010 elf_get_symtab_upper_bound (abfd
)
3015 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3017 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3018 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3024 elf_get_dynamic_symtab_upper_bound (abfd
)
3029 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3031 if (elf_dynsymtab (abfd
) == 0)
3033 bfd_set_error (bfd_error_invalid_operation
);
3037 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3038 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3044 elf_get_reloc_upper_bound (abfd
, asect
)
3048 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3051 /* Read in and swap the external relocs. */
3054 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3059 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
3060 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
3061 PTR allocated
= NULL
;
3062 bfd_byte
*native_relocs
;
3068 if (asect
->relocation
!= NULL
3069 || (asect
->flags
& SEC_RELOC
) == 0
3070 || asect
->reloc_count
== 0)
3073 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
3074 && (asect
->reloc_count
3075 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
3077 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
3078 if (allocated
== NULL
)
3080 bfd_set_error (bfd_error_no_memory
);
3084 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
3085 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
3086 != d
->rel_hdr
.sh_size
))
3089 native_relocs
= (bfd_byte
*) allocated
;
3091 relents
= ((arelent
*)
3092 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
3093 if (relents
== NULL
)
3095 bfd_set_error (bfd_error_no_memory
);
3099 entsize
= d
->rel_hdr
.sh_entsize
;
3100 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
3101 || entsize
== sizeof (Elf_External_Rela
));
3103 for (i
= 0, relent
= relents
;
3104 i
< asect
->reloc_count
;
3105 i
++, relent
++, native_relocs
+= entsize
)
3107 Elf_Internal_Rela rela
;
3108 Elf_Internal_Rel rel
;
3110 if (entsize
== sizeof (Elf_External_Rela
))
3111 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
3114 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
3115 rela
.r_offset
= rel
.r_offset
;
3116 rela
.r_info
= rel
.r_info
;
3120 /* The address of an ELF reloc is section relative for an object
3121 file, and absolute for an executable file or shared library.
3122 The address of a BFD reloc is always section relative. */
3123 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3124 relent
->address
= rela
.r_offset
;
3126 relent
->address
= rela
.r_offset
- asect
->vma
;
3128 if (ELF_R_SYM (rela
.r_info
) == 0)
3129 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3134 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3137 /* Canonicalize ELF section symbols. FIXME: Why? */
3138 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3139 relent
->sym_ptr_ptr
= ps
;
3141 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3144 relent
->addend
= rela
.r_addend
;
3146 if (entsize
== sizeof (Elf_External_Rela
))
3147 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3149 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3152 asect
->relocation
= relents
;
3154 if (allocated
!= NULL
)
3160 if (allocated
!= NULL
)
3167 elf_debug_section (num
, hdr
)
3169 Elf_Internal_Shdr
*hdr
;
3171 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3172 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3175 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3176 (long) hdr
->sh_name
,
3177 (long) hdr
->sh_type
,
3178 (long) hdr
->sh_flags
);
3180 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3181 (long) hdr
->sh_addr
,
3182 (long) hdr
->sh_offset
,
3183 (long) hdr
->sh_size
);
3185 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3186 (long) hdr
->sh_link
,
3187 (long) hdr
->sh_info
,
3188 (long) hdr
->sh_addralign
);
3189 fprintf (stderr
, "sh_entsize = %ld\n",
3190 (long) hdr
->sh_entsize
);
3195 elf_debug_file (ehdrp
)
3196 Elf_Internal_Ehdr
*ehdrp
;
3198 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3199 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3200 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3201 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3202 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3203 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3204 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3208 /* Canonicalize the relocs. */
3211 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3220 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3223 tblptr
= section
->relocation
;
3224 for (i
= 0; i
< section
->reloc_count
; i
++)
3225 *relptr
++ = tblptr
++;
3229 return section
->reloc_count
;
3233 elf_get_symtab (abfd
, alocation
)
3235 asymbol
**alocation
;
3237 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3240 bfd_get_symcount (abfd
) = symcount
;
3245 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3247 asymbol
**alocation
;
3249 return elf_slurp_symbol_table (abfd
, alocation
, true);
3253 elf_make_empty_symbol (abfd
)
3256 elf_symbol_type
*newsym
;
3258 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3261 bfd_set_error (bfd_error_no_memory
);
3266 newsym
->symbol
.the_bfd
= abfd
;
3267 return &newsym
->symbol
;
3272 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3277 bfd_symbol_info (symbol
, ret
);
3281 elf_get_lineno (ignore_abfd
, symbol
)
3285 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3292 elf_set_arch_mach (abfd
, arch
, machine
)
3294 enum bfd_architecture arch
;
3295 unsigned long machine
;
3297 /* If this isn't the right architecture for this backend, and this
3298 isn't the generic backend, fail. */
3299 if (arch
!= get_elf_backend_data (abfd
)->arch
3300 && arch
!= bfd_arch_unknown
3301 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3304 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3308 elf_find_nearest_line (abfd
,
3319 CONST
char **filename_ptr
;
3320 CONST
char **functionname_ptr
;
3321 unsigned int *line_ptr
;
3327 elf_sizeof_headers (abfd
, reloc
)
3333 ret
= sizeof (Elf_External_Ehdr
);
3335 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
3341 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3346 bfd_size_type count
;
3348 Elf_Internal_Shdr
*hdr
;
3350 if (! abfd
->output_has_begun
3351 && ! elf_compute_section_file_positions (abfd
,
3352 (struct bfd_link_info
*) NULL
))
3355 hdr
= &elf_section_data (section
)->this_hdr
;
3357 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3359 if (bfd_write (location
, 1, count
, abfd
) != count
)
3366 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3369 Elf_Internal_Rela
*dst
;
3371 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3377 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3380 Elf_Internal_Rel
*dst
;
3382 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3388 /* Core file support */
3390 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3391 #include <sys/procfs.h>
3393 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3394 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3395 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3401 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3408 prstatus_t
*status
= (prstatus_t
*) 0;
3410 if (descsz
== sizeof (prstatus_t
))
3412 newsect
= bfd_make_section (abfd
, ".reg");
3413 if (newsect
== NULL
)
3415 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3416 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3417 newsect
->flags
= SEC_HAS_CONTENTS
;
3418 newsect
->alignment_power
= 2;
3419 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3421 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3427 /* Stash a copy of the prpsinfo structure away for future use. */
3430 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3436 if (descsz
== sizeof (prpsinfo_t
))
3438 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3440 bfd_set_error (bfd_error_no_memory
);
3443 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3449 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3457 newsect
= bfd_make_section (abfd
, ".reg2");
3458 if (newsect
== NULL
)
3460 newsect
->_raw_size
= descsz
;
3461 newsect
->filepos
= filepos
;
3462 newsect
->flags
= SEC_HAS_CONTENTS
;
3463 newsect
->alignment_power
= 2;
3467 #endif /* HAVE_PROCFS */
3469 /* Return a pointer to the args (including the command name) that were
3470 seen by the program that generated the core dump. Note that for
3471 some reason, a spurious space is tacked onto the end of the args
3472 in some (at least one anyway) implementations, so strip it off if
3476 elf_core_file_failing_command (abfd
)
3480 if (core_prpsinfo (abfd
))
3482 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3483 char *scan
= p
->pr_psargs
;
3488 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3492 return p
->pr_psargs
;
3498 /* Return the number of the signal that caused the core dump. Presumably,
3499 since we have a core file, we got a signal of some kind, so don't bother
3500 checking the other process status fields, just return the signal number.
3504 elf_core_file_failing_signal (abfd
)
3508 if (core_prstatus (abfd
))
3510 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3516 /* Check to see if the core file could reasonably be expected to have
3517 come for the current executable file. Note that by default we return
3518 true unless we find something that indicates that there might be a
3523 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3532 /* First, xvecs must match since both are ELF files for the same target. */
3534 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3536 bfd_set_error (bfd_error_system_call
);
3542 /* If no prpsinfo, just return true. Otherwise, grab the last component
3543 of the exec'd pathname from the prpsinfo. */
3545 if (core_prpsinfo (core_bfd
))
3547 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3554 /* Find the last component of the executable pathname. */
3556 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3562 execname
= (char *) exec_bfd
->filename
;
3565 /* See if they match */
3567 return strcmp (execname
, corename
) ? false : true;
3573 #endif /* HAVE_PROCFS */
3576 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3577 the information that would normally be available from the /proc interface
3578 for the process, at the time the process dumped core. Currently this
3579 includes copies of the prstatus, prpsinfo, and fpregset structures.
3581 Since these structures are potentially machine dependent in size and
3582 ordering, bfd provides two levels of support for them. The first level,
3583 available on all machines since it does not require that the host
3584 have /proc support or the relevant include files, is to create a bfd
3585 section for each of the prstatus, prpsinfo, and fpregset structures,
3586 without any interpretation of their contents. With just this support,
3587 the bfd client will have to interpret the structures itself. Even with
3588 /proc support, it might want these full structures for it's own reasons.
3590 In the second level of support, where HAVE_PROCFS is defined, bfd will
3591 pick apart the structures to gather some additional information that
3592 clients may want, such as the general register set, the name of the
3593 exec'ed file and its arguments, the signal (if any) that caused the
3599 elf_corefile_note (abfd
, hdr
)
3601 Elf_Internal_Phdr
*hdr
;
3603 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3604 Elf_Internal_Note i_note
; /* Elf note, internal form */
3605 char *buf
= NULL
; /* Entire note segment contents */
3606 char *namedata
; /* Name portion of the note */
3607 char *descdata
; /* Descriptor portion of the note */
3608 char *sectname
; /* Name to use for new section */
3609 long filepos
; /* File offset to descriptor data */
3612 if (hdr
->p_filesz
> 0
3613 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3614 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3615 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3617 x_note_p
= (Elf_External_Note
*) buf
;
3618 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3620 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3621 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3622 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3623 namedata
= x_note_p
->name
;
3624 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3625 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3626 switch (i_note
.type
)
3629 /* process descdata as prstatus info */
3630 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3632 sectname
= ".prstatus";
3635 /* process descdata as fpregset info */
3636 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3638 sectname
= ".fpregset";
3641 /* process descdata as prpsinfo */
3642 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3644 sectname
= ".prpsinfo";
3647 /* Unknown descriptor, just ignore it. */
3651 if (sectname
!= NULL
)
3653 newsect
= bfd_make_section (abfd
, sectname
);
3654 if (newsect
== NULL
)
3656 newsect
->_raw_size
= i_note
.descsz
;
3657 newsect
->filepos
= filepos
;
3658 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3659 newsect
->alignment_power
= 2;
3661 x_note_p
= (Elf_External_Note
*)
3662 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3669 else if (hdr
->p_filesz
> 0)
3671 bfd_set_error (bfd_error_no_memory
);
3678 /* Core files are simply standard ELF formatted files that partition
3679 the file using the execution view of the file (program header table)
3680 rather than the linking view. In fact, there is no section header
3681 table in a core file.
3683 The process status information (including the contents of the general
3684 register set) and the floating point register set are stored in a
3685 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3686 that allow standard bfd access to the general registers (.reg) and the
3687 floating point registers (.reg2).
3692 elf_core_file_p (abfd
)
3695 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3696 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3697 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3698 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3699 unsigned int phindex
;
3700 struct elf_backend_data
*ebd
;
3702 /* Read in the ELF header in external format. */
3704 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3706 if (bfd_get_error () != bfd_error_system_call
)
3707 bfd_set_error (bfd_error_wrong_format
);
3711 /* Now check to see if we have a valid ELF file, and one that BFD can
3712 make use of. The magic number must match, the address size ('class')
3713 and byte-swapping must match our XVEC entry, and it must have a
3714 program header table (FIXME: See comments re segments at top of this
3717 if (elf_file_p (&x_ehdr
) == false)
3720 bfd_set_error (bfd_error_wrong_format
);
3724 /* FIXME, Check EI_VERSION here ! */
3728 int desired_address_size
= ELFCLASS32
;
3731 int desired_address_size
= ELFCLASS64
;
3734 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3738 /* Switch xvec to match the specified byte order. */
3739 switch (x_ehdr
.e_ident
[EI_DATA
])
3741 case ELFDATA2MSB
: /* Big-endian */
3742 if (abfd
->xvec
->byteorder_big_p
== false)
3745 case ELFDATA2LSB
: /* Little-endian */
3746 if (abfd
->xvec
->byteorder_big_p
== true)
3749 case ELFDATANONE
: /* No data encoding specified */
3750 default: /* Unknown data encoding specified */
3754 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3755 the tdata pointer in the bfd. */
3758 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3759 if (elf_tdata (abfd
) == NULL
)
3761 bfd_set_error (bfd_error_no_memory
);
3765 /* FIXME, `wrong' returns from this point onward, leak memory. */
3767 /* Now that we know the byte order, swap in the rest of the header */
3768 i_ehdrp
= elf_elfheader (abfd
);
3769 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3771 elf_debug_file (i_ehdrp
);
3774 ebd
= get_elf_backend_data (abfd
);
3776 /* Check that the ELF e_machine field matches what this particular
3777 BFD format expects. */
3778 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
3779 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
3780 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
3782 const bfd_target
* const *target_ptr
;
3784 if (ebd
->elf_machine_code
!= EM_NONE
)
3787 /* This is the generic ELF target. Let it match any ELF target
3788 for which we do not have a specific backend. */
3789 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3791 struct elf_backend_data
*back
;
3793 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3795 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3796 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3798 /* target_ptr is an ELF backend which matches this
3799 object file, so reject the generic ELF target. */
3805 /* If there is no program header, or the type is not a core file, then
3807 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3810 /* Allocate space for a copy of the program header table in
3811 internal form, seek to the program header table in the file,
3812 read it in, and convert it to internal form. As a simple sanity
3813 check, verify that the what BFD thinks is the size of each program
3814 header table entry actually matches the size recorded in the file. */
3816 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3818 i_phdrp
= (Elf_Internal_Phdr
*)
3819 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3822 bfd_set_error (bfd_error_no_memory
);
3825 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3827 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3829 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3832 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3835 /* Once all of the program headers have been read and converted, we
3836 can start processing them. */
3838 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3840 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3841 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3843 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3848 /* Remember the entry point specified in the ELF file header. */
3850 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3855 /* ELF linker code. */
3857 static boolean elf_link_add_object_symbols
3858 PARAMS ((bfd
*, struct bfd_link_info
*));
3859 static boolean elf_link_add_archive_symbols
3860 PARAMS ((bfd
*, struct bfd_link_info
*));
3861 static Elf_Internal_Rela
*elf_link_read_relocs
3862 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3863 static boolean elf_export_symbol
3864 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3865 static boolean elf_adjust_dynamic_symbol
3866 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3868 /* Given an ELF BFD, add symbols to the global hash table as
3872 elf_bfd_link_add_symbols (abfd
, info
)
3874 struct bfd_link_info
*info
;
3878 switch (bfd_get_format (abfd
))
3881 return elf_link_add_object_symbols (abfd
, info
);
3883 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3886 if (! bfd_check_format (first
, bfd_object
))
3888 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3890 /* On Linux, we may have an a.out archive which got
3891 recognized as an ELF archive. Therefore, we treat all
3892 archives as though they were actually of the flavour of
3893 their first element. */
3894 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3896 return elf_link_add_archive_symbols (abfd
, info
);
3898 bfd_set_error (bfd_error_wrong_format
);
3903 /* Add symbols from an ELF archive file to the linker hash table. We
3904 don't use _bfd_generic_link_add_archive_symbols because of a
3905 problem which arises on UnixWare. The UnixWare libc.so is an
3906 archive which includes an entry libc.so.1 which defines a bunch of
3907 symbols. The libc.so archive also includes a number of other
3908 object files, which also define symbols, some of which are the same
3909 as those defined in libc.so.1. Correct linking requires that we
3910 consider each object file in turn, and include it if it defines any
3911 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3912 this; it looks through the list of undefined symbols, and includes
3913 any object file which defines them. When this algorithm is used on
3914 UnixWare, it winds up pulling in libc.so.1 early and defining a
3915 bunch of symbols. This means that some of the other objects in the
3916 archive are not included in the link, which is incorrect since they
3917 precede libc.so.1 in the archive.
3919 Fortunately, ELF archive handling is simpler than that done by
3920 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3921 oddities. In ELF, if we find a symbol in the archive map, and the
3922 symbol is currently undefined, we know that we must pull in that
3925 Unfortunately, we do have to make multiple passes over the symbol
3926 table until nothing further is resolved. */
3929 elf_link_add_archive_symbols (abfd
, info
)
3931 struct bfd_link_info
*info
;
3934 boolean
*defined
= NULL
;
3935 boolean
*included
= NULL
;
3939 if (! bfd_has_map (abfd
))
3941 /* An empty archive is a special case. */
3942 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3944 bfd_set_error (bfd_error_no_symbols
);
3948 /* Keep track of all symbols we know to be already defined, and all
3949 files we know to be already included. This is to speed up the
3950 second and subsequent passes. */
3951 c
= bfd_ardata (abfd
)->symdef_count
;
3954 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3955 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3956 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3958 bfd_set_error (bfd_error_no_memory
);
3961 memset (defined
, 0, c
* sizeof (boolean
));
3962 memset (included
, 0, c
* sizeof (boolean
));
3964 symdefs
= bfd_ardata (abfd
)->symdefs
;
3977 symdefend
= symdef
+ c
;
3978 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3980 struct elf_link_hash_entry
*h
;
3982 struct bfd_link_hash_entry
*undefs_tail
;
3985 if (defined
[i
] || included
[i
])
3987 if (symdef
->file_offset
== last
)
3993 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3994 false, false, false);
3995 if (h
== (struct elf_link_hash_entry
*) NULL
)
3997 if (h
->root
.type
!= bfd_link_hash_undefined
)
4003 /* We need to include this archive member. */
4005 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
4006 if (element
== (bfd
*) NULL
)
4009 if (! bfd_check_format (element
, bfd_object
))
4012 /* Doublecheck that we have not included this object
4013 already--it should be impossible, but there may be
4014 something wrong with the archive. */
4015 if (element
->archive_pass
!= 0)
4017 bfd_set_error (bfd_error_bad_value
);
4020 element
->archive_pass
= 1;
4022 undefs_tail
= info
->hash
->undefs_tail
;
4024 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4027 if (! elf_link_add_object_symbols (element
, info
))
4030 /* If there are any new undefined symbols, we need to make
4031 another pass through the archive in order to see whether
4032 they can be defined. FIXME: This isn't perfect, because
4033 common symbols wind up on undefs_tail and because an
4034 undefined symbol which is defined later on in this pass
4035 does not require another pass. This isn't a bug, but it
4036 does make the code less efficient than it could be. */
4037 if (undefs_tail
!= info
->hash
->undefs_tail
)
4040 /* Look backward to mark all symbols from this object file
4041 which we have already seen in this pass. */
4045 included
[mark
] = true;
4050 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4052 /* We mark subsequent symbols from this object file as we go
4053 on through the loop. */
4054 last
= symdef
->file_offset
;
4065 if (defined
!= (boolean
*) NULL
)
4067 if (included
!= (boolean
*) NULL
)
4072 /* Record a new dynamic symbol. We record the dynamic symbols as we
4073 read the input files, since we need to have a list of all of them
4074 before we can determine the final sizes of the output sections.
4075 Note that we may actually call this function even though we are not
4076 going to output any dynamic symbols; in some cases we know that a
4077 symbol should be in the dynamic symbol table, but only if there is
4081 elf_link_record_dynamic_symbol (info
, h
)
4082 struct bfd_link_info
*info
;
4083 struct elf_link_hash_entry
*h
;
4085 if (h
->dynindx
== -1)
4087 struct bfd_strtab_hash
*dynstr
;
4089 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4090 ++elf_hash_table (info
)->dynsymcount
;
4092 dynstr
= elf_hash_table (info
)->dynstr
;
4095 /* Create a strtab to hold the dynamic symbol names. */
4096 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
4101 h
->dynstr_index
= ((unsigned long)
4102 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
4104 if (h
->dynstr_index
== (unsigned long) -1)
4111 /* Add symbols from an ELF object file to the linker hash table. */
4114 elf_link_add_object_symbols (abfd
, info
)
4116 struct bfd_link_info
*info
;
4118 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4119 const Elf_Internal_Sym
*,
4120 const char **, flagword
*,
4121 asection
**, bfd_vma
*));
4122 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4123 asection
*, const Elf_Internal_Rela
*));
4125 Elf_Internal_Shdr
*hdr
;
4129 Elf_External_Sym
*buf
= NULL
;
4130 struct elf_link_hash_entry
**sym_hash
;
4132 Elf_External_Dyn
*dynbuf
= NULL
;
4133 struct elf_link_hash_entry
*weaks
;
4134 Elf_External_Sym
*esym
;
4135 Elf_External_Sym
*esymend
;
4137 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4138 collect
= get_elf_backend_data (abfd
)->collect
;
4140 /* A stripped shared library might only have a dynamic symbol table,
4141 not a regular symbol table. In that case we can still go ahead
4142 and link using the dynamic symbol table. */
4143 if (elf_onesymtab (abfd
) == 0
4144 && elf_dynsymtab (abfd
) != 0)
4146 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4147 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4150 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4151 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4153 /* The sh_info field of the symtab header tells us where the
4154 external symbols start. We don't care about the local symbols at
4156 if (elf_bad_symtab (abfd
))
4158 extsymcount
= symcount
;
4163 extsymcount
= symcount
- hdr
->sh_info
;
4164 extsymoff
= hdr
->sh_info
;
4167 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4168 if (buf
== NULL
&& extsymcount
!= 0)
4170 bfd_set_error (bfd_error_no_memory
);
4174 /* We store a pointer to the hash table entry for each external
4176 sym_hash
= ((struct elf_link_hash_entry
**)
4178 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4179 if (sym_hash
== NULL
)
4181 bfd_set_error (bfd_error_no_memory
);
4184 elf_sym_hashes (abfd
) = sym_hash
;
4186 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4190 /* If we are creating a shared library, create all the dynamic
4191 sections immediately. We need to attach them to something,
4192 so we attach them to this BFD, provided it is the right
4193 format. FIXME: If there are no input BFD's of the same
4194 format as the output, we can't make a shared library. */
4196 && ! elf_hash_table (info
)->dynamic_sections_created
4197 && abfd
->xvec
== info
->hash
->creator
)
4199 if (! elf_link_create_dynamic_sections (abfd
, info
))
4207 bfd_size_type strindex
;
4211 /* You can't use -r against a dynamic object. Also, there's no
4212 hope of using a dynamic object which does not exactly match
4213 the format of the output file. */
4214 if (info
->relocateable
4215 || info
->hash
->creator
!= abfd
->xvec
)
4217 bfd_set_error (bfd_error_invalid_operation
);
4221 /* Find the name to use in a DT_NEEDED entry that refers to this
4222 object. If the object has a DT_SONAME entry, we use it.
4223 Otherwise, if the generic linker stuck something in
4224 elf_dt_needed_name, we use that. Otherwise, we just use the
4226 name
= bfd_get_filename (abfd
);
4227 if (elf_dt_needed_name (abfd
) != NULL
)
4228 name
= elf_dt_needed_name (abfd
);
4229 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4232 Elf_External_Dyn
*extdyn
;
4233 Elf_External_Dyn
*extdynend
;
4235 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4238 bfd_set_error (bfd_error_no_memory
);
4242 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4243 (file_ptr
) 0, s
->_raw_size
))
4247 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4248 for (; extdyn
< extdynend
; extdyn
++)
4250 Elf_Internal_Dyn dyn
;
4252 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4253 if (dyn
.d_tag
== DT_SONAME
)
4258 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4261 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4262 name
= elf_string_from_elf_section (abfd
, link
,
4267 if (dyn
.d_tag
== DT_NEEDED
)
4268 elf_hash_table (info
)->saw_needed
= true;
4275 /* We do not want to include any of the sections in a dynamic
4276 object in the output file. We hack by simply clobbering the
4277 list of sections in the BFD. This could be handled more
4278 cleanly by, say, a new section flag; the existing
4279 SEC_NEVER_LOAD flag is not the one we want, because that one
4280 still implies that the section takes up space in the output
4282 abfd
->sections
= NULL
;
4284 /* If this is the first dynamic object found in the link, create
4285 the special sections required for dynamic linking. */
4286 if (! elf_hash_table (info
)->dynamic_sections_created
)
4288 if (! elf_link_create_dynamic_sections (abfd
, info
))
4292 /* Add a DT_NEEDED entry for this dynamic object. */
4293 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4295 if (strindex
== (bfd_size_type
) -1)
4297 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4302 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4304 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4305 != extsymcount
* sizeof (Elf_External_Sym
)))
4310 esymend
= buf
+ extsymcount
;
4311 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4313 Elf_Internal_Sym sym
;
4319 struct elf_link_hash_entry
*h
= NULL
;
4322 elf_swap_symbol_in (abfd
, esym
, &sym
);
4324 flags
= BSF_NO_FLAGS
;
4326 value
= sym
.st_value
;
4329 bind
= ELF_ST_BIND (sym
.st_info
);
4330 if (bind
== STB_LOCAL
)
4332 /* This should be impossible, since ELF requires that all
4333 global symbols follow all local symbols, and that sh_info
4334 point to the first global symbol. Unfortunatealy, Irix 5
4338 else if (bind
== STB_GLOBAL
)
4340 if (sym
.st_shndx
!= SHN_UNDEF
4341 && sym
.st_shndx
!= SHN_COMMON
)
4346 else if (bind
== STB_WEAK
)
4350 /* Leave it up to the processor backend. */
4353 if (sym
.st_shndx
== SHN_UNDEF
)
4354 sec
= bfd_und_section_ptr
;
4355 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4357 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4361 sec
= bfd_abs_section_ptr
;
4363 else if (sym
.st_shndx
== SHN_ABS
)
4364 sec
= bfd_abs_section_ptr
;
4365 else if (sym
.st_shndx
== SHN_COMMON
)
4367 sec
= bfd_com_section_ptr
;
4368 /* What ELF calls the size we call the value. What ELF
4369 calls the value we call the alignment. */
4370 value
= sym
.st_size
;
4374 /* Leave it up to the processor backend. */
4377 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4378 if (name
== (const char *) NULL
)
4381 if (add_symbol_hook
)
4383 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4387 /* The hook function sets the name to NULL if this symbol
4388 should be skipped for some reason. */
4389 if (name
== (const char *) NULL
)
4393 /* Sanity check that all possibilities were handled. */
4394 if (sec
== (asection
*) NULL
)
4396 bfd_set_error (bfd_error_bad_value
);
4400 if (bfd_is_und_section (sec
)
4401 || bfd_is_com_section (sec
))
4406 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4408 /* We need to look up the symbol now in order to get some of
4409 the dynamic object handling right. We pass the hash
4410 table entry in to _bfd_generic_link_add_one_symbol so
4411 that it does not have to look it up again. */
4412 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4413 true, false, false);
4418 /* If we are looking at a dynamic object, and this is a
4419 definition, we need to see if it has already been defined
4420 by some other object. If it has, we want to use the
4421 existing definition, and we do not want to report a
4422 multiple symbol definition error; we do this by
4423 clobbering sec to be bfd_und_section_ptr. */
4424 if (dynamic
&& definition
)
4426 if (h
->root
.type
== bfd_link_hash_defined
4427 || h
->root
.type
== bfd_link_hash_defweak
)
4428 sec
= bfd_und_section_ptr
;
4431 /* Similarly, if we are not looking at a dynamic object, and
4432 we have a definition, we want to override any definition
4433 we may have from a dynamic object. Symbols from regular
4434 files always take precedence over symbols from dynamic
4435 objects, even if they are defined after the dynamic
4436 object in the link. */
4439 && (h
->root
.type
== bfd_link_hash_defined
4440 || h
->root
.type
== bfd_link_hash_defweak
)
4441 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4442 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4443 == bfd_target_elf_flavour
)
4444 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4447 /* Change the hash table entry to undefined, and let
4448 _bfd_generic_link_add_one_symbol do the right thing
4449 with the new definition. */
4450 h
->root
.type
= bfd_link_hash_undefined
;
4451 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4455 if (! (_bfd_generic_link_add_one_symbol
4456 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4457 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4462 && (flags
& BSF_WEAK
) != 0
4463 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4464 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4465 && (*sym_hash
)->weakdef
== NULL
)
4467 /* Keep a list of all weak defined non function symbols from
4468 a dynamic object, using the weakdef field. Later in this
4469 function we will set the weakdef field to the correct
4470 value. We only put non-function symbols from dynamic
4471 objects on this list, because that happens to be the only
4472 time we need to know the normal symbol corresponding to a
4473 weak symbol, and the information is time consuming to
4474 figure out. If the weakdef field is not already NULL,
4475 then this symbol was already defined by some previous
4476 dynamic object, and we will be using that previous
4477 definition anyhow. */
4479 (*sym_hash
)->weakdef
= weaks
;
4483 /* Get the alignment of a common symbol. */
4484 if (sym
.st_shndx
== SHN_COMMON
4485 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4486 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
4488 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4494 /* Remember the symbol size and type. */
4495 if (sym
.st_size
!= 0)
4497 /* FIXME: We should probably somehow give a warning if
4498 the symbol size changes. */
4499 h
->size
= sym
.st_size
;
4501 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4503 /* FIXME: We should probably somehow give a warning if
4504 the symbol type changes. */
4505 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4508 /* Set a flag in the hash table entry indicating the type of
4509 reference or definition we just found. Keep a count of
4510 the number of dynamic symbols we find. A dynamic symbol
4511 is one which is referenced or defined by both a regular
4512 object and a shared object, or one which is referenced or
4513 defined by more than one shared object. */
4514 old_flags
= h
->elf_link_hash_flags
;
4519 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4521 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4523 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4524 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4530 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4532 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4533 if ((old_flags
& new_flag
) != 0
4534 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4535 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4539 h
->elf_link_hash_flags
|= new_flag
;
4540 if (dynsym
&& h
->dynindx
== -1)
4542 if (! elf_link_record_dynamic_symbol (info
, h
))
4548 /* Now set the weakdefs field correctly for all the weak defined
4549 symbols we found. The only way to do this is to search all the
4550 symbols. Since we only need the information for non functions in
4551 dynamic objects, that's the only time we actually put anything on
4552 the list WEAKS. We need this information so that if a regular
4553 object refers to a symbol defined weakly in a dynamic object, the
4554 real symbol in the dynamic object is also put in the dynamic
4555 symbols; we also must arrange for both symbols to point to the
4556 same memory location. We could handle the general case of symbol
4557 aliasing, but a general symbol alias can only be generated in
4558 assembler code, handling it correctly would be very time
4559 consuming, and other ELF linkers don't handle general aliasing
4561 while (weaks
!= NULL
)
4563 struct elf_link_hash_entry
*hlook
;
4566 struct elf_link_hash_entry
**hpp
;
4567 struct elf_link_hash_entry
**hppend
;
4570 weaks
= hlook
->weakdef
;
4571 hlook
->weakdef
= NULL
;
4573 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4574 || hlook
->root
.type
== bfd_link_hash_defweak
);
4575 slook
= hlook
->root
.u
.def
.section
;
4576 vlook
= hlook
->root
.u
.def
.value
;
4578 hpp
= elf_sym_hashes (abfd
);
4579 hppend
= hpp
+ extsymcount
;
4580 for (; hpp
< hppend
; hpp
++)
4582 struct elf_link_hash_entry
*h
;
4586 && (h
->root
.type
== bfd_link_hash_defined
4587 || h
->root
.type
== bfd_link_hash_defweak
)
4588 && h
->root
.u
.def
.section
== slook
4589 && h
->root
.u
.def
.value
== vlook
)
4593 /* If the weak definition is in the list of dynamic
4594 symbols, make sure the real definition is put there
4596 if (hlook
->dynindx
!= -1
4597 && h
->dynindx
== -1)
4599 if (! elf_link_record_dynamic_symbol (info
, h
))
4614 /* If this object is the same format as the output object, and it is
4615 not a shared library, then let the backend look through the
4618 This is required to build global offset table entries and to
4619 arrange for dynamic relocs. It is not required for the
4620 particular common case of linking non PIC code, even when linking
4621 against shared libraries, but unfortunately there is no way of
4622 knowing whether an object file has been compiled PIC or not.
4623 Looking through the relocs is not particularly time consuming.
4624 The problem is that we must either (1) keep the relocs in memory,
4625 which causes the linker to require additional runtime memory or
4626 (2) read the relocs twice from the input file, which wastes time.
4627 This would be a good case for using mmap.
4629 I have no idea how to handle linking PIC code into a file of a
4630 different format. It probably can't be done. */
4631 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4633 && abfd
->xvec
== info
->hash
->creator
4634 && check_relocs
!= NULL
)
4638 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4640 Elf_Internal_Rela
*internal_relocs
;
4643 if ((o
->flags
& SEC_RELOC
) == 0
4644 || o
->reloc_count
== 0)
4647 /* I believe we can ignore the relocs for any section which
4648 does not form part of the final process image, such as a
4649 debugging section. */
4650 if ((o
->flags
& SEC_ALLOC
) == 0)
4653 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4654 (Elf_Internal_Rela
*) NULL
,
4656 if (internal_relocs
== NULL
)
4659 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4661 if (! info
->keep_memory
)
4662 free (internal_relocs
);
4679 /* Create some sections which will be filled in with dynamic linking
4680 information. ABFD is an input file which requires dynamic sections
4681 to be created. The dynamic sections take up virtual memory space
4682 when the final executable is run, so we need to create them before
4683 addresses are assigned to the output sections. We work out the
4684 actual contents and size of these sections later. */
4687 elf_link_create_dynamic_sections (abfd
, info
)
4689 struct bfd_link_info
*info
;
4692 register asection
*s
;
4693 struct elf_link_hash_entry
*h
;
4694 struct elf_backend_data
*bed
;
4696 if (elf_hash_table (info
)->dynamic_sections_created
)
4699 /* Make sure that all dynamic sections use the same input BFD. */
4700 if (elf_hash_table (info
)->dynobj
== NULL
)
4701 elf_hash_table (info
)->dynobj
= abfd
;
4703 abfd
= elf_hash_table (info
)->dynobj
;
4705 /* Note that we set the SEC_IN_MEMORY flag for all of these
4707 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4709 /* A dynamically linked executable has a .interp section, but a
4710 shared library does not. */
4713 s
= bfd_make_section (abfd
, ".interp");
4715 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4719 s
= bfd_make_section (abfd
, ".dynsym");
4721 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4722 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4725 s
= bfd_make_section (abfd
, ".dynstr");
4727 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4730 /* Create a strtab to hold the dynamic symbol names. */
4731 if (elf_hash_table (info
)->dynstr
== NULL
)
4733 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4734 if (elf_hash_table (info
)->dynstr
== NULL
)
4738 s
= bfd_make_section (abfd
, ".dynamic");
4740 || ! bfd_set_section_flags (abfd
, s
, flags
)
4741 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4744 /* The special symbol _DYNAMIC is always set to the start of the
4745 .dynamic section. This call occurs before we have processed the
4746 symbols for any dynamic object, so we don't have to worry about
4747 overriding a dynamic definition. We could set _DYNAMIC in a
4748 linker script, but we only want to define it if we are, in fact,
4749 creating a .dynamic section. We don't want to define it if there
4750 is no .dynamic section, since on some ELF platforms the start up
4751 code examines it to decide how to initialize the process. */
4753 if (! (_bfd_generic_link_add_one_symbol
4754 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4755 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4756 (struct bfd_link_hash_entry
**) &h
)))
4758 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4759 h
->type
= STT_OBJECT
;
4762 && ! elf_link_record_dynamic_symbol (info
, h
))
4765 s
= bfd_make_section (abfd
, ".hash");
4767 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4768 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4771 /* Let the backend create the rest of the sections. This lets the
4772 backend set the right flags. The backend will normally create
4773 the .got and .plt sections. */
4774 bed
= get_elf_backend_data (abfd
);
4775 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4778 elf_hash_table (info
)->dynamic_sections_created
= true;
4783 /* Add an entry to the .dynamic table. */
4786 elf_add_dynamic_entry (info
, tag
, val
)
4787 struct bfd_link_info
*info
;
4791 Elf_Internal_Dyn dyn
;
4795 bfd_byte
*newcontents
;
4797 dynobj
= elf_hash_table (info
)->dynobj
;
4799 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4800 BFD_ASSERT (s
!= NULL
);
4802 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4803 if (s
->contents
== NULL
)
4804 newcontents
= (bfd_byte
*) malloc (newsize
);
4806 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4807 if (newcontents
== NULL
)
4809 bfd_set_error (bfd_error_no_memory
);
4814 dyn
.d_un
.d_val
= val
;
4815 elf_swap_dyn_out (dynobj
, &dyn
,
4816 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4818 s
->_raw_size
= newsize
;
4819 s
->contents
= newcontents
;
4824 /* Read and swap the relocs for a section. They may have been cached.
4825 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4826 they are used as buffers to read into. They are known to be large
4827 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4828 value is allocated using either malloc or bfd_alloc, according to
4829 the KEEP_MEMORY argument. */
4831 static Elf_Internal_Rela
*
4832 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4835 PTR external_relocs
;
4836 Elf_Internal_Rela
*internal_relocs
;
4837 boolean keep_memory
;
4839 Elf_Internal_Shdr
*rel_hdr
;
4841 Elf_Internal_Rela
*alloc2
= NULL
;
4843 if (elf_section_data (o
)->relocs
!= NULL
)
4844 return elf_section_data (o
)->relocs
;
4846 if (o
->reloc_count
== 0)
4849 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4851 if (internal_relocs
== NULL
)
4855 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4857 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4859 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4860 if (internal_relocs
== NULL
)
4862 bfd_set_error (bfd_error_no_memory
);
4867 if (external_relocs
== NULL
)
4869 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4872 bfd_set_error (bfd_error_no_memory
);
4875 external_relocs
= alloc1
;
4878 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4879 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4880 != rel_hdr
->sh_size
))
4883 /* Swap in the relocs. For convenience, we always produce an
4884 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4886 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4888 Elf_External_Rel
*erel
;
4889 Elf_External_Rel
*erelend
;
4890 Elf_Internal_Rela
*irela
;
4892 erel
= (Elf_External_Rel
*) external_relocs
;
4893 erelend
= erel
+ o
->reloc_count
;
4894 irela
= internal_relocs
;
4895 for (; erel
< erelend
; erel
++, irela
++)
4897 Elf_Internal_Rel irel
;
4899 elf_swap_reloc_in (abfd
, erel
, &irel
);
4900 irela
->r_offset
= irel
.r_offset
;
4901 irela
->r_info
= irel
.r_info
;
4902 irela
->r_addend
= 0;
4907 Elf_External_Rela
*erela
;
4908 Elf_External_Rela
*erelaend
;
4909 Elf_Internal_Rela
*irela
;
4911 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4913 erela
= (Elf_External_Rela
*) external_relocs
;
4914 erelaend
= erela
+ o
->reloc_count
;
4915 irela
= internal_relocs
;
4916 for (; erela
< erelaend
; erela
++, irela
++)
4917 elf_swap_reloca_in (abfd
, erela
, irela
);
4920 /* Cache the results for next time, if we can. */
4922 elf_section_data (o
)->relocs
= internal_relocs
;
4927 /* Don't free alloc2, since if it was allocated we are passing it
4928 back (under the name of internal_relocs). */
4930 return internal_relocs
;
4940 /* Record an assignment to a symbol made by a linker script. We need
4941 this in case some dynamic object refers to this symbol. */
4945 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4947 struct bfd_link_info
*info
;
4950 struct elf_link_hash_entry
*h
;
4952 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4955 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4959 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4960 h
->type
= STT_OBJECT
;
4962 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4963 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4965 && h
->dynindx
== -1)
4967 if (! elf_link_record_dynamic_symbol (info
, h
))
4970 /* If this is a weak defined symbol, and we know a corresponding
4971 real symbol from the same dynamic object, make sure the real
4972 symbol is also made into a dynamic symbol. */
4973 if (h
->weakdef
!= NULL
4974 && h
->weakdef
->dynindx
== -1)
4976 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4984 /* Array used to determine the number of hash table buckets to use
4985 based on the number of symbols there are. If there are fewer than
4986 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4987 fewer than 37 we use 17 buckets, and so forth. We never use more
4988 than 521 buckets. */
4990 static const size_t elf_buckets
[] =
4992 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4995 /* Set up the sizes and contents of the ELF dynamic sections. This is
4996 called by the ELF linker emulation before_allocation routine. We
4997 must set the sizes of the sections before the linker sets the
4998 addresses of the various sections. */
5001 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
5002 export_dynamic
, info
, sinterpptr
)
5006 boolean export_dynamic
;
5007 struct bfd_link_info
*info
;
5008 asection
**sinterpptr
;
5012 Elf_Internal_Sym isym
;
5015 struct elf_backend_data
*bed
;
5019 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5022 dynobj
= elf_hash_table (info
)->dynobj
;
5024 /* If there were no dynamic objects in the link, there is nothing to
5029 /* If we are supposed to export all symbols into the dynamic symbol
5030 table (this is not the normal case), then do so. */
5032 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5035 if (elf_hash_table (info
)->dynamic_sections_created
)
5037 bfd_size_type strsize
;
5039 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5040 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5046 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5048 if (indx
== (bfd_size_type
) -1
5049 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5057 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5059 if (indx
== (bfd_size_type
) -1
5060 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5064 /* Find all symbols which were defined in a dynamic object and make
5065 the backend pick a reasonable value for them. */
5066 elf_link_hash_traverse (elf_hash_table (info
),
5067 elf_adjust_dynamic_symbol
,
5070 /* Add some entries to the .dynamic section. We fill in some of the
5071 values later, in elf_bfd_final_link, but we must add the entries
5072 now so that we know the final size of the .dynamic section. */
5073 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5074 false, false) != NULL
)
5076 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5079 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5080 false, false) != NULL
)
5082 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5085 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5086 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5087 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5088 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5089 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5090 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5091 sizeof (Elf_External_Sym
)))
5095 /* The backend must work out the sizes of all the other dynamic
5097 bed
= get_elf_backend_data (output_bfd
);
5098 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5101 if (elf_hash_table (info
)->dynamic_sections_created
)
5105 /* Set the size of the .dynsym and .hash sections. We counted
5106 the number of dynamic symbols in elf_link_add_object_symbols.
5107 We will build the contents of .dynsym and .hash when we build
5108 the final symbol table, because until then we do not know the
5109 correct value to give the symbols. We built the .dynstr
5110 section as we went along in elf_link_add_object_symbols. */
5111 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5112 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5113 BFD_ASSERT (s
!= NULL
);
5114 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5115 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5116 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5118 bfd_set_error (bfd_error_no_memory
);
5122 /* The first entry in .dynsym is a dummy symbol. */
5129 elf_swap_symbol_out (output_bfd
, &isym
,
5130 (Elf_External_Sym
*) s
->contents
);
5132 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5134 bucketcount
= elf_buckets
[i
];
5135 if (dynsymcount
< elf_buckets
[i
+ 1])
5139 s
= bfd_get_section_by_name (dynobj
, ".hash");
5140 BFD_ASSERT (s
!= NULL
);
5141 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5142 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5143 if (s
->contents
== NULL
)
5145 bfd_set_error (bfd_error_no_memory
);
5148 memset (s
->contents
, 0, s
->_raw_size
);
5150 put_word (output_bfd
, bucketcount
, s
->contents
);
5151 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5153 elf_hash_table (info
)->bucketcount
= bucketcount
;
5155 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5156 BFD_ASSERT (s
!= NULL
);
5157 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5159 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5166 /* This routine is used to export all defined symbols into the dynamic
5167 symbol table. It is called via elf_link_hash_traverse. */
5170 elf_export_symbol (h
, data
)
5171 struct elf_link_hash_entry
*h
;
5174 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5176 if (h
->dynindx
== -1
5177 && (h
->elf_link_hash_flags
5178 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5180 if (! elf_link_record_dynamic_symbol (info
, h
))
5182 /* FIXME: No way to report error. */
5190 /* Make the backend pick a good value for a dynamic symbol. This is
5191 called via elf_link_hash_traverse, and also calls itself
5195 elf_adjust_dynamic_symbol (h
, data
)
5196 struct elf_link_hash_entry
*h
;
5199 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5201 struct elf_backend_data
*bed
;
5203 /* If this symbol does not require a PLT entry, and it is not
5204 defined by a dynamic object, or is not referenced by a regular
5205 object, ignore it. FIXME: Do we need to worry about symbols
5206 which are defined by one dynamic object and referenced by another
5208 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5209 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5210 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5211 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5214 /* If we've already adjusted this symbol, don't do it again. This
5215 can happen via a recursive call. */
5216 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5219 /* Don't look at this symbol again. Note that we must set this
5220 after checking the above conditions, because we may look at a
5221 symbol once, decide not to do anything, and then get called
5222 recursively later after REF_REGULAR is set below. */
5223 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5225 /* If this is a weak definition, and we know a real definition, and
5226 the real symbol is not itself defined by a regular object file,
5227 then get a good value for the real definition. We handle the
5228 real symbol first, for the convenience of the backend routine.
5230 Note that there is a confusing case here. If the real definition
5231 is defined by a regular object file, we don't get the real symbol
5232 from the dynamic object, but we do get the weak symbol. If the
5233 processor backend uses a COPY reloc, then if some routine in the
5234 dynamic object changes the real symbol, we will not see that
5235 change in the corresponding weak symbol. This is the way other
5236 ELF linkers work as well, and seems to be a result of the shared
5239 I will clarify this issue. Most SVR4 shared libraries define the
5240 variable _timezone and define timezone as a weak synonym. The
5241 tzset call changes _timezone. If you write
5242 extern int timezone;
5244 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5245 you might expect that, since timezone is a synonym for _timezone,
5246 the same number will print both times. However, if the processor
5247 backend uses a COPY reloc, then actually timezone will be copied
5248 into your process image, and, since you define _timezone
5249 yourself, _timezone will not. Thus timezone and _timezone will
5250 wind up at different memory locations. The tzset call will set
5251 _timezone, leaving timezone unchanged. */
5253 if (h
->weakdef
!= NULL
)
5255 struct elf_link_hash_entry
*weakdef
;
5257 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5258 || h
->root
.type
== bfd_link_hash_defweak
);
5259 weakdef
= h
->weakdef
;
5260 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5261 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5262 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5263 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5265 /* This symbol is defined by a regular object file, so we
5266 will not do anything special. Clear weakdef for the
5267 convenience of the processor backend. */
5272 /* There is an implicit reference by a regular object file
5273 via the weak symbol. */
5274 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5275 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5280 dynobj
= elf_hash_table (info
)->dynobj
;
5281 bed
= get_elf_backend_data (dynobj
);
5282 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5284 /* FIXME: No way to return error. */
5291 /* Final phase of ELF linker. */
5293 /* A structure we use to avoid passing large numbers of arguments. */
5295 struct elf_final_link_info
5297 /* General link information. */
5298 struct bfd_link_info
*info
;
5301 /* Symbol string table. */
5302 struct bfd_strtab_hash
*symstrtab
;
5303 /* .dynsym section. */
5304 asection
*dynsym_sec
;
5305 /* .hash section. */
5307 /* Buffer large enough to hold contents of any section. */
5309 /* Buffer large enough to hold external relocs of any section. */
5310 PTR external_relocs
;
5311 /* Buffer large enough to hold internal relocs of any section. */
5312 Elf_Internal_Rela
*internal_relocs
;
5313 /* Buffer large enough to hold external local symbols of any input
5315 Elf_External_Sym
*external_syms
;
5316 /* Buffer large enough to hold internal local symbols of any input
5318 Elf_Internal_Sym
*internal_syms
;
5319 /* Array large enough to hold a symbol index for each local symbol
5320 of any input BFD. */
5322 /* Array large enough to hold a section pointer for each local
5323 symbol of any input BFD. */
5324 asection
**sections
;
5325 /* Buffer to hold swapped out symbols. */
5326 Elf_External_Sym
*symbuf
;
5327 /* Number of swapped out symbols in buffer. */
5328 size_t symbuf_count
;
5329 /* Number of symbols which fit in symbuf. */
5333 static boolean elf_link_output_sym
5334 PARAMS ((struct elf_final_link_info
*, const char *,
5335 Elf_Internal_Sym
*, asection
*));
5336 static boolean elf_link_flush_output_syms
5337 PARAMS ((struct elf_final_link_info
*));
5338 static boolean elf_link_output_extsym
5339 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5340 static boolean elf_link_input_bfd
5341 PARAMS ((struct elf_final_link_info
*, bfd
*));
5342 static boolean elf_reloc_link_order
5343 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5344 struct bfd_link_order
*));
5346 /* Do the final step of an ELF link. */
5349 elf_bfd_final_link (abfd
, info
)
5351 struct bfd_link_info
*info
;
5355 struct elf_final_link_info finfo
;
5356 register asection
*o
;
5357 register struct bfd_link_order
*p
;
5359 size_t max_contents_size
;
5360 size_t max_external_reloc_size
;
5361 size_t max_internal_reloc_count
;
5362 size_t max_sym_count
;
5364 Elf_Internal_Sym elfsym
;
5366 Elf_Internal_Shdr
*symtab_hdr
;
5367 Elf_Internal_Shdr
*symstrtab_hdr
;
5368 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5371 abfd
->flags
|= DYNAMIC
;
5373 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5374 dynobj
= elf_hash_table (info
)->dynobj
;
5377 finfo
.output_bfd
= abfd
;
5378 finfo
.symstrtab
= elf_stringtab_init ();
5379 if (finfo
.symstrtab
== NULL
)
5383 finfo
.dynsym_sec
= NULL
;
5384 finfo
.hash_sec
= NULL
;
5388 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5389 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5390 if (finfo
.dynsym_sec
== NULL
5391 || finfo
.hash_sec
== NULL
)
5394 finfo
.contents
= NULL
;
5395 finfo
.external_relocs
= NULL
;
5396 finfo
.internal_relocs
= NULL
;
5397 finfo
.external_syms
= NULL
;
5398 finfo
.internal_syms
= NULL
;
5399 finfo
.indices
= NULL
;
5400 finfo
.sections
= NULL
;
5401 finfo
.symbuf
= NULL
;
5402 finfo
.symbuf_count
= 0;
5404 /* Count up the number of relocations we will output for each output
5405 section, so that we know the sizes of the reloc sections. We
5406 also figure out some maximum sizes. */
5407 max_contents_size
= 0;
5408 max_external_reloc_size
= 0;
5409 max_internal_reloc_count
= 0;
5411 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5415 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5417 if (p
->type
== bfd_section_reloc_link_order
5418 || p
->type
== bfd_symbol_reloc_link_order
)
5420 else if (p
->type
== bfd_indirect_link_order
)
5424 sec
= p
->u
.indirect
.section
;
5426 if (info
->relocateable
)
5427 o
->reloc_count
+= sec
->reloc_count
;
5429 if (sec
->_raw_size
> max_contents_size
)
5430 max_contents_size
= sec
->_raw_size
;
5431 if (sec
->_cooked_size
> max_contents_size
)
5432 max_contents_size
= sec
->_cooked_size
;
5434 /* We are interested in just local symbols, not all
5436 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5440 if (elf_bad_symtab (sec
->owner
))
5441 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5442 / sizeof (Elf_External_Sym
));
5444 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5446 if (sym_count
> max_sym_count
)
5447 max_sym_count
= sym_count
;
5449 if ((sec
->flags
& SEC_RELOC
) != 0)
5453 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5454 if (ext_size
> max_external_reloc_size
)
5455 max_external_reloc_size
= ext_size
;
5456 if (sec
->reloc_count
> max_internal_reloc_count
)
5457 max_internal_reloc_count
= sec
->reloc_count
;
5463 if (o
->reloc_count
> 0)
5464 o
->flags
|= SEC_RELOC
;
5467 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5468 set it (this is probably a bug) and if it is set
5469 assign_section_numbers will create a reloc section. */
5470 o
->flags
&=~ SEC_RELOC
;
5473 /* If the SEC_ALLOC flag is not set, force the section VMA to
5474 zero. This is done in elf_fake_sections as well, but forcing
5475 the VMA to 0 here will ensure that relocs against these
5476 sections are handled correctly. */
5477 if ((o
->flags
& SEC_ALLOC
) == 0)
5481 /* Figure out the file positions for everything but the symbol table
5482 and the relocs. We set symcount to force assign_section_numbers
5483 to create a symbol table. */
5484 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5485 BFD_ASSERT (! abfd
->output_has_begun
);
5486 if (! elf_compute_section_file_positions (abfd
, info
))
5489 /* That created the reloc sections. Set their sizes, and assign
5490 them file positions, and allocate some buffers. */
5491 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5493 if ((o
->flags
& SEC_RELOC
) != 0)
5495 Elf_Internal_Shdr
*rel_hdr
;
5496 register struct elf_link_hash_entry
**p
, **pend
;
5498 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5500 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5502 /* The contents field must last into write_object_contents,
5503 so we allocate it with bfd_alloc rather than malloc. */
5504 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5505 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5507 bfd_set_error (bfd_error_no_memory
);
5511 p
= ((struct elf_link_hash_entry
**)
5512 malloc (o
->reloc_count
5513 * sizeof (struct elf_link_hash_entry
*)));
5514 if (p
== NULL
&& o
->reloc_count
!= 0)
5516 bfd_set_error (bfd_error_no_memory
);
5519 elf_section_data (o
)->rel_hashes
= p
;
5520 pend
= p
+ o
->reloc_count
;
5521 for (; p
< pend
; p
++)
5524 /* Use the reloc_count field as an index when outputting the
5530 assign_file_positions_for_relocs (abfd
);
5532 /* We have now assigned file positions for all the sections except
5533 .symtab and .strtab. We start the .symtab section at the current
5534 file position, and write directly to it. We build the .strtab
5535 section in memory. When we add .dynsym support, we will build
5536 that in memory as well (.dynsym is smaller than .symtab). */
5538 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5539 /* sh_name is set in prep_headers. */
5540 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5541 symtab_hdr
->sh_flags
= 0;
5542 symtab_hdr
->sh_addr
= 0;
5543 symtab_hdr
->sh_size
= 0;
5544 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5545 /* sh_link is set in assign_section_numbers. */
5546 /* sh_info is set below. */
5547 /* sh_offset is set just below. */
5548 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5550 off
= elf_tdata (abfd
)->next_file_pos
;
5551 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5553 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5554 incorrect. We do not yet know the size of the .symtab section.
5555 We correct next_file_pos below, after we do know the size. */
5557 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5558 continuously seeking to the right position in the file. */
5559 if (! info
->keep_memory
|| max_sym_count
< 20)
5560 finfo
.symbuf_size
= 20;
5562 finfo
.symbuf_size
= max_sym_count
;
5563 finfo
.symbuf
= ((Elf_External_Sym
*)
5564 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5565 if (finfo
.symbuf
== NULL
)
5567 bfd_set_error (bfd_error_no_memory
);
5571 /* Start writing out the symbol table. The first symbol is always a
5573 elfsym
.st_value
= 0;
5576 elfsym
.st_other
= 0;
5577 elfsym
.st_shndx
= SHN_UNDEF
;
5578 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5579 &elfsym
, bfd_und_section_ptr
))
5583 /* Some standard ELF linkers do this, but we don't because it causes
5584 bootstrap comparison failures. */
5585 /* Output a file symbol for the output file as the second symbol.
5586 We output this even if we are discarding local symbols, although
5587 I'm not sure if this is correct. */
5588 elfsym
.st_value
= 0;
5590 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5591 elfsym
.st_other
= 0;
5592 elfsym
.st_shndx
= SHN_ABS
;
5593 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5594 &elfsym
, bfd_abs_section_ptr
))
5598 /* Output a symbol for each section. We output these even if we are
5599 discarding local symbols, since they are used for relocs. These
5600 symbols have no names. We store the index of each one in the
5601 index field of the section, so that we can find it again when
5602 outputting relocs. */
5603 elfsym
.st_value
= 0;
5605 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5606 elfsym
.st_other
= 0;
5607 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5609 o
= section_from_elf_index (abfd
, i
);
5611 o
->target_index
= abfd
->symcount
;
5612 elfsym
.st_shndx
= i
;
5613 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5618 /* Allocate some memory to hold information read in from the input
5620 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5621 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5622 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5623 malloc (max_internal_reloc_count
5624 * sizeof (Elf_Internal_Rela
)));
5625 finfo
.external_syms
= ((Elf_External_Sym
*)
5626 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5627 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5628 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5629 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5630 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5631 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5632 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5633 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5634 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5635 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5636 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5637 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5639 bfd_set_error (bfd_error_no_memory
);
5643 /* Since ELF permits relocations to be against local symbols, we
5644 must have the local symbols available when we do the relocations.
5645 Since we would rather only read the local symbols once, and we
5646 would rather not keep them in memory, we handle all the
5647 relocations for a single input file at the same time.
5649 Unfortunately, there is no way to know the total number of local
5650 symbols until we have seen all of them, and the local symbol
5651 indices precede the global symbol indices. This means that when
5652 we are generating relocateable output, and we see a reloc against
5653 a global symbol, we can not know the symbol index until we have
5654 finished examining all the local symbols to see which ones we are
5655 going to output. To deal with this, we keep the relocations in
5656 memory, and don't output them until the end of the link. This is
5657 an unfortunate waste of memory, but I don't see a good way around
5658 it. Fortunately, it only happens when performing a relocateable
5659 link, which is not the common case. FIXME: If keep_memory is set
5660 we could write the relocs out and then read them again; I don't
5661 know how bad the memory loss will be. */
5663 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5664 sub
->output_has_begun
= false;
5665 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5667 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5669 if (p
->type
== bfd_indirect_link_order
5670 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5671 == bfd_target_elf_flavour
))
5673 sub
= p
->u
.indirect
.section
->owner
;
5674 if (! sub
->output_has_begun
)
5676 if (! elf_link_input_bfd (&finfo
, sub
))
5678 sub
->output_has_begun
= true;
5681 else if (p
->type
== bfd_section_reloc_link_order
5682 || p
->type
== bfd_symbol_reloc_link_order
)
5684 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5689 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5695 /* That wrote out all the local symbols. Finish up the symbol table
5696 with the global symbols. */
5698 /* The sh_info field records the index of the first non local
5700 symtab_hdr
->sh_info
= abfd
->symcount
;
5702 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5704 /* We get the global symbols from the hash table. */
5705 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5708 /* Flush all symbols to the file. */
5709 if (! elf_link_flush_output_syms (&finfo
))
5712 /* Now we know the size of the symtab section. */
5713 off
+= symtab_hdr
->sh_size
;
5715 /* Finish up and write out the symbol string table (.strtab)
5717 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5718 /* sh_name was set in prep_headers. */
5719 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5720 symstrtab_hdr
->sh_flags
= 0;
5721 symstrtab_hdr
->sh_addr
= 0;
5722 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5723 symstrtab_hdr
->sh_entsize
= 0;
5724 symstrtab_hdr
->sh_link
= 0;
5725 symstrtab_hdr
->sh_info
= 0;
5726 /* sh_offset is set just below. */
5727 symstrtab_hdr
->sh_addralign
= 1;
5729 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5730 elf_tdata (abfd
)->next_file_pos
= off
;
5732 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5733 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5736 /* Adjust the relocs to have the correct symbol indices. */
5737 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5739 struct elf_link_hash_entry
**rel_hash
;
5740 Elf_Internal_Shdr
*rel_hdr
;
5742 if ((o
->flags
& SEC_RELOC
) == 0)
5745 rel_hash
= elf_section_data (o
)->rel_hashes
;
5746 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5747 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5749 if (*rel_hash
== NULL
)
5752 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5754 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5756 Elf_External_Rel
*erel
;
5757 Elf_Internal_Rel irel
;
5759 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5760 elf_swap_reloc_in (abfd
, erel
, &irel
);
5761 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5762 ELF_R_TYPE (irel
.r_info
));
5763 elf_swap_reloc_out (abfd
, &irel
, erel
);
5767 Elf_External_Rela
*erela
;
5768 Elf_Internal_Rela irela
;
5770 BFD_ASSERT (rel_hdr
->sh_entsize
5771 == sizeof (Elf_External_Rela
));
5773 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5774 elf_swap_reloca_in (abfd
, erela
, &irela
);
5775 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5776 ELF_R_TYPE (irela
.r_info
));
5777 elf_swap_reloca_out (abfd
, &irela
, erela
);
5781 /* Set the reloc_count field to 0 to prevent write_relocs from
5782 trying to swap the relocs out itself. */
5786 /* If we are linking against a dynamic object, or generating a
5787 shared library, finish up the dynamic linking information. */
5790 Elf_External_Dyn
*dyncon
, *dynconend
;
5792 /* Fix up .dynamic entries. */
5793 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5794 BFD_ASSERT (o
!= NULL
);
5796 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5797 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5798 for (; dyncon
< dynconend
; dyncon
++)
5800 Elf_Internal_Dyn dyn
;
5804 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5811 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5812 magic _init and _fini symbols. This is pretty ugly,
5813 but we are compatible. */
5821 struct elf_link_hash_entry
*h
;
5823 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5824 false, false, true);
5825 BFD_ASSERT (h
!= NULL
);
5826 if (h
->root
.type
== bfd_link_hash_defined
5827 || h
->root
.type
== bfd_link_hash_defweak
)
5829 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5830 o
= h
->root
.u
.def
.section
;
5831 if (o
->output_section
!= NULL
)
5832 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5833 + o
->output_offset
);
5835 dyn
.d_un
.d_val
+= o
->vma
;
5837 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5850 o
= bfd_get_section_by_name (abfd
, name
);
5851 BFD_ASSERT (o
!= NULL
);
5852 dyn
.d_un
.d_ptr
= o
->vma
;
5853 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5860 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5865 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5867 Elf_Internal_Shdr
*hdr
;
5869 hdr
= elf_elfsections (abfd
)[i
];
5870 if (hdr
->sh_type
== type
5871 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5873 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5874 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5877 if (dyn
.d_un
.d_val
== 0
5878 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5879 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5883 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5889 /* If we have created any dynamic sections, then output them. */
5892 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5895 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5897 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5898 || o
->_raw_size
== 0)
5900 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5902 /* At this point, we are only interested in sections
5903 created by elf_link_create_dynamic_sections. FIXME:
5904 This test is fragile. */
5907 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5909 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5911 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5912 o
->contents
, o
->output_offset
,
5920 /* The contents of the .dynstr section are actually in a
5922 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5923 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5924 || ! _bfd_stringtab_emit (abfd
,
5925 elf_hash_table (info
)->dynstr
))
5931 if (finfo
.symstrtab
!= NULL
)
5932 _bfd_stringtab_free (finfo
.symstrtab
);
5933 if (finfo
.contents
!= NULL
)
5934 free (finfo
.contents
);
5935 if (finfo
.external_relocs
!= NULL
)
5936 free (finfo
.external_relocs
);
5937 if (finfo
.internal_relocs
!= NULL
)
5938 free (finfo
.internal_relocs
);
5939 if (finfo
.external_syms
!= NULL
)
5940 free (finfo
.external_syms
);
5941 if (finfo
.internal_syms
!= NULL
)
5942 free (finfo
.internal_syms
);
5943 if (finfo
.indices
!= NULL
)
5944 free (finfo
.indices
);
5945 if (finfo
.sections
!= NULL
)
5946 free (finfo
.sections
);
5947 if (finfo
.symbuf
!= NULL
)
5948 free (finfo
.symbuf
);
5949 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5951 if ((o
->flags
& SEC_RELOC
) != 0
5952 && elf_section_data (o
)->rel_hashes
!= NULL
)
5953 free (elf_section_data (o
)->rel_hashes
);
5956 elf_tdata (abfd
)->linker
= true;
5961 if (finfo
.symstrtab
!= NULL
)
5962 _bfd_stringtab_free (finfo
.symstrtab
);
5963 if (finfo
.contents
!= NULL
)
5964 free (finfo
.contents
);
5965 if (finfo
.external_relocs
!= NULL
)
5966 free (finfo
.external_relocs
);
5967 if (finfo
.internal_relocs
!= NULL
)
5968 free (finfo
.internal_relocs
);
5969 if (finfo
.external_syms
!= NULL
)
5970 free (finfo
.external_syms
);
5971 if (finfo
.internal_syms
!= NULL
)
5972 free (finfo
.internal_syms
);
5973 if (finfo
.indices
!= NULL
)
5974 free (finfo
.indices
);
5975 if (finfo
.sections
!= NULL
)
5976 free (finfo
.sections
);
5977 if (finfo
.symbuf
!= NULL
)
5978 free (finfo
.symbuf
);
5979 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5981 if ((o
->flags
& SEC_RELOC
) != 0
5982 && elf_section_data (o
)->rel_hashes
!= NULL
)
5983 free (elf_section_data (o
)->rel_hashes
);
5989 /* Add a symbol to the output symbol table. */
5992 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5993 struct elf_final_link_info
*finfo
;
5995 Elf_Internal_Sym
*elfsym
;
5996 asection
*input_sec
;
5998 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5999 struct bfd_link_info
*info
,
6004 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
6005 elf_backend_link_output_symbol_hook
;
6006 if (output_symbol_hook
!= NULL
)
6008 if (! ((*output_symbol_hook
)
6009 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
6013 if (name
== (const char *) NULL
|| *name
== '\0')
6014 elfsym
->st_name
= 0;
6017 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6020 if (elfsym
->st_name
== (unsigned long) -1)
6024 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6026 if (! elf_link_flush_output_syms (finfo
))
6030 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6031 finfo
->symbuf
+ finfo
->symbuf_count
);
6032 ++finfo
->symbuf_count
;
6034 ++finfo
->output_bfd
->symcount
;
6039 /* Flush the output symbols to the file. */
6042 elf_link_flush_output_syms (finfo
)
6043 struct elf_final_link_info
*finfo
;
6045 Elf_Internal_Shdr
*symtab
;
6047 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6049 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6051 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6052 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6053 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6056 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6058 finfo
->symbuf_count
= 0;
6063 /* Add an external symbol to the symbol table. This is called from
6064 the hash table traversal routine. */
6067 elf_link_output_extsym (h
, data
)
6068 struct elf_link_hash_entry
*h
;
6071 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
6073 Elf_Internal_Sym sym
;
6074 asection
*input_sec
;
6076 /* If we are not creating a shared library, and this symbol is
6077 referenced by a shared library but is not defined anywhere, then
6078 warn that it is undefined. If we do not do this, the runtime
6079 linker will complain that the symbol is undefined when the
6080 program is run. We don't have to worry about symbols that are
6081 referenced by regular files, because we will already have issued
6084 FIXME: If we are linking against an object which uses DT_NEEDED,
6085 we don't give this warning, because it might be the case that the
6086 needed dynamic object will define the symbols. Unfortunately,
6087 this makes this type of check much less useful, but the only way
6088 to fix it would be to locate the needed object and read its
6089 symbol table. That seems like a real waste of time just to give
6090 better error messages. */
6091 if (! finfo
->info
->relocateable
6092 && ! finfo
->info
->shared
6093 && ! elf_hash_table (finfo
->info
)->saw_needed
6094 && h
->root
.type
== bfd_link_hash_undefined
6095 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6096 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6098 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6099 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6100 (asection
*) NULL
, 0)))
6102 /* FIXME: No way to return error. */
6107 /* We don't want to output symbols that have never been mentioned by
6108 a regular file, or that we have been told to strip. However, if
6109 h->indx is set to -2, the symbol is used by a reloc and we must
6113 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6114 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6115 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6116 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6118 else if (finfo
->info
->strip
== strip_all
6119 || (finfo
->info
->strip
== strip_some
6120 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6121 h
->root
.root
.string
,
6122 false, false) == NULL
))
6127 /* If we're stripping it, and it's not a dynamic symbol, there's
6128 nothing else to do. */
6129 if (strip
&& h
->dynindx
== -1)
6133 sym
.st_size
= h
->size
;
6135 if (h
->root
.type
== bfd_link_hash_undefweak
6136 || h
->root
.type
== bfd_link_hash_defweak
)
6137 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6139 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6141 switch (h
->root
.type
)
6144 case bfd_link_hash_new
:
6148 case bfd_link_hash_undefined
:
6149 input_sec
= bfd_und_section_ptr
;
6150 sym
.st_shndx
= SHN_UNDEF
;
6153 case bfd_link_hash_undefweak
:
6154 input_sec
= bfd_und_section_ptr
;
6155 sym
.st_shndx
= SHN_UNDEF
;
6158 case bfd_link_hash_defined
:
6159 case bfd_link_hash_defweak
:
6161 input_sec
= h
->root
.u
.def
.section
;
6162 if (input_sec
->output_section
!= NULL
)
6165 elf_section_from_bfd_section (finfo
->output_bfd
,
6166 input_sec
->output_section
);
6167 if (sym
.st_shndx
== (unsigned short) -1)
6169 /* FIXME: No way to handle errors. */
6173 /* ELF symbols in relocateable files are section relative,
6174 but in nonrelocateable files they are virtual
6176 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6177 if (! finfo
->info
->relocateable
)
6178 sym
.st_value
+= input_sec
->output_section
->vma
;
6182 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6183 == bfd_target_elf_flavour
)
6184 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6185 sym
.st_shndx
= SHN_UNDEF
;
6186 input_sec
= bfd_und_section_ptr
;
6191 case bfd_link_hash_common
:
6192 input_sec
= bfd_com_section_ptr
;
6193 sym
.st_shndx
= SHN_COMMON
;
6194 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
6197 case bfd_link_hash_indirect
:
6198 case bfd_link_hash_warning
:
6199 /* I have no idea how these should be handled. */
6203 /* If this symbol should be put in the .dynsym section, then put it
6204 there now. We have already know the symbol index. We also fill
6205 in the entry in the .hash section. */
6206 if (h
->dynindx
!= -1
6207 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6209 struct elf_backend_data
*bed
;
6212 bfd_byte
*bucketpos
;
6215 sym
.st_name
= h
->dynstr_index
;
6217 /* Give the processor backend a chance to tweak the symbol
6218 value, and also to finish up anything that needs to be done
6220 bed
= get_elf_backend_data (finfo
->output_bfd
);
6221 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6222 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6224 /* FIXME: No way to return error. */
6228 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6229 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6232 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6233 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6235 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6236 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6237 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6238 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6239 put_word (finfo
->output_bfd
, chain
,
6240 ((bfd_byte
*) finfo
->hash_sec
->contents
6241 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6244 /* If we're stripping it, then it was just a dynamic symbol, and
6245 there's nothing else to do. */
6249 h
->indx
= finfo
->output_bfd
->symcount
;
6251 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6253 /* FIXME: No way to return error. */
6260 /* Link an input file into the linker output file. This function
6261 handles all the sections and relocations of the input file at once.
6262 This is so that we only have to read the local symbols once, and
6263 don't have to keep them in memory. */
6266 elf_link_input_bfd (finfo
, input_bfd
)
6267 struct elf_final_link_info
*finfo
;
6270 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6271 bfd
*, asection
*, bfd_byte
*,
6272 Elf_Internal_Rela
*,
6273 Elf_Internal_Sym
*, asection
**));
6275 Elf_Internal_Shdr
*symtab_hdr
;
6278 Elf_External_Sym
*esym
;
6279 Elf_External_Sym
*esymend
;
6280 Elf_Internal_Sym
*isym
;
6282 asection
**ppsection
;
6285 output_bfd
= finfo
->output_bfd
;
6287 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6289 /* If this is a dynamic object, we don't want to do anything here:
6290 we don't want the local symbols, and we don't want the section
6292 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6295 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6296 if (elf_bad_symtab (input_bfd
))
6298 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6303 locsymcount
= symtab_hdr
->sh_info
;
6304 extsymoff
= symtab_hdr
->sh_info
;
6307 /* Read the local symbols. */
6309 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6310 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6311 locsymcount
, input_bfd
)
6312 != locsymcount
* sizeof (Elf_External_Sym
))))
6315 /* Swap in the local symbols and write out the ones which we know
6316 are going into the output file. */
6317 esym
= finfo
->external_syms
;
6318 esymend
= esym
+ locsymcount
;
6319 isym
= finfo
->internal_syms
;
6320 pindex
= finfo
->indices
;
6321 ppsection
= finfo
->sections
;
6322 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6326 Elf_Internal_Sym osym
;
6328 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6331 if (elf_bad_symtab (input_bfd
))
6333 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6340 if (isym
->st_shndx
== SHN_UNDEF
)
6341 isec
= bfd_und_section_ptr
;
6342 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6343 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6344 else if (isym
->st_shndx
== SHN_ABS
)
6345 isec
= bfd_abs_section_ptr
;
6346 else if (isym
->st_shndx
== SHN_COMMON
)
6347 isec
= bfd_com_section_ptr
;
6356 /* Don't output the first, undefined, symbol. */
6357 if (esym
== finfo
->external_syms
)
6360 /* If we are stripping all symbols, we don't want to output this
6362 if (finfo
->info
->strip
== strip_all
)
6365 /* We never output section symbols. Instead, we use the section
6366 symbol of the corresponding section in the output file. */
6367 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6370 /* If we are discarding all local symbols, we don't want to
6371 output this one. If we are generating a relocateable output
6372 file, then some of the local symbols may be required by
6373 relocs; we output them below as we discover that they are
6375 if (finfo
->info
->discard
== discard_all
)
6378 /* Get the name of the symbol. */
6379 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6384 /* See if we are discarding symbols with this name. */
6385 if ((finfo
->info
->strip
== strip_some
6386 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6388 || (finfo
->info
->discard
== discard_l
6389 && strncmp (name
, finfo
->info
->lprefix
,
6390 finfo
->info
->lprefix_len
) == 0))
6393 /* If we get here, we are going to output this symbol. */
6397 /* Adjust the section index for the output file. */
6398 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6399 isec
->output_section
);
6400 if (osym
.st_shndx
== (unsigned short) -1)
6403 *pindex
= output_bfd
->symcount
;
6405 /* ELF symbols in relocateable files are section relative, but
6406 in executable files they are virtual addresses. Note that
6407 this code assumes that all ELF sections have an associated
6408 BFD section with a reasonable value for output_offset; below
6409 we assume that they also have a reasonable value for
6410 output_section. Any special sections must be set up to meet
6411 these requirements. */
6412 osym
.st_value
+= isec
->output_offset
;
6413 if (! finfo
->info
->relocateable
)
6414 osym
.st_value
+= isec
->output_section
->vma
;
6416 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6420 /* Relocate the contents of each section. */
6421 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6423 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6426 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6427 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6429 /* Section was created by elf_link_create_dynamic_sections.
6430 FIXME: This test is fragile. */
6434 /* Read the contents of the section. */
6435 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6436 (file_ptr
) 0, o
->_raw_size
))
6439 if ((o
->flags
& SEC_RELOC
) != 0)
6441 Elf_Internal_Rela
*internal_relocs
;
6443 /* Get the swapped relocs. */
6444 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6445 finfo
->external_relocs
,
6446 finfo
->internal_relocs
,
6448 if (internal_relocs
== NULL
6449 && o
->reloc_count
> 0)
6452 /* Relocate the section by invoking a back end routine.
6454 The back end routine is responsible for adjusting the
6455 section contents as necessary, and (if using Rela relocs
6456 and generating a relocateable output file) adjusting the
6457 reloc addend as necessary.
6459 The back end routine does not have to worry about setting
6460 the reloc address or the reloc symbol index.
6462 The back end routine is given a pointer to the swapped in
6463 internal symbols, and can access the hash table entries
6464 for the external symbols via elf_sym_hashes (input_bfd).
6466 When generating relocateable output, the back end routine
6467 must handle STB_LOCAL/STT_SECTION symbols specially. The
6468 output symbol is going to be a section symbol
6469 corresponding to the output section, which will require
6470 the addend to be adjusted. */
6472 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6476 finfo
->internal_syms
,
6480 if (finfo
->info
->relocateable
)
6482 Elf_Internal_Rela
*irela
;
6483 Elf_Internal_Rela
*irelaend
;
6484 struct elf_link_hash_entry
**rel_hash
;
6485 Elf_Internal_Shdr
*input_rel_hdr
;
6486 Elf_Internal_Shdr
*output_rel_hdr
;
6488 /* Adjust the reloc addresses and symbol indices. */
6490 irela
= internal_relocs
;
6491 irelaend
= irela
+ o
->reloc_count
;
6492 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6493 + o
->output_section
->reloc_count
);
6494 for (; irela
< irelaend
; irela
++, rel_hash
++)
6497 Elf_Internal_Sym
*isym
;
6500 irela
->r_offset
+= o
->output_offset
;
6502 r_symndx
= ELF_R_SYM (irela
->r_info
);
6507 if (r_symndx
>= locsymcount
6508 || (elf_bad_symtab (input_bfd
)
6509 && finfo
->sections
[r_symndx
] == NULL
))
6513 /* This is a reloc against a global symbol. We
6514 have not yet output all the local symbols, so
6515 we do not know the symbol index of any global
6516 symbol. We set the rel_hash entry for this
6517 reloc to point to the global hash table entry
6518 for this symbol. The symbol index is then
6519 set at the end of elf_bfd_final_link. */
6520 indx
= r_symndx
- extsymoff
;
6521 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6523 /* Setting the index to -2 tells
6524 elf_link_output_extsym that this symbol is
6526 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6527 (*rel_hash
)->indx
= -2;
6532 /* This is a reloc against a local symbol. */
6535 isym
= finfo
->internal_syms
+ r_symndx
;
6536 sec
= finfo
->sections
[r_symndx
];
6537 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6539 /* I suppose the backend ought to fill in the
6540 section of any STT_SECTION symbol against a
6541 processor specific section. */
6542 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6544 else if (sec
== NULL
|| sec
->owner
== NULL
)
6546 bfd_set_error (bfd_error_bad_value
);
6551 r_symndx
= sec
->output_section
->target_index
;
6558 if (finfo
->indices
[r_symndx
] == -1)
6564 if (finfo
->info
->strip
== strip_all
)
6566 /* You can't do ld -r -s. */
6567 bfd_set_error (bfd_error_invalid_operation
);
6571 /* This symbol was skipped earlier, but
6572 since it is needed by a reloc, we
6573 must output it now. */
6574 link
= symtab_hdr
->sh_link
;
6575 name
= elf_string_from_elf_section (input_bfd
,
6581 osec
= sec
->output_section
;
6583 elf_section_from_bfd_section (output_bfd
,
6585 if (isym
->st_shndx
== (unsigned short) -1)
6588 isym
->st_value
+= sec
->output_offset
;
6589 if (! finfo
->info
->relocateable
)
6590 isym
->st_value
+= osec
->vma
;
6592 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6594 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6598 r_symndx
= finfo
->indices
[r_symndx
];
6601 irela
->r_info
= ELF_R_INFO (r_symndx
,
6602 ELF_R_TYPE (irela
->r_info
));
6605 /* Swap out the relocs. */
6606 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6607 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6608 BFD_ASSERT (output_rel_hdr
->sh_entsize
6609 == input_rel_hdr
->sh_entsize
);
6610 irela
= internal_relocs
;
6611 irelaend
= irela
+ o
->reloc_count
;
6612 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6614 Elf_External_Rel
*erel
;
6616 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6617 + o
->output_section
->reloc_count
);
6618 for (; irela
< irelaend
; irela
++, erel
++)
6620 Elf_Internal_Rel irel
;
6622 irel
.r_offset
= irela
->r_offset
;
6623 irel
.r_info
= irela
->r_info
;
6624 BFD_ASSERT (irela
->r_addend
== 0);
6625 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6630 Elf_External_Rela
*erela
;
6632 BFD_ASSERT (input_rel_hdr
->sh_entsize
6633 == sizeof (Elf_External_Rela
));
6634 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6635 + o
->output_section
->reloc_count
);
6636 for (; irela
< irelaend
; irela
++, erela
++)
6637 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6640 o
->output_section
->reloc_count
+= o
->reloc_count
;
6644 /* Write out the modified section contents. */
6645 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6646 finfo
->contents
, o
->output_offset
,
6647 (o
->_cooked_size
!= 0
6656 /* Generate a reloc when linking an ELF file. This is a reloc
6657 requested by the linker, and does come from any input file. This
6658 is used to build constructor and destructor tables when linking
6662 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6664 struct bfd_link_info
*info
;
6665 asection
*output_section
;
6666 struct bfd_link_order
*link_order
;
6668 reloc_howto_type
*howto
;
6671 struct elf_link_hash_entry
**rel_hash_ptr
;
6672 Elf_Internal_Shdr
*rel_hdr
;
6674 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6677 bfd_set_error (bfd_error_bad_value
);
6681 /* If this is an inplace reloc, we must write the addend into the
6683 if (howto
->partial_inplace
6684 && link_order
->u
.reloc
.p
->addend
!= 0)
6687 bfd_reloc_status_type rstat
;
6691 size
= bfd_get_reloc_size (howto
);
6692 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6693 if (buf
== (bfd_byte
*) NULL
)
6695 bfd_set_error (bfd_error_no_memory
);
6698 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6699 link_order
->u
.reloc
.p
->addend
, buf
);
6705 case bfd_reloc_outofrange
:
6707 case bfd_reloc_overflow
:
6708 if (! ((*info
->callbacks
->reloc_overflow
)
6710 (link_order
->type
== bfd_section_reloc_link_order
6711 ? bfd_section_name (output_bfd
,
6712 link_order
->u
.reloc
.p
->u
.section
)
6713 : link_order
->u
.reloc
.p
->u
.name
),
6714 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6715 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6722 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6723 (file_ptr
) link_order
->offset
, size
);
6729 /* Figure out the symbol index. */
6730 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6731 + output_section
->reloc_count
);
6732 if (link_order
->type
== bfd_section_reloc_link_order
)
6734 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6737 *rel_hash_ptr
= NULL
;
6741 struct elf_link_hash_entry
*h
;
6743 h
= elf_link_hash_lookup (elf_hash_table (info
),
6744 link_order
->u
.reloc
.p
->u
.name
,
6745 false, false, true);
6748 /* Setting the index to -2 tells elf_link_output_extsym that
6749 this symbol is used by a reloc. */
6756 if (! ((*info
->callbacks
->unattached_reloc
)
6757 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6758 (asection
*) NULL
, (bfd_vma
) 0)))
6764 /* The address of a reloc is relative to the section in a
6765 relocateable file, and is a virtual address in an executable
6767 offset
= link_order
->offset
;
6768 if (! info
->relocateable
)
6769 offset
+= output_section
->vma
;
6771 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6773 if (rel_hdr
->sh_type
== SHT_REL
)
6775 Elf_Internal_Rel irel
;
6776 Elf_External_Rel
*erel
;
6778 irel
.r_offset
= offset
;
6779 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6780 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6781 + output_section
->reloc_count
);
6782 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6786 Elf_Internal_Rela irela
;
6787 Elf_External_Rela
*erela
;
6789 irela
.r_offset
= offset
;
6790 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6791 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6792 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6793 + output_section
->reloc_count
);
6794 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6797 ++output_section
->reloc_count
;