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 static file_ptr map_program_segments
168 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, Elf_Internal_Shdr
**,
171 static boolean elf_map_symbols
PARAMS ((bfd
*));
172 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
174 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
177 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
178 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
181 #define elf_string_from_elf_strtab(abfd,strindex) \
182 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
184 /* Structure swapping routines */
186 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
187 can be handled by explicitly specifying 32 bits or "the long type". */
189 #define put_word bfd_h_put_64
190 #define get_word bfd_h_get_64
193 #define put_word bfd_h_put_32
194 #define get_word bfd_h_get_32
197 /* Translate an ELF symbol in external format into an ELF symbol in internal
201 elf_swap_symbol_in (abfd
, src
, dst
)
203 Elf_External_Sym
*src
;
204 Elf_Internal_Sym
*dst
;
206 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
207 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
208 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
209 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
210 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
211 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
214 /* Translate an ELF symbol in internal format into an ELF symbol in external
218 elf_swap_symbol_out (abfd
, src
, dst
)
220 Elf_Internal_Sym
*src
;
221 Elf_External_Sym
*dst
;
223 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
224 put_word (abfd
, src
->st_value
, dst
->st_value
);
225 put_word (abfd
, src
->st_size
, dst
->st_size
);
226 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
227 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
228 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
232 /* Translate an ELF file header in external format into an ELF file header in
236 elf_swap_ehdr_in (abfd
, src
, dst
)
238 Elf_External_Ehdr
*src
;
239 Elf_Internal_Ehdr
*dst
;
241 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
242 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
243 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
244 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
245 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
246 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
247 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
248 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
249 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
250 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
251 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
252 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
253 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
254 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
257 /* Translate an ELF file header in internal format into an ELF file header in
261 elf_swap_ehdr_out (abfd
, src
, dst
)
263 Elf_Internal_Ehdr
*src
;
264 Elf_External_Ehdr
*dst
;
266 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
267 /* note that all elements of dst are *arrays of unsigned char* already... */
268 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
269 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
270 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
271 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
272 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
273 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
274 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
275 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
276 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
277 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
278 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
279 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
280 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
284 /* Translate an ELF section header table entry in external format into an
285 ELF section header table entry in internal format. */
288 elf_swap_shdr_in (abfd
, src
, dst
)
290 Elf_External_Shdr
*src
;
291 Elf_Internal_Shdr
*dst
;
293 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
294 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
295 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
296 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
297 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
298 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
299 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
300 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
301 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
302 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
303 dst
->bfd_section
= NULL
;
304 dst
->contents
= NULL
;
307 /* Translate an ELF section header table entry in internal format into an
308 ELF section header table entry in external format. */
311 elf_swap_shdr_out (abfd
, src
, dst
)
313 Elf_Internal_Shdr
*src
;
314 Elf_External_Shdr
*dst
;
316 /* note that all elements of dst are *arrays of unsigned char* already... */
317 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
318 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
319 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
320 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
321 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
322 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
323 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
324 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
325 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
326 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
330 /* Translate an ELF program header table entry in external format into an
331 ELF program header table entry in internal format. */
334 elf_swap_phdr_in (abfd
, src
, dst
)
336 Elf_External_Phdr
*src
;
337 Elf_Internal_Phdr
*dst
;
339 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
340 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
341 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
342 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
343 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
344 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
345 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
346 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
350 elf_swap_phdr_out (abfd
, src
, dst
)
352 Elf_Internal_Phdr
*src
;
353 Elf_External_Phdr
*dst
;
355 /* note that all elements of dst are *arrays of unsigned char* already... */
356 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
357 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
358 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
359 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
360 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
361 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
362 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
363 put_word (abfd
, src
->p_align
, dst
->p_align
);
366 /* Translate an ELF reloc from external format to internal format. */
368 elf_swap_reloc_in (abfd
, src
, dst
)
370 Elf_External_Rel
*src
;
371 Elf_Internal_Rel
*dst
;
373 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
374 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
378 elf_swap_reloca_in (abfd
, src
, dst
)
380 Elf_External_Rela
*src
;
381 Elf_Internal_Rela
*dst
;
383 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
384 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
385 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
388 /* Translate an ELF reloc from internal format to external format. */
390 elf_swap_reloc_out (abfd
, src
, dst
)
392 Elf_Internal_Rel
*src
;
393 Elf_External_Rel
*dst
;
395 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
396 put_word (abfd
, src
->r_info
, dst
->r_info
);
400 elf_swap_reloca_out (abfd
, src
, dst
)
402 Elf_Internal_Rela
*src
;
403 Elf_External_Rela
*dst
;
405 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
406 put_word (abfd
, src
->r_info
, dst
->r_info
);
407 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
411 elf_swap_dyn_in (abfd
, src
, dst
)
413 const Elf_External_Dyn
*src
;
414 Elf_Internal_Dyn
*dst
;
416 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
417 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
421 elf_swap_dyn_out (abfd
, src
, dst
)
423 const Elf_Internal_Dyn
*src
;
424 Elf_External_Dyn
*dst
;
426 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
427 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
430 /* Allocate an ELF string table--force the first byte to be zero. */
432 static struct bfd_strtab_hash
*
433 elf_stringtab_init ()
435 struct bfd_strtab_hash
*ret
;
437 ret
= _bfd_stringtab_init ();
442 loc
= _bfd_stringtab_add (ret
, "", true, false);
443 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
444 if (loc
== (bfd_size_type
) -1)
446 _bfd_stringtab_free (ret
);
453 /* ELF .o/exec file reading */
455 /* Create a new bfd section from an ELF section header. */
458 bfd_section_from_shdr (abfd
, shindex
)
460 unsigned int shindex
;
462 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
463 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
466 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
468 switch (hdr
->sh_type
)
471 /* Inactive section. Throw it away. */
474 case SHT_PROGBITS
: /* Normal section with contents. */
475 case SHT_DYNAMIC
: /* Dynamic linking information. */
476 case SHT_NOBITS
: /* .bss section. */
477 case SHT_HASH
: /* .hash section. */
478 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
480 case SHT_SYMTAB
: /* A symbol table */
481 if (elf_onesymtab (abfd
) == shindex
)
484 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
485 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
486 elf_onesymtab (abfd
) = shindex
;
487 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
488 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
489 abfd
->flags
|= HAS_SYMS
;
491 /* Sometimes a shared object will map in the symbol table. If
492 SHF_ALLOC is set, and this is a shared object, then we also
493 treat this section as a BFD section. We can not base the
494 decision purely on SHF_ALLOC, because that flag is sometimes
495 set in a relocateable object file, which would confuse the
497 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
498 && (abfd
->flags
& DYNAMIC
) != 0
499 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
504 case SHT_DYNSYM
: /* A dynamic symbol table */
505 if (elf_dynsymtab (abfd
) == shindex
)
508 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
509 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
510 elf_dynsymtab (abfd
) = shindex
;
511 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
512 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
513 abfd
->flags
|= HAS_SYMS
;
515 /* Besides being a symbol table, we also treat this as a regular
516 section, so that objcopy can handle it. */
517 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
519 case SHT_STRTAB
: /* A string table */
520 if (hdr
->bfd_section
!= NULL
)
522 if (ehdr
->e_shstrndx
== shindex
)
524 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
525 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
531 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
533 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
534 if (hdr2
->sh_link
== shindex
)
536 if (! bfd_section_from_shdr (abfd
, i
))
538 if (elf_onesymtab (abfd
) == i
)
540 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
541 elf_elfsections (abfd
)[shindex
] =
542 &elf_tdata (abfd
)->strtab_hdr
;
545 if (elf_dynsymtab (abfd
) == i
)
547 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
548 elf_elfsections (abfd
)[shindex
] =
549 &elf_tdata (abfd
)->dynstrtab_hdr
;
550 /* We also treat this as a regular section, so
551 that objcopy can handle it. */
554 #if 0 /* Not handling other string tables specially right now. */
555 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
556 /* We have a strtab for some random other section. */
557 newsect
= (asection
*) hdr2
->bfd_section
;
560 hdr
->bfd_section
= newsect
;
561 hdr2
= &elf_section_data (newsect
)->str_hdr
;
563 elf_elfsections (abfd
)[shindex
] = hdr2
;
569 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
573 /* *These* do a lot of work -- but build no sections! */
575 asection
*target_sect
;
576 Elf_Internal_Shdr
*hdr2
;
577 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
579 /* Get the symbol table. */
580 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
583 /* If this reloc section does not use the main symbol table we
584 don't treat it as a reloc section. BFD can't adequately
585 represent such a section, so at least for now, we don't
586 try. We just present it as a normal section. */
587 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
588 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
590 /* Don't allow REL relocations on a machine that uses RELA and
592 /* @@ Actually, the generic ABI does suggest that both might be
593 used in one file. But the four ABI Processor Supplements I
594 have access to right now all specify that only one is used on
595 each of those architectures. It's conceivable that, e.g., a
596 bunch of absolute 32-bit relocs might be more compact in REL
597 form even on a RELA machine... */
598 BFD_ASSERT (use_rela_p
599 ? (hdr
->sh_type
== SHT_RELA
600 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
601 : (hdr
->sh_type
== SHT_REL
602 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
604 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
606 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
607 if (target_sect
== NULL
)
610 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
612 elf_elfsections (abfd
)[shindex
] = hdr2
;
613 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
614 target_sect
->flags
|= SEC_RELOC
;
615 target_sect
->relocation
= NULL
;
616 target_sect
->rel_filepos
= hdr
->sh_offset
;
617 abfd
->flags
|= HAS_RELOC
;
624 fprintf (stderr
, "Note Sections not yet supported.\n");
631 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
636 /* Check for any processor-specific section types. */
638 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
640 if (bed
->elf_backend_section_from_shdr
)
641 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
650 elf_new_section_hook (abfd
, sec
)
655 struct bfd_elf_section_data
*sdata
;
657 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
660 bfd_set_error (bfd_error_no_memory
);
663 sec
->used_by_bfd
= (PTR
) sdata
;
664 memset (sdata
, 0, sizeof (*sdata
));
668 /* Create a new bfd section from an ELF program header.
670 Since program segments have no names, we generate a synthetic name
671 of the form segment<NUM>, where NUM is generally the index in the
672 program header table. For segments that are split (see below) we
673 generate the names segment<NUM>a and segment<NUM>b.
675 Note that some program segments may have a file size that is different than
676 (less than) the memory size. All this means is that at execution the
677 system must allocate the amount of memory specified by the memory size,
678 but only initialize it with the first "file size" bytes read from the
679 file. This would occur for example, with program segments consisting
680 of combined data+bss.
682 To handle the above situation, this routine generates TWO bfd sections
683 for the single program segment. The first has the length specified by
684 the file size of the segment, and the second has the length specified
685 by the difference between the two sizes. In effect, the segment is split
686 into it's initialized and uninitialized parts.
691 bfd_section_from_phdr (abfd
, hdr
, index
)
693 Elf_Internal_Phdr
*hdr
;
701 split
= ((hdr
->p_memsz
> 0) &&
702 (hdr
->p_filesz
> 0) &&
703 (hdr
->p_memsz
> hdr
->p_filesz
));
704 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
705 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
708 bfd_set_error (bfd_error_no_memory
);
711 strcpy (name
, namebuf
);
712 newsect
= bfd_make_section (abfd
, name
);
715 newsect
->vma
= hdr
->p_vaddr
;
716 newsect
->_raw_size
= hdr
->p_filesz
;
717 newsect
->filepos
= hdr
->p_offset
;
718 newsect
->flags
|= SEC_HAS_CONTENTS
;
719 if (hdr
->p_type
== PT_LOAD
)
721 newsect
->flags
|= SEC_ALLOC
;
722 newsect
->flags
|= SEC_LOAD
;
723 if (hdr
->p_flags
& PF_X
)
725 /* FIXME: all we known is that it has execute PERMISSION,
727 newsect
->flags
|= SEC_CODE
;
730 if (!(hdr
->p_flags
& PF_W
))
732 newsect
->flags
|= SEC_READONLY
;
737 sprintf (namebuf
, "segment%db", index
);
738 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
741 bfd_set_error (bfd_error_no_memory
);
744 strcpy (name
, namebuf
);
745 newsect
= bfd_make_section (abfd
, name
);
748 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
749 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
750 if (hdr
->p_type
== PT_LOAD
)
752 newsect
->flags
|= SEC_ALLOC
;
753 if (hdr
->p_flags
& PF_X
)
754 newsect
->flags
|= SEC_CODE
;
756 if (!(hdr
->p_flags
& PF_W
))
757 newsect
->flags
|= SEC_READONLY
;
763 /* Begin processing a given object.
765 First we validate the file by reading in the ELF header and checking
768 static INLINE boolean
770 Elf_External_Ehdr
*x_ehdrp
;
772 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
773 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
774 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
775 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
778 /* Check to see if the file associated with ABFD matches the target vector
781 Note that we may be called several times with the same ABFD, but different
782 target vectors, most of which will not match. We have to avoid leaving
783 any side effects in ABFD, or any data it points to (like tdata), if the
784 file does not match the target vector. */
790 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
791 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
792 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
793 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
794 unsigned int shindex
;
795 char *shstrtab
; /* Internal copy of section header stringtab */
796 struct elf_backend_data
*ebd
;
797 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
798 struct elf_obj_tdata
*new_tdata
= NULL
;
800 /* Read in the ELF header in external format. */
802 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
804 if (bfd_get_error () != bfd_error_system_call
)
805 goto got_wrong_format_error
;
810 /* Now check to see if we have a valid ELF file, and one that BFD can
811 make use of. The magic number must match, the address size ('class')
812 and byte-swapping must match our XVEC entry, and it must have a
813 section header table (FIXME: See comments re sections at top of this
816 if ((elf_file_p (&x_ehdr
) == false) ||
817 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
818 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
819 goto got_wrong_format_error
;
821 /* Check that file's byte order matches xvec's */
822 switch (x_ehdr
.e_ident
[EI_DATA
])
824 case ELFDATA2MSB
: /* Big-endian */
825 if (!abfd
->xvec
->header_byteorder_big_p
)
826 goto got_wrong_format_error
;
828 case ELFDATA2LSB
: /* Little-endian */
829 if (abfd
->xvec
->header_byteorder_big_p
)
830 goto got_wrong_format_error
;
832 case ELFDATANONE
: /* No data encoding specified */
833 default: /* Unknown data encoding specified */
834 goto got_wrong_format_error
;
837 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
838 the tdata pointer in the bfd. */
840 new_tdata
= ((struct elf_obj_tdata
*)
841 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
842 if (new_tdata
== NULL
)
843 goto got_no_memory_error
;
844 elf_tdata (abfd
) = new_tdata
;
846 /* Now that we know the byte order, swap in the rest of the header */
847 i_ehdrp
= elf_elfheader (abfd
);
848 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
850 elf_debug_file (i_ehdrp
);
853 /* If there is no section header table, we're hosed. */
854 if (i_ehdrp
->e_shoff
== 0)
855 goto got_wrong_format_error
;
857 /* As a simple sanity check, verify that the what BFD thinks is the
858 size of each section header table entry actually matches the size
859 recorded in the file. */
860 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
861 goto got_wrong_format_error
;
863 ebd
= get_elf_backend_data (abfd
);
865 /* Check that the ELF e_machine field matches what this particular
866 BFD format expects. */
867 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
869 const bfd_target
* const *target_ptr
;
871 if (ebd
->elf_machine_code
!= EM_NONE
)
872 goto got_wrong_format_error
;
874 /* This is the generic ELF target. Let it match any ELF target
875 for which we do not have a specific backend. */
876 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
878 struct elf_backend_data
*back
;
880 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
882 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
883 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
885 /* target_ptr is an ELF backend which matches this
886 object file, so reject the generic ELF target. */
887 goto got_wrong_format_error
;
892 if (i_ehdrp
->e_type
== ET_EXEC
)
893 abfd
->flags
|= EXEC_P
;
894 else if (i_ehdrp
->e_type
== ET_DYN
)
895 abfd
->flags
|= DYNAMIC
;
897 if (i_ehdrp
->e_phnum
> 0)
898 abfd
->flags
|= D_PAGED
;
900 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
903 /* Remember the entry point specified in the ELF file header. */
904 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
906 /* Allocate space for a copy of the section header table in
907 internal form, seek to the section header table in the file,
908 read it in, and convert it to internal form. */
909 i_shdrp
= ((Elf_Internal_Shdr
*)
910 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
911 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
913 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
914 if (!i_shdrp
|| !elf_elfsections (abfd
))
915 goto got_no_memory_error
;
916 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
918 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
920 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
922 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
923 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
925 if (i_ehdrp
->e_shstrndx
)
927 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
931 /* Read in the string table containing the names of the sections. We
932 will need the base pointer to this table later. */
933 /* We read this inline now, so that we don't have to go through
934 bfd_section_from_shdr with it (since this particular strtab is
935 used to find all of the ELF section names.) */
937 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
941 /* Once all of the section headers have been read and converted, we
942 can start processing them. Note that the first section header is
943 a dummy placeholder entry, so we ignore it. */
945 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
947 if (! bfd_section_from_shdr (abfd
, shindex
))
951 /* Let the backend double check the format and override global
953 if (ebd
->elf_backend_object_p
)
955 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
956 goto got_wrong_format_error
;
961 got_wrong_format_error
:
962 bfd_set_error (bfd_error_wrong_format
);
965 bfd_set_error (bfd_error_no_memory
);
968 if (new_tdata
!= NULL
969 && new_tdata
->elf_sect_ptr
!= NULL
)
970 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
972 bfd_release (abfd
, i_shdrp
);
973 if (new_tdata
!= NULL
)
974 bfd_release (abfd
, new_tdata
);
975 elf_tdata (abfd
) = preserved_tdata
;
980 /* ELF .o/exec file writing */
982 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
983 of the symbol if there is one. */
984 static INLINE elf_symbol_type
*
985 elf_symbol_from (ignore_abfd
, symbol
)
989 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
992 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
995 return (elf_symbol_type
*) symbol
;
999 write_relocs (abfd
, sec
, xxx
)
1004 Elf_Internal_Shdr
*rela_hdr
;
1005 Elf_External_Rela
*outbound_relocas
;
1006 Elf_External_Rel
*outbound_relocs
;
1008 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1009 asymbol
*last_sym
= 0;
1010 int last_sym_idx
= 9999999; /* should always be written before use */
1012 if ((sec
->flags
& SEC_RELOC
) == 0)
1015 /* The linker backend writes the relocs out itself, and sets the
1016 reloc_count field to zero to inhibit writing them here. Also,
1017 sometimes the SEC_RELOC flag gets set even when there aren't any
1019 if (sec
->reloc_count
== 0)
1022 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1024 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1025 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1026 if (!rela_hdr
->contents
)
1028 bfd_set_error (bfd_error_no_memory
);
1029 abort (); /* FIXME */
1032 /* orelocation has the data, reloc_count has the count... */
1035 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1037 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1039 Elf_Internal_Rela dst_rela
;
1040 Elf_External_Rela
*src_rela
;
1045 ptr
= sec
->orelocation
[idx
];
1046 src_rela
= outbound_relocas
+ idx
;
1048 /* The address of an ELF reloc is section relative for an object
1049 file, and absolute for an executable file or shared library.
1050 The address of a BFD reloc is always section relative. */
1051 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1052 dst_rela
.r_offset
= ptr
->address
;
1054 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
1056 sym
= *ptr
->sym_ptr_ptr
;
1057 if (sym
== last_sym
)
1062 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1064 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1066 dst_rela
.r_addend
= ptr
->addend
;
1067 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1071 /* REL relocations */
1073 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1075 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1077 Elf_Internal_Rel dst_rel
;
1078 Elf_External_Rel
*src_rel
;
1083 ptr
= sec
->orelocation
[idx
];
1084 sym
= *ptr
->sym_ptr_ptr
;
1085 src_rel
= outbound_relocs
+ idx
;
1087 /* The address of an ELF reloc is section relative for an object
1088 file, and absolute for an executable file or shared library.
1089 The address of a BFD reloc is always section relative. */
1090 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1091 dst_rel
.r_offset
= ptr
->address
;
1093 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1095 if (sym
== last_sym
)
1100 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1102 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1104 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1109 /* Set up an ELF internal section header for a section. */
1113 elf_fake_sections (abfd
, asect
, failedptrarg
)
1118 boolean
*failedptr
= (boolean
*) failedptrarg
;
1119 Elf_Internal_Shdr
*this_hdr
;
1123 /* We already failed; just get out of the bfd_map_over_sections
1128 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1130 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1133 if (this_hdr
->sh_name
== (unsigned long) -1)
1139 this_hdr
->sh_flags
= 0;
1140 if ((asect
->flags
& SEC_ALLOC
) != 0)
1141 this_hdr
->sh_addr
= asect
->vma
;
1143 this_hdr
->sh_addr
= 0;
1144 this_hdr
->sh_offset
= 0;
1145 this_hdr
->sh_size
= asect
->_raw_size
;
1146 this_hdr
->sh_link
= 0;
1147 this_hdr
->sh_info
= 0;
1148 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1149 this_hdr
->sh_entsize
= 0;
1151 this_hdr
->bfd_section
= asect
;
1152 this_hdr
->contents
= NULL
;
1154 /* FIXME: This should not be based on section names. */
1155 if (strcmp (asect
->name
, ".dynstr") == 0)
1156 this_hdr
->sh_type
= SHT_STRTAB
;
1157 else if (strcmp (asect
->name
, ".hash") == 0)
1159 this_hdr
->sh_type
= SHT_HASH
;
1160 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1162 else if (strcmp (asect
->name
, ".dynsym") == 0)
1164 this_hdr
->sh_type
= SHT_DYNSYM
;
1165 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1167 else if (strcmp (asect
->name
, ".dynamic") == 0)
1169 this_hdr
->sh_type
= SHT_DYNAMIC
;
1170 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1172 else if (strncmp (asect
->name
, ".rela", 5) == 0
1173 && get_elf_backend_data (abfd
)->use_rela_p
)
1175 this_hdr
->sh_type
= SHT_RELA
;
1176 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1178 else if (strncmp (asect
->name
, ".rel", 4) == 0
1179 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1181 this_hdr
->sh_type
= SHT_REL
;
1182 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1184 else if (strcmp (asect
->name
, ".note") == 0)
1185 this_hdr
->sh_type
= SHT_NOTE
;
1186 else if (strncmp (asect
->name
, ".stab", 5) == 0
1187 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1188 this_hdr
->sh_type
= SHT_STRTAB
;
1189 else if ((asect
->flags
& SEC_ALLOC
) != 0
1190 && (asect
->flags
& SEC_LOAD
) != 0)
1191 this_hdr
->sh_type
= SHT_PROGBITS
;
1192 else if ((asect
->flags
& SEC_ALLOC
) != 0
1193 && ((asect
->flags
& SEC_LOAD
) == 0))
1195 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1196 || strcmp (asect
->name
, ".sbss") == 0);
1197 this_hdr
->sh_type
= SHT_NOBITS
;
1202 this_hdr
->sh_type
= SHT_PROGBITS
;
1205 if ((asect
->flags
& SEC_ALLOC
) != 0)
1206 this_hdr
->sh_flags
|= SHF_ALLOC
;
1207 if ((asect
->flags
& SEC_READONLY
) == 0)
1208 this_hdr
->sh_flags
|= SHF_WRITE
;
1209 if ((asect
->flags
& SEC_CODE
) != 0)
1210 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1212 /* Check for processor-specific section types. */
1214 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1216 if (bed
->elf_backend_fake_sections
)
1217 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1220 /* If the section has relocs, set up a section header for the
1221 SHT_REL[A] section. */
1222 if ((asect
->flags
& SEC_RELOC
) != 0)
1224 Elf_Internal_Shdr
*rela_hdr
;
1225 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1228 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1229 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1232 bfd_set_error (bfd_error_no_memory
);
1236 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1238 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1240 if (rela_hdr
->sh_name
== (unsigned int) -1)
1245 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1246 rela_hdr
->sh_entsize
= (use_rela_p
1247 ? sizeof (Elf_External_Rela
)
1248 : sizeof (Elf_External_Rel
));
1249 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1250 rela_hdr
->sh_flags
= 0;
1251 rela_hdr
->sh_addr
= 0;
1252 rela_hdr
->sh_size
= 0;
1253 rela_hdr
->sh_offset
= 0;
1257 /* Assign all ELF section numbers. The dummy first section is handled here
1258 too. The link/info pointers for the standard section types are filled
1259 in here too, while we're at it. */
1262 assign_section_numbers (abfd
)
1265 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1267 unsigned int section_number
;
1268 Elf_Internal_Shdr
**i_shdrp
;
1272 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1274 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1276 d
->this_idx
= section_number
++;
1277 if ((sec
->flags
& SEC_RELOC
) == 0)
1280 d
->rel_idx
= section_number
++;
1283 t
->shstrtab_section
= section_number
++;
1284 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1285 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1287 if (abfd
->symcount
> 0)
1289 t
->symtab_section
= section_number
++;
1290 t
->strtab_section
= section_number
++;
1293 elf_elfheader (abfd
)->e_shnum
= section_number
;
1295 /* Set up the list of section header pointers, in agreement with the
1297 i_shdrp
= ((Elf_Internal_Shdr
**)
1298 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1299 if (i_shdrp
== NULL
)
1301 bfd_set_error (bfd_error_no_memory
);
1305 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1306 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1307 if (i_shdrp
[0] == NULL
)
1309 bfd_release (abfd
, i_shdrp
);
1310 bfd_set_error (bfd_error_no_memory
);
1313 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1315 elf_elfsections (abfd
) = i_shdrp
;
1317 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1318 if (abfd
->symcount
> 0)
1320 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1321 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1322 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1324 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1326 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1330 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1331 if (d
->rel_idx
!= 0)
1332 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1334 /* Fill in the sh_link and sh_info fields while we're at it. */
1336 /* sh_link of a reloc section is the section index of the symbol
1337 table. sh_info is the section index of the section to which
1338 the relocation entries apply. */
1339 if (d
->rel_idx
!= 0)
1341 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1342 d
->rel_hdr
.sh_info
= d
->this_idx
;
1345 switch (d
->this_hdr
.sh_type
)
1349 /* A reloc section which we are treating as a normal BFD
1350 section. sh_link is the section index of the symbol
1351 table. sh_info is the section index of the section to
1352 which the relocation entries apply. We assume that an
1353 allocated reloc section uses the dynamic symbol table.
1354 FIXME: How can we be sure? */
1355 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1357 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1359 /* We look up the section the relocs apply to by name. */
1361 if (d
->this_hdr
.sh_type
== SHT_REL
)
1365 s
= bfd_get_section_by_name (abfd
, name
);
1367 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1371 /* We assume that a section named .stab*str is a stabs
1372 string section. We look for a section with the same name
1373 but without the trailing ``str'', and set its sh_link
1374 field to point to this section. */
1375 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1376 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1381 len
= strlen (sec
->name
);
1382 alc
= (char *) malloc (len
- 2);
1385 bfd_set_error (bfd_error_no_memory
);
1388 strncpy (alc
, sec
->name
, len
- 3);
1389 alc
[len
- 3] = '\0';
1390 s
= bfd_get_section_by_name (abfd
, alc
);
1394 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1396 /* This is a .stab section. */
1397 elf_section_data (s
)->this_hdr
.sh_entsize
=
1398 4 + 2 * (ARCH_SIZE
/ 8);
1405 /* sh_link is the section header index of the string table
1406 used for the dynamic entries or symbol table. */
1407 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1409 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1413 /* sh_link is the section header index of the symbol table
1414 this hash table is for. */
1415 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1417 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1425 /* Map symbol from it's internal number to the external number, moving
1426 all local symbols to be at the head of the list. */
1429 sym_is_global (abfd
, sym
)
1433 /* If the backend has a special mapping, use it. */
1434 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1435 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1438 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1440 if (sym
->flags
& BSF_LOCAL
)
1444 if (sym
->section
== 0)
1446 /* Is this valid? */
1451 if (bfd_is_und_section (sym
->section
))
1453 if (bfd_is_com_section (sym
->section
))
1455 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1461 elf_map_symbols (abfd
)
1464 int symcount
= bfd_get_symcount (abfd
);
1465 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1466 asymbol
**sect_syms
;
1468 int num_globals
= 0;
1469 int num_locals2
= 0;
1470 int num_globals2
= 0;
1472 int num_sections
= 0;
1478 fprintf (stderr
, "elf_map_symbols\n");
1482 /* Add a section symbol for each BFD section. FIXME: Is this really
1484 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1486 if (max_index
< asect
->index
)
1487 max_index
= asect
->index
;
1491 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1492 if (sect_syms
== NULL
)
1494 bfd_set_error (bfd_error_no_memory
);
1497 elf_section_syms (abfd
) = sect_syms
;
1499 for (idx
= 0; idx
< symcount
; idx
++)
1501 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1502 && syms
[idx
]->value
== 0)
1506 sec
= syms
[idx
]->section
;
1507 if (sec
->owner
!= NULL
)
1509 if (sec
->owner
!= abfd
)
1511 if (sec
->output_offset
!= 0)
1513 sec
= sec
->output_section
;
1514 BFD_ASSERT (sec
->owner
== abfd
);
1516 sect_syms
[sec
->index
] = syms
[idx
];
1521 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1525 if (sect_syms
[asect
->index
] != NULL
)
1528 sym
= bfd_make_empty_symbol (abfd
);
1531 sym
->the_bfd
= abfd
;
1532 sym
->name
= asect
->name
;
1534 /* Set the flags to 0 to indicate that this one was newly added. */
1536 sym
->section
= asect
;
1537 sect_syms
[asect
->index
] = sym
;
1541 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1542 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1546 /* Classify all of the symbols. */
1547 for (idx
= 0; idx
< symcount
; idx
++)
1549 if (!sym_is_global (abfd
, syms
[idx
]))
1554 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1556 if (sect_syms
[asect
->index
] != NULL
1557 && sect_syms
[asect
->index
]->flags
== 0)
1559 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1560 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1564 sect_syms
[asect
->index
]->flags
= 0;
1568 /* Now sort the symbols so the local symbols are first. */
1569 new_syms
= ((asymbol
**)
1571 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1572 if (new_syms
== NULL
)
1574 bfd_set_error (bfd_error_no_memory
);
1578 for (idx
= 0; idx
< symcount
; idx
++)
1580 asymbol
*sym
= syms
[idx
];
1583 if (!sym_is_global (abfd
, sym
))
1586 i
= num_locals
+ num_globals2
++;
1588 sym
->udata
.i
= i
+ 1;
1590 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1592 if (sect_syms
[asect
->index
] != NULL
1593 && sect_syms
[asect
->index
]->flags
== 0)
1595 asymbol
*sym
= sect_syms
[asect
->index
];
1598 sym
->flags
= BSF_SECTION_SYM
;
1599 if (!sym_is_global (abfd
, sym
))
1602 i
= num_locals
+ num_globals2
++;
1604 sym
->udata
.i
= i
+ 1;
1608 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1610 elf_num_locals (abfd
) = num_locals
;
1611 elf_num_globals (abfd
) = num_globals
;
1615 /* Compute the file positions we are going to put the sections at, and
1616 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1617 is not NULL, this is being called by the ELF backend linker. */
1620 elf_compute_section_file_positions (abfd
, link_info
)
1622 struct bfd_link_info
*link_info
;
1624 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1626 struct bfd_strtab_hash
*strtab
;
1627 Elf_Internal_Shdr
*shstrtab_hdr
;
1629 if (abfd
->output_has_begun
)
1632 /* Do any elf backend specific processing first. */
1633 if (bed
->elf_backend_begin_write_processing
)
1634 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1636 if (! prep_headers (abfd
))
1640 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1644 if (!assign_section_numbers (abfd
))
1647 /* The backend linker builds symbol table information itself. */
1648 if (link_info
== NULL
)
1650 if (! swap_out_syms (abfd
, &strtab
))
1654 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1655 /* sh_name was set in prep_headers. */
1656 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1657 shstrtab_hdr
->sh_flags
= 0;
1658 shstrtab_hdr
->sh_addr
= 0;
1659 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1660 shstrtab_hdr
->sh_entsize
= 0;
1661 shstrtab_hdr
->sh_link
= 0;
1662 shstrtab_hdr
->sh_info
= 0;
1663 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1664 shstrtab_hdr
->sh_addralign
= 1;
1666 if (!assign_file_positions_except_relocs (abfd
,
1667 link_info
== NULL
? true : false))
1670 if (link_info
== NULL
)
1672 /* Now that we know where the .strtab section goes, write it
1674 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1676 || ! _bfd_stringtab_emit (abfd
, strtab
))
1678 _bfd_stringtab_free (strtab
);
1681 abfd
->output_has_begun
= true;
1687 /* Align to the maximum file alignment that could be required for any
1688 ELF data structure. */
1690 static INLINE file_ptr
1691 align_file_position (off
)
1694 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1697 /* Assign a file position to a section, optionally aligning to the
1698 required section alignment. */
1700 static INLINE file_ptr
1701 assign_file_position_for_section (i_shdrp
, offset
, align
)
1702 Elf_Internal_Shdr
*i_shdrp
;
1710 al
= i_shdrp
->sh_addralign
;
1712 offset
= BFD_ALIGN (offset
, al
);
1714 i_shdrp
->sh_offset
= offset
;
1715 if (i_shdrp
->bfd_section
!= NULL
)
1716 i_shdrp
->bfd_section
->filepos
= offset
;
1717 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1718 offset
+= i_shdrp
->sh_size
;
1722 /* Get the size of the program header. This is called by the linker
1723 before any of the section VMA's are set, so it can't calculate the
1724 correct value for a strange memory layout. */
1726 static bfd_size_type
1727 get_program_header_size (abfd
)
1733 /* Assume we will need exactly two PT_LOAD segments: one for text
1734 and one for data. */
1737 s
= bfd_get_section_by_name (abfd
, ".interp");
1738 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1740 /* If we have a loadable interpreter section, we need a
1741 PT_INTERP segment. In this case, assume we also need a
1742 PT_PHDR segment, although that may not be true for all
1747 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1749 /* We need a PT_DYNAMIC segment. */
1753 return segs
* sizeof (Elf_External_Phdr
);
1756 /* Create the program header. OFF is the file offset where the
1757 program header should be written. FIRST is the first loadable ELF
1758 section. SORTED_HDRS is the ELF sections sorted by section
1759 address. PHDR_SIZE is the size of the program header as returned
1760 by get_program_header_size. */
1763 map_program_segments (abfd
, off
, first
, sorted_hdrs
, phdr_size
)
1766 Elf_Internal_Shdr
*first
;
1767 Elf_Internal_Shdr
**sorted_hdrs
;
1768 bfd_size_type phdr_size
;
1770 Elf_Internal_Phdr phdrs
[10];
1771 unsigned int phdr_count
;
1772 Elf_Internal_Phdr
*phdr
;
1773 int phdr_size_adjust
;
1775 Elf_Internal_Shdr
**hdrpp
;
1776 asection
*sinterp
, *sdyn
;
1777 unsigned int last_type
;
1778 Elf_Internal_Ehdr
*i_ehdrp
;
1780 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1781 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1782 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1787 phdr_size_adjust
= 0;
1789 /* If we have a loadable .interp section, we must create a PT_INTERP
1790 segment which must precede all PT_LOAD segments. We assume that
1791 we must also create a PT_PHDR segment, although that may not be
1792 true for all targets. */
1793 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1794 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1796 BFD_ASSERT (first
!= NULL
);
1798 phdr
->p_type
= PT_PHDR
;
1800 phdr
->p_offset
= off
;
1802 /* Account for any adjustment made because of the alignment of
1803 the first loadable section. */
1804 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1805 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1807 /* The program header precedes all loadable sections. This lets
1808 us compute its loadable address. This depends on the linker
1810 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1813 phdr
->p_filesz
= phdr_size
;
1814 phdr
->p_memsz
= phdr_size
;
1816 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1817 phdr
->p_flags
= PF_R
| PF_X
;
1819 phdr
->p_align
= FILE_ALIGN
;
1820 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1822 /* Include the ELF header in the first loadable segment. */
1823 phdr_size_adjust
+= off
;
1828 phdr
->p_type
= PT_INTERP
;
1829 phdr
->p_offset
= sinterp
->filepos
;
1830 phdr
->p_vaddr
= sinterp
->vma
;
1832 phdr
->p_filesz
= sinterp
->_raw_size
;
1833 phdr
->p_memsz
= sinterp
->_raw_size
;
1834 phdr
->p_flags
= PF_R
;
1835 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1841 /* Look through the sections to see how they will be divided into
1842 program segments. The sections must be arranged in order by
1843 sh_addr for this to work correctly. */
1844 phdr
->p_type
= PT_NULL
;
1845 last_type
= SHT_PROGBITS
;
1846 for (i
= 1, hdrpp
= sorted_hdrs
;
1847 i
< elf_elfheader (abfd
)->e_shnum
;
1850 Elf_Internal_Shdr
*hdr
;
1854 /* Ignore any section which will not be part of the process
1856 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1859 /* If this section fits in the segment we are constructing, add
1861 if (phdr
->p_type
!= PT_NULL
1862 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1863 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1864 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1866 bfd_size_type adjust
;
1868 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1869 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1870 if (hdr
->sh_type
!= SHT_NOBITS
)
1871 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1872 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1873 phdr
->p_flags
|= PF_W
;
1874 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1875 phdr
->p_flags
|= PF_X
;
1876 last_type
= hdr
->sh_type
;
1880 /* If we have a segment, move to the next one. */
1881 if (phdr
->p_type
!= PT_NULL
)
1887 /* Start a new segment. */
1888 phdr
->p_type
= PT_LOAD
;
1889 phdr
->p_offset
= hdr
->sh_offset
;
1890 phdr
->p_vaddr
= hdr
->sh_addr
;
1892 if (hdr
->sh_type
== SHT_NOBITS
)
1895 phdr
->p_filesz
= hdr
->sh_size
;
1896 phdr
->p_memsz
= hdr
->sh_size
;
1897 phdr
->p_flags
= PF_R
;
1898 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1899 phdr
->p_flags
|= PF_W
;
1900 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1901 phdr
->p_flags
|= PF_X
;
1902 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1906 && (sinterp
->flags
& SEC_LOAD
) != 0)
1908 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1909 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1910 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1911 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1914 last_type
= hdr
->sh_type
;
1917 if (phdr
->p_type
!= PT_NULL
)
1923 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1924 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1925 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1927 phdr
->p_type
= PT_DYNAMIC
;
1928 phdr
->p_offset
= sdyn
->filepos
;
1929 phdr
->p_vaddr
= sdyn
->vma
;
1931 phdr
->p_filesz
= sdyn
->_raw_size
;
1932 phdr
->p_memsz
= sdyn
->_raw_size
;
1933 phdr
->p_flags
= PF_R
;
1934 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1935 phdr
->p_flags
|= PF_W
;
1936 if ((sdyn
->flags
& SEC_CODE
) != 0)
1937 phdr
->p_flags
|= PF_X
;
1938 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1944 /* Make sure the return value from get_program_header_size matches
1945 what we computed here. Actually, it's OK if we allocated too
1946 much space in the program header. */
1947 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1950 /* Set up program header information. */
1951 i_ehdrp
= elf_elfheader (abfd
);
1952 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1953 i_ehdrp
->e_phoff
= off
;
1954 i_ehdrp
->e_phnum
= phdr_count
;
1956 /* Save the program headers away. I don't think anybody uses this
1957 information right now. */
1958 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1961 * sizeof (Elf_Internal_Phdr
))));
1962 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1964 bfd_set_error (bfd_error_no_memory
);
1965 return (file_ptr
) -1;
1967 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1968 phdr_count
* sizeof (Elf_Internal_Phdr
));
1970 /* Write out the program headers. */
1971 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1972 return (file_ptr
) -1;
1974 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1976 Elf_External_Phdr extphdr
;
1978 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1979 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1980 != sizeof (Elf_External_Phdr
))
1981 return (file_ptr
) -1;
1984 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1987 /* Work out the file positions of all the sections. This is called by
1988 elf_compute_section_file_positions. All the section sizes and VMAs
1989 must be known before this is called.
1991 We do not consider reloc sections at this point, unless they form
1992 part of the loadable image. Reloc sections are assigned file
1993 positions in assign_file_positions_for_relocs, which is called by
1994 write_object_contents and final_link.
1996 If DOSYMS is false, we do not assign file positions for the symbol
1997 table or the string table. */
2000 assign_file_positions_except_relocs (abfd
, dosyms
)
2004 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2005 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2006 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2009 /* Start after the ELF header. */
2010 off
= i_ehdrp
->e_ehsize
;
2012 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2014 Elf_Internal_Shdr
**hdrpp
;
2017 /* We are not creating an executable, which means that we are
2018 not creating a program header, and that the actual order of
2019 the sections in the file is unimportant. */
2020 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2022 Elf_Internal_Shdr
*hdr
;
2025 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2027 hdr
->sh_offset
= -1;
2031 && (i
== tdata
->symtab_section
2032 || i
== tdata
->strtab_section
))
2034 hdr
->sh_offset
= -1;
2038 off
= assign_file_position_for_section (hdr
, off
, true);
2044 bfd_size_type phdr_size
;
2045 bfd_vma maxpagesize
;
2047 Elf_Internal_Shdr
**sorted_hdrs
;
2048 Elf_Internal_Shdr
**hdrpp
;
2050 Elf_Internal_Shdr
*first
;
2053 /* We are creating an executable. We must create a program
2054 header. We can't actually create the program header until we
2055 have set the file positions for the sections, but we can
2056 figure out how big it is going to be. */
2057 off
= align_file_position (off
);
2058 phdr_size
= get_program_header_size (abfd
);
2059 if (phdr_size
== (file_ptr
) -1)
2064 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2065 if (maxpagesize
== 0)
2068 /* We must sort the sections. The GNU linker will always create
2069 the sections in an appropriate order, but the Irix 5 linker
2070 will not. We don't include the dummy first section in the
2071 sort. We sort sections which are not SHF_ALLOC to the end. */
2072 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2073 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2074 if (sorted_hdrs
== NULL
)
2076 bfd_set_error (bfd_error_no_memory
);
2080 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2081 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2085 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2087 Elf_Internal_Shdr
*hdr
;
2090 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2092 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2094 hdr
->sh_offset
= -1;
2098 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2099 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2101 hdr
->sh_offset
= -1;
2110 /* The section VMA must equal the file position modulo
2111 the page size. This is required by the program
2113 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2116 off
= assign_file_position_for_section (hdr
, off
, false);
2119 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, sorted_hdrs
,
2121 if (phdr_map
== (file_ptr
) -1)
2123 BFD_ASSERT ((bfd_size_type
) phdr_map
<= (bfd_size_type
) phdr_off
+ phdr_size
);
2128 /* Place the section headers. */
2129 off
= align_file_position (off
);
2130 i_ehdrp
->e_shoff
= off
;
2131 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2133 elf_tdata (abfd
)->next_file_pos
= off
;
2138 /* Sort the ELF headers by VMA. We sort headers which are not
2139 SHF_ALLOC to the end. */
2142 elf_sort_hdrs (arg1
, arg2
)
2146 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2147 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2149 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2151 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2153 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2155 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2162 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2172 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2173 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2174 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2176 struct bfd_strtab_hash
*shstrtab
;
2178 i_ehdrp
= elf_elfheader (abfd
);
2179 i_shdrp
= elf_elfsections (abfd
);
2181 shstrtab
= elf_stringtab_init ();
2182 if (shstrtab
== NULL
)
2185 elf_shstrtab (abfd
) = shstrtab
;
2187 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2188 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2189 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2190 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2192 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2193 i_ehdrp
->e_ident
[EI_DATA
] =
2194 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2195 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2197 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2198 i_ehdrp
->e_ident
[count
] = 0;
2200 if ((abfd
->flags
& DYNAMIC
) != 0)
2201 i_ehdrp
->e_type
= ET_DYN
;
2202 else if ((abfd
->flags
& EXEC_P
) != 0)
2203 i_ehdrp
->e_type
= ET_EXEC
;
2205 i_ehdrp
->e_type
= ET_REL
;
2207 switch (bfd_get_arch (abfd
))
2209 case bfd_arch_unknown
:
2210 i_ehdrp
->e_machine
= EM_NONE
;
2212 case bfd_arch_sparc
:
2214 i_ehdrp
->e_machine
= EM_SPARC64
;
2216 i_ehdrp
->e_machine
= EM_SPARC
;
2220 i_ehdrp
->e_machine
= EM_386
;
2223 i_ehdrp
->e_machine
= EM_68K
;
2226 i_ehdrp
->e_machine
= EM_88K
;
2229 i_ehdrp
->e_machine
= EM_860
;
2231 case bfd_arch_mips
: /* MIPS Rxxxx */
2232 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2235 i_ehdrp
->e_machine
= EM_PARISC
;
2237 case bfd_arch_powerpc
:
2238 i_ehdrp
->e_machine
= EM_PPC
;
2240 /* start-sanitize-arc */
2242 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2244 /* end-sanitize-arc */
2245 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2247 i_ehdrp
->e_machine
= EM_NONE
;
2249 i_ehdrp
->e_version
= EV_CURRENT
;
2250 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2252 /* no program header, for now. */
2253 i_ehdrp
->e_phoff
= 0;
2254 i_ehdrp
->e_phentsize
= 0;
2255 i_ehdrp
->e_phnum
= 0;
2257 /* each bfd section is section header entry */
2258 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2259 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2261 /* if we're building an executable, we'll need a program header table */
2262 if (abfd
->flags
& EXEC_P
)
2264 /* it all happens later */
2266 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2268 /* elf_build_phdrs() returns a (NULL-terminated) array of
2269 Elf_Internal_Phdrs */
2270 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2271 i_ehdrp
->e_phoff
= outbase
;
2272 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2277 i_ehdrp
->e_phentsize
= 0;
2279 i_ehdrp
->e_phoff
= 0;
2282 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2283 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2284 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2285 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2286 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2287 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2288 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2289 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2290 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2297 swap_out_syms (abfd
, sttp
)
2299 struct bfd_strtab_hash
**sttp
;
2301 if (!elf_map_symbols (abfd
))
2304 /* Dump out the symtabs. */
2306 int symcount
= bfd_get_symcount (abfd
);
2307 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2308 struct bfd_strtab_hash
*stt
;
2309 Elf_Internal_Shdr
*symtab_hdr
;
2310 Elf_Internal_Shdr
*symstrtab_hdr
;
2311 Elf_External_Sym
*outbound_syms
;
2314 stt
= elf_stringtab_init ();
2318 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2319 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2320 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2321 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2322 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2323 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2325 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2326 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2328 outbound_syms
= ((Elf_External_Sym
*)
2330 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2331 if (outbound_syms
== NULL
)
2333 bfd_set_error (bfd_error_no_memory
);
2336 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2338 /* now generate the data (for "contents") */
2340 /* Fill in zeroth symbol and swap it out. */
2341 Elf_Internal_Sym sym
;
2347 sym
.st_shndx
= SHN_UNDEF
;
2348 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2351 for (idx
= 0; idx
< symcount
; idx
++)
2353 Elf_Internal_Sym sym
;
2354 bfd_vma value
= syms
[idx
]->value
;
2355 elf_symbol_type
*type_ptr
;
2357 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2358 /* Section symbols have no names. */
2362 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2365 if (sym
.st_name
== (unsigned long) -1)
2369 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2371 if (bfd_is_com_section (syms
[idx
]->section
))
2373 /* ELF common symbols put the alignment into the `value' field,
2374 and the size into the `size' field. This is backwards from
2375 how BFD handles it, so reverse it here. */
2376 sym
.st_size
= value
;
2377 if (type_ptr
== NULL
2378 || type_ptr
->internal_elf_sym
.st_value
== 0)
2379 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2381 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2382 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2383 syms
[idx
]->section
);
2387 asection
*sec
= syms
[idx
]->section
;
2390 if (sec
->output_section
)
2392 value
+= sec
->output_offset
;
2393 sec
= sec
->output_section
;
2396 sym
.st_value
= value
;
2397 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2398 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2402 /* Writing this would be a hell of a lot easier if we had
2403 some decent documentation on bfd, and knew what to expect
2404 of the library, and what to demand of applications. For
2405 example, it appears that `objcopy' might not set the
2406 section of a symbol to be a section that is actually in
2408 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2409 BFD_ASSERT (sec2
!= 0);
2410 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2411 BFD_ASSERT (shndx
!= -1);
2415 if (bfd_is_com_section (syms
[idx
]->section
))
2416 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2417 else if (bfd_is_und_section (syms
[idx
]->section
))
2418 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2419 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2422 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2423 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2424 else if (syms
[idx
]->flags
& BSF_FILE
)
2425 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2428 int bind
= STB_LOCAL
;
2429 int type
= STT_OBJECT
;
2430 unsigned int flags
= syms
[idx
]->flags
;
2432 if (flags
& BSF_LOCAL
)
2434 else if (flags
& BSF_WEAK
)
2436 else if (flags
& BSF_GLOBAL
)
2439 if (flags
& BSF_FUNCTION
)
2442 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2446 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2451 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2452 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2454 symstrtab_hdr
->sh_flags
= 0;
2455 symstrtab_hdr
->sh_addr
= 0;
2456 symstrtab_hdr
->sh_entsize
= 0;
2457 symstrtab_hdr
->sh_link
= 0;
2458 symstrtab_hdr
->sh_info
= 0;
2459 symstrtab_hdr
->sh_addralign
= 1;
2466 write_shdrs_and_ehdr (abfd
)
2469 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2470 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2471 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2472 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2475 i_ehdrp
= elf_elfheader (abfd
);
2476 i_shdrp
= elf_elfsections (abfd
);
2478 /* swap the header before spitting it out... */
2481 elf_debug_file (i_ehdrp
);
2483 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2484 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2485 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2486 != sizeof (x_ehdr
)))
2489 /* at this point we've concocted all the ELF sections... */
2490 x_shdrp
= (Elf_External_Shdr
*)
2491 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2494 bfd_set_error (bfd_error_no_memory
);
2498 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2501 elf_debug_section (count
, i_shdrp
[count
]);
2503 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2505 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2506 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2507 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2510 /* need to dump the string table too... */
2515 /* Assign file positions for all the reloc sections which are not part
2516 of the loadable file image. */
2519 assign_file_positions_for_relocs (abfd
)
2524 Elf_Internal_Shdr
**shdrpp
;
2526 off
= elf_tdata (abfd
)->next_file_pos
;
2528 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2529 i
< elf_elfheader (abfd
)->e_shnum
;
2532 Elf_Internal_Shdr
*shdrp
;
2535 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2536 && shdrp
->sh_offset
== -1)
2537 off
= assign_file_position_for_section (shdrp
, off
, true);
2540 elf_tdata (abfd
)->next_file_pos
= off
;
2544 NAME(bfd_elf
,write_object_contents
) (abfd
)
2547 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2548 Elf_Internal_Ehdr
*i_ehdrp
;
2549 Elf_Internal_Shdr
**i_shdrp
;
2552 if (! abfd
->output_has_begun
2553 && ! elf_compute_section_file_positions (abfd
,
2554 (struct bfd_link_info
*) NULL
))
2557 i_shdrp
= elf_elfsections (abfd
);
2558 i_ehdrp
= elf_elfheader (abfd
);
2560 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2561 assign_file_positions_for_relocs (abfd
);
2563 /* After writing the headers, we need to write the sections too... */
2564 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2566 if (bed
->elf_backend_section_processing
)
2567 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2568 if (i_shdrp
[count
]->contents
)
2570 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2571 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2573 != i_shdrp
[count
]->sh_size
))
2578 /* Write out the section header names. */
2579 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2580 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2583 if (bed
->elf_backend_final_write_processing
)
2584 (*bed
->elf_backend_final_write_processing
) (abfd
,
2585 elf_tdata (abfd
)->linker
);
2587 return write_shdrs_and_ehdr (abfd
);
2590 /* Given an ELF section number, retrieve the corresponding BFD
2594 section_from_elf_index (abfd
, index
)
2598 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2599 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2601 return elf_elfsections (abfd
)[index
]->bfd_section
;
2604 /* given a section, search the header to find them... */
2606 elf_section_from_bfd_section (abfd
, asect
)
2610 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2611 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2613 Elf_Internal_Shdr
*hdr
;
2614 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2616 for (index
= 0; index
< maxindex
; index
++)
2618 hdr
= i_shdrp
[index
];
2619 if (hdr
->bfd_section
== asect
)
2623 if (bed
->elf_backend_section_from_bfd_section
)
2625 for (index
= 0; index
< maxindex
; index
++)
2629 hdr
= i_shdrp
[index
];
2631 if ((*bed
->elf_backend_section_from_bfd_section
)
2632 (abfd
, hdr
, asect
, &retval
))
2637 if (bfd_is_abs_section (asect
))
2639 if (bfd_is_com_section (asect
))
2641 if (bfd_is_und_section (asect
))
2647 /* given a symbol, return the bfd index for that symbol. */
2649 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2651 struct symbol_cache_entry
**asym_ptr_ptr
;
2653 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2655 flagword flags
= asym_ptr
->flags
;
2657 /* When gas creates relocations against local labels, it creates its
2658 own symbol for the section, but does put the symbol into the
2659 symbol chain, so udata is 0. When the linker is generating
2660 relocatable output, this section symbol may be for one of the
2661 input sections rather than the output section. */
2662 if (asym_ptr
->udata
.i
== 0
2663 && (flags
& BSF_SECTION_SYM
)
2664 && asym_ptr
->section
)
2668 if (asym_ptr
->section
->output_section
!= NULL
)
2669 indx
= asym_ptr
->section
->output_section
->index
;
2671 indx
= asym_ptr
->section
->index
;
2672 if (elf_section_syms (abfd
)[indx
])
2673 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2676 idx
= asym_ptr
->udata
.i
;
2684 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2685 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2694 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2696 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2699 Elf_Internal_Shdr
*hdr
;
2700 long symcount
; /* Number of external ELF symbols */
2701 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2702 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2703 Elf_Internal_Sym i_sym
;
2704 Elf_External_Sym
*x_symp
= NULL
;
2706 /* Read each raw ELF symbol, converting from external ELF form to
2707 internal ELF form, and then using the information to create a
2708 canonical bfd symbol table entry.
2710 Note that we allocate the initial bfd canonical symbol buffer
2711 based on a one-to-one mapping of the ELF symbols to canonical
2712 symbols. We actually use all the ELF symbols, so there will be no
2713 space left over at the end. When we have all the symbols, we
2714 build the caller's pointer vector. */
2717 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2719 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2720 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2723 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2726 sym
= symbase
= NULL
;
2731 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2734 symbase
= ((elf_symbol_type
*)
2735 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2736 if (symbase
== (elf_symbol_type
*) NULL
)
2738 bfd_set_error (bfd_error_no_memory
);
2743 /* Temporarily allocate room for the raw ELF symbols. */
2744 x_symp
= ((Elf_External_Sym
*)
2745 malloc (symcount
* sizeof (Elf_External_Sym
)));
2746 if (x_symp
== NULL
&& symcount
!= 0)
2748 bfd_set_error (bfd_error_no_memory
);
2752 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2753 != symcount
* sizeof (Elf_External_Sym
))
2755 /* Skip first symbol, which is a null dummy. */
2756 for (i
= 1; i
< symcount
; i
++)
2758 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2759 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2760 #ifdef ELF_KEEP_EXTSYM
2761 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2763 sym
->symbol
.the_bfd
= abfd
;
2765 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2768 sym
->symbol
.value
= i_sym
.st_value
;
2770 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2772 sym
->symbol
.section
= section_from_elf_index (abfd
,
2774 if (sym
->symbol
.section
== NULL
)
2776 /* This symbol is in a section for which we did not
2777 create a BFD section. Just use bfd_abs_section,
2778 although it is wrong. FIXME. */
2779 sym
->symbol
.section
= bfd_abs_section_ptr
;
2782 else if (i_sym
.st_shndx
== SHN_ABS
)
2784 sym
->symbol
.section
= bfd_abs_section_ptr
;
2786 else if (i_sym
.st_shndx
== SHN_COMMON
)
2788 sym
->symbol
.section
= bfd_com_section_ptr
;
2789 /* Elf puts the alignment into the `value' field, and
2790 the size into the `size' field. BFD wants to see the
2791 size in the value field, and doesn't care (at the
2792 moment) about the alignment. */
2793 sym
->symbol
.value
= i_sym
.st_size
;
2795 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2797 sym
->symbol
.section
= bfd_und_section_ptr
;
2800 sym
->symbol
.section
= bfd_abs_section_ptr
;
2802 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2804 switch (ELF_ST_BIND (i_sym
.st_info
))
2807 sym
->symbol
.flags
|= BSF_LOCAL
;
2810 if (i_sym
.st_shndx
!= SHN_UNDEF
2811 && i_sym
.st_shndx
!= SHN_COMMON
)
2812 sym
->symbol
.flags
|= BSF_GLOBAL
;
2815 sym
->symbol
.flags
|= BSF_WEAK
;
2819 switch (ELF_ST_TYPE (i_sym
.st_info
))
2822 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2825 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2828 sym
->symbol
.flags
|= BSF_FUNCTION
;
2833 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2835 /* Do some backend-specific processing on this symbol. */
2837 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2838 if (ebd
->elf_backend_symbol_processing
)
2839 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2846 /* Do some backend-specific processing on this symbol table. */
2848 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2849 if (ebd
->elf_backend_symbol_table_processing
)
2850 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2853 /* We rely on the zalloc to clear out the final symbol entry. */
2855 symcount
= sym
- symbase
;
2857 /* Fill in the user's symbol pointer vector if needed. */
2865 *symptrs
++ = &sym
->symbol
;
2868 *symptrs
= 0; /* Final null pointer */
2880 /* Return the number of bytes required to hold the symtab vector.
2882 Note that we base it on the count plus 1, since we will null terminate
2883 the vector allocated based on this size. However, the ELF symbol table
2884 always has a dummy entry as symbol #0, so it ends up even. */
2887 elf_get_symtab_upper_bound (abfd
)
2892 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2894 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2895 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2901 elf_get_dynamic_symtab_upper_bound (abfd
)
2906 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2908 if (elf_dynsymtab (abfd
) == 0)
2910 bfd_set_error (bfd_error_invalid_operation
);
2914 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2915 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2921 elf_get_reloc_upper_bound (abfd
, asect
)
2925 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2928 /* Read in and swap the external relocs. */
2931 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2936 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2937 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2938 PTR allocated
= NULL
;
2939 bfd_byte
*native_relocs
;
2945 if (asect
->relocation
!= NULL
2946 || (asect
->flags
& SEC_RELOC
) == 0
2947 || asect
->reloc_count
== 0)
2950 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2951 && (asect
->reloc_count
2952 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2954 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2955 if (allocated
== NULL
)
2957 bfd_set_error (bfd_error_no_memory
);
2961 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2962 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2963 != d
->rel_hdr
.sh_size
))
2966 native_relocs
= (bfd_byte
*) allocated
;
2968 relents
= ((arelent
*)
2969 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2970 if (relents
== NULL
)
2972 bfd_set_error (bfd_error_no_memory
);
2976 entsize
= d
->rel_hdr
.sh_entsize
;
2977 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2978 || entsize
== sizeof (Elf_External_Rela
));
2980 for (i
= 0, relent
= relents
;
2981 i
< asect
->reloc_count
;
2982 i
++, relent
++, native_relocs
+= entsize
)
2984 Elf_Internal_Rela rela
;
2985 Elf_Internal_Rel rel
;
2987 if (entsize
== sizeof (Elf_External_Rela
))
2988 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2991 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2992 rela
.r_offset
= rel
.r_offset
;
2993 rela
.r_info
= rel
.r_info
;
2997 /* The address of an ELF reloc is section relative for an object
2998 file, and absolute for an executable file or shared library.
2999 The address of a BFD reloc is always section relative. */
3000 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3001 relent
->address
= rela
.r_offset
;
3003 relent
->address
= rela
.r_offset
- asect
->vma
;
3005 if (ELF_R_SYM (rela
.r_info
) == 0)
3006 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3011 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3014 /* Canonicalize ELF section symbols. FIXME: Why? */
3015 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3016 relent
->sym_ptr_ptr
= ps
;
3018 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3021 relent
->addend
= rela
.r_addend
;
3023 if (entsize
== sizeof (Elf_External_Rela
))
3024 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3026 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3029 asect
->relocation
= relents
;
3031 if (allocated
!= NULL
)
3037 if (allocated
!= NULL
)
3044 elf_debug_section (num
, hdr
)
3046 Elf_Internal_Shdr
*hdr
;
3048 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3049 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3052 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3053 (long) hdr
->sh_name
,
3054 (long) hdr
->sh_type
,
3055 (long) hdr
->sh_flags
);
3057 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3058 (long) hdr
->sh_addr
,
3059 (long) hdr
->sh_offset
,
3060 (long) hdr
->sh_size
);
3062 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3063 (long) hdr
->sh_link
,
3064 (long) hdr
->sh_info
,
3065 (long) hdr
->sh_addralign
);
3066 fprintf (stderr
, "sh_entsize = %ld\n",
3067 (long) hdr
->sh_entsize
);
3072 elf_debug_file (ehdrp
)
3073 Elf_Internal_Ehdr
*ehdrp
;
3075 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3076 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3077 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3078 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3079 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3080 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3081 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3085 /* Canonicalize the relocs. */
3088 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3097 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3100 tblptr
= section
->relocation
;
3101 for (i
= 0; i
< section
->reloc_count
; i
++)
3102 *relptr
++ = tblptr
++;
3106 return section
->reloc_count
;
3110 elf_get_symtab (abfd
, alocation
)
3112 asymbol
**alocation
;
3114 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3117 bfd_get_symcount (abfd
) = symcount
;
3122 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3124 asymbol
**alocation
;
3126 return elf_slurp_symbol_table (abfd
, alocation
, true);
3130 elf_make_empty_symbol (abfd
)
3133 elf_symbol_type
*newsym
;
3135 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3138 bfd_set_error (bfd_error_no_memory
);
3143 newsym
->symbol
.the_bfd
= abfd
;
3144 return &newsym
->symbol
;
3149 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3154 bfd_symbol_info (symbol
, ret
);
3158 elf_get_lineno (ignore_abfd
, symbol
)
3162 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3169 elf_set_arch_mach (abfd
, arch
, machine
)
3171 enum bfd_architecture arch
;
3172 unsigned long machine
;
3174 /* If this isn't the right architecture for this backend, and this
3175 isn't the generic backend, fail. */
3176 if (arch
!= get_elf_backend_data (abfd
)->arch
3177 && arch
!= bfd_arch_unknown
3178 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3181 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3185 elf_find_nearest_line (abfd
,
3196 CONST
char **filename_ptr
;
3197 CONST
char **functionname_ptr
;
3198 unsigned int *line_ptr
;
3204 elf_sizeof_headers (abfd
, reloc
)
3210 ret
= sizeof (Elf_External_Ehdr
);
3212 ret
+= get_program_header_size (abfd
);
3217 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3222 bfd_size_type count
;
3224 Elf_Internal_Shdr
*hdr
;
3226 if (! abfd
->output_has_begun
3227 && ! elf_compute_section_file_positions (abfd
,
3228 (struct bfd_link_info
*) NULL
))
3231 hdr
= &elf_section_data (section
)->this_hdr
;
3233 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3235 if (bfd_write (location
, 1, count
, abfd
) != count
)
3242 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3245 Elf_Internal_Rela
*dst
;
3247 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3253 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3256 Elf_Internal_Rel
*dst
;
3258 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3264 /* Core file support */
3266 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3267 #include <sys/procfs.h>
3269 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3270 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3271 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3277 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3284 prstatus_t
*status
= (prstatus_t
*) 0;
3286 if (descsz
== sizeof (prstatus_t
))
3288 newsect
= bfd_make_section (abfd
, ".reg");
3289 if (newsect
== NULL
)
3291 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3292 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3293 newsect
->flags
= SEC_HAS_CONTENTS
;
3294 newsect
->alignment_power
= 2;
3295 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3297 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3303 /* Stash a copy of the prpsinfo structure away for future use. */
3306 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3312 if (descsz
== sizeof (prpsinfo_t
))
3314 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3316 bfd_set_error (bfd_error_no_memory
);
3319 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3325 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3333 newsect
= bfd_make_section (abfd
, ".reg2");
3334 if (newsect
== NULL
)
3336 newsect
->_raw_size
= descsz
;
3337 newsect
->filepos
= filepos
;
3338 newsect
->flags
= SEC_HAS_CONTENTS
;
3339 newsect
->alignment_power
= 2;
3343 #endif /* HAVE_PROCFS */
3345 /* Return a pointer to the args (including the command name) that were
3346 seen by the program that generated the core dump. Note that for
3347 some reason, a spurious space is tacked onto the end of the args
3348 in some (at least one anyway) implementations, so strip it off if
3352 elf_core_file_failing_command (abfd
)
3356 if (core_prpsinfo (abfd
))
3358 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3359 char *scan
= p
->pr_psargs
;
3364 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3368 return p
->pr_psargs
;
3374 /* Return the number of the signal that caused the core dump. Presumably,
3375 since we have a core file, we got a signal of some kind, so don't bother
3376 checking the other process status fields, just return the signal number.
3380 elf_core_file_failing_signal (abfd
)
3384 if (core_prstatus (abfd
))
3386 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3392 /* Check to see if the core file could reasonably be expected to have
3393 come for the current executable file. Note that by default we return
3394 true unless we find something that indicates that there might be a
3399 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3408 /* First, xvecs must match since both are ELF files for the same target. */
3410 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3412 bfd_set_error (bfd_error_system_call
);
3418 /* If no prpsinfo, just return true. Otherwise, grab the last component
3419 of the exec'd pathname from the prpsinfo. */
3421 if (core_prpsinfo (core_bfd
))
3423 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3430 /* Find the last component of the executable pathname. */
3432 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3438 execname
= (char *) exec_bfd
->filename
;
3441 /* See if they match */
3443 return strcmp (execname
, corename
) ? false : true;
3449 #endif /* HAVE_PROCFS */
3452 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3453 the information that would normally be available from the /proc interface
3454 for the process, at the time the process dumped core. Currently this
3455 includes copies of the prstatus, prpsinfo, and fpregset structures.
3457 Since these structures are potentially machine dependent in size and
3458 ordering, bfd provides two levels of support for them. The first level,
3459 available on all machines since it does not require that the host
3460 have /proc support or the relevant include files, is to create a bfd
3461 section for each of the prstatus, prpsinfo, and fpregset structures,
3462 without any interpretation of their contents. With just this support,
3463 the bfd client will have to interpret the structures itself. Even with
3464 /proc support, it might want these full structures for it's own reasons.
3466 In the second level of support, where HAVE_PROCFS is defined, bfd will
3467 pick apart the structures to gather some additional information that
3468 clients may want, such as the general register set, the name of the
3469 exec'ed file and its arguments, the signal (if any) that caused the
3475 elf_corefile_note (abfd
, hdr
)
3477 Elf_Internal_Phdr
*hdr
;
3479 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3480 Elf_Internal_Note i_note
; /* Elf note, internal form */
3481 char *buf
= NULL
; /* Entire note segment contents */
3482 char *namedata
; /* Name portion of the note */
3483 char *descdata
; /* Descriptor portion of the note */
3484 char *sectname
; /* Name to use for new section */
3485 long filepos
; /* File offset to descriptor data */
3488 if (hdr
->p_filesz
> 0
3489 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3490 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3491 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3493 x_note_p
= (Elf_External_Note
*) buf
;
3494 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3496 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3497 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3498 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3499 namedata
= x_note_p
->name
;
3500 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3501 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3502 switch (i_note
.type
)
3505 /* process descdata as prstatus info */
3506 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3508 sectname
= ".prstatus";
3511 /* process descdata as fpregset info */
3512 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3514 sectname
= ".fpregset";
3517 /* process descdata as prpsinfo */
3518 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3520 sectname
= ".prpsinfo";
3523 /* Unknown descriptor, just ignore it. */
3527 if (sectname
!= NULL
)
3529 newsect
= bfd_make_section (abfd
, sectname
);
3530 if (newsect
== NULL
)
3532 newsect
->_raw_size
= i_note
.descsz
;
3533 newsect
->filepos
= filepos
;
3534 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3535 newsect
->alignment_power
= 2;
3537 x_note_p
= (Elf_External_Note
*)
3538 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3545 else if (hdr
->p_filesz
> 0)
3547 bfd_set_error (bfd_error_no_memory
);
3554 /* Core files are simply standard ELF formatted files that partition
3555 the file using the execution view of the file (program header table)
3556 rather than the linking view. In fact, there is no section header
3557 table in a core file.
3559 The process status information (including the contents of the general
3560 register set) and the floating point register set are stored in a
3561 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3562 that allow standard bfd access to the general registers (.reg) and the
3563 floating point registers (.reg2).
3568 elf_core_file_p (abfd
)
3571 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3572 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3573 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3574 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3575 unsigned int phindex
;
3576 struct elf_backend_data
*ebd
;
3578 /* Read in the ELF header in external format. */
3580 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3582 if (bfd_get_error () != bfd_error_system_call
)
3583 bfd_set_error (bfd_error_wrong_format
);
3587 /* Now check to see if we have a valid ELF file, and one that BFD can
3588 make use of. The magic number must match, the address size ('class')
3589 and byte-swapping must match our XVEC entry, and it must have a
3590 program header table (FIXME: See comments re segments at top of this
3593 if (elf_file_p (&x_ehdr
) == false)
3596 bfd_set_error (bfd_error_wrong_format
);
3600 /* FIXME, Check EI_VERSION here ! */
3604 int desired_address_size
= ELFCLASS32
;
3607 int desired_address_size
= ELFCLASS64
;
3610 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3614 /* Switch xvec to match the specified byte order. */
3615 switch (x_ehdr
.e_ident
[EI_DATA
])
3617 case ELFDATA2MSB
: /* Big-endian */
3618 if (abfd
->xvec
->byteorder_big_p
== false)
3621 case ELFDATA2LSB
: /* Little-endian */
3622 if (abfd
->xvec
->byteorder_big_p
== true)
3625 case ELFDATANONE
: /* No data encoding specified */
3626 default: /* Unknown data encoding specified */
3630 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3631 the tdata pointer in the bfd. */
3634 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3635 if (elf_tdata (abfd
) == NULL
)
3637 bfd_set_error (bfd_error_no_memory
);
3641 /* FIXME, `wrong' returns from this point onward, leak memory. */
3643 /* Now that we know the byte order, swap in the rest of the header */
3644 i_ehdrp
= elf_elfheader (abfd
);
3645 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3647 elf_debug_file (i_ehdrp
);
3650 ebd
= get_elf_backend_data (abfd
);
3652 /* Check that the ELF e_machine field matches what this particular
3653 BFD format expects. */
3654 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3656 const bfd_target
* const *target_ptr
;
3658 if (ebd
->elf_machine_code
!= EM_NONE
)
3661 /* This is the generic ELF target. Let it match any ELF target
3662 for which we do not have a specific backend. */
3663 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3665 struct elf_backend_data
*back
;
3667 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3669 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3670 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3672 /* target_ptr is an ELF backend which matches this
3673 object file, so reject the generic ELF target. */
3679 /* If there is no program header, or the type is not a core file, then
3681 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3684 /* Allocate space for a copy of the program header table in
3685 internal form, seek to the program header table in the file,
3686 read it in, and convert it to internal form. As a simple sanity
3687 check, verify that the what BFD thinks is the size of each program
3688 header table entry actually matches the size recorded in the file. */
3690 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3692 i_phdrp
= (Elf_Internal_Phdr
*)
3693 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3696 bfd_set_error (bfd_error_no_memory
);
3699 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3701 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3703 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3706 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3709 /* Once all of the program headers have been read and converted, we
3710 can start processing them. */
3712 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3714 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3715 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3717 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3722 /* Remember the entry point specified in the ELF file header. */
3724 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3729 /* ELF linker code. */
3731 static boolean elf_link_add_object_symbols
3732 PARAMS ((bfd
*, struct bfd_link_info
*));
3733 static boolean elf_link_add_archive_symbols
3734 PARAMS ((bfd
*, struct bfd_link_info
*));
3735 static Elf_Internal_Rela
*elf_link_read_relocs
3736 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3737 static boolean elf_export_symbol
3738 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3739 static boolean elf_adjust_dynamic_symbol
3740 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3742 /* Given an ELF BFD, add symbols to the global hash table as
3746 elf_bfd_link_add_symbols (abfd
, info
)
3748 struct bfd_link_info
*info
;
3752 switch (bfd_get_format (abfd
))
3755 return elf_link_add_object_symbols (abfd
, info
);
3757 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3760 if (! bfd_check_format (first
, bfd_object
))
3762 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3764 /* On Linux, we may have an a.out archive which got
3765 recognized as an ELF archive. Therefore, we treat all
3766 archives as though they were actually of the flavour of
3767 their first element. */
3768 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3770 return elf_link_add_archive_symbols (abfd
, info
);
3772 bfd_set_error (bfd_error_wrong_format
);
3777 /* Add symbols from an ELF archive file to the linker hash table. We
3778 don't use _bfd_generic_link_add_archive_symbols because of a
3779 problem which arises on UnixWare. The UnixWare libc.so is an
3780 archive which includes an entry libc.so.1 which defines a bunch of
3781 symbols. The libc.so archive also includes a number of other
3782 object files, which also define symbols, some of which are the same
3783 as those defined in libc.so.1. Correct linking requires that we
3784 consider each object file in turn, and include it if it defines any
3785 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3786 this; it looks through the list of undefined symbols, and includes
3787 any object file which defines them. When this algorithm is used on
3788 UnixWare, it winds up pulling in libc.so.1 early and defining a
3789 bunch of symbols. This means that some of the other objects in the
3790 archive are not included in the link, which is incorrect since they
3791 precede libc.so.1 in the archive.
3793 Fortunately, ELF archive handling is simpler than that done by
3794 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3795 oddities. In ELF, if we find a symbol in the archive map, and the
3796 symbol is currently undefined, we know that we must pull in that
3799 Unfortunately, we do have to make multiple passes over the symbol
3800 table until nothing further is resolved. */
3803 elf_link_add_archive_symbols (abfd
, info
)
3805 struct bfd_link_info
*info
;
3808 boolean
*defined
= NULL
;
3809 boolean
*included
= NULL
;
3813 if (! bfd_has_map (abfd
))
3815 /* An empty archive is a special case. */
3816 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3818 bfd_set_error (bfd_error_no_symbols
);
3822 /* Keep track of all symbols we know to be already defined, and all
3823 files we know to be already included. This is to speed up the
3824 second and subsequent passes. */
3825 c
= bfd_ardata (abfd
)->symdef_count
;
3828 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3829 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3830 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3832 bfd_set_error (bfd_error_no_memory
);
3835 memset (defined
, 0, c
* sizeof (boolean
));
3836 memset (included
, 0, c
* sizeof (boolean
));
3838 symdefs
= bfd_ardata (abfd
)->symdefs
;
3851 symdefend
= symdef
+ c
;
3852 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3854 struct elf_link_hash_entry
*h
;
3856 struct bfd_link_hash_entry
*undefs_tail
;
3859 if (defined
[i
] || included
[i
])
3861 if (symdef
->file_offset
== last
)
3867 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3868 false, false, false);
3869 if (h
== (struct elf_link_hash_entry
*) NULL
)
3871 if (h
->root
.type
!= bfd_link_hash_undefined
)
3877 /* We need to include this archive member. */
3879 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3880 if (element
== (bfd
*) NULL
)
3883 if (! bfd_check_format (element
, bfd_object
))
3886 /* Doublecheck that we have not included this object
3887 already--it should be impossible, but there may be
3888 something wrong with the archive. */
3889 if (element
->archive_pass
!= 0)
3891 bfd_set_error (bfd_error_bad_value
);
3894 element
->archive_pass
= 1;
3896 undefs_tail
= info
->hash
->undefs_tail
;
3898 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3901 if (! elf_link_add_object_symbols (element
, info
))
3904 /* If there are any new undefined symbols, we need to make
3905 another pass through the archive in order to see whether
3906 they can be defined. FIXME: This isn't perfect, because
3907 common symbols wind up on undefs_tail and because an
3908 undefined symbol which is defined later on in this pass
3909 does not require another pass. This isn't a bug, but it
3910 does make the code less efficient than it could be. */
3911 if (undefs_tail
!= info
->hash
->undefs_tail
)
3914 /* Look backward to mark all symbols from this object file
3915 which we have already seen in this pass. */
3919 included
[mark
] = true;
3924 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3926 /* We mark subsequent symbols from this object file as we go
3927 on through the loop. */
3928 last
= symdef
->file_offset
;
3939 if (defined
!= (boolean
*) NULL
)
3941 if (included
!= (boolean
*) NULL
)
3946 /* Record a new dynamic symbol. We record the dynamic symbols as we
3947 read the input files, since we need to have a list of all of them
3948 before we can determine the final sizes of the output sections.
3949 Note that we may actually call this function even though we are not
3950 going to output any dynamic symbols; in some cases we know that a
3951 symbol should be in the dynamic symbol table, but only if there is
3955 elf_link_record_dynamic_symbol (info
, h
)
3956 struct bfd_link_info
*info
;
3957 struct elf_link_hash_entry
*h
;
3959 if (h
->dynindx
== -1)
3961 struct bfd_strtab_hash
*dynstr
;
3963 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3964 ++elf_hash_table (info
)->dynsymcount
;
3966 dynstr
= elf_hash_table (info
)->dynstr
;
3969 /* Create a strtab to hold the dynamic symbol names. */
3970 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3975 h
->dynstr_index
= ((unsigned long)
3976 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3978 if (h
->dynstr_index
== (unsigned long) -1)
3985 /* Add symbols from an ELF object file to the linker hash table. */
3988 elf_link_add_object_symbols (abfd
, info
)
3990 struct bfd_link_info
*info
;
3992 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3993 const Elf_Internal_Sym
*,
3994 const char **, flagword
*,
3995 asection
**, bfd_vma
*));
3996 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3997 asection
*, const Elf_Internal_Rela
*));
3999 Elf_Internal_Shdr
*hdr
;
4003 Elf_External_Sym
*buf
= NULL
;
4004 struct elf_link_hash_entry
**sym_hash
;
4006 Elf_External_Dyn
*dynbuf
= NULL
;
4007 struct elf_link_hash_entry
*weaks
;
4008 Elf_External_Sym
*esym
;
4009 Elf_External_Sym
*esymend
;
4011 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4012 collect
= get_elf_backend_data (abfd
)->collect
;
4014 /* A stripped shared library might only have a dynamic symbol table,
4015 not a regular symbol table. In that case we can still go ahead
4016 and link using the dynamic symbol table. */
4017 if (elf_onesymtab (abfd
) == 0
4018 && elf_dynsymtab (abfd
) != 0)
4020 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4021 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4024 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4025 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4027 /* The sh_info field of the symtab header tells us where the
4028 external symbols start. We don't care about the local symbols at
4030 if (elf_bad_symtab (abfd
))
4032 extsymcount
= symcount
;
4037 extsymcount
= symcount
- hdr
->sh_info
;
4038 extsymoff
= hdr
->sh_info
;
4041 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4042 if (buf
== NULL
&& extsymcount
!= 0)
4044 bfd_set_error (bfd_error_no_memory
);
4048 /* We store a pointer to the hash table entry for each external
4050 sym_hash
= ((struct elf_link_hash_entry
**)
4052 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4053 if (sym_hash
== NULL
)
4055 bfd_set_error (bfd_error_no_memory
);
4058 elf_sym_hashes (abfd
) = sym_hash
;
4060 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4064 /* If we are creating a shared library, create all the dynamic
4065 sections immediately. We need to attach them to something,
4066 so we attach them to this BFD, provided it is the right
4067 format. FIXME: If there are no input BFD's of the same
4068 format as the output, we can't make a shared library. */
4070 && ! elf_hash_table (info
)->dynamic_sections_created
4071 && abfd
->xvec
== info
->hash
->creator
)
4073 if (! elf_link_create_dynamic_sections (abfd
, info
))
4081 bfd_size_type strindex
;
4085 /* You can't use -r against a dynamic object. Also, there's no
4086 hope of using a dynamic object which does not exactly match
4087 the format of the output file. */
4088 if (info
->relocateable
4089 || info
->hash
->creator
!= abfd
->xvec
)
4091 bfd_set_error (bfd_error_invalid_operation
);
4095 /* Find the name to use in a DT_NEEDED entry that refers to this
4096 object. If the object has a DT_SONAME entry, we use it.
4097 Otherwise, if the generic linker stuck something in
4098 elf_dt_needed_name, we use that. Otherwise, we just use the
4100 name
= bfd_get_filename (abfd
);
4101 if (elf_dt_needed_name (abfd
) != NULL
)
4102 name
= elf_dt_needed_name (abfd
);
4103 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4106 Elf_External_Dyn
*extdyn
;
4107 Elf_External_Dyn
*extdynend
;
4109 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4112 bfd_set_error (bfd_error_no_memory
);
4116 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4117 (file_ptr
) 0, s
->_raw_size
))
4121 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4122 for (; extdyn
< extdynend
; extdyn
++)
4124 Elf_Internal_Dyn dyn
;
4126 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4127 if (dyn
.d_tag
== DT_SONAME
)
4132 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4135 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4136 name
= elf_string_from_elf_section (abfd
, link
,
4149 /* We do not want to include any of the sections in a dynamic
4150 object in the output file. We hack by simply clobbering the
4151 list of sections in the BFD. This could be handled more
4152 cleanly by, say, a new section flag; the existing
4153 SEC_NEVER_LOAD flag is not the one we want, because that one
4154 still implies that the section takes up space in the output
4156 abfd
->sections
= NULL
;
4158 /* If this is the first dynamic object found in the link, create
4159 the special sections required for dynamic linking. */
4160 if (! elf_hash_table (info
)->dynamic_sections_created
)
4162 if (! elf_link_create_dynamic_sections (abfd
, info
))
4166 /* Add a DT_NEEDED entry for this dynamic object. */
4167 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4169 if (strindex
== (bfd_size_type
) -1)
4171 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4176 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4178 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4179 != extsymcount
* sizeof (Elf_External_Sym
)))
4184 esymend
= buf
+ extsymcount
;
4185 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4187 Elf_Internal_Sym sym
;
4193 struct elf_link_hash_entry
*h
= NULL
;
4196 elf_swap_symbol_in (abfd
, esym
, &sym
);
4198 flags
= BSF_NO_FLAGS
;
4200 value
= sym
.st_value
;
4203 bind
= ELF_ST_BIND (sym
.st_info
);
4204 if (bind
== STB_LOCAL
)
4206 /* This should be impossible, since ELF requires that all
4207 global symbols follow all local symbols, and that sh_info
4208 point to the first global symbol. Unfortunatealy, Irix 5
4212 else if (bind
== STB_GLOBAL
)
4214 if (sym
.st_shndx
!= SHN_UNDEF
4215 && sym
.st_shndx
!= SHN_COMMON
)
4220 else if (bind
== STB_WEAK
)
4224 /* Leave it up to the processor backend. */
4227 if (sym
.st_shndx
== SHN_UNDEF
)
4228 sec
= bfd_und_section_ptr
;
4229 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4231 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4235 sec
= bfd_abs_section_ptr
;
4237 else if (sym
.st_shndx
== SHN_ABS
)
4238 sec
= bfd_abs_section_ptr
;
4239 else if (sym
.st_shndx
== SHN_COMMON
)
4241 sec
= bfd_com_section_ptr
;
4242 /* What ELF calls the size we call the value. What ELF
4243 calls the value we call the alignment. */
4244 value
= sym
.st_size
;
4248 /* Leave it up to the processor backend. */
4251 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4252 if (name
== (const char *) NULL
)
4255 if (add_symbol_hook
)
4257 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4261 /* The hook function sets the name to NULL if this symbol
4262 should be skipped for some reason. */
4263 if (name
== (const char *) NULL
)
4267 /* Sanity check that all possibilities were handled. */
4268 if (sec
== (asection
*) NULL
)
4270 bfd_set_error (bfd_error_bad_value
);
4274 if (bfd_is_und_section (sec
)
4275 || bfd_is_com_section (sec
))
4280 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4282 /* We need to look up the symbol now in order to get some of
4283 the dynamic object handling right. We pass the hash
4284 table entry in to _bfd_generic_link_add_one_symbol so
4285 that it does not have to look it up again. */
4286 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4287 true, false, false);
4292 /* If we are looking at a dynamic object, and this is a
4293 definition, we need to see if it has already been defined
4294 by some other object. If it has, we want to use the
4295 existing definition, and we do not want to report a
4296 multiple symbol definition error; we do this by
4297 clobbering sec to be bfd_und_section_ptr. */
4298 if (dynamic
&& definition
)
4300 if (h
->root
.type
== bfd_link_hash_defined
)
4301 sec
= bfd_und_section_ptr
;
4304 /* Similarly, if we are not looking at a dynamic object, and
4305 we have a definition, we want to override any definition
4306 we may have from a dynamic object. Symbols from regular
4307 files always take precedence over symbols from dynamic
4308 objects, even if they are defined after the dynamic
4309 object in the link. */
4312 && h
->root
.type
== bfd_link_hash_defined
4313 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4314 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4315 == bfd_target_elf_flavour
)
4316 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4319 /* Change the hash table entry to undefined, and let
4320 _bfd_generic_link_add_one_symbol do the right thing
4321 with the new definition. */
4322 h
->root
.type
= bfd_link_hash_undefined
;
4323 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4324 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4327 /* If this is a weak definition which we are going to use,
4328 and the symbol is currently undefined, record that the
4329 definition is weak. */
4331 && (flags
& BSF_WEAK
) != 0
4332 && ! bfd_is_und_section (sec
)
4333 && (h
->root
.type
== bfd_link_hash_new
4334 || h
->root
.type
== bfd_link_hash_undefined
4335 || h
->root
.type
== bfd_link_hash_weak
))
4336 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4339 if (! (_bfd_generic_link_add_one_symbol
4340 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4341 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4346 && (flags
& BSF_WEAK
) != 0
4347 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4348 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4349 && (*sym_hash
)->weakdef
== NULL
)
4351 /* Keep a list of all weak defined non function symbols from
4352 a dynamic object, using the weakdef field. Later in this
4353 function we will set the weakdef field to the correct
4354 value. We only put non-function symbols from dynamic
4355 objects on this list, because that happens to be the only
4356 time we need to know the normal symbol corresponding to a
4357 weak symbol, and the information is time consuming to
4358 figure out. If the weakdef field is not already NULL,
4359 then this symbol was already defined by some previous
4360 dynamic object, and we will be using that previous
4361 definition anyhow. */
4363 (*sym_hash
)->weakdef
= weaks
;
4367 /* Get the alignment of a common symbol. */
4368 if (sym
.st_shndx
== SHN_COMMON
4369 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4370 (*sym_hash
)->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4372 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4378 /* Remember the symbol size and type. */
4379 if (sym
.st_size
!= 0)
4381 /* FIXME: We should probably somehow give a warning if
4382 the symbol size changes. */
4383 h
->size
= sym
.st_size
;
4385 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4387 /* FIXME: We should probably somehow give a warning if
4388 the symbol type changes. */
4389 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4392 /* Set a flag in the hash table entry indicating the type of
4393 reference or definition we just found. Keep a count of
4394 the number of dynamic symbols we find. A dynamic symbol
4395 is one which is referenced or defined by both a regular
4396 object and a shared object, or one which is referenced or
4397 defined by more than one shared object. */
4398 old_flags
= h
->elf_link_hash_flags
;
4403 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4405 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4407 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4408 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4414 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4416 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4417 if ((old_flags
& new_flag
) != 0
4418 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4419 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4423 h
->elf_link_hash_flags
|= new_flag
;
4424 if (dynsym
&& h
->dynindx
== -1)
4426 if (! elf_link_record_dynamic_symbol (info
, h
))
4432 /* Now set the weakdefs field correctly for all the weak defined
4433 symbols we found. The only way to do this is to search all the
4434 symbols. Since we only need the information for non functions in
4435 dynamic objects, that's the only time we actually put anything on
4436 the list WEAKS. We need this information so that if a regular
4437 object refers to a symbol defined weakly in a dynamic object, the
4438 real symbol in the dynamic object is also put in the dynamic
4439 symbols; we also must arrange for both symbols to point to the
4440 same memory location. We could handle the general case of symbol
4441 aliasing, but a general symbol alias can only be generated in
4442 assembler code, handling it correctly would be very time
4443 consuming, and other ELF linkers don't handle general aliasing
4445 while (weaks
!= NULL
)
4447 struct elf_link_hash_entry
*hlook
;
4450 struct elf_link_hash_entry
**hpp
;
4451 struct elf_link_hash_entry
**hppend
;
4454 weaks
= hlook
->weakdef
;
4455 hlook
->weakdef
= NULL
;
4457 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4458 slook
= hlook
->root
.u
.def
.section
;
4459 vlook
= hlook
->root
.u
.def
.value
;
4461 hpp
= elf_sym_hashes (abfd
);
4462 hppend
= hpp
+ extsymcount
;
4463 for (; hpp
< hppend
; hpp
++)
4465 struct elf_link_hash_entry
*h
;
4469 && h
->root
.type
== bfd_link_hash_defined
4470 && h
->root
.u
.def
.section
== slook
4471 && h
->root
.u
.def
.value
== vlook
)
4475 /* If the weak definition is in the list of dynamic
4476 symbols, make sure the real definition is put there
4478 if (hlook
->dynindx
!= -1
4479 && h
->dynindx
== -1)
4481 if (! elf_link_record_dynamic_symbol (info
, h
))
4496 /* If this object is the same format as the output object, and it is
4497 not a shared library, then let the backend look through the
4500 This is required to build global offset table entries and to
4501 arrange for dynamic relocs. It is not required for the
4502 particular common case of linking non PIC code, even when linking
4503 against shared libraries, but unfortunately there is no way of
4504 knowing whether an object file has been compiled PIC or not.
4505 Looking through the relocs is not particularly time consuming.
4506 The problem is that we must either (1) keep the relocs in memory,
4507 which causes the linker to require additional runtime memory or
4508 (2) read the relocs twice from the input file, which wastes time.
4509 This would be a good case for using mmap.
4511 I have no idea how to handle linking PIC code into a file of a
4512 different format. It probably can't be done. */
4513 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4515 && abfd
->xvec
== info
->hash
->creator
4516 && check_relocs
!= NULL
)
4520 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4522 Elf_Internal_Rela
*internal_relocs
;
4525 if ((o
->flags
& SEC_RELOC
) == 0
4526 || o
->reloc_count
== 0)
4529 /* I believe we can ignore the relocs for any section which
4530 does not form part of the final process image, such as a
4531 debugging section. */
4532 if ((o
->flags
& SEC_ALLOC
) == 0)
4535 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4536 (Elf_Internal_Rela
*) NULL
,
4538 if (internal_relocs
== NULL
)
4541 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4543 if (! info
->keep_memory
)
4544 free (internal_relocs
);
4561 /* Create some sections which will be filled in with dynamic linking
4562 information. ABFD is an input file which requires dynamic sections
4563 to be created. The dynamic sections take up virtual memory space
4564 when the final executable is run, so we need to create them before
4565 addresses are assigned to the output sections. We work out the
4566 actual contents and size of these sections later. */
4569 elf_link_create_dynamic_sections (abfd
, info
)
4571 struct bfd_link_info
*info
;
4574 register asection
*s
;
4575 struct elf_link_hash_entry
*h
;
4576 struct elf_backend_data
*bed
;
4578 if (elf_hash_table (info
)->dynamic_sections_created
)
4581 /* Make sure that all dynamic sections use the same input BFD. */
4582 if (elf_hash_table (info
)->dynobj
== NULL
)
4583 elf_hash_table (info
)->dynobj
= abfd
;
4585 abfd
= elf_hash_table (info
)->dynobj
;
4587 /* Note that we set the SEC_IN_MEMORY flag for all of these
4589 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4591 /* A dynamically linked executable has a .interp section, but a
4592 shared library does not. */
4595 s
= bfd_make_section (abfd
, ".interp");
4597 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4601 s
= bfd_make_section (abfd
, ".dynsym");
4603 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4604 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4607 s
= bfd_make_section (abfd
, ".dynstr");
4609 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4612 /* Create a strtab to hold the dynamic symbol names. */
4613 if (elf_hash_table (info
)->dynstr
== NULL
)
4615 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4616 if (elf_hash_table (info
)->dynstr
== NULL
)
4620 s
= bfd_make_section (abfd
, ".dynamic");
4622 || ! bfd_set_section_flags (abfd
, s
, flags
)
4623 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4626 /* The special symbol _DYNAMIC is always set to the start of the
4627 .dynamic section. This call occurs before we have processed the
4628 symbols for any dynamic object, so we don't have to worry about
4629 overriding a dynamic definition. We could set _DYNAMIC in a
4630 linker script, but we only want to define it if we are, in fact,
4631 creating a .dynamic section. We don't want to define it if there
4632 is no .dynamic section, since on some ELF platforms the start up
4633 code examines it to decide how to initialize the process. */
4635 if (! (_bfd_generic_link_add_one_symbol
4636 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4637 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4638 (struct bfd_link_hash_entry
**) &h
)))
4640 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4641 h
->type
= STT_OBJECT
;
4644 && ! elf_link_record_dynamic_symbol (info
, h
))
4647 s
= bfd_make_section (abfd
, ".hash");
4649 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4650 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4653 /* Let the backend create the rest of the sections. This lets the
4654 backend set the right flags. The backend will normally create
4655 the .got and .plt sections. */
4656 bed
= get_elf_backend_data (abfd
);
4657 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4660 elf_hash_table (info
)->dynamic_sections_created
= true;
4665 /* Add an entry to the .dynamic table. */
4668 elf_add_dynamic_entry (info
, tag
, val
)
4669 struct bfd_link_info
*info
;
4673 Elf_Internal_Dyn dyn
;
4677 bfd_byte
*newcontents
;
4679 dynobj
= elf_hash_table (info
)->dynobj
;
4681 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4682 BFD_ASSERT (s
!= NULL
);
4684 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4685 if (s
->contents
== NULL
)
4686 newcontents
= (bfd_byte
*) malloc (newsize
);
4688 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4689 if (newcontents
== NULL
)
4691 bfd_set_error (bfd_error_no_memory
);
4696 dyn
.d_un
.d_val
= val
;
4697 elf_swap_dyn_out (dynobj
, &dyn
,
4698 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4700 s
->_raw_size
= newsize
;
4701 s
->contents
= newcontents
;
4706 /* Read and swap the relocs for a section. They may have been cached.
4707 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4708 they are used as buffers to read into. They are known to be large
4709 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4710 value is allocated using either malloc or bfd_alloc, according to
4711 the KEEP_MEMORY argument. */
4713 static Elf_Internal_Rela
*
4714 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4717 PTR external_relocs
;
4718 Elf_Internal_Rela
*internal_relocs
;
4719 boolean keep_memory
;
4721 Elf_Internal_Shdr
*rel_hdr
;
4723 Elf_Internal_Rela
*alloc2
= NULL
;
4725 if (elf_section_data (o
)->relocs
!= NULL
)
4726 return elf_section_data (o
)->relocs
;
4728 if (o
->reloc_count
== 0)
4731 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4733 if (internal_relocs
== NULL
)
4737 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4739 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4741 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4742 if (internal_relocs
== NULL
)
4744 bfd_set_error (bfd_error_no_memory
);
4749 if (external_relocs
== NULL
)
4751 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4754 bfd_set_error (bfd_error_no_memory
);
4757 external_relocs
= alloc1
;
4760 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4761 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4762 != rel_hdr
->sh_size
))
4765 /* Swap in the relocs. For convenience, we always produce an
4766 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4768 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4770 Elf_External_Rel
*erel
;
4771 Elf_External_Rel
*erelend
;
4772 Elf_Internal_Rela
*irela
;
4774 erel
= (Elf_External_Rel
*) external_relocs
;
4775 erelend
= erel
+ o
->reloc_count
;
4776 irela
= internal_relocs
;
4777 for (; erel
< erelend
; erel
++, irela
++)
4779 Elf_Internal_Rel irel
;
4781 elf_swap_reloc_in (abfd
, erel
, &irel
);
4782 irela
->r_offset
= irel
.r_offset
;
4783 irela
->r_info
= irel
.r_info
;
4784 irela
->r_addend
= 0;
4789 Elf_External_Rela
*erela
;
4790 Elf_External_Rela
*erelaend
;
4791 Elf_Internal_Rela
*irela
;
4793 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4795 erela
= (Elf_External_Rela
*) external_relocs
;
4796 erelaend
= erela
+ o
->reloc_count
;
4797 irela
= internal_relocs
;
4798 for (; erela
< erelaend
; erela
++, irela
++)
4799 elf_swap_reloca_in (abfd
, erela
, irela
);
4802 /* Cache the results for next time, if we can. */
4804 elf_section_data (o
)->relocs
= internal_relocs
;
4809 /* Don't free alloc2, since if it was allocated we are passing it
4810 back (under the name of internal_relocs). */
4812 return internal_relocs
;
4822 /* Record an assignment to a symbol made by a linker script. We need
4823 this in case some dynamic object refers to this symbol. */
4827 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4829 struct bfd_link_info
*info
;
4832 struct elf_link_hash_entry
*h
;
4834 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4837 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4841 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4842 h
->type
= STT_OBJECT
;
4844 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4845 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4847 && h
->dynindx
== -1)
4849 if (! elf_link_record_dynamic_symbol (info
, h
))
4852 /* If this is a weak defined symbol, and we know a corresponding
4853 real symbol from the same dynamic object, make sure the real
4854 symbol is also made into a dynamic symbol. */
4855 if (h
->weakdef
!= NULL
4856 && h
->weakdef
->dynindx
== -1)
4858 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4866 /* Array used to determine the number of hash table buckets to use
4867 based on the number of symbols there are. If there are fewer than
4868 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4869 fewer than 37 we use 17 buckets, and so forth. We never use more
4870 than 521 buckets. */
4872 static const size_t elf_buckets
[] =
4874 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4877 /* Set up the sizes and contents of the ELF dynamic sections. This is
4878 called by the ELF linker emulation before_allocation routine. We
4879 must set the sizes of the sections before the linker sets the
4880 addresses of the various sections. */
4883 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4884 export_dynamic
, info
, sinterpptr
)
4888 boolean export_dynamic
;
4889 struct bfd_link_info
*info
;
4890 asection
**sinterpptr
;
4894 Elf_Internal_Sym isym
;
4897 struct elf_backend_data
*bed
;
4901 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4904 dynobj
= elf_hash_table (info
)->dynobj
;
4906 /* If there were no dynamic objects in the link, there is nothing to
4911 /* If we are supposed to export all symbols into the dynamic symbol
4912 table (this is not the normal case), then do so. */
4914 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4917 if (elf_hash_table (info
)->dynamic_sections_created
)
4919 bfd_size_type strsize
;
4921 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4922 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4928 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4930 if (indx
== (bfd_size_type
) -1
4931 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4939 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4941 if (indx
== (bfd_size_type
) -1
4942 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4946 /* Find all symbols which were defined in a dynamic object and make
4947 the backend pick a reasonable value for them. */
4948 elf_link_hash_traverse (elf_hash_table (info
),
4949 elf_adjust_dynamic_symbol
,
4952 /* Add some entries to the .dynamic section. We fill in some of the
4953 values later, in elf_bfd_final_link, but we must add the entries
4954 now so that we know the final size of the .dynamic section. */
4955 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4956 false, false) != NULL
)
4958 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4961 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4962 false, false) != NULL
)
4964 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4967 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4968 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4969 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4970 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4971 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4972 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4973 sizeof (Elf_External_Sym
)))
4977 /* The backend must work out the sizes of all the other dynamic
4979 bed
= get_elf_backend_data (output_bfd
);
4980 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4983 if (elf_hash_table (info
)->dynamic_sections_created
)
4987 /* Set the size of the .dynsym and .hash sections. We counted
4988 the number of dynamic symbols in elf_link_add_object_symbols.
4989 We will build the contents of .dynsym and .hash when we build
4990 the final symbol table, because until then we do not know the
4991 correct value to give the symbols. We built the .dynstr
4992 section as we went along in elf_link_add_object_symbols. */
4993 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4994 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4995 BFD_ASSERT (s
!= NULL
);
4996 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4997 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4998 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5000 bfd_set_error (bfd_error_no_memory
);
5004 /* The first entry in .dynsym is a dummy symbol. */
5011 elf_swap_symbol_out (output_bfd
, &isym
,
5012 (Elf_External_Sym
*) s
->contents
);
5014 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5016 bucketcount
= elf_buckets
[i
];
5017 if (dynsymcount
< elf_buckets
[i
+ 1])
5021 s
= bfd_get_section_by_name (dynobj
, ".hash");
5022 BFD_ASSERT (s
!= NULL
);
5023 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5024 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5025 if (s
->contents
== NULL
)
5027 bfd_set_error (bfd_error_no_memory
);
5030 memset (s
->contents
, 0, s
->_raw_size
);
5032 put_word (output_bfd
, bucketcount
, s
->contents
);
5033 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5035 elf_hash_table (info
)->bucketcount
= bucketcount
;
5037 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5038 BFD_ASSERT (s
!= NULL
);
5039 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5041 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5048 /* This routine is used to export all defined symbols into the dynamic
5049 symbol table. It is called via elf_link_hash_traverse. */
5052 elf_export_symbol (h
, data
)
5053 struct elf_link_hash_entry
*h
;
5056 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5058 if (h
->dynindx
== -1
5059 && (h
->elf_link_hash_flags
5060 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5062 if (! elf_link_record_dynamic_symbol (info
, h
))
5064 /* FIXME: No way to report error. */
5072 /* Make the backend pick a good value for a dynamic symbol. This is
5073 called via elf_link_hash_traverse, and also calls itself
5077 elf_adjust_dynamic_symbol (h
, data
)
5078 struct elf_link_hash_entry
*h
;
5081 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5083 struct elf_backend_data
*bed
;
5085 /* If this symbol does not require a PLT entry, and it is not
5086 defined by a dynamic object, or is not referenced by a regular
5087 object, ignore it. FIXME: Do we need to worry about symbols
5088 which are defined by one dynamic object and referenced by another
5090 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5091 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5092 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5093 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5096 /* If we've already adjusted this symbol, don't do it again. This
5097 can happen via a recursive call. */
5098 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5101 /* Don't look at this symbol again. Note that we must set this
5102 after checking the above conditions, because we may look at a
5103 symbol once, decide not to do anything, and then get called
5104 recursively later after REF_REGULAR is set below. */
5105 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5107 /* If this is a weak definition, and we know a real definition, and
5108 the real symbol is not itself defined by a regular object file,
5109 then get a good value for the real definition. We handle the
5110 real symbol first, for the convenience of the backend routine.
5112 Note that there is a confusing case here. If the real definition
5113 is defined by a regular object file, we don't get the real symbol
5114 from the dynamic object, but we do get the weak symbol. If the
5115 processor backend uses a COPY reloc, then if some routine in the
5116 dynamic object changes the real symbol, we will not see that
5117 change in the corresponding weak symbol. This is the way other
5118 ELF linkers work as well, and seems to be a result of the shared
5121 I will clarify this issue. Most SVR4 shared libraries define the
5122 variable _timezone and define timezone as a weak synonym. The
5123 tzset call changes _timezone. If you write
5124 extern int timezone;
5126 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5127 you might expect that, since timezone is a synonym for _timezone,
5128 the same number will print both times. However, if the processor
5129 backend uses a COPY reloc, then actually timezone will be copied
5130 into your process image, and, since you define _timezone
5131 yourself, _timezone will not. Thus timezone and _timezone will
5132 wind up at different memory locations. The tzset call will set
5133 _timezone, leaving timezone unchanged. */
5135 if (h
->weakdef
!= NULL
)
5137 struct elf_link_hash_entry
*weakdef
;
5139 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5140 weakdef
= h
->weakdef
;
5141 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5142 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5143 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5145 /* This symbol is defined by a regular object file, so we
5146 will not do anything special. Clear weakdef for the
5147 convenience of the processor backend. */
5152 /* There is an implicit reference by a regular object file
5153 via the weak symbol. */
5154 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5155 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5160 dynobj
= elf_hash_table (info
)->dynobj
;
5161 bed
= get_elf_backend_data (dynobj
);
5162 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5164 /* FIXME: No way to return error. */
5171 /* Final phase of ELF linker. */
5173 /* A structure we use to avoid passing large numbers of arguments. */
5175 struct elf_final_link_info
5177 /* General link information. */
5178 struct bfd_link_info
*info
;
5181 /* Symbol string table. */
5182 struct bfd_strtab_hash
*symstrtab
;
5183 /* .dynsym section. */
5184 asection
*dynsym_sec
;
5185 /* .hash section. */
5187 /* Buffer large enough to hold contents of any section. */
5189 /* Buffer large enough to hold external relocs of any section. */
5190 PTR external_relocs
;
5191 /* Buffer large enough to hold internal relocs of any section. */
5192 Elf_Internal_Rela
*internal_relocs
;
5193 /* Buffer large enough to hold external local symbols of any input
5195 Elf_External_Sym
*external_syms
;
5196 /* Buffer large enough to hold internal local symbols of any input
5198 Elf_Internal_Sym
*internal_syms
;
5199 /* Array large enough to hold a symbol index for each local symbol
5200 of any input BFD. */
5202 /* Array large enough to hold a section pointer for each local
5203 symbol of any input BFD. */
5204 asection
**sections
;
5205 /* Buffer to hold swapped out symbols. */
5206 Elf_External_Sym
*symbuf
;
5207 /* Number of swapped out symbols in buffer. */
5208 size_t symbuf_count
;
5209 /* Number of symbols which fit in symbuf. */
5213 static boolean elf_link_output_sym
5214 PARAMS ((struct elf_final_link_info
*, const char *,
5215 Elf_Internal_Sym
*, asection
*));
5216 static boolean elf_link_flush_output_syms
5217 PARAMS ((struct elf_final_link_info
*));
5218 static boolean elf_link_output_extsym
5219 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5220 static boolean elf_link_input_bfd
5221 PARAMS ((struct elf_final_link_info
*, bfd
*));
5222 static boolean elf_reloc_link_order
5223 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5224 struct bfd_link_order
*));
5226 /* Do the final step of an ELF link. */
5229 elf_bfd_final_link (abfd
, info
)
5231 struct bfd_link_info
*info
;
5235 struct elf_final_link_info finfo
;
5236 register asection
*o
;
5237 register struct bfd_link_order
*p
;
5239 size_t max_contents_size
;
5240 size_t max_external_reloc_size
;
5241 size_t max_internal_reloc_count
;
5242 size_t max_sym_count
;
5244 Elf_Internal_Sym elfsym
;
5246 Elf_Internal_Shdr
*symtab_hdr
;
5247 Elf_Internal_Shdr
*symstrtab_hdr
;
5248 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5251 abfd
->flags
|= DYNAMIC
;
5253 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5254 dynobj
= elf_hash_table (info
)->dynobj
;
5257 finfo
.output_bfd
= abfd
;
5258 finfo
.symstrtab
= elf_stringtab_init ();
5259 if (finfo
.symstrtab
== NULL
)
5263 finfo
.dynsym_sec
= NULL
;
5264 finfo
.hash_sec
= NULL
;
5268 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5269 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5270 if (finfo
.dynsym_sec
== NULL
5271 || finfo
.hash_sec
== NULL
)
5274 finfo
.contents
= NULL
;
5275 finfo
.external_relocs
= NULL
;
5276 finfo
.internal_relocs
= NULL
;
5277 finfo
.external_syms
= NULL
;
5278 finfo
.internal_syms
= NULL
;
5279 finfo
.indices
= NULL
;
5280 finfo
.sections
= NULL
;
5281 finfo
.symbuf
= NULL
;
5282 finfo
.symbuf_count
= 0;
5284 /* Count up the number of relocations we will output for each output
5285 section, so that we know the sizes of the reloc sections. We
5286 also figure out some maximum sizes. */
5287 max_contents_size
= 0;
5288 max_external_reloc_size
= 0;
5289 max_internal_reloc_count
= 0;
5291 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5295 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5297 if (p
->type
== bfd_section_reloc_link_order
5298 || p
->type
== bfd_symbol_reloc_link_order
)
5300 else if (p
->type
== bfd_indirect_link_order
)
5304 sec
= p
->u
.indirect
.section
;
5306 if (info
->relocateable
)
5307 o
->reloc_count
+= sec
->reloc_count
;
5309 if (sec
->_raw_size
> max_contents_size
)
5310 max_contents_size
= sec
->_raw_size
;
5311 if (sec
->_cooked_size
> max_contents_size
)
5312 max_contents_size
= sec
->_cooked_size
;
5314 /* We are interested in just local symbols, not all
5316 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5320 if (elf_bad_symtab (sec
->owner
))
5321 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5322 / sizeof (Elf_External_Sym
));
5324 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5326 if (sym_count
> max_sym_count
)
5327 max_sym_count
= sym_count
;
5329 if ((sec
->flags
& SEC_RELOC
) != 0)
5333 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5334 if (ext_size
> max_external_reloc_size
)
5335 max_external_reloc_size
= ext_size
;
5336 if (sec
->reloc_count
> max_internal_reloc_count
)
5337 max_internal_reloc_count
= sec
->reloc_count
;
5343 if (o
->reloc_count
> 0)
5344 o
->flags
|= SEC_RELOC
;
5347 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5348 set it (this is probably a bug) and if it is set
5349 assign_section_numbers will create a reloc section. */
5350 o
->flags
&=~ SEC_RELOC
;
5353 /* If the SEC_ALLOC flag is not set, force the section VMA to
5354 zero. This is done in elf_fake_sections as well, but forcing
5355 the VMA to 0 here will ensure that relocs against these
5356 sections are handled correctly. */
5357 if ((o
->flags
& SEC_ALLOC
) == 0)
5361 /* Figure out the file positions for everything but the symbol table
5362 and the relocs. We set symcount to force assign_section_numbers
5363 to create a symbol table. */
5364 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5365 BFD_ASSERT (! abfd
->output_has_begun
);
5366 if (! elf_compute_section_file_positions (abfd
, info
))
5369 /* That created the reloc sections. Set their sizes, and assign
5370 them file positions, and allocate some buffers. */
5371 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5373 if ((o
->flags
& SEC_RELOC
) != 0)
5375 Elf_Internal_Shdr
*rel_hdr
;
5376 register struct elf_link_hash_entry
**p
, **pend
;
5378 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5380 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5382 /* The contents field must last into write_object_contents,
5383 so we allocate it with bfd_alloc rather than malloc. */
5384 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5385 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5387 bfd_set_error (bfd_error_no_memory
);
5391 p
= ((struct elf_link_hash_entry
**)
5392 malloc (o
->reloc_count
5393 * sizeof (struct elf_link_hash_entry
*)));
5394 if (p
== NULL
&& o
->reloc_count
!= 0)
5396 bfd_set_error (bfd_error_no_memory
);
5399 elf_section_data (o
)->rel_hashes
= p
;
5400 pend
= p
+ o
->reloc_count
;
5401 for (; p
< pend
; p
++)
5404 /* Use the reloc_count field as an index when outputting the
5410 assign_file_positions_for_relocs (abfd
);
5412 /* We have now assigned file positions for all the sections except
5413 .symtab and .strtab. We start the .symtab section at the current
5414 file position, and write directly to it. We build the .strtab
5415 section in memory. When we add .dynsym support, we will build
5416 that in memory as well (.dynsym is smaller than .symtab). */
5418 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5419 /* sh_name is set in prep_headers. */
5420 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5421 symtab_hdr
->sh_flags
= 0;
5422 symtab_hdr
->sh_addr
= 0;
5423 symtab_hdr
->sh_size
= 0;
5424 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5425 /* sh_link is set in assign_section_numbers. */
5426 /* sh_info is set below. */
5427 /* sh_offset is set just below. */
5428 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5430 off
= elf_tdata (abfd
)->next_file_pos
;
5431 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5433 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5434 incorrect. We do not yet know the size of the .symtab section.
5435 We correct next_file_pos below, after we do know the size. */
5437 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5438 continuously seeking to the right position in the file. */
5439 if (! info
->keep_memory
|| max_sym_count
< 20)
5440 finfo
.symbuf_size
= 20;
5442 finfo
.symbuf_size
= max_sym_count
;
5443 finfo
.symbuf
= ((Elf_External_Sym
*)
5444 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5445 if (finfo
.symbuf
== NULL
)
5447 bfd_set_error (bfd_error_no_memory
);
5451 /* Start writing out the symbol table. The first symbol is always a
5453 elfsym
.st_value
= 0;
5456 elfsym
.st_other
= 0;
5457 elfsym
.st_shndx
= SHN_UNDEF
;
5458 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5459 &elfsym
, bfd_und_section_ptr
))
5463 /* Some standard ELF linkers do this, but we don't because it causes
5464 bootstrap comparison failures. */
5465 /* Output a file symbol for the output file as the second symbol.
5466 We output this even if we are discarding local symbols, although
5467 I'm not sure if this is correct. */
5468 elfsym
.st_value
= 0;
5470 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5471 elfsym
.st_other
= 0;
5472 elfsym
.st_shndx
= SHN_ABS
;
5473 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5474 &elfsym
, bfd_abs_section_ptr
))
5478 /* Output a symbol for each section. We output these even if we are
5479 discarding local symbols, since they are used for relocs. These
5480 symbols have no names. We store the index of each one in the
5481 index field of the section, so that we can find it again when
5482 outputting relocs. */
5483 elfsym
.st_value
= 0;
5485 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5486 elfsym
.st_other
= 0;
5487 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5489 o
= section_from_elf_index (abfd
, i
);
5491 o
->target_index
= abfd
->symcount
;
5492 elfsym
.st_shndx
= i
;
5493 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5498 /* Allocate some memory to hold information read in from the input
5500 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5501 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5502 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5503 malloc (max_internal_reloc_count
5504 * sizeof (Elf_Internal_Rela
)));
5505 finfo
.external_syms
= ((Elf_External_Sym
*)
5506 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5507 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5508 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5509 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5510 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5511 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5512 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5513 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5514 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5515 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5516 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5517 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5519 bfd_set_error (bfd_error_no_memory
);
5523 /* Since ELF permits relocations to be against local symbols, we
5524 must have the local symbols available when we do the relocations.
5525 Since we would rather only read the local symbols once, and we
5526 would rather not keep them in memory, we handle all the
5527 relocations for a single input file at the same time.
5529 Unfortunately, there is no way to know the total number of local
5530 symbols until we have seen all of them, and the local symbol
5531 indices precede the global symbol indices. This means that when
5532 we are generating relocateable output, and we see a reloc against
5533 a global symbol, we can not know the symbol index until we have
5534 finished examining all the local symbols to see which ones we are
5535 going to output. To deal with this, we keep the relocations in
5536 memory, and don't output them until the end of the link. This is
5537 an unfortunate waste of memory, but I don't see a good way around
5538 it. Fortunately, it only happens when performing a relocateable
5539 link, which is not the common case. FIXME: If keep_memory is set
5540 we could write the relocs out and then read them again; I don't
5541 know how bad the memory loss will be. */
5543 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5544 sub
->output_has_begun
= false;
5545 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5547 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5549 if (p
->type
== bfd_indirect_link_order
5550 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5551 == bfd_target_elf_flavour
))
5553 sub
= p
->u
.indirect
.section
->owner
;
5554 if (! sub
->output_has_begun
)
5556 if (! elf_link_input_bfd (&finfo
, sub
))
5558 sub
->output_has_begun
= true;
5561 else if (p
->type
== bfd_section_reloc_link_order
5562 || p
->type
== bfd_symbol_reloc_link_order
)
5564 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5569 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5575 /* That wrote out all the local symbols. Finish up the symbol table
5576 with the global symbols. */
5578 /* The sh_info field records the index of the first non local
5580 symtab_hdr
->sh_info
= abfd
->symcount
;
5582 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5584 /* We get the global symbols from the hash table. */
5585 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5588 /* Flush all symbols to the file. */
5589 if (! elf_link_flush_output_syms (&finfo
))
5592 /* Now we know the size of the symtab section. */
5593 off
+= symtab_hdr
->sh_size
;
5595 /* Finish up and write out the symbol string table (.strtab)
5597 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5598 /* sh_name was set in prep_headers. */
5599 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5600 symstrtab_hdr
->sh_flags
= 0;
5601 symstrtab_hdr
->sh_addr
= 0;
5602 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5603 symstrtab_hdr
->sh_entsize
= 0;
5604 symstrtab_hdr
->sh_link
= 0;
5605 symstrtab_hdr
->sh_info
= 0;
5606 /* sh_offset is set just below. */
5607 symstrtab_hdr
->sh_addralign
= 1;
5609 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5610 elf_tdata (abfd
)->next_file_pos
= off
;
5612 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5613 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5616 /* Adjust the relocs to have the correct symbol indices. */
5617 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5619 struct elf_link_hash_entry
**rel_hash
;
5620 Elf_Internal_Shdr
*rel_hdr
;
5622 if ((o
->flags
& SEC_RELOC
) == 0)
5625 rel_hash
= elf_section_data (o
)->rel_hashes
;
5626 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5627 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5629 if (*rel_hash
== NULL
)
5632 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5634 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5636 Elf_External_Rel
*erel
;
5637 Elf_Internal_Rel irel
;
5639 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5640 elf_swap_reloc_in (abfd
, erel
, &irel
);
5641 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5642 ELF_R_TYPE (irel
.r_info
));
5643 elf_swap_reloc_out (abfd
, &irel
, erel
);
5647 Elf_External_Rela
*erela
;
5648 Elf_Internal_Rela irela
;
5650 BFD_ASSERT (rel_hdr
->sh_entsize
5651 == sizeof (Elf_External_Rela
));
5653 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5654 elf_swap_reloca_in (abfd
, erela
, &irela
);
5655 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5656 ELF_R_TYPE (irela
.r_info
));
5657 elf_swap_reloca_out (abfd
, &irela
, erela
);
5661 /* Set the reloc_count field to 0 to prevent write_relocs from
5662 trying to swap the relocs out itself. */
5666 /* If we are linking against a dynamic object, or generating a
5667 shared library, finish up the dynamic linking information. */
5670 Elf_External_Dyn
*dyncon
, *dynconend
;
5672 /* Fix up .dynamic entries. */
5673 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5674 BFD_ASSERT (o
!= NULL
);
5676 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5677 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5678 for (; dyncon
< dynconend
; dyncon
++)
5680 Elf_Internal_Dyn dyn
;
5684 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5691 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5692 magic _init and _fini symbols. This is pretty ugly,
5693 but we are compatible. */
5701 struct elf_link_hash_entry
*h
;
5703 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5704 false, false, true);
5705 BFD_ASSERT (h
!= NULL
);
5706 if (h
->root
.type
== bfd_link_hash_defined
)
5708 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5709 o
= h
->root
.u
.def
.section
;
5710 if (o
->output_section
!= NULL
)
5711 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5712 + o
->output_offset
);
5714 dyn
.d_un
.d_val
+= o
->vma
;
5716 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5729 o
= bfd_get_section_by_name (abfd
, name
);
5730 BFD_ASSERT (o
!= NULL
);
5731 dyn
.d_un
.d_ptr
= o
->vma
;
5732 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5739 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5744 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5746 Elf_Internal_Shdr
*hdr
;
5748 hdr
= elf_elfsections (abfd
)[i
];
5749 if (hdr
->sh_type
== type
5750 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5752 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5753 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5756 if (dyn
.d_un
.d_val
== 0
5757 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5758 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5762 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5768 /* If we have created any dynamic sections, then output them. */
5771 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5774 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5776 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5777 || o
->_raw_size
== 0)
5779 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5781 /* At this point, we are only interested in sections
5782 created by elf_link_create_dynamic_sections. FIXME:
5783 This test is fragile. */
5786 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5788 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5790 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5791 o
->contents
, o
->output_offset
,
5799 /* The contents of the .dynstr section are actually in a
5801 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5802 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5803 || ! _bfd_stringtab_emit (abfd
,
5804 elf_hash_table (info
)->dynstr
))
5810 if (finfo
.symstrtab
!= NULL
)
5811 _bfd_stringtab_free (finfo
.symstrtab
);
5812 if (finfo
.contents
!= NULL
)
5813 free (finfo
.contents
);
5814 if (finfo
.external_relocs
!= NULL
)
5815 free (finfo
.external_relocs
);
5816 if (finfo
.internal_relocs
!= NULL
)
5817 free (finfo
.internal_relocs
);
5818 if (finfo
.external_syms
!= NULL
)
5819 free (finfo
.external_syms
);
5820 if (finfo
.internal_syms
!= NULL
)
5821 free (finfo
.internal_syms
);
5822 if (finfo
.indices
!= NULL
)
5823 free (finfo
.indices
);
5824 if (finfo
.sections
!= NULL
)
5825 free (finfo
.sections
);
5826 if (finfo
.symbuf
!= NULL
)
5827 free (finfo
.symbuf
);
5828 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5830 if ((o
->flags
& SEC_RELOC
) != 0
5831 && elf_section_data (o
)->rel_hashes
!= NULL
)
5832 free (elf_section_data (o
)->rel_hashes
);
5835 elf_tdata (abfd
)->linker
= true;
5840 if (finfo
.symstrtab
!= NULL
)
5841 _bfd_stringtab_free (finfo
.symstrtab
);
5842 if (finfo
.contents
!= NULL
)
5843 free (finfo
.contents
);
5844 if (finfo
.external_relocs
!= NULL
)
5845 free (finfo
.external_relocs
);
5846 if (finfo
.internal_relocs
!= NULL
)
5847 free (finfo
.internal_relocs
);
5848 if (finfo
.external_syms
!= NULL
)
5849 free (finfo
.external_syms
);
5850 if (finfo
.internal_syms
!= NULL
)
5851 free (finfo
.internal_syms
);
5852 if (finfo
.indices
!= NULL
)
5853 free (finfo
.indices
);
5854 if (finfo
.sections
!= NULL
)
5855 free (finfo
.sections
);
5856 if (finfo
.symbuf
!= NULL
)
5857 free (finfo
.symbuf
);
5858 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5860 if ((o
->flags
& SEC_RELOC
) != 0
5861 && elf_section_data (o
)->rel_hashes
!= NULL
)
5862 free (elf_section_data (o
)->rel_hashes
);
5868 /* Add a symbol to the output symbol table. */
5871 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5872 struct elf_final_link_info
*finfo
;
5874 Elf_Internal_Sym
*elfsym
;
5875 asection
*input_sec
;
5877 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5878 struct bfd_link_info
*info
,
5883 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5884 elf_backend_link_output_symbol_hook
;
5885 if (output_symbol_hook
!= NULL
)
5887 if (! ((*output_symbol_hook
)
5888 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5892 if (name
== (const char *) NULL
|| *name
== '\0')
5893 elfsym
->st_name
= 0;
5896 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5899 if (elfsym
->st_name
== (unsigned long) -1)
5903 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5905 if (! elf_link_flush_output_syms (finfo
))
5909 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5910 finfo
->symbuf
+ finfo
->symbuf_count
);
5911 ++finfo
->symbuf_count
;
5913 ++finfo
->output_bfd
->symcount
;
5918 /* Flush the output symbols to the file. */
5921 elf_link_flush_output_syms (finfo
)
5922 struct elf_final_link_info
*finfo
;
5924 Elf_Internal_Shdr
*symtab
;
5926 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5928 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5930 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5931 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5932 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5935 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5937 finfo
->symbuf_count
= 0;
5942 /* Add an external symbol to the symbol table. This is called from
5943 the hash table traversal routine. */
5946 elf_link_output_extsym (h
, data
)
5947 struct elf_link_hash_entry
*h
;
5950 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5952 Elf_Internal_Sym sym
;
5953 asection
*input_sec
;
5955 /* We don't want to output symbols that have never been mentioned by
5956 a regular file, or that we have been told to strip. However, if
5957 h->indx is set to -2, the symbol is used by a reloc and we must
5961 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5962 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5963 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5964 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5966 else if (finfo
->info
->strip
== strip_all
5967 || (finfo
->info
->strip
== strip_some
5968 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5969 h
->root
.root
.string
,
5970 false, false) == NULL
))
5975 /* If we're stripping it, and it's not a dynamic symbol, there's
5976 nothing else to do. */
5977 if (strip
&& h
->dynindx
== -1)
5981 sym
.st_size
= h
->size
;
5983 if (h
->root
.type
== bfd_link_hash_weak
5984 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5985 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5987 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5989 switch (h
->root
.type
)
5992 case bfd_link_hash_new
:
5996 case bfd_link_hash_undefined
:
5997 input_sec
= bfd_und_section_ptr
;
5998 sym
.st_shndx
= SHN_UNDEF
;
6001 case bfd_link_hash_weak
:
6002 input_sec
= bfd_und_section_ptr
;
6003 sym
.st_shndx
= SHN_UNDEF
;
6006 case bfd_link_hash_defined
:
6008 input_sec
= h
->root
.u
.def
.section
;
6009 if (input_sec
->output_section
!= NULL
)
6012 elf_section_from_bfd_section (finfo
->output_bfd
,
6013 input_sec
->output_section
);
6014 if (sym
.st_shndx
== (unsigned short) -1)
6016 /* FIXME: No way to handle errors. */
6020 /* ELF symbols in relocateable files are section relative,
6021 but in nonrelocateable files they are virtual
6023 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6024 if (! finfo
->info
->relocateable
)
6025 sym
.st_value
+= input_sec
->output_section
->vma
;
6029 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6030 == bfd_target_elf_flavour
)
6031 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6032 sym
.st_shndx
= SHN_UNDEF
;
6033 input_sec
= bfd_und_section_ptr
;
6038 case bfd_link_hash_common
:
6039 input_sec
= bfd_com_section_ptr
;
6040 sym
.st_shndx
= SHN_COMMON
;
6041 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6044 case bfd_link_hash_indirect
:
6045 case bfd_link_hash_warning
:
6046 /* I have no idea how these should be handled. */
6050 /* If this symbol should be put in the .dynsym section, then put it
6051 there now. We have already know the symbol index. We also fill
6052 in the entry in the .hash section. */
6053 if (h
->dynindx
!= -1
6054 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6056 struct elf_backend_data
*bed
;
6059 bfd_byte
*bucketpos
;
6062 sym
.st_name
= h
->dynstr_index
;
6064 /* Give the processor backend a chance to tweak the symbol
6065 value, and also to finish up anything that needs to be done
6067 bed
= get_elf_backend_data (finfo
->output_bfd
);
6068 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6069 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6071 /* FIXME: No way to return error. */
6075 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6076 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6079 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6080 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6082 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6083 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6084 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6085 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6086 put_word (finfo
->output_bfd
, chain
,
6087 ((bfd_byte
*) finfo
->hash_sec
->contents
6088 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6091 /* If we're stripping it, then it was just a dynamic symbol, and
6092 there's nothing else to do. */
6096 h
->indx
= finfo
->output_bfd
->symcount
;
6098 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6100 /* FIXME: No way to return error. */
6107 /* Link an input file into the linker output file. This function
6108 handles all the sections and relocations of the input file at once.
6109 This is so that we only have to read the local symbols once, and
6110 don't have to keep them in memory. */
6113 elf_link_input_bfd (finfo
, input_bfd
)
6114 struct elf_final_link_info
*finfo
;
6117 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6118 bfd
*, asection
*, bfd_byte
*,
6119 Elf_Internal_Rela
*,
6120 Elf_Internal_Sym
*, asection
**));
6122 Elf_Internal_Shdr
*symtab_hdr
;
6125 Elf_External_Sym
*esym
;
6126 Elf_External_Sym
*esymend
;
6127 Elf_Internal_Sym
*isym
;
6129 asection
**ppsection
;
6132 output_bfd
= finfo
->output_bfd
;
6134 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6136 /* If this is a dynamic object, we don't want to do anything here:
6137 we don't want the local symbols, and we don't want the section
6139 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6142 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6143 if (elf_bad_symtab (input_bfd
))
6145 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6150 locsymcount
= symtab_hdr
->sh_info
;
6151 extsymoff
= symtab_hdr
->sh_info
;
6154 /* Read the local symbols. */
6156 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6157 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6158 locsymcount
, input_bfd
)
6159 != locsymcount
* sizeof (Elf_External_Sym
))))
6162 /* Swap in the local symbols and write out the ones which we know
6163 are going into the output file. */
6164 esym
= finfo
->external_syms
;
6165 esymend
= esym
+ locsymcount
;
6166 isym
= finfo
->internal_syms
;
6167 pindex
= finfo
->indices
;
6168 ppsection
= finfo
->sections
;
6169 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6173 Elf_Internal_Sym osym
;
6175 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6178 if (elf_bad_symtab (input_bfd
))
6180 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6187 if (isym
->st_shndx
== SHN_UNDEF
)
6188 isec
= bfd_und_section_ptr
;
6189 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6190 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6191 else if (isym
->st_shndx
== SHN_ABS
)
6192 isec
= bfd_abs_section_ptr
;
6193 else if (isym
->st_shndx
== SHN_COMMON
)
6194 isec
= bfd_com_section_ptr
;
6203 /* Don't output the first, undefined, symbol. */
6204 if (esym
== finfo
->external_syms
)
6207 /* If we are stripping all symbols, we don't want to output this
6209 if (finfo
->info
->strip
== strip_all
)
6212 /* We never output section symbols. Instead, we use the section
6213 symbol of the corresponding section in the output file. */
6214 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6217 /* If we are discarding all local symbols, we don't want to
6218 output this one. If we are generating a relocateable output
6219 file, then some of the local symbols may be required by
6220 relocs; we output them below as we discover that they are
6222 if (finfo
->info
->discard
== discard_all
)
6225 /* Get the name of the symbol. */
6226 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6231 /* See if we are discarding symbols with this name. */
6232 if ((finfo
->info
->strip
== strip_some
6233 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6235 || (finfo
->info
->discard
== discard_l
6236 && strncmp (name
, finfo
->info
->lprefix
,
6237 finfo
->info
->lprefix_len
) == 0))
6240 /* If we get here, we are going to output this symbol. */
6244 /* Adjust the section index for the output file. */
6245 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6246 isec
->output_section
);
6247 if (osym
.st_shndx
== (unsigned short) -1)
6250 *pindex
= output_bfd
->symcount
;
6252 /* ELF symbols in relocateable files are section relative, but
6253 in executable files they are virtual addresses. Note that
6254 this code assumes that all ELF sections have an associated
6255 BFD section with a reasonable value for output_offset; below
6256 we assume that they also have a reasonable value for
6257 output_section. Any special sections must be set up to meet
6258 these requirements. */
6259 osym
.st_value
+= isec
->output_offset
;
6260 if (! finfo
->info
->relocateable
)
6261 osym
.st_value
+= isec
->output_section
->vma
;
6263 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6267 /* Relocate the contents of each section. */
6268 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6270 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6273 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6274 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6276 /* Section was created by elf_link_create_dynamic_sections.
6277 FIXME: This test is fragile. */
6281 /* Read the contents of the section. */
6282 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6283 (file_ptr
) 0, o
->_raw_size
))
6286 if ((o
->flags
& SEC_RELOC
) != 0)
6288 Elf_Internal_Rela
*internal_relocs
;
6290 /* Get the swapped relocs. */
6291 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6292 finfo
->external_relocs
,
6293 finfo
->internal_relocs
,
6295 if (internal_relocs
== NULL
6296 && o
->reloc_count
> 0)
6299 /* Relocate the section by invoking a back end routine.
6301 The back end routine is responsible for adjusting the
6302 section contents as necessary, and (if using Rela relocs
6303 and generating a relocateable output file) adjusting the
6304 reloc addend as necessary.
6306 The back end routine does not have to worry about setting
6307 the reloc address or the reloc symbol index.
6309 The back end routine is given a pointer to the swapped in
6310 internal symbols, and can access the hash table entries
6311 for the external symbols via elf_sym_hashes (input_bfd).
6313 When generating relocateable output, the back end routine
6314 must handle STB_LOCAL/STT_SECTION symbols specially. The
6315 output symbol is going to be a section symbol
6316 corresponding to the output section, which will require
6317 the addend to be adjusted. */
6319 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6323 finfo
->internal_syms
,
6327 if (finfo
->info
->relocateable
)
6329 Elf_Internal_Rela
*irela
;
6330 Elf_Internal_Rela
*irelaend
;
6331 struct elf_link_hash_entry
**rel_hash
;
6332 Elf_Internal_Shdr
*input_rel_hdr
;
6333 Elf_Internal_Shdr
*output_rel_hdr
;
6335 /* Adjust the reloc addresses and symbol indices. */
6337 irela
= internal_relocs
;
6338 irelaend
= irela
+ o
->reloc_count
;
6339 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6340 + o
->output_section
->reloc_count
);
6341 for (; irela
< irelaend
; irela
++, rel_hash
++)
6344 Elf_Internal_Sym
*isym
;
6347 irela
->r_offset
+= o
->output_offset
;
6349 r_symndx
= ELF_R_SYM (irela
->r_info
);
6354 if (r_symndx
>= locsymcount
6355 || (elf_bad_symtab (input_bfd
)
6356 && finfo
->sections
[r_symndx
] == NULL
))
6360 /* This is a reloc against a global symbol. We
6361 have not yet output all the local symbols, so
6362 we do not know the symbol index of any global
6363 symbol. We set the rel_hash entry for this
6364 reloc to point to the global hash table entry
6365 for this symbol. The symbol index is then
6366 set at the end of elf_bfd_final_link. */
6367 indx
= r_symndx
- extsymoff
;
6368 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6370 /* Setting the index to -2 tells
6371 elf_link_output_extsym that this symbol is
6373 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6374 (*rel_hash
)->indx
= -2;
6379 /* This is a reloc against a local symbol. */
6382 isym
= finfo
->internal_syms
+ r_symndx
;
6383 sec
= finfo
->sections
[r_symndx
];
6384 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6386 /* I suppose the backend ought to fill in the
6387 section of any STT_SECTION symbol against a
6388 processor specific section. */
6389 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6391 else if (sec
== NULL
|| sec
->owner
== NULL
)
6393 bfd_set_error (bfd_error_bad_value
);
6398 r_symndx
= sec
->output_section
->target_index
;
6405 if (finfo
->indices
[r_symndx
] == -1)
6411 if (finfo
->info
->strip
== strip_all
)
6413 /* You can't do ld -r -s. */
6414 bfd_set_error (bfd_error_invalid_operation
);
6418 /* This symbol was skipped earlier, but
6419 since it is needed by a reloc, we
6420 must output it now. */
6421 link
= symtab_hdr
->sh_link
;
6422 name
= elf_string_from_elf_section (input_bfd
,
6428 osec
= sec
->output_section
;
6430 elf_section_from_bfd_section (output_bfd
,
6432 if (isym
->st_shndx
== (unsigned short) -1)
6435 isym
->st_value
+= sec
->output_offset
;
6436 if (! finfo
->info
->relocateable
)
6437 isym
->st_value
+= osec
->vma
;
6439 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6441 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6445 r_symndx
= finfo
->indices
[r_symndx
];
6448 irela
->r_info
= ELF_R_INFO (r_symndx
,
6449 ELF_R_TYPE (irela
->r_info
));
6452 /* Swap out the relocs. */
6453 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6454 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6455 BFD_ASSERT (output_rel_hdr
->sh_entsize
6456 == input_rel_hdr
->sh_entsize
);
6457 irela
= internal_relocs
;
6458 irelaend
= irela
+ o
->reloc_count
;
6459 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6461 Elf_External_Rel
*erel
;
6463 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6464 + o
->output_section
->reloc_count
);
6465 for (; irela
< irelaend
; irela
++, erel
++)
6467 Elf_Internal_Rel irel
;
6469 irel
.r_offset
= irela
->r_offset
;
6470 irel
.r_info
= irela
->r_info
;
6471 BFD_ASSERT (irela
->r_addend
== 0);
6472 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6477 Elf_External_Rela
*erela
;
6479 BFD_ASSERT (input_rel_hdr
->sh_entsize
6480 == sizeof (Elf_External_Rela
));
6481 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6482 + o
->output_section
->reloc_count
);
6483 for (; irela
< irelaend
; irela
++, erela
++)
6484 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6487 o
->output_section
->reloc_count
+= o
->reloc_count
;
6491 /* Write out the modified section contents. */
6492 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6493 finfo
->contents
, o
->output_offset
,
6494 (o
->_cooked_size
!= 0
6503 /* Generate a reloc when linking an ELF file. This is a reloc
6504 requested by the linker, and does come from any input file. This
6505 is used to build constructor and destructor tables when linking
6509 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6511 struct bfd_link_info
*info
;
6512 asection
*output_section
;
6513 struct bfd_link_order
*link_order
;
6515 reloc_howto_type
*howto
;
6518 struct elf_link_hash_entry
**rel_hash_ptr
;
6519 Elf_Internal_Shdr
*rel_hdr
;
6521 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6524 bfd_set_error (bfd_error_bad_value
);
6528 /* If this is an inplace reloc, we must write the addend into the
6530 if (howto
->partial_inplace
6531 && link_order
->u
.reloc
.p
->addend
!= 0)
6534 bfd_reloc_status_type rstat
;
6538 size
= bfd_get_reloc_size (howto
);
6539 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6540 if (buf
== (bfd_byte
*) NULL
)
6542 bfd_set_error (bfd_error_no_memory
);
6545 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6546 link_order
->u
.reloc
.p
->addend
, buf
);
6552 case bfd_reloc_outofrange
:
6554 case bfd_reloc_overflow
:
6555 if (! ((*info
->callbacks
->reloc_overflow
)
6557 (link_order
->type
== bfd_section_reloc_link_order
6558 ? bfd_section_name (output_bfd
,
6559 link_order
->u
.reloc
.p
->u
.section
)
6560 : link_order
->u
.reloc
.p
->u
.name
),
6561 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6562 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6569 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6570 (file_ptr
) link_order
->offset
, size
);
6576 /* Figure out the symbol index. */
6577 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6578 + output_section
->reloc_count
);
6579 if (link_order
->type
== bfd_section_reloc_link_order
)
6581 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6584 *rel_hash_ptr
= NULL
;
6588 struct elf_link_hash_entry
*h
;
6590 h
= elf_link_hash_lookup (elf_hash_table (info
),
6591 link_order
->u
.reloc
.p
->u
.name
,
6592 false, false, true);
6595 /* Setting the index to -2 tells elf_link_output_extsym that
6596 this symbol is used by a reloc. */
6603 if (! ((*info
->callbacks
->unattached_reloc
)
6604 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6605 (asection
*) NULL
, (bfd_vma
) 0)))
6611 /* The address of a reloc is relative to the section in a
6612 relocateable file, and is a virtual address in an executable
6614 offset
= link_order
->offset
;
6615 if (! info
->relocateable
)
6616 offset
+= output_section
->vma
;
6618 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6620 if (rel_hdr
->sh_type
== SHT_REL
)
6622 Elf_Internal_Rel irel
;
6623 Elf_External_Rel
*erel
;
6625 irel
.r_offset
= offset
;
6626 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6627 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6628 + output_section
->reloc_count
);
6629 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6633 Elf_Internal_Rela irela
;
6634 Elf_External_Rela
*erela
;
6636 irela
.r_offset
= offset
;
6637 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6638 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6639 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6640 + output_section
->reloc_count
);
6641 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6644 ++output_section
->reloc_count
;