1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
98 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
99 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
100 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
101 #define elf_get_symtab NAME(bfd_elf,get_symtab)
102 #define elf_canonicalize_dynamic_symtab \
103 NAME(bfd_elf,canonicalize_dynamic_symtab)
104 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
105 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
106 #define elf_get_lineno NAME(bfd_elf,get_lineno)
107 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
108 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
109 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
110 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
111 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
112 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
113 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
114 #define write_relocs NAME(bfd_elf,_write_relocs)
115 #define elf_find_section NAME(bfd_elf,find_section)
116 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
117 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
118 #define elf_link_create_dynamic_sections \
119 NAME(bfd_elf,link_create_dynamic_sections)
120 #define elf_link_record_dynamic_symbol \
121 NAME(bfd_elf,link_record_dynamic_symbol)
122 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
125 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
126 #define ELF_R_SYM(X) ELF64_R_SYM(X)
127 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
128 #define ELFCLASS ELFCLASS64
130 #define LOG_FILE_ALIGN 3
133 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
134 #define ELF_R_SYM(X) ELF32_R_SYM(X)
135 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
136 #define ELFCLASS ELFCLASS32
138 #define LOG_FILE_ALIGN 2
141 /* Forward declarations of static functions */
143 static struct bfd_strtab_hash
*elf_stringtab_init
PARAMS ((void));
144 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
146 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
148 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
150 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
152 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
153 struct symbol_cache_entry
**));
155 static boolean elf_compute_section_file_positions
156 PARAMS ((bfd
*, struct bfd_link_info
*));
157 static boolean prep_headers
PARAMS ((bfd
*));
158 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
159 static boolean assign_section_numbers
PARAMS ((bfd
*));
160 static file_ptr align_file_position
PARAMS ((file_ptr
));
161 static file_ptr assign_file_position_for_section
162 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
163 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
164 static int elf_sort_hdrs
PARAMS ((const PTR
, const PTR
));
165 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
166 static bfd_size_type get_program_header_size
PARAMS ((bfd
*,
167 Elf_Internal_Shdr
**,
170 static file_ptr map_program_segments
171 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, Elf_Internal_Shdr
**,
174 static boolean elf_map_symbols
PARAMS ((bfd
*));
175 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
177 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
180 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
181 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
184 #define elf_string_from_elf_strtab(abfd,strindex) \
185 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
187 /* Structure swapping routines */
189 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
190 can be handled by explicitly specifying 32 bits or "the long type". */
192 #define put_word bfd_h_put_64
193 #define get_word bfd_h_get_64
196 #define put_word bfd_h_put_32
197 #define get_word bfd_h_get_32
200 /* Translate an ELF symbol in external format into an ELF symbol in internal
204 elf_swap_symbol_in (abfd
, src
, dst
)
206 Elf_External_Sym
*src
;
207 Elf_Internal_Sym
*dst
;
209 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
210 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
211 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
212 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
213 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
214 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
217 /* Translate an ELF symbol in internal format into an ELF symbol in external
221 elf_swap_symbol_out (abfd
, src
, dst
)
223 Elf_Internal_Sym
*src
;
224 Elf_External_Sym
*dst
;
226 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
227 put_word (abfd
, src
->st_value
, dst
->st_value
);
228 put_word (abfd
, src
->st_size
, dst
->st_size
);
229 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
230 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
231 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
235 /* Translate an ELF file header in external format into an ELF file header in
239 elf_swap_ehdr_in (abfd
, src
, dst
)
241 Elf_External_Ehdr
*src
;
242 Elf_Internal_Ehdr
*dst
;
244 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
245 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
246 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
247 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
248 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
249 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
250 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
251 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
252 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
253 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
254 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
255 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
256 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
257 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
260 /* Translate an ELF file header in internal format into an ELF file header in
264 elf_swap_ehdr_out (abfd
, src
, dst
)
266 Elf_Internal_Ehdr
*src
;
267 Elf_External_Ehdr
*dst
;
269 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
270 /* note that all elements of dst are *arrays of unsigned char* already... */
271 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
272 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
273 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
274 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
275 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
276 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
277 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
278 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
279 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
280 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
281 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
282 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
283 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
287 /* Translate an ELF section header table entry in external format into an
288 ELF section header table entry in internal format. */
291 elf_swap_shdr_in (abfd
, src
, dst
)
293 Elf_External_Shdr
*src
;
294 Elf_Internal_Shdr
*dst
;
296 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
297 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
298 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
299 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
300 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
301 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
302 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
303 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
304 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
305 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
306 dst
->bfd_section
= NULL
;
307 dst
->contents
= NULL
;
310 /* Translate an ELF section header table entry in internal format into an
311 ELF section header table entry in external format. */
314 elf_swap_shdr_out (abfd
, src
, dst
)
316 Elf_Internal_Shdr
*src
;
317 Elf_External_Shdr
*dst
;
319 /* note that all elements of dst are *arrays of unsigned char* already... */
320 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
321 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
322 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
323 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
324 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
325 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
326 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
327 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
328 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
329 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
333 /* Translate an ELF program header table entry in external format into an
334 ELF program header table entry in internal format. */
337 elf_swap_phdr_in (abfd
, src
, dst
)
339 Elf_External_Phdr
*src
;
340 Elf_Internal_Phdr
*dst
;
342 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
343 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
344 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
345 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
346 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
347 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
348 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
349 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
353 elf_swap_phdr_out (abfd
, src
, dst
)
355 Elf_Internal_Phdr
*src
;
356 Elf_External_Phdr
*dst
;
358 /* note that all elements of dst are *arrays of unsigned char* already... */
359 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
360 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
361 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
362 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
363 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
364 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
365 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
366 put_word (abfd
, src
->p_align
, dst
->p_align
);
369 /* Translate an ELF reloc from external format to internal format. */
371 elf_swap_reloc_in (abfd
, src
, dst
)
373 Elf_External_Rel
*src
;
374 Elf_Internal_Rel
*dst
;
376 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
377 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
381 elf_swap_reloca_in (abfd
, src
, dst
)
383 Elf_External_Rela
*src
;
384 Elf_Internal_Rela
*dst
;
386 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
387 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
388 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
391 /* Translate an ELF reloc from internal format to external format. */
393 elf_swap_reloc_out (abfd
, src
, dst
)
395 Elf_Internal_Rel
*src
;
396 Elf_External_Rel
*dst
;
398 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
399 put_word (abfd
, src
->r_info
, dst
->r_info
);
403 elf_swap_reloca_out (abfd
, src
, dst
)
405 Elf_Internal_Rela
*src
;
406 Elf_External_Rela
*dst
;
408 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
409 put_word (abfd
, src
->r_info
, dst
->r_info
);
410 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
414 elf_swap_dyn_in (abfd
, src
, dst
)
416 const Elf_External_Dyn
*src
;
417 Elf_Internal_Dyn
*dst
;
419 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
420 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
424 elf_swap_dyn_out (abfd
, src
, dst
)
426 const Elf_Internal_Dyn
*src
;
427 Elf_External_Dyn
*dst
;
429 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
430 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
433 /* Allocate an ELF string table--force the first byte to be zero. */
435 static struct bfd_strtab_hash
*
436 elf_stringtab_init ()
438 struct bfd_strtab_hash
*ret
;
440 ret
= _bfd_stringtab_init ();
445 loc
= _bfd_stringtab_add (ret
, "", true, false);
446 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
447 if (loc
== (bfd_size_type
) -1)
449 _bfd_stringtab_free (ret
);
456 /* ELF .o/exec file reading */
458 /* Create a new bfd section from an ELF section header. */
461 bfd_section_from_shdr (abfd
, shindex
)
463 unsigned int shindex
;
465 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
466 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
469 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
471 switch (hdr
->sh_type
)
474 /* Inactive section. Throw it away. */
477 case SHT_PROGBITS
: /* Normal section with contents. */
478 case SHT_DYNAMIC
: /* Dynamic linking information. */
479 case SHT_NOBITS
: /* .bss section. */
480 case SHT_HASH
: /* .hash section. */
481 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
483 case SHT_SYMTAB
: /* A symbol table */
484 if (elf_onesymtab (abfd
) == shindex
)
487 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
488 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
489 elf_onesymtab (abfd
) = shindex
;
490 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
491 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
492 abfd
->flags
|= HAS_SYMS
;
494 /* Sometimes a shared object will map in the symbol table. If
495 SHF_ALLOC is set, and this is a shared object, then we also
496 treat this section as a BFD section. We can not base the
497 decision purely on SHF_ALLOC, because that flag is sometimes
498 set in a relocateable object file, which would confuse the
500 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
501 && (abfd
->flags
& DYNAMIC
) != 0
502 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
507 case SHT_DYNSYM
: /* A dynamic symbol table */
508 if (elf_dynsymtab (abfd
) == shindex
)
511 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
512 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
513 elf_dynsymtab (abfd
) = shindex
;
514 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
515 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
516 abfd
->flags
|= HAS_SYMS
;
518 /* Besides being a symbol table, we also treat this as a regular
519 section, so that objcopy can handle it. */
520 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
522 case SHT_STRTAB
: /* A string table */
523 if (hdr
->bfd_section
!= NULL
)
525 if (ehdr
->e_shstrndx
== shindex
)
527 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
528 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
534 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
536 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
537 if (hdr2
->sh_link
== shindex
)
539 if (! bfd_section_from_shdr (abfd
, i
))
541 if (elf_onesymtab (abfd
) == i
)
543 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
544 elf_elfsections (abfd
)[shindex
] =
545 &elf_tdata (abfd
)->strtab_hdr
;
548 if (elf_dynsymtab (abfd
) == i
)
550 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
551 elf_elfsections (abfd
)[shindex
] =
552 &elf_tdata (abfd
)->dynstrtab_hdr
;
553 /* We also treat this as a regular section, so
554 that objcopy can handle it. */
557 #if 0 /* Not handling other string tables specially right now. */
558 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
559 /* We have a strtab for some random other section. */
560 newsect
= (asection
*) hdr2
->bfd_section
;
563 hdr
->bfd_section
= newsect
;
564 hdr2
= &elf_section_data (newsect
)->str_hdr
;
566 elf_elfsections (abfd
)[shindex
] = hdr2
;
572 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
576 /* *These* do a lot of work -- but build no sections! */
578 asection
*target_sect
;
579 Elf_Internal_Shdr
*hdr2
;
580 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
582 /* Get the symbol table. */
583 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
586 /* If this reloc section does not use the main symbol table we
587 don't treat it as a reloc section. BFD can't adequately
588 represent such a section, so at least for now, we don't
589 try. We just present it as a normal section. */
590 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
591 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
593 /* Don't allow REL relocations on a machine that uses RELA and
595 /* @@ Actually, the generic ABI does suggest that both might be
596 used in one file. But the four ABI Processor Supplements I
597 have access to right now all specify that only one is used on
598 each of those architectures. It's conceivable that, e.g., a
599 bunch of absolute 32-bit relocs might be more compact in REL
600 form even on a RELA machine... */
601 BFD_ASSERT (use_rela_p
602 ? (hdr
->sh_type
== SHT_RELA
603 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
604 : (hdr
->sh_type
== SHT_REL
605 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
607 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
609 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
610 if (target_sect
== NULL
)
613 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
615 elf_elfsections (abfd
)[shindex
] = hdr2
;
616 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
617 target_sect
->flags
|= SEC_RELOC
;
618 target_sect
->relocation
= NULL
;
619 target_sect
->rel_filepos
= hdr
->sh_offset
;
620 abfd
->flags
|= HAS_RELOC
;
627 fprintf (stderr
, "Note Sections not yet supported.\n");
634 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
639 /* Check for any processor-specific section types. */
641 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
643 if (bed
->elf_backend_section_from_shdr
)
644 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
653 elf_new_section_hook (abfd
, sec
)
658 struct bfd_elf_section_data
*sdata
;
660 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
663 bfd_set_error (bfd_error_no_memory
);
666 sec
->used_by_bfd
= (PTR
) sdata
;
667 memset (sdata
, 0, sizeof (*sdata
));
671 /* Create a new bfd section from an ELF program header.
673 Since program segments have no names, we generate a synthetic name
674 of the form segment<NUM>, where NUM is generally the index in the
675 program header table. For segments that are split (see below) we
676 generate the names segment<NUM>a and segment<NUM>b.
678 Note that some program segments may have a file size that is different than
679 (less than) the memory size. All this means is that at execution the
680 system must allocate the amount of memory specified by the memory size,
681 but only initialize it with the first "file size" bytes read from the
682 file. This would occur for example, with program segments consisting
683 of combined data+bss.
685 To handle the above situation, this routine generates TWO bfd sections
686 for the single program segment. The first has the length specified by
687 the file size of the segment, and the second has the length specified
688 by the difference between the two sizes. In effect, the segment is split
689 into it's initialized and uninitialized parts.
694 bfd_section_from_phdr (abfd
, hdr
, index
)
696 Elf_Internal_Phdr
*hdr
;
704 split
= ((hdr
->p_memsz
> 0) &&
705 (hdr
->p_filesz
> 0) &&
706 (hdr
->p_memsz
> hdr
->p_filesz
));
707 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
708 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
711 bfd_set_error (bfd_error_no_memory
);
714 strcpy (name
, namebuf
);
715 newsect
= bfd_make_section (abfd
, name
);
718 newsect
->vma
= hdr
->p_vaddr
;
719 newsect
->_raw_size
= hdr
->p_filesz
;
720 newsect
->filepos
= hdr
->p_offset
;
721 newsect
->flags
|= SEC_HAS_CONTENTS
;
722 if (hdr
->p_type
== PT_LOAD
)
724 newsect
->flags
|= SEC_ALLOC
;
725 newsect
->flags
|= SEC_LOAD
;
726 if (hdr
->p_flags
& PF_X
)
728 /* FIXME: all we known is that it has execute PERMISSION,
730 newsect
->flags
|= SEC_CODE
;
733 if (!(hdr
->p_flags
& PF_W
))
735 newsect
->flags
|= SEC_READONLY
;
740 sprintf (namebuf
, "segment%db", index
);
741 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
744 bfd_set_error (bfd_error_no_memory
);
747 strcpy (name
, namebuf
);
748 newsect
= bfd_make_section (abfd
, name
);
751 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
752 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
753 if (hdr
->p_type
== PT_LOAD
)
755 newsect
->flags
|= SEC_ALLOC
;
756 if (hdr
->p_flags
& PF_X
)
757 newsect
->flags
|= SEC_CODE
;
759 if (!(hdr
->p_flags
& PF_W
))
760 newsect
->flags
|= SEC_READONLY
;
766 /* Begin processing a given object.
768 First we validate the file by reading in the ELF header and checking
771 static INLINE boolean
773 Elf_External_Ehdr
*x_ehdrp
;
775 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
776 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
777 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
778 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
781 /* Check to see if the file associated with ABFD matches the target vector
784 Note that we may be called several times with the same ABFD, but different
785 target vectors, most of which will not match. We have to avoid leaving
786 any side effects in ABFD, or any data it points to (like tdata), if the
787 file does not match the target vector. */
793 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
794 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
795 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
796 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
797 unsigned int shindex
;
798 char *shstrtab
; /* Internal copy of section header stringtab */
799 struct elf_backend_data
*ebd
;
800 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
801 struct elf_obj_tdata
*new_tdata
= NULL
;
803 /* Read in the ELF header in external format. */
805 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
807 if (bfd_get_error () != bfd_error_system_call
)
808 goto got_wrong_format_error
;
813 /* Now check to see if we have a valid ELF file, and one that BFD can
814 make use of. The magic number must match, the address size ('class')
815 and byte-swapping must match our XVEC entry, and it must have a
816 section header table (FIXME: See comments re sections at top of this
819 if ((elf_file_p (&x_ehdr
) == false) ||
820 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
821 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
822 goto got_wrong_format_error
;
824 /* Check that file's byte order matches xvec's */
825 switch (x_ehdr
.e_ident
[EI_DATA
])
827 case ELFDATA2MSB
: /* Big-endian */
828 if (!abfd
->xvec
->header_byteorder_big_p
)
829 goto got_wrong_format_error
;
831 case ELFDATA2LSB
: /* Little-endian */
832 if (abfd
->xvec
->header_byteorder_big_p
)
833 goto got_wrong_format_error
;
835 case ELFDATANONE
: /* No data encoding specified */
836 default: /* Unknown data encoding specified */
837 goto got_wrong_format_error
;
840 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
841 the tdata pointer in the bfd. */
843 new_tdata
= ((struct elf_obj_tdata
*)
844 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
845 if (new_tdata
== NULL
)
846 goto got_no_memory_error
;
847 elf_tdata (abfd
) = new_tdata
;
849 /* Now that we know the byte order, swap in the rest of the header */
850 i_ehdrp
= elf_elfheader (abfd
);
851 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
853 elf_debug_file (i_ehdrp
);
856 /* If there is no section header table, we're hosed. */
857 if (i_ehdrp
->e_shoff
== 0)
858 goto got_wrong_format_error
;
860 /* As a simple sanity check, verify that the what BFD thinks is the
861 size of each section header table entry actually matches the size
862 recorded in the file. */
863 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
864 goto got_wrong_format_error
;
866 ebd
= get_elf_backend_data (abfd
);
868 /* Check that the ELF e_machine field matches what this particular
869 BFD format expects. */
870 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
872 const bfd_target
* const *target_ptr
;
874 if (ebd
->elf_machine_code
!= EM_NONE
)
875 goto got_wrong_format_error
;
877 /* This is the generic ELF target. Let it match any ELF target
878 for which we do not have a specific backend. */
879 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
881 struct elf_backend_data
*back
;
883 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
885 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
886 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
888 /* target_ptr is an ELF backend which matches this
889 object file, so reject the generic ELF target. */
890 goto got_wrong_format_error
;
895 if (i_ehdrp
->e_type
== ET_EXEC
)
896 abfd
->flags
|= EXEC_P
;
897 else if (i_ehdrp
->e_type
== ET_DYN
)
898 abfd
->flags
|= DYNAMIC
;
900 if (i_ehdrp
->e_phnum
> 0)
901 abfd
->flags
|= D_PAGED
;
903 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
906 /* Remember the entry point specified in the ELF file header. */
907 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
909 /* Allocate space for a copy of the section header table in
910 internal form, seek to the section header table in the file,
911 read it in, and convert it to internal form. */
912 i_shdrp
= ((Elf_Internal_Shdr
*)
913 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
914 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
916 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
917 if (!i_shdrp
|| !elf_elfsections (abfd
))
918 goto got_no_memory_error
;
919 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
921 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
923 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
925 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
926 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
928 if (i_ehdrp
->e_shstrndx
)
930 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
934 /* Read in the string table containing the names of the sections. We
935 will need the base pointer to this table later. */
936 /* We read this inline now, so that we don't have to go through
937 bfd_section_from_shdr with it (since this particular strtab is
938 used to find all of the ELF section names.) */
940 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
944 /* Once all of the section headers have been read and converted, we
945 can start processing them. Note that the first section header is
946 a dummy placeholder entry, so we ignore it. */
948 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
950 if (! bfd_section_from_shdr (abfd
, shindex
))
954 /* Let the backend double check the format and override global
956 if (ebd
->elf_backend_object_p
)
958 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
959 goto got_wrong_format_error
;
964 got_wrong_format_error
:
965 bfd_set_error (bfd_error_wrong_format
);
968 bfd_set_error (bfd_error_no_memory
);
971 if (new_tdata
!= NULL
972 && new_tdata
->elf_sect_ptr
!= NULL
)
973 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
975 bfd_release (abfd
, i_shdrp
);
976 if (new_tdata
!= NULL
)
977 bfd_release (abfd
, new_tdata
);
978 elf_tdata (abfd
) = preserved_tdata
;
983 /* ELF .o/exec file writing */
985 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
986 of the symbol if there is one. */
987 static INLINE elf_symbol_type
*
988 elf_symbol_from (ignore_abfd
, symbol
)
992 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
995 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
998 return (elf_symbol_type
*) symbol
;
1002 write_relocs (abfd
, sec
, xxx
)
1007 Elf_Internal_Shdr
*rela_hdr
;
1008 Elf_External_Rela
*outbound_relocas
;
1009 Elf_External_Rel
*outbound_relocs
;
1011 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1012 asymbol
*last_sym
= 0;
1013 int last_sym_idx
= 9999999; /* should always be written before use */
1015 if ((sec
->flags
& SEC_RELOC
) == 0)
1018 /* The linker backend writes the relocs out itself, and sets the
1019 reloc_count field to zero to inhibit writing them here. Also,
1020 sometimes the SEC_RELOC flag gets set even when there aren't any
1022 if (sec
->reloc_count
== 0)
1025 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1027 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1028 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1029 if (!rela_hdr
->contents
)
1031 bfd_set_error (bfd_error_no_memory
);
1032 abort (); /* FIXME */
1035 /* orelocation has the data, reloc_count has the count... */
1038 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1040 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1042 Elf_Internal_Rela dst_rela
;
1043 Elf_External_Rela
*src_rela
;
1048 ptr
= sec
->orelocation
[idx
];
1049 src_rela
= outbound_relocas
+ idx
;
1051 /* The address of an ELF reloc is section relative for an object
1052 file, and absolute for an executable file or shared library.
1053 The address of a BFD reloc is always section relative. */
1054 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1055 dst_rela
.r_offset
= ptr
->address
;
1057 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
1059 sym
= *ptr
->sym_ptr_ptr
;
1060 if (sym
== last_sym
)
1065 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1067 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1069 dst_rela
.r_addend
= ptr
->addend
;
1070 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1074 /* REL relocations */
1076 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1078 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1080 Elf_Internal_Rel dst_rel
;
1081 Elf_External_Rel
*src_rel
;
1086 ptr
= sec
->orelocation
[idx
];
1087 sym
= *ptr
->sym_ptr_ptr
;
1088 src_rel
= outbound_relocs
+ idx
;
1090 /* The address of an ELF reloc is section relative for an object
1091 file, and absolute for an executable file or shared library.
1092 The address of a BFD reloc is always section relative. */
1093 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1094 dst_rel
.r_offset
= ptr
->address
;
1096 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1098 if (sym
== last_sym
)
1103 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1105 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1107 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1112 /* Set up an ELF internal section header for a section. */
1116 elf_fake_sections (abfd
, asect
, failedptrarg
)
1121 boolean
*failedptr
= (boolean
*) failedptrarg
;
1122 Elf_Internal_Shdr
*this_hdr
;
1126 /* We already failed; just get out of the bfd_map_over_sections
1131 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1133 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1136 if (this_hdr
->sh_name
== (unsigned long) -1)
1142 this_hdr
->sh_flags
= 0;
1143 if ((asect
->flags
& SEC_ALLOC
) != 0)
1144 this_hdr
->sh_addr
= asect
->vma
;
1146 this_hdr
->sh_addr
= 0;
1147 this_hdr
->sh_offset
= 0;
1148 this_hdr
->sh_size
= asect
->_raw_size
;
1149 this_hdr
->sh_link
= 0;
1150 this_hdr
->sh_info
= 0;
1151 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1152 this_hdr
->sh_entsize
= 0;
1154 this_hdr
->bfd_section
= asect
;
1155 this_hdr
->contents
= NULL
;
1157 /* FIXME: This should not be based on section names. */
1158 if (strcmp (asect
->name
, ".dynstr") == 0)
1159 this_hdr
->sh_type
= SHT_STRTAB
;
1160 else if (strcmp (asect
->name
, ".hash") == 0)
1162 this_hdr
->sh_type
= SHT_HASH
;
1163 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1165 else if (strcmp (asect
->name
, ".dynsym") == 0)
1167 this_hdr
->sh_type
= SHT_DYNSYM
;
1168 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1170 else if (strcmp (asect
->name
, ".dynamic") == 0)
1172 this_hdr
->sh_type
= SHT_DYNAMIC
;
1173 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1175 else if (strncmp (asect
->name
, ".rela", 5) == 0
1176 && get_elf_backend_data (abfd
)->use_rela_p
)
1178 this_hdr
->sh_type
= SHT_RELA
;
1179 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1181 else if (strncmp (asect
->name
, ".rel", 4) == 0
1182 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1184 this_hdr
->sh_type
= SHT_REL
;
1185 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1187 else if (strcmp (asect
->name
, ".note") == 0)
1188 this_hdr
->sh_type
= SHT_NOTE
;
1189 else if (strncmp (asect
->name
, ".stab", 5) == 0
1190 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1191 this_hdr
->sh_type
= SHT_STRTAB
;
1192 else if ((asect
->flags
& SEC_ALLOC
) != 0
1193 && (asect
->flags
& SEC_LOAD
) != 0)
1194 this_hdr
->sh_type
= SHT_PROGBITS
;
1195 else if ((asect
->flags
& SEC_ALLOC
) != 0
1196 && ((asect
->flags
& SEC_LOAD
) == 0))
1198 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1199 || strcmp (asect
->name
, ".sbss") == 0);
1200 this_hdr
->sh_type
= SHT_NOBITS
;
1205 this_hdr
->sh_type
= SHT_PROGBITS
;
1208 if ((asect
->flags
& SEC_ALLOC
) != 0)
1209 this_hdr
->sh_flags
|= SHF_ALLOC
;
1210 if ((asect
->flags
& SEC_READONLY
) == 0)
1211 this_hdr
->sh_flags
|= SHF_WRITE
;
1212 if ((asect
->flags
& SEC_CODE
) != 0)
1213 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1215 /* Check for processor-specific section types. */
1217 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1219 if (bed
->elf_backend_fake_sections
)
1220 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1223 /* If the section has relocs, set up a section header for the
1224 SHT_REL[A] section. */
1225 if ((asect
->flags
& SEC_RELOC
) != 0)
1227 Elf_Internal_Shdr
*rela_hdr
;
1228 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1231 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1232 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1235 bfd_set_error (bfd_error_no_memory
);
1239 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1241 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1243 if (rela_hdr
->sh_name
== (unsigned int) -1)
1248 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1249 rela_hdr
->sh_entsize
= (use_rela_p
1250 ? sizeof (Elf_External_Rela
)
1251 : sizeof (Elf_External_Rel
));
1252 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1253 rela_hdr
->sh_flags
= 0;
1254 rela_hdr
->sh_addr
= 0;
1255 rela_hdr
->sh_size
= 0;
1256 rela_hdr
->sh_offset
= 0;
1260 /* Assign all ELF section numbers. The dummy first section is handled here
1261 too. The link/info pointers for the standard section types are filled
1262 in here too, while we're at it. */
1265 assign_section_numbers (abfd
)
1268 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1270 unsigned int section_number
;
1271 Elf_Internal_Shdr
**i_shdrp
;
1275 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1277 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1279 d
->this_idx
= section_number
++;
1280 if ((sec
->flags
& SEC_RELOC
) == 0)
1283 d
->rel_idx
= section_number
++;
1286 t
->shstrtab_section
= section_number
++;
1287 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1288 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1290 if (abfd
->symcount
> 0)
1292 t
->symtab_section
= section_number
++;
1293 t
->strtab_section
= section_number
++;
1296 elf_elfheader (abfd
)->e_shnum
= section_number
;
1298 /* Set up the list of section header pointers, in agreement with the
1300 i_shdrp
= ((Elf_Internal_Shdr
**)
1301 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1302 if (i_shdrp
== NULL
)
1304 bfd_set_error (bfd_error_no_memory
);
1308 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1309 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1310 if (i_shdrp
[0] == NULL
)
1312 bfd_release (abfd
, i_shdrp
);
1313 bfd_set_error (bfd_error_no_memory
);
1316 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1318 elf_elfsections (abfd
) = i_shdrp
;
1320 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1321 if (abfd
->symcount
> 0)
1323 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1324 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1325 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1327 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1329 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1333 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1334 if (d
->rel_idx
!= 0)
1335 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1337 /* Fill in the sh_link and sh_info fields while we're at it. */
1339 /* sh_link of a reloc section is the section index of the symbol
1340 table. sh_info is the section index of the section to which
1341 the relocation entries apply. */
1342 if (d
->rel_idx
!= 0)
1344 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1345 d
->rel_hdr
.sh_info
= d
->this_idx
;
1348 switch (d
->this_hdr
.sh_type
)
1352 /* A reloc section which we are treating as a normal BFD
1353 section. sh_link is the section index of the symbol
1354 table. sh_info is the section index of the section to
1355 which the relocation entries apply. We assume that an
1356 allocated reloc section uses the dynamic symbol table.
1357 FIXME: How can we be sure? */
1358 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1360 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1362 /* We look up the section the relocs apply to by name. */
1364 if (d
->this_hdr
.sh_type
== SHT_REL
)
1368 s
= bfd_get_section_by_name (abfd
, name
);
1370 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1374 /* We assume that a section named .stab*str is a stabs
1375 string section. We look for a section with the same name
1376 but without the trailing ``str'', and set its sh_link
1377 field to point to this section. */
1378 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1379 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1384 len
= strlen (sec
->name
);
1385 alc
= (char *) malloc (len
- 2);
1388 bfd_set_error (bfd_error_no_memory
);
1391 strncpy (alc
, sec
->name
, len
- 3);
1392 alc
[len
- 3] = '\0';
1393 s
= bfd_get_section_by_name (abfd
, alc
);
1397 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1399 /* This is a .stab section. */
1400 elf_section_data (s
)->this_hdr
.sh_entsize
=
1401 4 + 2 * (ARCH_SIZE
/ 8);
1408 /* sh_link is the section header index of the string table
1409 used for the dynamic entries or symbol table. */
1410 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1412 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1416 /* sh_link is the section header index of the symbol table
1417 this hash table is for. */
1418 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1420 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1428 /* Map symbol from it's internal number to the external number, moving
1429 all local symbols to be at the head of the list. */
1432 sym_is_global (abfd
, sym
)
1436 /* If the backend has a special mapping, use it. */
1437 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1438 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1441 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1443 if (sym
->flags
& BSF_LOCAL
)
1447 if (sym
->section
== 0)
1449 /* Is this valid? */
1454 if (bfd_is_und_section (sym
->section
))
1456 if (bfd_is_com_section (sym
->section
))
1458 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1464 elf_map_symbols (abfd
)
1467 int symcount
= bfd_get_symcount (abfd
);
1468 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1469 asymbol
**sect_syms
;
1471 int num_globals
= 0;
1472 int num_locals2
= 0;
1473 int num_globals2
= 0;
1475 int num_sections
= 0;
1481 fprintf (stderr
, "elf_map_symbols\n");
1485 /* Add a section symbol for each BFD section. FIXME: Is this really
1487 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1489 if (max_index
< asect
->index
)
1490 max_index
= asect
->index
;
1494 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1495 if (sect_syms
== NULL
)
1497 bfd_set_error (bfd_error_no_memory
);
1500 elf_section_syms (abfd
) = sect_syms
;
1502 for (idx
= 0; idx
< symcount
; idx
++)
1504 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1505 && syms
[idx
]->value
== 0)
1509 sec
= syms
[idx
]->section
;
1510 if (sec
->owner
!= NULL
)
1512 if (sec
->owner
!= abfd
)
1514 if (sec
->output_offset
!= 0)
1516 sec
= sec
->output_section
;
1517 BFD_ASSERT (sec
->owner
== abfd
);
1519 sect_syms
[sec
->index
] = syms
[idx
];
1524 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1528 if (sect_syms
[asect
->index
] != NULL
)
1531 sym
= bfd_make_empty_symbol (abfd
);
1534 sym
->the_bfd
= abfd
;
1535 sym
->name
= asect
->name
;
1537 /* Set the flags to 0 to indicate that this one was newly added. */
1539 sym
->section
= asect
;
1540 sect_syms
[asect
->index
] = sym
;
1544 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1545 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1549 /* Classify all of the symbols. */
1550 for (idx
= 0; idx
< symcount
; idx
++)
1552 if (!sym_is_global (abfd
, syms
[idx
]))
1557 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1559 if (sect_syms
[asect
->index
] != NULL
1560 && sect_syms
[asect
->index
]->flags
== 0)
1562 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1563 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1567 sect_syms
[asect
->index
]->flags
= 0;
1571 /* Now sort the symbols so the local symbols are first. */
1572 new_syms
= ((asymbol
**)
1574 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1575 if (new_syms
== NULL
)
1577 bfd_set_error (bfd_error_no_memory
);
1581 for (idx
= 0; idx
< symcount
; idx
++)
1583 asymbol
*sym
= syms
[idx
];
1586 if (!sym_is_global (abfd
, sym
))
1589 i
= num_locals
+ num_globals2
++;
1591 sym
->udata
.i
= i
+ 1;
1593 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1595 if (sect_syms
[asect
->index
] != NULL
1596 && sect_syms
[asect
->index
]->flags
== 0)
1598 asymbol
*sym
= sect_syms
[asect
->index
];
1601 sym
->flags
= BSF_SECTION_SYM
;
1602 if (!sym_is_global (abfd
, sym
))
1605 i
= num_locals
+ num_globals2
++;
1607 sym
->udata
.i
= i
+ 1;
1611 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1613 elf_num_locals (abfd
) = num_locals
;
1614 elf_num_globals (abfd
) = num_globals
;
1618 /* Compute the file positions we are going to put the sections at, and
1619 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1620 is not NULL, this is being called by the ELF backend linker. */
1623 elf_compute_section_file_positions (abfd
, link_info
)
1625 struct bfd_link_info
*link_info
;
1627 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1629 struct bfd_strtab_hash
*strtab
;
1630 Elf_Internal_Shdr
*shstrtab_hdr
;
1632 if (abfd
->output_has_begun
)
1635 /* Do any elf backend specific processing first. */
1636 if (bed
->elf_backend_begin_write_processing
)
1637 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1639 if (! prep_headers (abfd
))
1643 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1647 if (!assign_section_numbers (abfd
))
1650 /* The backend linker builds symbol table information itself. */
1651 if (link_info
== NULL
)
1653 if (! swap_out_syms (abfd
, &strtab
))
1657 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1658 /* sh_name was set in prep_headers. */
1659 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1660 shstrtab_hdr
->sh_flags
= 0;
1661 shstrtab_hdr
->sh_addr
= 0;
1662 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1663 shstrtab_hdr
->sh_entsize
= 0;
1664 shstrtab_hdr
->sh_link
= 0;
1665 shstrtab_hdr
->sh_info
= 0;
1666 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1667 shstrtab_hdr
->sh_addralign
= 1;
1669 if (!assign_file_positions_except_relocs (abfd
,
1670 link_info
== NULL
? true : false))
1673 if (link_info
== NULL
)
1675 /* Now that we know where the .strtab section goes, write it
1677 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1679 || ! _bfd_stringtab_emit (abfd
, strtab
))
1681 _bfd_stringtab_free (strtab
);
1684 abfd
->output_has_begun
= true;
1690 /* Align to the maximum file alignment that could be required for any
1691 ELF data structure. */
1693 static INLINE file_ptr
1694 align_file_position (off
)
1697 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1700 /* Assign a file position to a section, optionally aligning to the
1701 required section alignment. */
1703 static INLINE file_ptr
1704 assign_file_position_for_section (i_shdrp
, offset
, align
)
1705 Elf_Internal_Shdr
*i_shdrp
;
1713 al
= i_shdrp
->sh_addralign
;
1715 offset
= BFD_ALIGN (offset
, al
);
1717 i_shdrp
->sh_offset
= offset
;
1718 if (i_shdrp
->bfd_section
!= NULL
)
1719 i_shdrp
->bfd_section
->filepos
= offset
;
1720 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1721 offset
+= i_shdrp
->sh_size
;
1725 /* Get the size of the program header.
1727 SORTED_HDRS, if non-NULL, is an array of COUNT pointers to headers sorted
1728 by VMA. Non-allocated sections (!SHF_ALLOC) must appear last. All
1729 section VMAs and sizes are known so we can compute the correct value.
1730 (??? This may not be perfectly true. What cases do we miss?)
1732 If SORTED_HDRS is NULL we assume there are two segments: text and data
1733 (exclusive of .interp and .dynamic).
1735 If this is called by the linker before any of the section VMA's are set, it
1736 can't calculate the correct value for a strange memory layout. This only
1737 happens when SIZEOF_HEADERS is used in a linker script. In this case,
1738 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
1739 data segment (exclusive of .interp and .dynamic).
1741 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
1742 will be two segments. */
1744 static bfd_size_type
1745 get_program_header_size (abfd
, sorted_hdrs
, count
, maxpagesize
)
1747 Elf_Internal_Shdr
**sorted_hdrs
;
1749 bfd_vma maxpagesize
;
1754 /* We can't return a different result each time we're called. */
1755 if (elf_tdata (abfd
)->program_header_size
!= 0)
1756 return elf_tdata (abfd
)->program_header_size
;
1758 if (sorted_hdrs
!= NULL
)
1761 unsigned int last_type
;
1762 Elf_Internal_Shdr
**hdrpp
;
1763 /* What we think the current segment's offset is. */
1765 /* What we think the current segment's address is. */
1767 /* How big we think the current segment is. */
1769 /* What we think the current file offset is. */
1770 bfd_vma file_offset
;
1771 bfd_vma next_offset
;
1773 /* Scan the headers and compute the number of segments required. This
1774 code is intentionally similar to the code in map_program_segments.
1776 The `sh_offset' field isn't valid at this point, so we keep our own
1777 running total in `file_offset'.
1779 This works because section VMAs are already known. */
1782 /* Make sure the first section goes in the first segment. */
1783 file_offset
= p_offset
= sorted_hdrs
[0]->sh_addr
% maxpagesize
;
1784 p_vaddr
= sorted_hdrs
[0]->sh_addr
;
1786 last_type
= SHT_PROGBITS
;
1788 for (i
= 0, hdrpp
= sorted_hdrs
; i
< count
; i
++, hdrpp
++)
1790 Elf_Internal_Shdr
*hdr
;
1794 /* Ignore any section which will not be part of the process
1796 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1799 /* Keep track of where this and the next sections go.
1800 The section VMA must equal the file position modulo
1802 file_offset
+= (hdr
->sh_addr
- file_offset
) % maxpagesize
;
1803 next_offset
= file_offset
;
1804 if (hdr
->sh_type
!= SHT_NOBITS
)
1805 next_offset
= file_offset
+ hdr
->sh_size
;
1807 /* If this section fits in the segment we are constructing, add
1809 if ((file_offset
- (p_offset
+ p_memsz
)
1810 == hdr
->sh_addr
- (p_vaddr
+ p_memsz
))
1811 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1813 bfd_size_type adjust
;
1815 adjust
= hdr
->sh_addr
- (p_vaddr
+ p_memsz
);
1816 p_memsz
+= hdr
->sh_size
+ adjust
;
1817 file_offset
= next_offset
;
1818 last_type
= hdr
->sh_type
;
1822 /* The section won't fit, start a new segment. */
1825 /* Initialize the segment. */
1826 p_vaddr
= hdr
->sh_addr
;
1827 p_memsz
= hdr
->sh_size
;
1828 p_offset
= file_offset
;
1829 file_offset
= next_offset
;
1831 last_type
= hdr
->sh_type
;
1836 /* Assume we will need exactly two PT_LOAD segments: one for text
1837 and one for data. */
1841 s
= bfd_get_section_by_name (abfd
, ".interp");
1842 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1844 /* If we have a loadable interpreter section, we need a
1845 PT_INTERP segment. In this case, assume we also need a
1846 PT_PHDR segment, although that may not be true for all
1851 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1853 /* We need a PT_DYNAMIC segment. */
1857 elf_tdata (abfd
)->program_header_size
= segs
* sizeof (Elf_External_Phdr
);
1858 return elf_tdata (abfd
)->program_header_size
;
1861 /* Create the program header. OFF is the file offset where the
1862 program header should be written. FIRST is the first loadable ELF
1863 section. SORTED_HDRS is the ELF sections sorted by section
1864 address. PHDR_SIZE is the size of the program header as returned
1865 by get_program_header_size. */
1868 map_program_segments (abfd
, off
, first
, sorted_hdrs
, phdr_size
)
1871 Elf_Internal_Shdr
*first
;
1872 Elf_Internal_Shdr
**sorted_hdrs
;
1873 bfd_size_type phdr_size
;
1875 Elf_Internal_Phdr phdrs
[10];
1876 unsigned int phdr_count
;
1877 Elf_Internal_Phdr
*phdr
;
1878 int phdr_size_adjust
;
1880 Elf_Internal_Shdr
**hdrpp
;
1881 asection
*sinterp
, *sdyn
;
1882 unsigned int last_type
;
1883 Elf_Internal_Ehdr
*i_ehdrp
;
1885 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1886 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1887 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1892 phdr_size_adjust
= 0;
1894 /* If we have a loadable .interp section, we must create a PT_INTERP
1895 segment which must precede all PT_LOAD segments. We assume that
1896 we must also create a PT_PHDR segment, although that may not be
1897 true for all targets. */
1898 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1899 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1901 BFD_ASSERT (first
!= NULL
);
1903 phdr
->p_type
= PT_PHDR
;
1905 phdr
->p_offset
= off
;
1907 /* Account for any adjustment made because of the alignment of
1908 the first loadable section. */
1909 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1910 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1912 /* The program header precedes all loadable sections. This lets
1913 us compute its loadable address. This depends on the linker
1915 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1918 phdr
->p_filesz
= phdr_size
;
1919 phdr
->p_memsz
= phdr_size
;
1921 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1922 phdr
->p_flags
= PF_R
| PF_X
;
1924 phdr
->p_align
= FILE_ALIGN
;
1925 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1927 /* Include the ELF header in the first loadable segment. */
1928 phdr_size_adjust
+= off
;
1933 phdr
->p_type
= PT_INTERP
;
1934 phdr
->p_offset
= sinterp
->filepos
;
1935 phdr
->p_vaddr
= sinterp
->vma
;
1937 phdr
->p_filesz
= sinterp
->_raw_size
;
1938 phdr
->p_memsz
= sinterp
->_raw_size
;
1939 phdr
->p_flags
= PF_R
;
1940 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1946 /* Look through the sections to see how they will be divided into
1947 program segments. The sections must be arranged in order by
1948 sh_addr for this to work correctly. */
1949 phdr
->p_type
= PT_NULL
;
1950 last_type
= SHT_PROGBITS
;
1951 for (i
= 1, hdrpp
= sorted_hdrs
;
1952 i
< elf_elfheader (abfd
)->e_shnum
;
1955 Elf_Internal_Shdr
*hdr
;
1959 /* Ignore any section which will not be part of the process
1961 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1964 /* If this section fits in the segment we are constructing, add
1966 if (phdr
->p_type
!= PT_NULL
1967 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1968 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1969 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1971 bfd_size_type adjust
;
1973 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1974 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1975 if (hdr
->sh_type
!= SHT_NOBITS
)
1976 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1977 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1978 phdr
->p_flags
|= PF_W
;
1979 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1980 phdr
->p_flags
|= PF_X
;
1981 last_type
= hdr
->sh_type
;
1985 /* The section won't fit, start a new segment. If we're already in one,
1986 move to the next one. */
1987 if (phdr
->p_type
!= PT_NULL
)
1993 /* Initialize the segment. */
1994 phdr
->p_type
= PT_LOAD
;
1995 phdr
->p_offset
= hdr
->sh_offset
;
1996 phdr
->p_vaddr
= hdr
->sh_addr
;
1998 if (hdr
->sh_type
== SHT_NOBITS
)
2001 phdr
->p_filesz
= hdr
->sh_size
;
2002 phdr
->p_memsz
= hdr
->sh_size
;
2003 phdr
->p_flags
= PF_R
;
2004 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
2005 phdr
->p_flags
|= PF_W
;
2006 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
2007 phdr
->p_flags
|= PF_X
;
2008 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
2012 && (sinterp
->flags
& SEC_LOAD
) != 0)
2014 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
2015 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
2016 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
2017 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
2020 last_type
= hdr
->sh_type
;
2023 if (phdr
->p_type
!= PT_NULL
)
2029 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
2030 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
2031 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
2033 phdr
->p_type
= PT_DYNAMIC
;
2034 phdr
->p_offset
= sdyn
->filepos
;
2035 phdr
->p_vaddr
= sdyn
->vma
;
2037 phdr
->p_filesz
= sdyn
->_raw_size
;
2038 phdr
->p_memsz
= sdyn
->_raw_size
;
2039 phdr
->p_flags
= PF_R
;
2040 if ((sdyn
->flags
& SEC_READONLY
) == 0)
2041 phdr
->p_flags
|= PF_W
;
2042 if ((sdyn
->flags
& SEC_CODE
) != 0)
2043 phdr
->p_flags
|= PF_X
;
2044 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
2050 /* Make sure the return value from get_program_header_size matches
2051 what we computed here. Actually, it's OK if we allocated too
2052 much space in the program header. */
2053 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
2056 /* Set up program header information. */
2057 i_ehdrp
= elf_elfheader (abfd
);
2058 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2059 i_ehdrp
->e_phoff
= off
;
2060 i_ehdrp
->e_phnum
= phdr_count
;
2062 /* Save the program headers away. I don't think anybody uses this
2063 information right now. */
2064 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
2067 * sizeof (Elf_Internal_Phdr
))));
2068 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
2070 bfd_set_error (bfd_error_no_memory
);
2071 return (file_ptr
) -1;
2073 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
2074 phdr_count
* sizeof (Elf_Internal_Phdr
));
2076 /* Write out the program headers. */
2077 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
2078 return (file_ptr
) -1;
2080 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
2082 Elf_External_Phdr extphdr
;
2084 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
2085 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
2086 != sizeof (Elf_External_Phdr
))
2087 return (file_ptr
) -1;
2090 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
2093 /* Work out the file positions of all the sections. This is called by
2094 elf_compute_section_file_positions. All the section sizes and VMAs
2095 must be known before this is called.
2097 We do not consider reloc sections at this point, unless they form
2098 part of the loadable image. Reloc sections are assigned file
2099 positions in assign_file_positions_for_relocs, which is called by
2100 write_object_contents and final_link.
2102 If DOSYMS is false, we do not assign file positions for the symbol
2103 table or the string table. */
2106 assign_file_positions_except_relocs (abfd
, dosyms
)
2110 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2111 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2112 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2115 /* Start after the ELF header. */
2116 off
= i_ehdrp
->e_ehsize
;
2118 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2120 Elf_Internal_Shdr
**hdrpp
;
2123 /* We are not creating an executable, which means that we are
2124 not creating a program header, and that the actual order of
2125 the sections in the file is unimportant. */
2126 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2128 Elf_Internal_Shdr
*hdr
;
2131 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2133 hdr
->sh_offset
= -1;
2137 && (i
== tdata
->symtab_section
2138 || i
== tdata
->strtab_section
))
2140 hdr
->sh_offset
= -1;
2144 off
= assign_file_position_for_section (hdr
, off
, true);
2150 bfd_size_type phdr_size
;
2151 bfd_vma maxpagesize
;
2153 Elf_Internal_Shdr
**sorted_hdrs
;
2154 Elf_Internal_Shdr
**hdrpp
;
2156 Elf_Internal_Shdr
*first
;
2159 /* We are creating an executable. */
2161 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2162 if (maxpagesize
== 0)
2165 /* We must sort the sections. The GNU linker will always create
2166 the sections in an appropriate order, but the Irix 5 linker
2167 will not. We don't include the dummy first section in the
2168 sort. We sort sections which are not SHF_ALLOC to the end. */
2169 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2170 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2171 if (sorted_hdrs
== NULL
)
2173 bfd_set_error (bfd_error_no_memory
);
2177 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2178 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2181 /* We can't actually create the program header until we have set the
2182 file positions for the sections, and we can't do that until we know
2183 how big the header is going to be. */
2184 off
= align_file_position (off
);
2185 phdr_size
= get_program_header_size (abfd
,
2186 sorted_hdrs
, i_ehdrp
->e_shnum
- 1,
2188 if (phdr_size
== (file_ptr
) -1)
2191 /* Compute the file offsets of each section. */
2195 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2197 Elf_Internal_Shdr
*hdr
;
2200 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2202 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2204 hdr
->sh_offset
= -1;
2208 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2209 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2211 hdr
->sh_offset
= -1;
2220 /* The section VMA must equal the file position modulo
2221 the page size. This is required by the program
2223 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2226 off
= assign_file_position_for_section (hdr
, off
, false);
2229 /* Create the program header. */
2230 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, sorted_hdrs
,
2232 if (phdr_map
== (file_ptr
) -1)
2234 BFD_ASSERT ((bfd_size_type
) phdr_map
<= (bfd_size_type
) phdr_off
+ phdr_size
);
2239 /* Place the section headers. */
2240 off
= align_file_position (off
);
2241 i_ehdrp
->e_shoff
= off
;
2242 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2244 elf_tdata (abfd
)->next_file_pos
= off
;
2249 /* Sort the ELF headers by VMA. We sort headers which are not
2250 SHF_ALLOC to the end. */
2253 elf_sort_hdrs (arg1
, arg2
)
2257 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2258 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2260 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2262 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2264 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2266 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2268 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2269 The main loop in map_program_segments assumes this. */
2270 return (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2274 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2284 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2285 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2286 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2288 struct bfd_strtab_hash
*shstrtab
;
2290 i_ehdrp
= elf_elfheader (abfd
);
2291 i_shdrp
= elf_elfsections (abfd
);
2293 shstrtab
= elf_stringtab_init ();
2294 if (shstrtab
== NULL
)
2297 elf_shstrtab (abfd
) = shstrtab
;
2299 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2300 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2301 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2302 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2304 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2305 i_ehdrp
->e_ident
[EI_DATA
] =
2306 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2307 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2309 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2310 i_ehdrp
->e_ident
[count
] = 0;
2312 if ((abfd
->flags
& DYNAMIC
) != 0)
2313 i_ehdrp
->e_type
= ET_DYN
;
2314 else if ((abfd
->flags
& EXEC_P
) != 0)
2315 i_ehdrp
->e_type
= ET_EXEC
;
2317 i_ehdrp
->e_type
= ET_REL
;
2319 switch (bfd_get_arch (abfd
))
2321 case bfd_arch_unknown
:
2322 i_ehdrp
->e_machine
= EM_NONE
;
2324 case bfd_arch_sparc
:
2326 i_ehdrp
->e_machine
= EM_SPARC64
;
2328 i_ehdrp
->e_machine
= EM_SPARC
;
2332 i_ehdrp
->e_machine
= EM_386
;
2335 i_ehdrp
->e_machine
= EM_68K
;
2338 i_ehdrp
->e_machine
= EM_88K
;
2341 i_ehdrp
->e_machine
= EM_860
;
2343 case bfd_arch_mips
: /* MIPS Rxxxx */
2344 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2347 i_ehdrp
->e_machine
= EM_PARISC
;
2349 case bfd_arch_powerpc
:
2350 i_ehdrp
->e_machine
= EM_PPC
;
2352 /* start-sanitize-arc */
2354 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2356 /* end-sanitize-arc */
2357 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2359 i_ehdrp
->e_machine
= EM_NONE
;
2361 i_ehdrp
->e_version
= EV_CURRENT
;
2362 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2364 /* no program header, for now. */
2365 i_ehdrp
->e_phoff
= 0;
2366 i_ehdrp
->e_phentsize
= 0;
2367 i_ehdrp
->e_phnum
= 0;
2369 /* each bfd section is section header entry */
2370 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2371 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2373 /* if we're building an executable, we'll need a program header table */
2374 if (abfd
->flags
& EXEC_P
)
2376 /* it all happens later */
2378 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2380 /* elf_build_phdrs() returns a (NULL-terminated) array of
2381 Elf_Internal_Phdrs */
2382 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2383 i_ehdrp
->e_phoff
= outbase
;
2384 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2389 i_ehdrp
->e_phentsize
= 0;
2391 i_ehdrp
->e_phoff
= 0;
2394 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2395 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2396 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2397 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2398 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2399 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2400 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2401 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2402 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2409 swap_out_syms (abfd
, sttp
)
2411 struct bfd_strtab_hash
**sttp
;
2413 if (!elf_map_symbols (abfd
))
2416 /* Dump out the symtabs. */
2418 int symcount
= bfd_get_symcount (abfd
);
2419 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2420 struct bfd_strtab_hash
*stt
;
2421 Elf_Internal_Shdr
*symtab_hdr
;
2422 Elf_Internal_Shdr
*symstrtab_hdr
;
2423 Elf_External_Sym
*outbound_syms
;
2426 stt
= elf_stringtab_init ();
2430 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2431 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2432 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2433 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2434 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2435 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2437 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2438 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2440 outbound_syms
= ((Elf_External_Sym
*)
2442 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2443 if (outbound_syms
== NULL
)
2445 bfd_set_error (bfd_error_no_memory
);
2448 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2450 /* now generate the data (for "contents") */
2452 /* Fill in zeroth symbol and swap it out. */
2453 Elf_Internal_Sym sym
;
2459 sym
.st_shndx
= SHN_UNDEF
;
2460 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2463 for (idx
= 0; idx
< symcount
; idx
++)
2465 Elf_Internal_Sym sym
;
2466 bfd_vma value
= syms
[idx
]->value
;
2467 elf_symbol_type
*type_ptr
;
2469 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2470 /* Section symbols have no names. */
2474 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2477 if (sym
.st_name
== (unsigned long) -1)
2481 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2483 if (bfd_is_com_section (syms
[idx
]->section
))
2485 /* ELF common symbols put the alignment into the `value' field,
2486 and the size into the `size' field. This is backwards from
2487 how BFD handles it, so reverse it here. */
2488 sym
.st_size
= value
;
2489 if (type_ptr
== NULL
2490 || type_ptr
->internal_elf_sym
.st_value
== 0)
2491 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2493 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2494 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2495 syms
[idx
]->section
);
2499 asection
*sec
= syms
[idx
]->section
;
2502 if (sec
->output_section
)
2504 value
+= sec
->output_offset
;
2505 sec
= sec
->output_section
;
2508 sym
.st_value
= value
;
2509 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2510 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2514 /* Writing this would be a hell of a lot easier if we had
2515 some decent documentation on bfd, and knew what to expect
2516 of the library, and what to demand of applications. For
2517 example, it appears that `objcopy' might not set the
2518 section of a symbol to be a section that is actually in
2520 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2521 BFD_ASSERT (sec2
!= 0);
2522 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2523 BFD_ASSERT (shndx
!= -1);
2527 if (bfd_is_com_section (syms
[idx
]->section
))
2528 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2529 else if (bfd_is_und_section (syms
[idx
]->section
))
2530 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2531 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2534 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2535 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2536 else if (syms
[idx
]->flags
& BSF_FILE
)
2537 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2540 int bind
= STB_LOCAL
;
2541 int type
= STT_OBJECT
;
2542 unsigned int flags
= syms
[idx
]->flags
;
2544 if (flags
& BSF_LOCAL
)
2546 else if (flags
& BSF_WEAK
)
2548 else if (flags
& BSF_GLOBAL
)
2551 if (flags
& BSF_FUNCTION
)
2554 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2558 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2563 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2564 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2566 symstrtab_hdr
->sh_flags
= 0;
2567 symstrtab_hdr
->sh_addr
= 0;
2568 symstrtab_hdr
->sh_entsize
= 0;
2569 symstrtab_hdr
->sh_link
= 0;
2570 symstrtab_hdr
->sh_info
= 0;
2571 symstrtab_hdr
->sh_addralign
= 1;
2578 write_shdrs_and_ehdr (abfd
)
2581 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2582 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2583 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2584 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2587 i_ehdrp
= elf_elfheader (abfd
);
2588 i_shdrp
= elf_elfsections (abfd
);
2590 /* swap the header before spitting it out... */
2593 elf_debug_file (i_ehdrp
);
2595 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2596 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2597 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2598 != sizeof (x_ehdr
)))
2601 /* at this point we've concocted all the ELF sections... */
2602 x_shdrp
= (Elf_External_Shdr
*)
2603 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2606 bfd_set_error (bfd_error_no_memory
);
2610 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2613 elf_debug_section (count
, i_shdrp
[count
]);
2615 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2617 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2618 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2619 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2622 /* need to dump the string table too... */
2627 /* Assign file positions for all the reloc sections which are not part
2628 of the loadable file image. */
2631 assign_file_positions_for_relocs (abfd
)
2636 Elf_Internal_Shdr
**shdrpp
;
2638 off
= elf_tdata (abfd
)->next_file_pos
;
2640 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2641 i
< elf_elfheader (abfd
)->e_shnum
;
2644 Elf_Internal_Shdr
*shdrp
;
2647 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2648 && shdrp
->sh_offset
== -1)
2649 off
= assign_file_position_for_section (shdrp
, off
, true);
2652 elf_tdata (abfd
)->next_file_pos
= off
;
2656 NAME(bfd_elf
,write_object_contents
) (abfd
)
2659 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2660 Elf_Internal_Ehdr
*i_ehdrp
;
2661 Elf_Internal_Shdr
**i_shdrp
;
2664 if (! abfd
->output_has_begun
2665 && ! elf_compute_section_file_positions (abfd
,
2666 (struct bfd_link_info
*) NULL
))
2669 i_shdrp
= elf_elfsections (abfd
);
2670 i_ehdrp
= elf_elfheader (abfd
);
2672 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2673 assign_file_positions_for_relocs (abfd
);
2675 /* After writing the headers, we need to write the sections too... */
2676 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2678 if (bed
->elf_backend_section_processing
)
2679 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2680 if (i_shdrp
[count
]->contents
)
2682 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2683 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2685 != i_shdrp
[count
]->sh_size
))
2690 /* Write out the section header names. */
2691 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2692 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2695 if (bed
->elf_backend_final_write_processing
)
2696 (*bed
->elf_backend_final_write_processing
) (abfd
,
2697 elf_tdata (abfd
)->linker
);
2699 return write_shdrs_and_ehdr (abfd
);
2702 /* Given an ELF section number, retrieve the corresponding BFD
2706 section_from_elf_index (abfd
, index
)
2710 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2711 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2713 return elf_elfsections (abfd
)[index
]->bfd_section
;
2716 /* given a section, search the header to find them... */
2718 elf_section_from_bfd_section (abfd
, asect
)
2722 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2723 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2725 Elf_Internal_Shdr
*hdr
;
2726 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2728 for (index
= 0; index
< maxindex
; index
++)
2730 hdr
= i_shdrp
[index
];
2731 if (hdr
->bfd_section
== asect
)
2735 if (bed
->elf_backend_section_from_bfd_section
)
2737 for (index
= 0; index
< maxindex
; index
++)
2741 hdr
= i_shdrp
[index
];
2743 if ((*bed
->elf_backend_section_from_bfd_section
)
2744 (abfd
, hdr
, asect
, &retval
))
2749 if (bfd_is_abs_section (asect
))
2751 if (bfd_is_com_section (asect
))
2753 if (bfd_is_und_section (asect
))
2759 /* given a symbol, return the bfd index for that symbol. */
2761 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2763 struct symbol_cache_entry
**asym_ptr_ptr
;
2765 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2767 flagword flags
= asym_ptr
->flags
;
2769 /* When gas creates relocations against local labels, it creates its
2770 own symbol for the section, but does put the symbol into the
2771 symbol chain, so udata is 0. When the linker is generating
2772 relocatable output, this section symbol may be for one of the
2773 input sections rather than the output section. */
2774 if (asym_ptr
->udata
.i
== 0
2775 && (flags
& BSF_SECTION_SYM
)
2776 && asym_ptr
->section
)
2780 if (asym_ptr
->section
->output_section
!= NULL
)
2781 indx
= asym_ptr
->section
->output_section
->index
;
2783 indx
= asym_ptr
->section
->index
;
2784 if (elf_section_syms (abfd
)[indx
])
2785 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2788 idx
= asym_ptr
->udata
.i
;
2796 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2797 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2806 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2808 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2811 Elf_Internal_Shdr
*hdr
;
2812 long symcount
; /* Number of external ELF symbols */
2813 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2814 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2815 Elf_Internal_Sym i_sym
;
2816 Elf_External_Sym
*x_symp
= NULL
;
2818 /* Read each raw ELF symbol, converting from external ELF form to
2819 internal ELF form, and then using the information to create a
2820 canonical bfd symbol table entry.
2822 Note that we allocate the initial bfd canonical symbol buffer
2823 based on a one-to-one mapping of the ELF symbols to canonical
2824 symbols. We actually use all the ELF symbols, so there will be no
2825 space left over at the end. When we have all the symbols, we
2826 build the caller's pointer vector. */
2829 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2831 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2832 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2835 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2838 sym
= symbase
= NULL
;
2843 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2846 symbase
= ((elf_symbol_type
*)
2847 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2848 if (symbase
== (elf_symbol_type
*) NULL
)
2850 bfd_set_error (bfd_error_no_memory
);
2855 /* Temporarily allocate room for the raw ELF symbols. */
2856 x_symp
= ((Elf_External_Sym
*)
2857 malloc (symcount
* sizeof (Elf_External_Sym
)));
2858 if (x_symp
== NULL
&& symcount
!= 0)
2860 bfd_set_error (bfd_error_no_memory
);
2864 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2865 != symcount
* sizeof (Elf_External_Sym
))
2867 /* Skip first symbol, which is a null dummy. */
2868 for (i
= 1; i
< symcount
; i
++)
2870 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2871 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2872 #ifdef ELF_KEEP_EXTSYM
2873 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2875 sym
->symbol
.the_bfd
= abfd
;
2877 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2880 sym
->symbol
.value
= i_sym
.st_value
;
2882 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2884 sym
->symbol
.section
= section_from_elf_index (abfd
,
2886 if (sym
->symbol
.section
== NULL
)
2888 /* This symbol is in a section for which we did not
2889 create a BFD section. Just use bfd_abs_section,
2890 although it is wrong. FIXME. */
2891 sym
->symbol
.section
= bfd_abs_section_ptr
;
2894 else if (i_sym
.st_shndx
== SHN_ABS
)
2896 sym
->symbol
.section
= bfd_abs_section_ptr
;
2898 else if (i_sym
.st_shndx
== SHN_COMMON
)
2900 sym
->symbol
.section
= bfd_com_section_ptr
;
2901 /* Elf puts the alignment into the `value' field, and
2902 the size into the `size' field. BFD wants to see the
2903 size in the value field, and doesn't care (at the
2904 moment) about the alignment. */
2905 sym
->symbol
.value
= i_sym
.st_size
;
2907 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2909 sym
->symbol
.section
= bfd_und_section_ptr
;
2912 sym
->symbol
.section
= bfd_abs_section_ptr
;
2914 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2916 switch (ELF_ST_BIND (i_sym
.st_info
))
2919 sym
->symbol
.flags
|= BSF_LOCAL
;
2922 if (i_sym
.st_shndx
!= SHN_UNDEF
2923 && i_sym
.st_shndx
!= SHN_COMMON
)
2924 sym
->symbol
.flags
|= BSF_GLOBAL
;
2927 sym
->symbol
.flags
|= BSF_WEAK
;
2931 switch (ELF_ST_TYPE (i_sym
.st_info
))
2934 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2937 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2940 sym
->symbol
.flags
|= BSF_FUNCTION
;
2945 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2947 /* Do some backend-specific processing on this symbol. */
2949 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2950 if (ebd
->elf_backend_symbol_processing
)
2951 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2958 /* Do some backend-specific processing on this symbol table. */
2960 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2961 if (ebd
->elf_backend_symbol_table_processing
)
2962 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2965 /* We rely on the zalloc to clear out the final symbol entry. */
2967 symcount
= sym
- symbase
;
2969 /* Fill in the user's symbol pointer vector if needed. */
2977 *symptrs
++ = &sym
->symbol
;
2980 *symptrs
= 0; /* Final null pointer */
2992 /* Return the number of bytes required to hold the symtab vector.
2994 Note that we base it on the count plus 1, since we will null terminate
2995 the vector allocated based on this size. However, the ELF symbol table
2996 always has a dummy entry as symbol #0, so it ends up even. */
2999 elf_get_symtab_upper_bound (abfd
)
3004 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3006 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3007 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3013 elf_get_dynamic_symtab_upper_bound (abfd
)
3018 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3020 if (elf_dynsymtab (abfd
) == 0)
3022 bfd_set_error (bfd_error_invalid_operation
);
3026 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3027 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3033 elf_get_reloc_upper_bound (abfd
, asect
)
3037 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3040 /* Read in and swap the external relocs. */
3043 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3048 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
3049 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
3050 PTR allocated
= NULL
;
3051 bfd_byte
*native_relocs
;
3057 if (asect
->relocation
!= NULL
3058 || (asect
->flags
& SEC_RELOC
) == 0
3059 || asect
->reloc_count
== 0)
3062 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
3063 && (asect
->reloc_count
3064 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
3066 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
3067 if (allocated
== NULL
)
3069 bfd_set_error (bfd_error_no_memory
);
3073 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
3074 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
3075 != d
->rel_hdr
.sh_size
))
3078 native_relocs
= (bfd_byte
*) allocated
;
3080 relents
= ((arelent
*)
3081 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
3082 if (relents
== NULL
)
3084 bfd_set_error (bfd_error_no_memory
);
3088 entsize
= d
->rel_hdr
.sh_entsize
;
3089 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
3090 || entsize
== sizeof (Elf_External_Rela
));
3092 for (i
= 0, relent
= relents
;
3093 i
< asect
->reloc_count
;
3094 i
++, relent
++, native_relocs
+= entsize
)
3096 Elf_Internal_Rela rela
;
3097 Elf_Internal_Rel rel
;
3099 if (entsize
== sizeof (Elf_External_Rela
))
3100 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
3103 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
3104 rela
.r_offset
= rel
.r_offset
;
3105 rela
.r_info
= rel
.r_info
;
3109 /* The address of an ELF reloc is section relative for an object
3110 file, and absolute for an executable file or shared library.
3111 The address of a BFD reloc is always section relative. */
3112 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3113 relent
->address
= rela
.r_offset
;
3115 relent
->address
= rela
.r_offset
- asect
->vma
;
3117 if (ELF_R_SYM (rela
.r_info
) == 0)
3118 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3123 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3126 /* Canonicalize ELF section symbols. FIXME: Why? */
3127 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3128 relent
->sym_ptr_ptr
= ps
;
3130 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3133 relent
->addend
= rela
.r_addend
;
3135 if (entsize
== sizeof (Elf_External_Rela
))
3136 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3138 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3141 asect
->relocation
= relents
;
3143 if (allocated
!= NULL
)
3149 if (allocated
!= NULL
)
3156 elf_debug_section (num
, hdr
)
3158 Elf_Internal_Shdr
*hdr
;
3160 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3161 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3164 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3165 (long) hdr
->sh_name
,
3166 (long) hdr
->sh_type
,
3167 (long) hdr
->sh_flags
);
3169 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3170 (long) hdr
->sh_addr
,
3171 (long) hdr
->sh_offset
,
3172 (long) hdr
->sh_size
);
3174 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3175 (long) hdr
->sh_link
,
3176 (long) hdr
->sh_info
,
3177 (long) hdr
->sh_addralign
);
3178 fprintf (stderr
, "sh_entsize = %ld\n",
3179 (long) hdr
->sh_entsize
);
3184 elf_debug_file (ehdrp
)
3185 Elf_Internal_Ehdr
*ehdrp
;
3187 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3188 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3189 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3190 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3191 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3192 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3193 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3197 /* Canonicalize the relocs. */
3200 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3209 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3212 tblptr
= section
->relocation
;
3213 for (i
= 0; i
< section
->reloc_count
; i
++)
3214 *relptr
++ = tblptr
++;
3218 return section
->reloc_count
;
3222 elf_get_symtab (abfd
, alocation
)
3224 asymbol
**alocation
;
3226 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3229 bfd_get_symcount (abfd
) = symcount
;
3234 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3236 asymbol
**alocation
;
3238 return elf_slurp_symbol_table (abfd
, alocation
, true);
3242 elf_make_empty_symbol (abfd
)
3245 elf_symbol_type
*newsym
;
3247 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3250 bfd_set_error (bfd_error_no_memory
);
3255 newsym
->symbol
.the_bfd
= abfd
;
3256 return &newsym
->symbol
;
3261 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3266 bfd_symbol_info (symbol
, ret
);
3270 elf_get_lineno (ignore_abfd
, symbol
)
3274 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3281 elf_set_arch_mach (abfd
, arch
, machine
)
3283 enum bfd_architecture arch
;
3284 unsigned long machine
;
3286 /* If this isn't the right architecture for this backend, and this
3287 isn't the generic backend, fail. */
3288 if (arch
!= get_elf_backend_data (abfd
)->arch
3289 && arch
!= bfd_arch_unknown
3290 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3293 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3297 elf_find_nearest_line (abfd
,
3308 CONST
char **filename_ptr
;
3309 CONST
char **functionname_ptr
;
3310 unsigned int *line_ptr
;
3316 elf_sizeof_headers (abfd
, reloc
)
3322 ret
= sizeof (Elf_External_Ehdr
);
3324 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
3330 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3335 bfd_size_type count
;
3337 Elf_Internal_Shdr
*hdr
;
3339 if (! abfd
->output_has_begun
3340 && ! elf_compute_section_file_positions (abfd
,
3341 (struct bfd_link_info
*) NULL
))
3344 hdr
= &elf_section_data (section
)->this_hdr
;
3346 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3348 if (bfd_write (location
, 1, count
, abfd
) != count
)
3355 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3358 Elf_Internal_Rela
*dst
;
3360 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3366 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3369 Elf_Internal_Rel
*dst
;
3371 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3377 /* Core file support */
3379 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3380 #include <sys/procfs.h>
3382 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3383 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3384 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3390 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3397 prstatus_t
*status
= (prstatus_t
*) 0;
3399 if (descsz
== sizeof (prstatus_t
))
3401 newsect
= bfd_make_section (abfd
, ".reg");
3402 if (newsect
== NULL
)
3404 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3405 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3406 newsect
->flags
= SEC_HAS_CONTENTS
;
3407 newsect
->alignment_power
= 2;
3408 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3410 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3416 /* Stash a copy of the prpsinfo structure away for future use. */
3419 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3425 if (descsz
== sizeof (prpsinfo_t
))
3427 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3429 bfd_set_error (bfd_error_no_memory
);
3432 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3438 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3446 newsect
= bfd_make_section (abfd
, ".reg2");
3447 if (newsect
== NULL
)
3449 newsect
->_raw_size
= descsz
;
3450 newsect
->filepos
= filepos
;
3451 newsect
->flags
= SEC_HAS_CONTENTS
;
3452 newsect
->alignment_power
= 2;
3456 #endif /* HAVE_PROCFS */
3458 /* Return a pointer to the args (including the command name) that were
3459 seen by the program that generated the core dump. Note that for
3460 some reason, a spurious space is tacked onto the end of the args
3461 in some (at least one anyway) implementations, so strip it off if
3465 elf_core_file_failing_command (abfd
)
3469 if (core_prpsinfo (abfd
))
3471 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3472 char *scan
= p
->pr_psargs
;
3477 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3481 return p
->pr_psargs
;
3487 /* Return the number of the signal that caused the core dump. Presumably,
3488 since we have a core file, we got a signal of some kind, so don't bother
3489 checking the other process status fields, just return the signal number.
3493 elf_core_file_failing_signal (abfd
)
3497 if (core_prstatus (abfd
))
3499 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3505 /* Check to see if the core file could reasonably be expected to have
3506 come for the current executable file. Note that by default we return
3507 true unless we find something that indicates that there might be a
3512 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3521 /* First, xvecs must match since both are ELF files for the same target. */
3523 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3525 bfd_set_error (bfd_error_system_call
);
3531 /* If no prpsinfo, just return true. Otherwise, grab the last component
3532 of the exec'd pathname from the prpsinfo. */
3534 if (core_prpsinfo (core_bfd
))
3536 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3543 /* Find the last component of the executable pathname. */
3545 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3551 execname
= (char *) exec_bfd
->filename
;
3554 /* See if they match */
3556 return strcmp (execname
, corename
) ? false : true;
3562 #endif /* HAVE_PROCFS */
3565 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3566 the information that would normally be available from the /proc interface
3567 for the process, at the time the process dumped core. Currently this
3568 includes copies of the prstatus, prpsinfo, and fpregset structures.
3570 Since these structures are potentially machine dependent in size and
3571 ordering, bfd provides two levels of support for them. The first level,
3572 available on all machines since it does not require that the host
3573 have /proc support or the relevant include files, is to create a bfd
3574 section for each of the prstatus, prpsinfo, and fpregset structures,
3575 without any interpretation of their contents. With just this support,
3576 the bfd client will have to interpret the structures itself. Even with
3577 /proc support, it might want these full structures for it's own reasons.
3579 In the second level of support, where HAVE_PROCFS is defined, bfd will
3580 pick apart the structures to gather some additional information that
3581 clients may want, such as the general register set, the name of the
3582 exec'ed file and its arguments, the signal (if any) that caused the
3588 elf_corefile_note (abfd
, hdr
)
3590 Elf_Internal_Phdr
*hdr
;
3592 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3593 Elf_Internal_Note i_note
; /* Elf note, internal form */
3594 char *buf
= NULL
; /* Entire note segment contents */
3595 char *namedata
; /* Name portion of the note */
3596 char *descdata
; /* Descriptor portion of the note */
3597 char *sectname
; /* Name to use for new section */
3598 long filepos
; /* File offset to descriptor data */
3601 if (hdr
->p_filesz
> 0
3602 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3603 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3604 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3606 x_note_p
= (Elf_External_Note
*) buf
;
3607 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3609 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3610 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3611 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3612 namedata
= x_note_p
->name
;
3613 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3614 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3615 switch (i_note
.type
)
3618 /* process descdata as prstatus info */
3619 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3621 sectname
= ".prstatus";
3624 /* process descdata as fpregset info */
3625 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3627 sectname
= ".fpregset";
3630 /* process descdata as prpsinfo */
3631 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3633 sectname
= ".prpsinfo";
3636 /* Unknown descriptor, just ignore it. */
3640 if (sectname
!= NULL
)
3642 newsect
= bfd_make_section (abfd
, sectname
);
3643 if (newsect
== NULL
)
3645 newsect
->_raw_size
= i_note
.descsz
;
3646 newsect
->filepos
= filepos
;
3647 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3648 newsect
->alignment_power
= 2;
3650 x_note_p
= (Elf_External_Note
*)
3651 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3658 else if (hdr
->p_filesz
> 0)
3660 bfd_set_error (bfd_error_no_memory
);
3667 /* Core files are simply standard ELF formatted files that partition
3668 the file using the execution view of the file (program header table)
3669 rather than the linking view. In fact, there is no section header
3670 table in a core file.
3672 The process status information (including the contents of the general
3673 register set) and the floating point register set are stored in a
3674 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3675 that allow standard bfd access to the general registers (.reg) and the
3676 floating point registers (.reg2).
3681 elf_core_file_p (abfd
)
3684 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3685 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3686 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3687 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3688 unsigned int phindex
;
3689 struct elf_backend_data
*ebd
;
3691 /* Read in the ELF header in external format. */
3693 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3695 if (bfd_get_error () != bfd_error_system_call
)
3696 bfd_set_error (bfd_error_wrong_format
);
3700 /* Now check to see if we have a valid ELF file, and one that BFD can
3701 make use of. The magic number must match, the address size ('class')
3702 and byte-swapping must match our XVEC entry, and it must have a
3703 program header table (FIXME: See comments re segments at top of this
3706 if (elf_file_p (&x_ehdr
) == false)
3709 bfd_set_error (bfd_error_wrong_format
);
3713 /* FIXME, Check EI_VERSION here ! */
3717 int desired_address_size
= ELFCLASS32
;
3720 int desired_address_size
= ELFCLASS64
;
3723 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3727 /* Switch xvec to match the specified byte order. */
3728 switch (x_ehdr
.e_ident
[EI_DATA
])
3730 case ELFDATA2MSB
: /* Big-endian */
3731 if (abfd
->xvec
->byteorder_big_p
== false)
3734 case ELFDATA2LSB
: /* Little-endian */
3735 if (abfd
->xvec
->byteorder_big_p
== true)
3738 case ELFDATANONE
: /* No data encoding specified */
3739 default: /* Unknown data encoding specified */
3743 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3744 the tdata pointer in the bfd. */
3747 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3748 if (elf_tdata (abfd
) == NULL
)
3750 bfd_set_error (bfd_error_no_memory
);
3754 /* FIXME, `wrong' returns from this point onward, leak memory. */
3756 /* Now that we know the byte order, swap in the rest of the header */
3757 i_ehdrp
= elf_elfheader (abfd
);
3758 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3760 elf_debug_file (i_ehdrp
);
3763 ebd
= get_elf_backend_data (abfd
);
3765 /* Check that the ELF e_machine field matches what this particular
3766 BFD format expects. */
3767 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3769 const bfd_target
* const *target_ptr
;
3771 if (ebd
->elf_machine_code
!= EM_NONE
)
3774 /* This is the generic ELF target. Let it match any ELF target
3775 for which we do not have a specific backend. */
3776 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3778 struct elf_backend_data
*back
;
3780 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3782 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3783 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3785 /* target_ptr is an ELF backend which matches this
3786 object file, so reject the generic ELF target. */
3792 /* If there is no program header, or the type is not a core file, then
3794 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3797 /* Allocate space for a copy of the program header table in
3798 internal form, seek to the program header table in the file,
3799 read it in, and convert it to internal form. As a simple sanity
3800 check, verify that the what BFD thinks is the size of each program
3801 header table entry actually matches the size recorded in the file. */
3803 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3805 i_phdrp
= (Elf_Internal_Phdr
*)
3806 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3809 bfd_set_error (bfd_error_no_memory
);
3812 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3814 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3816 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3819 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3822 /* Once all of the program headers have been read and converted, we
3823 can start processing them. */
3825 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3827 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3828 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3830 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3835 /* Remember the entry point specified in the ELF file header. */
3837 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3842 /* ELF linker code. */
3844 static boolean elf_link_add_object_symbols
3845 PARAMS ((bfd
*, struct bfd_link_info
*));
3846 static boolean elf_link_add_archive_symbols
3847 PARAMS ((bfd
*, struct bfd_link_info
*));
3848 static Elf_Internal_Rela
*elf_link_read_relocs
3849 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3850 static boolean elf_export_symbol
3851 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3852 static boolean elf_adjust_dynamic_symbol
3853 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3855 /* Given an ELF BFD, add symbols to the global hash table as
3859 elf_bfd_link_add_symbols (abfd
, info
)
3861 struct bfd_link_info
*info
;
3865 switch (bfd_get_format (abfd
))
3868 return elf_link_add_object_symbols (abfd
, info
);
3870 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3873 if (! bfd_check_format (first
, bfd_object
))
3875 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3877 /* On Linux, we may have an a.out archive which got
3878 recognized as an ELF archive. Therefore, we treat all
3879 archives as though they were actually of the flavour of
3880 their first element. */
3881 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3883 return elf_link_add_archive_symbols (abfd
, info
);
3885 bfd_set_error (bfd_error_wrong_format
);
3890 /* Add symbols from an ELF archive file to the linker hash table. We
3891 don't use _bfd_generic_link_add_archive_symbols because of a
3892 problem which arises on UnixWare. The UnixWare libc.so is an
3893 archive which includes an entry libc.so.1 which defines a bunch of
3894 symbols. The libc.so archive also includes a number of other
3895 object files, which also define symbols, some of which are the same
3896 as those defined in libc.so.1. Correct linking requires that we
3897 consider each object file in turn, and include it if it defines any
3898 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3899 this; it looks through the list of undefined symbols, and includes
3900 any object file which defines them. When this algorithm is used on
3901 UnixWare, it winds up pulling in libc.so.1 early and defining a
3902 bunch of symbols. This means that some of the other objects in the
3903 archive are not included in the link, which is incorrect since they
3904 precede libc.so.1 in the archive.
3906 Fortunately, ELF archive handling is simpler than that done by
3907 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3908 oddities. In ELF, if we find a symbol in the archive map, and the
3909 symbol is currently undefined, we know that we must pull in that
3912 Unfortunately, we do have to make multiple passes over the symbol
3913 table until nothing further is resolved. */
3916 elf_link_add_archive_symbols (abfd
, info
)
3918 struct bfd_link_info
*info
;
3921 boolean
*defined
= NULL
;
3922 boolean
*included
= NULL
;
3926 if (! bfd_has_map (abfd
))
3928 /* An empty archive is a special case. */
3929 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3931 bfd_set_error (bfd_error_no_symbols
);
3935 /* Keep track of all symbols we know to be already defined, and all
3936 files we know to be already included. This is to speed up the
3937 second and subsequent passes. */
3938 c
= bfd_ardata (abfd
)->symdef_count
;
3941 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3942 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3943 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3945 bfd_set_error (bfd_error_no_memory
);
3948 memset (defined
, 0, c
* sizeof (boolean
));
3949 memset (included
, 0, c
* sizeof (boolean
));
3951 symdefs
= bfd_ardata (abfd
)->symdefs
;
3964 symdefend
= symdef
+ c
;
3965 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3967 struct elf_link_hash_entry
*h
;
3969 struct bfd_link_hash_entry
*undefs_tail
;
3972 if (defined
[i
] || included
[i
])
3974 if (symdef
->file_offset
== last
)
3980 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3981 false, false, false);
3982 if (h
== (struct elf_link_hash_entry
*) NULL
)
3984 if (h
->root
.type
!= bfd_link_hash_undefined
)
3990 /* We need to include this archive member. */
3992 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3993 if (element
== (bfd
*) NULL
)
3996 if (! bfd_check_format (element
, bfd_object
))
3999 /* Doublecheck that we have not included this object
4000 already--it should be impossible, but there may be
4001 something wrong with the archive. */
4002 if (element
->archive_pass
!= 0)
4004 bfd_set_error (bfd_error_bad_value
);
4007 element
->archive_pass
= 1;
4009 undefs_tail
= info
->hash
->undefs_tail
;
4011 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4014 if (! elf_link_add_object_symbols (element
, info
))
4017 /* If there are any new undefined symbols, we need to make
4018 another pass through the archive in order to see whether
4019 they can be defined. FIXME: This isn't perfect, because
4020 common symbols wind up on undefs_tail and because an
4021 undefined symbol which is defined later on in this pass
4022 does not require another pass. This isn't a bug, but it
4023 does make the code less efficient than it could be. */
4024 if (undefs_tail
!= info
->hash
->undefs_tail
)
4027 /* Look backward to mark all symbols from this object file
4028 which we have already seen in this pass. */
4032 included
[mark
] = true;
4037 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4039 /* We mark subsequent symbols from this object file as we go
4040 on through the loop. */
4041 last
= symdef
->file_offset
;
4052 if (defined
!= (boolean
*) NULL
)
4054 if (included
!= (boolean
*) NULL
)
4059 /* Record a new dynamic symbol. We record the dynamic symbols as we
4060 read the input files, since we need to have a list of all of them
4061 before we can determine the final sizes of the output sections.
4062 Note that we may actually call this function even though we are not
4063 going to output any dynamic symbols; in some cases we know that a
4064 symbol should be in the dynamic symbol table, but only if there is
4068 elf_link_record_dynamic_symbol (info
, h
)
4069 struct bfd_link_info
*info
;
4070 struct elf_link_hash_entry
*h
;
4072 if (h
->dynindx
== -1)
4074 struct bfd_strtab_hash
*dynstr
;
4076 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4077 ++elf_hash_table (info
)->dynsymcount
;
4079 dynstr
= elf_hash_table (info
)->dynstr
;
4082 /* Create a strtab to hold the dynamic symbol names. */
4083 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
4088 h
->dynstr_index
= ((unsigned long)
4089 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
4091 if (h
->dynstr_index
== (unsigned long) -1)
4098 /* Add symbols from an ELF object file to the linker hash table. */
4101 elf_link_add_object_symbols (abfd
, info
)
4103 struct bfd_link_info
*info
;
4105 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4106 const Elf_Internal_Sym
*,
4107 const char **, flagword
*,
4108 asection
**, bfd_vma
*));
4109 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4110 asection
*, const Elf_Internal_Rela
*));
4112 Elf_Internal_Shdr
*hdr
;
4116 Elf_External_Sym
*buf
= NULL
;
4117 struct elf_link_hash_entry
**sym_hash
;
4119 Elf_External_Dyn
*dynbuf
= NULL
;
4120 struct elf_link_hash_entry
*weaks
;
4121 Elf_External_Sym
*esym
;
4122 Elf_External_Sym
*esymend
;
4124 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4125 collect
= get_elf_backend_data (abfd
)->collect
;
4127 /* A stripped shared library might only have a dynamic symbol table,
4128 not a regular symbol table. In that case we can still go ahead
4129 and link using the dynamic symbol table. */
4130 if (elf_onesymtab (abfd
) == 0
4131 && elf_dynsymtab (abfd
) != 0)
4133 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4134 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4137 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4138 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4140 /* The sh_info field of the symtab header tells us where the
4141 external symbols start. We don't care about the local symbols at
4143 if (elf_bad_symtab (abfd
))
4145 extsymcount
= symcount
;
4150 extsymcount
= symcount
- hdr
->sh_info
;
4151 extsymoff
= hdr
->sh_info
;
4154 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4155 if (buf
== NULL
&& extsymcount
!= 0)
4157 bfd_set_error (bfd_error_no_memory
);
4161 /* We store a pointer to the hash table entry for each external
4163 sym_hash
= ((struct elf_link_hash_entry
**)
4165 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4166 if (sym_hash
== NULL
)
4168 bfd_set_error (bfd_error_no_memory
);
4171 elf_sym_hashes (abfd
) = sym_hash
;
4173 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4177 /* If we are creating a shared library, create all the dynamic
4178 sections immediately. We need to attach them to something,
4179 so we attach them to this BFD, provided it is the right
4180 format. FIXME: If there are no input BFD's of the same
4181 format as the output, we can't make a shared library. */
4183 && ! elf_hash_table (info
)->dynamic_sections_created
4184 && abfd
->xvec
== info
->hash
->creator
)
4186 if (! elf_link_create_dynamic_sections (abfd
, info
))
4194 bfd_size_type strindex
;
4198 /* You can't use -r against a dynamic object. Also, there's no
4199 hope of using a dynamic object which does not exactly match
4200 the format of the output file. */
4201 if (info
->relocateable
4202 || info
->hash
->creator
!= abfd
->xvec
)
4204 bfd_set_error (bfd_error_invalid_operation
);
4208 /* Find the name to use in a DT_NEEDED entry that refers to this
4209 object. If the object has a DT_SONAME entry, we use it.
4210 Otherwise, if the generic linker stuck something in
4211 elf_dt_needed_name, we use that. Otherwise, we just use the
4213 name
= bfd_get_filename (abfd
);
4214 if (elf_dt_needed_name (abfd
) != NULL
)
4215 name
= elf_dt_needed_name (abfd
);
4216 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4219 Elf_External_Dyn
*extdyn
;
4220 Elf_External_Dyn
*extdynend
;
4222 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4225 bfd_set_error (bfd_error_no_memory
);
4229 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4230 (file_ptr
) 0, s
->_raw_size
))
4234 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4235 for (; extdyn
< extdynend
; extdyn
++)
4237 Elf_Internal_Dyn dyn
;
4239 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4240 if (dyn
.d_tag
== DT_SONAME
)
4245 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4248 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4249 name
= elf_string_from_elf_section (abfd
, link
,
4254 if (dyn
.d_tag
== DT_NEEDED
)
4255 elf_hash_table (info
)->saw_needed
= true;
4262 /* We do not want to include any of the sections in a dynamic
4263 object in the output file. We hack by simply clobbering the
4264 list of sections in the BFD. This could be handled more
4265 cleanly by, say, a new section flag; the existing
4266 SEC_NEVER_LOAD flag is not the one we want, because that one
4267 still implies that the section takes up space in the output
4269 abfd
->sections
= NULL
;
4271 /* If this is the first dynamic object found in the link, create
4272 the special sections required for dynamic linking. */
4273 if (! elf_hash_table (info
)->dynamic_sections_created
)
4275 if (! elf_link_create_dynamic_sections (abfd
, info
))
4279 /* Add a DT_NEEDED entry for this dynamic object. */
4280 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4282 if (strindex
== (bfd_size_type
) -1)
4284 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4289 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4291 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4292 != extsymcount
* sizeof (Elf_External_Sym
)))
4297 esymend
= buf
+ extsymcount
;
4298 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4300 Elf_Internal_Sym sym
;
4306 struct elf_link_hash_entry
*h
= NULL
;
4309 elf_swap_symbol_in (abfd
, esym
, &sym
);
4311 flags
= BSF_NO_FLAGS
;
4313 value
= sym
.st_value
;
4316 bind
= ELF_ST_BIND (sym
.st_info
);
4317 if (bind
== STB_LOCAL
)
4319 /* This should be impossible, since ELF requires that all
4320 global symbols follow all local symbols, and that sh_info
4321 point to the first global symbol. Unfortunatealy, Irix 5
4325 else if (bind
== STB_GLOBAL
)
4327 if (sym
.st_shndx
!= SHN_UNDEF
4328 && sym
.st_shndx
!= SHN_COMMON
)
4333 else if (bind
== STB_WEAK
)
4337 /* Leave it up to the processor backend. */
4340 if (sym
.st_shndx
== SHN_UNDEF
)
4341 sec
= bfd_und_section_ptr
;
4342 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4344 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4348 sec
= bfd_abs_section_ptr
;
4350 else if (sym
.st_shndx
== SHN_ABS
)
4351 sec
= bfd_abs_section_ptr
;
4352 else if (sym
.st_shndx
== SHN_COMMON
)
4354 sec
= bfd_com_section_ptr
;
4355 /* What ELF calls the size we call the value. What ELF
4356 calls the value we call the alignment. */
4357 value
= sym
.st_size
;
4361 /* Leave it up to the processor backend. */
4364 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4365 if (name
== (const char *) NULL
)
4368 if (add_symbol_hook
)
4370 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4374 /* The hook function sets the name to NULL if this symbol
4375 should be skipped for some reason. */
4376 if (name
== (const char *) NULL
)
4380 /* Sanity check that all possibilities were handled. */
4381 if (sec
== (asection
*) NULL
)
4383 bfd_set_error (bfd_error_bad_value
);
4387 if (bfd_is_und_section (sec
)
4388 || bfd_is_com_section (sec
))
4393 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4395 /* We need to look up the symbol now in order to get some of
4396 the dynamic object handling right. We pass the hash
4397 table entry in to _bfd_generic_link_add_one_symbol so
4398 that it does not have to look it up again. */
4399 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4400 true, false, false);
4405 /* If we are looking at a dynamic object, and this is a
4406 definition, we need to see if it has already been defined
4407 by some other object. If it has, we want to use the
4408 existing definition, and we do not want to report a
4409 multiple symbol definition error; we do this by
4410 clobbering sec to be bfd_und_section_ptr. */
4411 if (dynamic
&& definition
)
4413 if (h
->root
.type
== bfd_link_hash_defined
4414 || h
->root
.type
== bfd_link_hash_defweak
)
4415 sec
= bfd_und_section_ptr
;
4418 /* Similarly, if we are not looking at a dynamic object, and
4419 we have a definition, we want to override any definition
4420 we may have from a dynamic object. Symbols from regular
4421 files always take precedence over symbols from dynamic
4422 objects, even if they are defined after the dynamic
4423 object in the link. */
4426 && (h
->root
.type
== bfd_link_hash_defined
4427 || h
->root
.type
== bfd_link_hash_defweak
)
4428 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4429 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4430 == bfd_target_elf_flavour
)
4431 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4434 /* Change the hash table entry to undefined, and let
4435 _bfd_generic_link_add_one_symbol do the right thing
4436 with the new definition. */
4437 h
->root
.type
= bfd_link_hash_undefined
;
4438 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4442 if (! (_bfd_generic_link_add_one_symbol
4443 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4444 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4449 && (flags
& BSF_WEAK
) != 0
4450 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4451 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4452 && (*sym_hash
)->weakdef
== NULL
)
4454 /* Keep a list of all weak defined non function symbols from
4455 a dynamic object, using the weakdef field. Later in this
4456 function we will set the weakdef field to the correct
4457 value. We only put non-function symbols from dynamic
4458 objects on this list, because that happens to be the only
4459 time we need to know the normal symbol corresponding to a
4460 weak symbol, and the information is time consuming to
4461 figure out. If the weakdef field is not already NULL,
4462 then this symbol was already defined by some previous
4463 dynamic object, and we will be using that previous
4464 definition anyhow. */
4466 (*sym_hash
)->weakdef
= weaks
;
4470 /* Get the alignment of a common symbol. */
4471 if (sym
.st_shndx
== SHN_COMMON
4472 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4473 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
4475 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4481 /* Remember the symbol size and type. */
4482 if (sym
.st_size
!= 0)
4484 /* FIXME: We should probably somehow give a warning if
4485 the symbol size changes. */
4486 h
->size
= sym
.st_size
;
4488 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4490 /* FIXME: We should probably somehow give a warning if
4491 the symbol type changes. */
4492 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4495 /* Set a flag in the hash table entry indicating the type of
4496 reference or definition we just found. Keep a count of
4497 the number of dynamic symbols we find. A dynamic symbol
4498 is one which is referenced or defined by both a regular
4499 object and a shared object, or one which is referenced or
4500 defined by more than one shared object. */
4501 old_flags
= h
->elf_link_hash_flags
;
4506 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4508 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4510 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4511 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4517 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4519 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4520 if ((old_flags
& new_flag
) != 0
4521 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4522 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4526 h
->elf_link_hash_flags
|= new_flag
;
4527 if (dynsym
&& h
->dynindx
== -1)
4529 if (! elf_link_record_dynamic_symbol (info
, h
))
4535 /* Now set the weakdefs field correctly for all the weak defined
4536 symbols we found. The only way to do this is to search all the
4537 symbols. Since we only need the information for non functions in
4538 dynamic objects, that's the only time we actually put anything on
4539 the list WEAKS. We need this information so that if a regular
4540 object refers to a symbol defined weakly in a dynamic object, the
4541 real symbol in the dynamic object is also put in the dynamic
4542 symbols; we also must arrange for both symbols to point to the
4543 same memory location. We could handle the general case of symbol
4544 aliasing, but a general symbol alias can only be generated in
4545 assembler code, handling it correctly would be very time
4546 consuming, and other ELF linkers don't handle general aliasing
4548 while (weaks
!= NULL
)
4550 struct elf_link_hash_entry
*hlook
;
4553 struct elf_link_hash_entry
**hpp
;
4554 struct elf_link_hash_entry
**hppend
;
4557 weaks
= hlook
->weakdef
;
4558 hlook
->weakdef
= NULL
;
4560 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4561 || hlook
->root
.type
== bfd_link_hash_defweak
);
4562 slook
= hlook
->root
.u
.def
.section
;
4563 vlook
= hlook
->root
.u
.def
.value
;
4565 hpp
= elf_sym_hashes (abfd
);
4566 hppend
= hpp
+ extsymcount
;
4567 for (; hpp
< hppend
; hpp
++)
4569 struct elf_link_hash_entry
*h
;
4573 && (h
->root
.type
== bfd_link_hash_defined
4574 || h
->root
.type
== bfd_link_hash_defweak
)
4575 && h
->root
.u
.def
.section
== slook
4576 && h
->root
.u
.def
.value
== vlook
)
4580 /* If the weak definition is in the list of dynamic
4581 symbols, make sure the real definition is put there
4583 if (hlook
->dynindx
!= -1
4584 && h
->dynindx
== -1)
4586 if (! elf_link_record_dynamic_symbol (info
, h
))
4601 /* If this object is the same format as the output object, and it is
4602 not a shared library, then let the backend look through the
4605 This is required to build global offset table entries and to
4606 arrange for dynamic relocs. It is not required for the
4607 particular common case of linking non PIC code, even when linking
4608 against shared libraries, but unfortunately there is no way of
4609 knowing whether an object file has been compiled PIC or not.
4610 Looking through the relocs is not particularly time consuming.
4611 The problem is that we must either (1) keep the relocs in memory,
4612 which causes the linker to require additional runtime memory or
4613 (2) read the relocs twice from the input file, which wastes time.
4614 This would be a good case for using mmap.
4616 I have no idea how to handle linking PIC code into a file of a
4617 different format. It probably can't be done. */
4618 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4620 && abfd
->xvec
== info
->hash
->creator
4621 && check_relocs
!= NULL
)
4625 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4627 Elf_Internal_Rela
*internal_relocs
;
4630 if ((o
->flags
& SEC_RELOC
) == 0
4631 || o
->reloc_count
== 0)
4634 /* I believe we can ignore the relocs for any section which
4635 does not form part of the final process image, such as a
4636 debugging section. */
4637 if ((o
->flags
& SEC_ALLOC
) == 0)
4640 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4641 (Elf_Internal_Rela
*) NULL
,
4643 if (internal_relocs
== NULL
)
4646 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4648 if (! info
->keep_memory
)
4649 free (internal_relocs
);
4666 /* Create some sections which will be filled in with dynamic linking
4667 information. ABFD is an input file which requires dynamic sections
4668 to be created. The dynamic sections take up virtual memory space
4669 when the final executable is run, so we need to create them before
4670 addresses are assigned to the output sections. We work out the
4671 actual contents and size of these sections later. */
4674 elf_link_create_dynamic_sections (abfd
, info
)
4676 struct bfd_link_info
*info
;
4679 register asection
*s
;
4680 struct elf_link_hash_entry
*h
;
4681 struct elf_backend_data
*bed
;
4683 if (elf_hash_table (info
)->dynamic_sections_created
)
4686 /* Make sure that all dynamic sections use the same input BFD. */
4687 if (elf_hash_table (info
)->dynobj
== NULL
)
4688 elf_hash_table (info
)->dynobj
= abfd
;
4690 abfd
= elf_hash_table (info
)->dynobj
;
4692 /* Note that we set the SEC_IN_MEMORY flag for all of these
4694 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4696 /* A dynamically linked executable has a .interp section, but a
4697 shared library does not. */
4700 s
= bfd_make_section (abfd
, ".interp");
4702 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4706 s
= bfd_make_section (abfd
, ".dynsym");
4708 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4709 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4712 s
= bfd_make_section (abfd
, ".dynstr");
4714 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4717 /* Create a strtab to hold the dynamic symbol names. */
4718 if (elf_hash_table (info
)->dynstr
== NULL
)
4720 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4721 if (elf_hash_table (info
)->dynstr
== NULL
)
4725 s
= bfd_make_section (abfd
, ".dynamic");
4727 || ! bfd_set_section_flags (abfd
, s
, flags
)
4728 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4731 /* The special symbol _DYNAMIC is always set to the start of the
4732 .dynamic section. This call occurs before we have processed the
4733 symbols for any dynamic object, so we don't have to worry about
4734 overriding a dynamic definition. We could set _DYNAMIC in a
4735 linker script, but we only want to define it if we are, in fact,
4736 creating a .dynamic section. We don't want to define it if there
4737 is no .dynamic section, since on some ELF platforms the start up
4738 code examines it to decide how to initialize the process. */
4740 if (! (_bfd_generic_link_add_one_symbol
4741 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4742 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4743 (struct bfd_link_hash_entry
**) &h
)))
4745 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4746 h
->type
= STT_OBJECT
;
4749 && ! elf_link_record_dynamic_symbol (info
, h
))
4752 s
= bfd_make_section (abfd
, ".hash");
4754 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4755 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4758 /* Let the backend create the rest of the sections. This lets the
4759 backend set the right flags. The backend will normally create
4760 the .got and .plt sections. */
4761 bed
= get_elf_backend_data (abfd
);
4762 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4765 elf_hash_table (info
)->dynamic_sections_created
= true;
4770 /* Add an entry to the .dynamic table. */
4773 elf_add_dynamic_entry (info
, tag
, val
)
4774 struct bfd_link_info
*info
;
4778 Elf_Internal_Dyn dyn
;
4782 bfd_byte
*newcontents
;
4784 dynobj
= elf_hash_table (info
)->dynobj
;
4786 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4787 BFD_ASSERT (s
!= NULL
);
4789 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4790 if (s
->contents
== NULL
)
4791 newcontents
= (bfd_byte
*) malloc (newsize
);
4793 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4794 if (newcontents
== NULL
)
4796 bfd_set_error (bfd_error_no_memory
);
4801 dyn
.d_un
.d_val
= val
;
4802 elf_swap_dyn_out (dynobj
, &dyn
,
4803 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4805 s
->_raw_size
= newsize
;
4806 s
->contents
= newcontents
;
4811 /* Read and swap the relocs for a section. They may have been cached.
4812 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4813 they are used as buffers to read into. They are known to be large
4814 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4815 value is allocated using either malloc or bfd_alloc, according to
4816 the KEEP_MEMORY argument. */
4818 static Elf_Internal_Rela
*
4819 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4822 PTR external_relocs
;
4823 Elf_Internal_Rela
*internal_relocs
;
4824 boolean keep_memory
;
4826 Elf_Internal_Shdr
*rel_hdr
;
4828 Elf_Internal_Rela
*alloc2
= NULL
;
4830 if (elf_section_data (o
)->relocs
!= NULL
)
4831 return elf_section_data (o
)->relocs
;
4833 if (o
->reloc_count
== 0)
4836 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4838 if (internal_relocs
== NULL
)
4842 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4844 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4846 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4847 if (internal_relocs
== NULL
)
4849 bfd_set_error (bfd_error_no_memory
);
4854 if (external_relocs
== NULL
)
4856 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4859 bfd_set_error (bfd_error_no_memory
);
4862 external_relocs
= alloc1
;
4865 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4866 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4867 != rel_hdr
->sh_size
))
4870 /* Swap in the relocs. For convenience, we always produce an
4871 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4873 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4875 Elf_External_Rel
*erel
;
4876 Elf_External_Rel
*erelend
;
4877 Elf_Internal_Rela
*irela
;
4879 erel
= (Elf_External_Rel
*) external_relocs
;
4880 erelend
= erel
+ o
->reloc_count
;
4881 irela
= internal_relocs
;
4882 for (; erel
< erelend
; erel
++, irela
++)
4884 Elf_Internal_Rel irel
;
4886 elf_swap_reloc_in (abfd
, erel
, &irel
);
4887 irela
->r_offset
= irel
.r_offset
;
4888 irela
->r_info
= irel
.r_info
;
4889 irela
->r_addend
= 0;
4894 Elf_External_Rela
*erela
;
4895 Elf_External_Rela
*erelaend
;
4896 Elf_Internal_Rela
*irela
;
4898 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4900 erela
= (Elf_External_Rela
*) external_relocs
;
4901 erelaend
= erela
+ o
->reloc_count
;
4902 irela
= internal_relocs
;
4903 for (; erela
< erelaend
; erela
++, irela
++)
4904 elf_swap_reloca_in (abfd
, erela
, irela
);
4907 /* Cache the results for next time, if we can. */
4909 elf_section_data (o
)->relocs
= internal_relocs
;
4914 /* Don't free alloc2, since if it was allocated we are passing it
4915 back (under the name of internal_relocs). */
4917 return internal_relocs
;
4927 /* Record an assignment to a symbol made by a linker script. We need
4928 this in case some dynamic object refers to this symbol. */
4932 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4934 struct bfd_link_info
*info
;
4937 struct elf_link_hash_entry
*h
;
4939 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4942 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4946 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4947 h
->type
= STT_OBJECT
;
4949 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4950 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4952 && h
->dynindx
== -1)
4954 if (! elf_link_record_dynamic_symbol (info
, h
))
4957 /* If this is a weak defined symbol, and we know a corresponding
4958 real symbol from the same dynamic object, make sure the real
4959 symbol is also made into a dynamic symbol. */
4960 if (h
->weakdef
!= NULL
4961 && h
->weakdef
->dynindx
== -1)
4963 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4971 /* Array used to determine the number of hash table buckets to use
4972 based on the number of symbols there are. If there are fewer than
4973 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4974 fewer than 37 we use 17 buckets, and so forth. We never use more
4975 than 521 buckets. */
4977 static const size_t elf_buckets
[] =
4979 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4982 /* Set up the sizes and contents of the ELF dynamic sections. This is
4983 called by the ELF linker emulation before_allocation routine. We
4984 must set the sizes of the sections before the linker sets the
4985 addresses of the various sections. */
4988 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4989 export_dynamic
, info
, sinterpptr
)
4993 boolean export_dynamic
;
4994 struct bfd_link_info
*info
;
4995 asection
**sinterpptr
;
4999 Elf_Internal_Sym isym
;
5002 struct elf_backend_data
*bed
;
5006 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5009 dynobj
= elf_hash_table (info
)->dynobj
;
5011 /* If there were no dynamic objects in the link, there is nothing to
5016 /* If we are supposed to export all symbols into the dynamic symbol
5017 table (this is not the normal case), then do so. */
5019 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5022 if (elf_hash_table (info
)->dynamic_sections_created
)
5024 bfd_size_type strsize
;
5026 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5027 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5033 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5035 if (indx
== (bfd_size_type
) -1
5036 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5044 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5046 if (indx
== (bfd_size_type
) -1
5047 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5051 /* Find all symbols which were defined in a dynamic object and make
5052 the backend pick a reasonable value for them. */
5053 elf_link_hash_traverse (elf_hash_table (info
),
5054 elf_adjust_dynamic_symbol
,
5057 /* Add some entries to the .dynamic section. We fill in some of the
5058 values later, in elf_bfd_final_link, but we must add the entries
5059 now so that we know the final size of the .dynamic section. */
5060 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5061 false, false) != NULL
)
5063 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5066 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5067 false, false) != NULL
)
5069 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5072 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5073 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5074 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5075 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5076 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5077 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5078 sizeof (Elf_External_Sym
)))
5082 /* The backend must work out the sizes of all the other dynamic
5084 bed
= get_elf_backend_data (output_bfd
);
5085 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5088 if (elf_hash_table (info
)->dynamic_sections_created
)
5092 /* Set the size of the .dynsym and .hash sections. We counted
5093 the number of dynamic symbols in elf_link_add_object_symbols.
5094 We will build the contents of .dynsym and .hash when we build
5095 the final symbol table, because until then we do not know the
5096 correct value to give the symbols. We built the .dynstr
5097 section as we went along in elf_link_add_object_symbols. */
5098 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5099 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5100 BFD_ASSERT (s
!= NULL
);
5101 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5102 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5103 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5105 bfd_set_error (bfd_error_no_memory
);
5109 /* The first entry in .dynsym is a dummy symbol. */
5116 elf_swap_symbol_out (output_bfd
, &isym
,
5117 (Elf_External_Sym
*) s
->contents
);
5119 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5121 bucketcount
= elf_buckets
[i
];
5122 if (dynsymcount
< elf_buckets
[i
+ 1])
5126 s
= bfd_get_section_by_name (dynobj
, ".hash");
5127 BFD_ASSERT (s
!= NULL
);
5128 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5129 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5130 if (s
->contents
== NULL
)
5132 bfd_set_error (bfd_error_no_memory
);
5135 memset (s
->contents
, 0, s
->_raw_size
);
5137 put_word (output_bfd
, bucketcount
, s
->contents
);
5138 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5140 elf_hash_table (info
)->bucketcount
= bucketcount
;
5142 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5143 BFD_ASSERT (s
!= NULL
);
5144 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5146 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5153 /* This routine is used to export all defined symbols into the dynamic
5154 symbol table. It is called via elf_link_hash_traverse. */
5157 elf_export_symbol (h
, data
)
5158 struct elf_link_hash_entry
*h
;
5161 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5163 if (h
->dynindx
== -1
5164 && (h
->elf_link_hash_flags
5165 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5167 if (! elf_link_record_dynamic_symbol (info
, h
))
5169 /* FIXME: No way to report error. */
5177 /* Make the backend pick a good value for a dynamic symbol. This is
5178 called via elf_link_hash_traverse, and also calls itself
5182 elf_adjust_dynamic_symbol (h
, data
)
5183 struct elf_link_hash_entry
*h
;
5186 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5188 struct elf_backend_data
*bed
;
5190 /* If this symbol does not require a PLT entry, and it is not
5191 defined by a dynamic object, or is not referenced by a regular
5192 object, ignore it. FIXME: Do we need to worry about symbols
5193 which are defined by one dynamic object and referenced by another
5195 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5196 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5197 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5198 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5201 /* If we've already adjusted this symbol, don't do it again. This
5202 can happen via a recursive call. */
5203 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5206 /* Don't look at this symbol again. Note that we must set this
5207 after checking the above conditions, because we may look at a
5208 symbol once, decide not to do anything, and then get called
5209 recursively later after REF_REGULAR is set below. */
5210 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5212 /* If this is a weak definition, and we know a real definition, and
5213 the real symbol is not itself defined by a regular object file,
5214 then get a good value for the real definition. We handle the
5215 real symbol first, for the convenience of the backend routine.
5217 Note that there is a confusing case here. If the real definition
5218 is defined by a regular object file, we don't get the real symbol
5219 from the dynamic object, but we do get the weak symbol. If the
5220 processor backend uses a COPY reloc, then if some routine in the
5221 dynamic object changes the real symbol, we will not see that
5222 change in the corresponding weak symbol. This is the way other
5223 ELF linkers work as well, and seems to be a result of the shared
5226 I will clarify this issue. Most SVR4 shared libraries define the
5227 variable _timezone and define timezone as a weak synonym. The
5228 tzset call changes _timezone. If you write
5229 extern int timezone;
5231 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5232 you might expect that, since timezone is a synonym for _timezone,
5233 the same number will print both times. However, if the processor
5234 backend uses a COPY reloc, then actually timezone will be copied
5235 into your process image, and, since you define _timezone
5236 yourself, _timezone will not. Thus timezone and _timezone will
5237 wind up at different memory locations. The tzset call will set
5238 _timezone, leaving timezone unchanged. */
5240 if (h
->weakdef
!= NULL
)
5242 struct elf_link_hash_entry
*weakdef
;
5244 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5245 || h
->root
.type
== bfd_link_hash_defweak
);
5246 weakdef
= h
->weakdef
;
5247 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5248 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5249 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5250 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5252 /* This symbol is defined by a regular object file, so we
5253 will not do anything special. Clear weakdef for the
5254 convenience of the processor backend. */
5259 /* There is an implicit reference by a regular object file
5260 via the weak symbol. */
5261 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5262 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5267 dynobj
= elf_hash_table (info
)->dynobj
;
5268 bed
= get_elf_backend_data (dynobj
);
5269 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5271 /* FIXME: No way to return error. */
5278 /* Final phase of ELF linker. */
5280 /* A structure we use to avoid passing large numbers of arguments. */
5282 struct elf_final_link_info
5284 /* General link information. */
5285 struct bfd_link_info
*info
;
5288 /* Symbol string table. */
5289 struct bfd_strtab_hash
*symstrtab
;
5290 /* .dynsym section. */
5291 asection
*dynsym_sec
;
5292 /* .hash section. */
5294 /* Buffer large enough to hold contents of any section. */
5296 /* Buffer large enough to hold external relocs of any section. */
5297 PTR external_relocs
;
5298 /* Buffer large enough to hold internal relocs of any section. */
5299 Elf_Internal_Rela
*internal_relocs
;
5300 /* Buffer large enough to hold external local symbols of any input
5302 Elf_External_Sym
*external_syms
;
5303 /* Buffer large enough to hold internal local symbols of any input
5305 Elf_Internal_Sym
*internal_syms
;
5306 /* Array large enough to hold a symbol index for each local symbol
5307 of any input BFD. */
5309 /* Array large enough to hold a section pointer for each local
5310 symbol of any input BFD. */
5311 asection
**sections
;
5312 /* Buffer to hold swapped out symbols. */
5313 Elf_External_Sym
*symbuf
;
5314 /* Number of swapped out symbols in buffer. */
5315 size_t symbuf_count
;
5316 /* Number of symbols which fit in symbuf. */
5320 static boolean elf_link_output_sym
5321 PARAMS ((struct elf_final_link_info
*, const char *,
5322 Elf_Internal_Sym
*, asection
*));
5323 static boolean elf_link_flush_output_syms
5324 PARAMS ((struct elf_final_link_info
*));
5325 static boolean elf_link_output_extsym
5326 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5327 static boolean elf_link_input_bfd
5328 PARAMS ((struct elf_final_link_info
*, bfd
*));
5329 static boolean elf_reloc_link_order
5330 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5331 struct bfd_link_order
*));
5333 /* Do the final step of an ELF link. */
5336 elf_bfd_final_link (abfd
, info
)
5338 struct bfd_link_info
*info
;
5342 struct elf_final_link_info finfo
;
5343 register asection
*o
;
5344 register struct bfd_link_order
*p
;
5346 size_t max_contents_size
;
5347 size_t max_external_reloc_size
;
5348 size_t max_internal_reloc_count
;
5349 size_t max_sym_count
;
5351 Elf_Internal_Sym elfsym
;
5353 Elf_Internal_Shdr
*symtab_hdr
;
5354 Elf_Internal_Shdr
*symstrtab_hdr
;
5355 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5358 abfd
->flags
|= DYNAMIC
;
5360 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5361 dynobj
= elf_hash_table (info
)->dynobj
;
5364 finfo
.output_bfd
= abfd
;
5365 finfo
.symstrtab
= elf_stringtab_init ();
5366 if (finfo
.symstrtab
== NULL
)
5370 finfo
.dynsym_sec
= NULL
;
5371 finfo
.hash_sec
= NULL
;
5375 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5376 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5377 if (finfo
.dynsym_sec
== NULL
5378 || finfo
.hash_sec
== NULL
)
5381 finfo
.contents
= NULL
;
5382 finfo
.external_relocs
= NULL
;
5383 finfo
.internal_relocs
= NULL
;
5384 finfo
.external_syms
= NULL
;
5385 finfo
.internal_syms
= NULL
;
5386 finfo
.indices
= NULL
;
5387 finfo
.sections
= NULL
;
5388 finfo
.symbuf
= NULL
;
5389 finfo
.symbuf_count
= 0;
5391 /* Count up the number of relocations we will output for each output
5392 section, so that we know the sizes of the reloc sections. We
5393 also figure out some maximum sizes. */
5394 max_contents_size
= 0;
5395 max_external_reloc_size
= 0;
5396 max_internal_reloc_count
= 0;
5398 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5402 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5404 if (p
->type
== bfd_section_reloc_link_order
5405 || p
->type
== bfd_symbol_reloc_link_order
)
5407 else if (p
->type
== bfd_indirect_link_order
)
5411 sec
= p
->u
.indirect
.section
;
5413 if (info
->relocateable
)
5414 o
->reloc_count
+= sec
->reloc_count
;
5416 if (sec
->_raw_size
> max_contents_size
)
5417 max_contents_size
= sec
->_raw_size
;
5418 if (sec
->_cooked_size
> max_contents_size
)
5419 max_contents_size
= sec
->_cooked_size
;
5421 /* We are interested in just local symbols, not all
5423 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5427 if (elf_bad_symtab (sec
->owner
))
5428 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5429 / sizeof (Elf_External_Sym
));
5431 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5433 if (sym_count
> max_sym_count
)
5434 max_sym_count
= sym_count
;
5436 if ((sec
->flags
& SEC_RELOC
) != 0)
5440 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5441 if (ext_size
> max_external_reloc_size
)
5442 max_external_reloc_size
= ext_size
;
5443 if (sec
->reloc_count
> max_internal_reloc_count
)
5444 max_internal_reloc_count
= sec
->reloc_count
;
5450 if (o
->reloc_count
> 0)
5451 o
->flags
|= SEC_RELOC
;
5454 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5455 set it (this is probably a bug) and if it is set
5456 assign_section_numbers will create a reloc section. */
5457 o
->flags
&=~ SEC_RELOC
;
5460 /* If the SEC_ALLOC flag is not set, force the section VMA to
5461 zero. This is done in elf_fake_sections as well, but forcing
5462 the VMA to 0 here will ensure that relocs against these
5463 sections are handled correctly. */
5464 if ((o
->flags
& SEC_ALLOC
) == 0)
5468 /* Figure out the file positions for everything but the symbol table
5469 and the relocs. We set symcount to force assign_section_numbers
5470 to create a symbol table. */
5471 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5472 BFD_ASSERT (! abfd
->output_has_begun
);
5473 if (! elf_compute_section_file_positions (abfd
, info
))
5476 /* That created the reloc sections. Set their sizes, and assign
5477 them file positions, and allocate some buffers. */
5478 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5480 if ((o
->flags
& SEC_RELOC
) != 0)
5482 Elf_Internal_Shdr
*rel_hdr
;
5483 register struct elf_link_hash_entry
**p
, **pend
;
5485 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5487 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5489 /* The contents field must last into write_object_contents,
5490 so we allocate it with bfd_alloc rather than malloc. */
5491 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5492 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5494 bfd_set_error (bfd_error_no_memory
);
5498 p
= ((struct elf_link_hash_entry
**)
5499 malloc (o
->reloc_count
5500 * sizeof (struct elf_link_hash_entry
*)));
5501 if (p
== NULL
&& o
->reloc_count
!= 0)
5503 bfd_set_error (bfd_error_no_memory
);
5506 elf_section_data (o
)->rel_hashes
= p
;
5507 pend
= p
+ o
->reloc_count
;
5508 for (; p
< pend
; p
++)
5511 /* Use the reloc_count field as an index when outputting the
5517 assign_file_positions_for_relocs (abfd
);
5519 /* We have now assigned file positions for all the sections except
5520 .symtab and .strtab. We start the .symtab section at the current
5521 file position, and write directly to it. We build the .strtab
5522 section in memory. When we add .dynsym support, we will build
5523 that in memory as well (.dynsym is smaller than .symtab). */
5525 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5526 /* sh_name is set in prep_headers. */
5527 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5528 symtab_hdr
->sh_flags
= 0;
5529 symtab_hdr
->sh_addr
= 0;
5530 symtab_hdr
->sh_size
= 0;
5531 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5532 /* sh_link is set in assign_section_numbers. */
5533 /* sh_info is set below. */
5534 /* sh_offset is set just below. */
5535 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5537 off
= elf_tdata (abfd
)->next_file_pos
;
5538 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5540 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5541 incorrect. We do not yet know the size of the .symtab section.
5542 We correct next_file_pos below, after we do know the size. */
5544 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5545 continuously seeking to the right position in the file. */
5546 if (! info
->keep_memory
|| max_sym_count
< 20)
5547 finfo
.symbuf_size
= 20;
5549 finfo
.symbuf_size
= max_sym_count
;
5550 finfo
.symbuf
= ((Elf_External_Sym
*)
5551 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5552 if (finfo
.symbuf
== NULL
)
5554 bfd_set_error (bfd_error_no_memory
);
5558 /* Start writing out the symbol table. The first symbol is always a
5560 elfsym
.st_value
= 0;
5563 elfsym
.st_other
= 0;
5564 elfsym
.st_shndx
= SHN_UNDEF
;
5565 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5566 &elfsym
, bfd_und_section_ptr
))
5570 /* Some standard ELF linkers do this, but we don't because it causes
5571 bootstrap comparison failures. */
5572 /* Output a file symbol for the output file as the second symbol.
5573 We output this even if we are discarding local symbols, although
5574 I'm not sure if this is correct. */
5575 elfsym
.st_value
= 0;
5577 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5578 elfsym
.st_other
= 0;
5579 elfsym
.st_shndx
= SHN_ABS
;
5580 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5581 &elfsym
, bfd_abs_section_ptr
))
5585 /* Output a symbol for each section. We output these even if we are
5586 discarding local symbols, since they are used for relocs. These
5587 symbols have no names. We store the index of each one in the
5588 index field of the section, so that we can find it again when
5589 outputting relocs. */
5590 elfsym
.st_value
= 0;
5592 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5593 elfsym
.st_other
= 0;
5594 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5596 o
= section_from_elf_index (abfd
, i
);
5598 o
->target_index
= abfd
->symcount
;
5599 elfsym
.st_shndx
= i
;
5600 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5605 /* Allocate some memory to hold information read in from the input
5607 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5608 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5609 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5610 malloc (max_internal_reloc_count
5611 * sizeof (Elf_Internal_Rela
)));
5612 finfo
.external_syms
= ((Elf_External_Sym
*)
5613 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5614 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5615 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5616 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5617 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5618 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5619 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5620 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5621 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5622 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5623 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5624 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5626 bfd_set_error (bfd_error_no_memory
);
5630 /* Since ELF permits relocations to be against local symbols, we
5631 must have the local symbols available when we do the relocations.
5632 Since we would rather only read the local symbols once, and we
5633 would rather not keep them in memory, we handle all the
5634 relocations for a single input file at the same time.
5636 Unfortunately, there is no way to know the total number of local
5637 symbols until we have seen all of them, and the local symbol
5638 indices precede the global symbol indices. This means that when
5639 we are generating relocateable output, and we see a reloc against
5640 a global symbol, we can not know the symbol index until we have
5641 finished examining all the local symbols to see which ones we are
5642 going to output. To deal with this, we keep the relocations in
5643 memory, and don't output them until the end of the link. This is
5644 an unfortunate waste of memory, but I don't see a good way around
5645 it. Fortunately, it only happens when performing a relocateable
5646 link, which is not the common case. FIXME: If keep_memory is set
5647 we could write the relocs out and then read them again; I don't
5648 know how bad the memory loss will be. */
5650 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5651 sub
->output_has_begun
= false;
5652 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5654 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5656 if (p
->type
== bfd_indirect_link_order
5657 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5658 == bfd_target_elf_flavour
))
5660 sub
= p
->u
.indirect
.section
->owner
;
5661 if (! sub
->output_has_begun
)
5663 if (! elf_link_input_bfd (&finfo
, sub
))
5665 sub
->output_has_begun
= true;
5668 else if (p
->type
== bfd_section_reloc_link_order
5669 || p
->type
== bfd_symbol_reloc_link_order
)
5671 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5676 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5682 /* That wrote out all the local symbols. Finish up the symbol table
5683 with the global symbols. */
5685 /* The sh_info field records the index of the first non local
5687 symtab_hdr
->sh_info
= abfd
->symcount
;
5689 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5691 /* We get the global symbols from the hash table. */
5692 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5695 /* Flush all symbols to the file. */
5696 if (! elf_link_flush_output_syms (&finfo
))
5699 /* Now we know the size of the symtab section. */
5700 off
+= symtab_hdr
->sh_size
;
5702 /* Finish up and write out the symbol string table (.strtab)
5704 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5705 /* sh_name was set in prep_headers. */
5706 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5707 symstrtab_hdr
->sh_flags
= 0;
5708 symstrtab_hdr
->sh_addr
= 0;
5709 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5710 symstrtab_hdr
->sh_entsize
= 0;
5711 symstrtab_hdr
->sh_link
= 0;
5712 symstrtab_hdr
->sh_info
= 0;
5713 /* sh_offset is set just below. */
5714 symstrtab_hdr
->sh_addralign
= 1;
5716 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5717 elf_tdata (abfd
)->next_file_pos
= off
;
5719 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5720 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5723 /* Adjust the relocs to have the correct symbol indices. */
5724 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5726 struct elf_link_hash_entry
**rel_hash
;
5727 Elf_Internal_Shdr
*rel_hdr
;
5729 if ((o
->flags
& SEC_RELOC
) == 0)
5732 rel_hash
= elf_section_data (o
)->rel_hashes
;
5733 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5734 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5736 if (*rel_hash
== NULL
)
5739 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5741 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5743 Elf_External_Rel
*erel
;
5744 Elf_Internal_Rel irel
;
5746 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5747 elf_swap_reloc_in (abfd
, erel
, &irel
);
5748 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5749 ELF_R_TYPE (irel
.r_info
));
5750 elf_swap_reloc_out (abfd
, &irel
, erel
);
5754 Elf_External_Rela
*erela
;
5755 Elf_Internal_Rela irela
;
5757 BFD_ASSERT (rel_hdr
->sh_entsize
5758 == sizeof (Elf_External_Rela
));
5760 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5761 elf_swap_reloca_in (abfd
, erela
, &irela
);
5762 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5763 ELF_R_TYPE (irela
.r_info
));
5764 elf_swap_reloca_out (abfd
, &irela
, erela
);
5768 /* Set the reloc_count field to 0 to prevent write_relocs from
5769 trying to swap the relocs out itself. */
5773 /* If we are linking against a dynamic object, or generating a
5774 shared library, finish up the dynamic linking information. */
5777 Elf_External_Dyn
*dyncon
, *dynconend
;
5779 /* Fix up .dynamic entries. */
5780 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5781 BFD_ASSERT (o
!= NULL
);
5783 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5784 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5785 for (; dyncon
< dynconend
; dyncon
++)
5787 Elf_Internal_Dyn dyn
;
5791 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5798 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5799 magic _init and _fini symbols. This is pretty ugly,
5800 but we are compatible. */
5808 struct elf_link_hash_entry
*h
;
5810 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5811 false, false, true);
5812 BFD_ASSERT (h
!= NULL
);
5813 if (h
->root
.type
== bfd_link_hash_defined
5814 || h
->root
.type
== bfd_link_hash_defweak
)
5816 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5817 o
= h
->root
.u
.def
.section
;
5818 if (o
->output_section
!= NULL
)
5819 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5820 + o
->output_offset
);
5822 dyn
.d_un
.d_val
+= o
->vma
;
5824 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5837 o
= bfd_get_section_by_name (abfd
, name
);
5838 BFD_ASSERT (o
!= NULL
);
5839 dyn
.d_un
.d_ptr
= o
->vma
;
5840 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5847 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5852 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5854 Elf_Internal_Shdr
*hdr
;
5856 hdr
= elf_elfsections (abfd
)[i
];
5857 if (hdr
->sh_type
== type
5858 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5860 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5861 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5864 if (dyn
.d_un
.d_val
== 0
5865 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5866 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5870 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5876 /* If we have created any dynamic sections, then output them. */
5879 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5882 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5884 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5885 || o
->_raw_size
== 0)
5887 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5889 /* At this point, we are only interested in sections
5890 created by elf_link_create_dynamic_sections. FIXME:
5891 This test is fragile. */
5894 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5896 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5898 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5899 o
->contents
, o
->output_offset
,
5907 /* The contents of the .dynstr section are actually in a
5909 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5910 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5911 || ! _bfd_stringtab_emit (abfd
,
5912 elf_hash_table (info
)->dynstr
))
5918 if (finfo
.symstrtab
!= NULL
)
5919 _bfd_stringtab_free (finfo
.symstrtab
);
5920 if (finfo
.contents
!= NULL
)
5921 free (finfo
.contents
);
5922 if (finfo
.external_relocs
!= NULL
)
5923 free (finfo
.external_relocs
);
5924 if (finfo
.internal_relocs
!= NULL
)
5925 free (finfo
.internal_relocs
);
5926 if (finfo
.external_syms
!= NULL
)
5927 free (finfo
.external_syms
);
5928 if (finfo
.internal_syms
!= NULL
)
5929 free (finfo
.internal_syms
);
5930 if (finfo
.indices
!= NULL
)
5931 free (finfo
.indices
);
5932 if (finfo
.sections
!= NULL
)
5933 free (finfo
.sections
);
5934 if (finfo
.symbuf
!= NULL
)
5935 free (finfo
.symbuf
);
5936 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5938 if ((o
->flags
& SEC_RELOC
) != 0
5939 && elf_section_data (o
)->rel_hashes
!= NULL
)
5940 free (elf_section_data (o
)->rel_hashes
);
5943 elf_tdata (abfd
)->linker
= true;
5948 if (finfo
.symstrtab
!= NULL
)
5949 _bfd_stringtab_free (finfo
.symstrtab
);
5950 if (finfo
.contents
!= NULL
)
5951 free (finfo
.contents
);
5952 if (finfo
.external_relocs
!= NULL
)
5953 free (finfo
.external_relocs
);
5954 if (finfo
.internal_relocs
!= NULL
)
5955 free (finfo
.internal_relocs
);
5956 if (finfo
.external_syms
!= NULL
)
5957 free (finfo
.external_syms
);
5958 if (finfo
.internal_syms
!= NULL
)
5959 free (finfo
.internal_syms
);
5960 if (finfo
.indices
!= NULL
)
5961 free (finfo
.indices
);
5962 if (finfo
.sections
!= NULL
)
5963 free (finfo
.sections
);
5964 if (finfo
.symbuf
!= NULL
)
5965 free (finfo
.symbuf
);
5966 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5968 if ((o
->flags
& SEC_RELOC
) != 0
5969 && elf_section_data (o
)->rel_hashes
!= NULL
)
5970 free (elf_section_data (o
)->rel_hashes
);
5976 /* Add a symbol to the output symbol table. */
5979 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5980 struct elf_final_link_info
*finfo
;
5982 Elf_Internal_Sym
*elfsym
;
5983 asection
*input_sec
;
5985 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5986 struct bfd_link_info
*info
,
5991 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5992 elf_backend_link_output_symbol_hook
;
5993 if (output_symbol_hook
!= NULL
)
5995 if (! ((*output_symbol_hook
)
5996 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
6000 if (name
== (const char *) NULL
|| *name
== '\0')
6001 elfsym
->st_name
= 0;
6004 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6007 if (elfsym
->st_name
== (unsigned long) -1)
6011 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6013 if (! elf_link_flush_output_syms (finfo
))
6017 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6018 finfo
->symbuf
+ finfo
->symbuf_count
);
6019 ++finfo
->symbuf_count
;
6021 ++finfo
->output_bfd
->symcount
;
6026 /* Flush the output symbols to the file. */
6029 elf_link_flush_output_syms (finfo
)
6030 struct elf_final_link_info
*finfo
;
6032 Elf_Internal_Shdr
*symtab
;
6034 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6036 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6038 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6039 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6040 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6043 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6045 finfo
->symbuf_count
= 0;
6050 /* Add an external symbol to the symbol table. This is called from
6051 the hash table traversal routine. */
6054 elf_link_output_extsym (h
, data
)
6055 struct elf_link_hash_entry
*h
;
6058 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
6060 Elf_Internal_Sym sym
;
6061 asection
*input_sec
;
6063 /* If we are not creating a shared library, and this symbol is
6064 referenced by a shared library but is not defined anywhere, then
6065 warn that it is undefined. If we do not do this, the runtime
6066 linker will complain that the symbol is undefined when the
6067 program is run. We don't have to worry about symbols that are
6068 referenced by regular files, because we will already have issued
6071 FIXME: If we are linking against an object which uses DT_NEEDED,
6072 we don't give this warning, because it might be the case that the
6073 needed dynamic object will define the symbols. Unfortunately,
6074 this makes this type of check much less useful, but the only way
6075 to fix it would be to locate the needed object and read its
6076 symbol table. That seems like a real waste of time just to give
6077 better error messages. */
6078 if (! finfo
->info
->relocateable
6079 && ! finfo
->info
->shared
6080 && ! elf_hash_table (finfo
->info
)->saw_needed
6081 && h
->root
.type
== bfd_link_hash_undefined
6082 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6083 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6085 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6086 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6087 (asection
*) NULL
, 0)))
6089 /* FIXME: No way to return error. */
6094 /* We don't want to output symbols that have never been mentioned by
6095 a regular file, or that we have been told to strip. However, if
6096 h->indx is set to -2, the symbol is used by a reloc and we must
6100 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6101 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6102 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6103 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6105 else if (finfo
->info
->strip
== strip_all
6106 || (finfo
->info
->strip
== strip_some
6107 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6108 h
->root
.root
.string
,
6109 false, false) == NULL
))
6114 /* If we're stripping it, and it's not a dynamic symbol, there's
6115 nothing else to do. */
6116 if (strip
&& h
->dynindx
== -1)
6120 sym
.st_size
= h
->size
;
6122 if (h
->root
.type
== bfd_link_hash_undefweak
6123 || h
->root
.type
== bfd_link_hash_defweak
)
6124 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6126 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6128 switch (h
->root
.type
)
6131 case bfd_link_hash_new
:
6135 case bfd_link_hash_undefined
:
6136 input_sec
= bfd_und_section_ptr
;
6137 sym
.st_shndx
= SHN_UNDEF
;
6140 case bfd_link_hash_undefweak
:
6141 input_sec
= bfd_und_section_ptr
;
6142 sym
.st_shndx
= SHN_UNDEF
;
6145 case bfd_link_hash_defined
:
6146 case bfd_link_hash_defweak
:
6148 input_sec
= h
->root
.u
.def
.section
;
6149 if (input_sec
->output_section
!= NULL
)
6152 elf_section_from_bfd_section (finfo
->output_bfd
,
6153 input_sec
->output_section
);
6154 if (sym
.st_shndx
== (unsigned short) -1)
6156 /* FIXME: No way to handle errors. */
6160 /* ELF symbols in relocateable files are section relative,
6161 but in nonrelocateable files they are virtual
6163 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6164 if (! finfo
->info
->relocateable
)
6165 sym
.st_value
+= input_sec
->output_section
->vma
;
6169 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6170 == bfd_target_elf_flavour
)
6171 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6172 sym
.st_shndx
= SHN_UNDEF
;
6173 input_sec
= bfd_und_section_ptr
;
6178 case bfd_link_hash_common
:
6179 input_sec
= bfd_com_section_ptr
;
6180 sym
.st_shndx
= SHN_COMMON
;
6181 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
6184 case bfd_link_hash_indirect
:
6185 case bfd_link_hash_warning
:
6186 /* I have no idea how these should be handled. */
6190 /* If this symbol should be put in the .dynsym section, then put it
6191 there now. We have already know the symbol index. We also fill
6192 in the entry in the .hash section. */
6193 if (h
->dynindx
!= -1
6194 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6196 struct elf_backend_data
*bed
;
6199 bfd_byte
*bucketpos
;
6202 sym
.st_name
= h
->dynstr_index
;
6204 /* Give the processor backend a chance to tweak the symbol
6205 value, and also to finish up anything that needs to be done
6207 bed
= get_elf_backend_data (finfo
->output_bfd
);
6208 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6209 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6211 /* FIXME: No way to return error. */
6215 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6216 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6219 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6220 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6222 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6223 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6224 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6225 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6226 put_word (finfo
->output_bfd
, chain
,
6227 ((bfd_byte
*) finfo
->hash_sec
->contents
6228 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6231 /* If we're stripping it, then it was just a dynamic symbol, and
6232 there's nothing else to do. */
6236 h
->indx
= finfo
->output_bfd
->symcount
;
6238 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6240 /* FIXME: No way to return error. */
6247 /* Link an input file into the linker output file. This function
6248 handles all the sections and relocations of the input file at once.
6249 This is so that we only have to read the local symbols once, and
6250 don't have to keep them in memory. */
6253 elf_link_input_bfd (finfo
, input_bfd
)
6254 struct elf_final_link_info
*finfo
;
6257 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6258 bfd
*, asection
*, bfd_byte
*,
6259 Elf_Internal_Rela
*,
6260 Elf_Internal_Sym
*, asection
**));
6262 Elf_Internal_Shdr
*symtab_hdr
;
6265 Elf_External_Sym
*esym
;
6266 Elf_External_Sym
*esymend
;
6267 Elf_Internal_Sym
*isym
;
6269 asection
**ppsection
;
6272 output_bfd
= finfo
->output_bfd
;
6274 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6276 /* If this is a dynamic object, we don't want to do anything here:
6277 we don't want the local symbols, and we don't want the section
6279 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6282 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6283 if (elf_bad_symtab (input_bfd
))
6285 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6290 locsymcount
= symtab_hdr
->sh_info
;
6291 extsymoff
= symtab_hdr
->sh_info
;
6294 /* Read the local symbols. */
6296 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6297 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6298 locsymcount
, input_bfd
)
6299 != locsymcount
* sizeof (Elf_External_Sym
))))
6302 /* Swap in the local symbols and write out the ones which we know
6303 are going into the output file. */
6304 esym
= finfo
->external_syms
;
6305 esymend
= esym
+ locsymcount
;
6306 isym
= finfo
->internal_syms
;
6307 pindex
= finfo
->indices
;
6308 ppsection
= finfo
->sections
;
6309 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6313 Elf_Internal_Sym osym
;
6315 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6318 if (elf_bad_symtab (input_bfd
))
6320 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6327 if (isym
->st_shndx
== SHN_UNDEF
)
6328 isec
= bfd_und_section_ptr
;
6329 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6330 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6331 else if (isym
->st_shndx
== SHN_ABS
)
6332 isec
= bfd_abs_section_ptr
;
6333 else if (isym
->st_shndx
== SHN_COMMON
)
6334 isec
= bfd_com_section_ptr
;
6343 /* Don't output the first, undefined, symbol. */
6344 if (esym
== finfo
->external_syms
)
6347 /* If we are stripping all symbols, we don't want to output this
6349 if (finfo
->info
->strip
== strip_all
)
6352 /* We never output section symbols. Instead, we use the section
6353 symbol of the corresponding section in the output file. */
6354 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6357 /* If we are discarding all local symbols, we don't want to
6358 output this one. If we are generating a relocateable output
6359 file, then some of the local symbols may be required by
6360 relocs; we output them below as we discover that they are
6362 if (finfo
->info
->discard
== discard_all
)
6365 /* Get the name of the symbol. */
6366 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6371 /* See if we are discarding symbols with this name. */
6372 if ((finfo
->info
->strip
== strip_some
6373 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6375 || (finfo
->info
->discard
== discard_l
6376 && strncmp (name
, finfo
->info
->lprefix
,
6377 finfo
->info
->lprefix_len
) == 0))
6380 /* If we get here, we are going to output this symbol. */
6384 /* Adjust the section index for the output file. */
6385 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6386 isec
->output_section
);
6387 if (osym
.st_shndx
== (unsigned short) -1)
6390 *pindex
= output_bfd
->symcount
;
6392 /* ELF symbols in relocateable files are section relative, but
6393 in executable files they are virtual addresses. Note that
6394 this code assumes that all ELF sections have an associated
6395 BFD section with a reasonable value for output_offset; below
6396 we assume that they also have a reasonable value for
6397 output_section. Any special sections must be set up to meet
6398 these requirements. */
6399 osym
.st_value
+= isec
->output_offset
;
6400 if (! finfo
->info
->relocateable
)
6401 osym
.st_value
+= isec
->output_section
->vma
;
6403 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6407 /* Relocate the contents of each section. */
6408 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6410 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6413 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6414 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6416 /* Section was created by elf_link_create_dynamic_sections.
6417 FIXME: This test is fragile. */
6421 /* Read the contents of the section. */
6422 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6423 (file_ptr
) 0, o
->_raw_size
))
6426 if ((o
->flags
& SEC_RELOC
) != 0)
6428 Elf_Internal_Rela
*internal_relocs
;
6430 /* Get the swapped relocs. */
6431 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6432 finfo
->external_relocs
,
6433 finfo
->internal_relocs
,
6435 if (internal_relocs
== NULL
6436 && o
->reloc_count
> 0)
6439 /* Relocate the section by invoking a back end routine.
6441 The back end routine is responsible for adjusting the
6442 section contents as necessary, and (if using Rela relocs
6443 and generating a relocateable output file) adjusting the
6444 reloc addend as necessary.
6446 The back end routine does not have to worry about setting
6447 the reloc address or the reloc symbol index.
6449 The back end routine is given a pointer to the swapped in
6450 internal symbols, and can access the hash table entries
6451 for the external symbols via elf_sym_hashes (input_bfd).
6453 When generating relocateable output, the back end routine
6454 must handle STB_LOCAL/STT_SECTION symbols specially. The
6455 output symbol is going to be a section symbol
6456 corresponding to the output section, which will require
6457 the addend to be adjusted. */
6459 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6463 finfo
->internal_syms
,
6467 if (finfo
->info
->relocateable
)
6469 Elf_Internal_Rela
*irela
;
6470 Elf_Internal_Rela
*irelaend
;
6471 struct elf_link_hash_entry
**rel_hash
;
6472 Elf_Internal_Shdr
*input_rel_hdr
;
6473 Elf_Internal_Shdr
*output_rel_hdr
;
6475 /* Adjust the reloc addresses and symbol indices. */
6477 irela
= internal_relocs
;
6478 irelaend
= irela
+ o
->reloc_count
;
6479 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6480 + o
->output_section
->reloc_count
);
6481 for (; irela
< irelaend
; irela
++, rel_hash
++)
6484 Elf_Internal_Sym
*isym
;
6487 irela
->r_offset
+= o
->output_offset
;
6489 r_symndx
= ELF_R_SYM (irela
->r_info
);
6494 if (r_symndx
>= locsymcount
6495 || (elf_bad_symtab (input_bfd
)
6496 && finfo
->sections
[r_symndx
] == NULL
))
6500 /* This is a reloc against a global symbol. We
6501 have not yet output all the local symbols, so
6502 we do not know the symbol index of any global
6503 symbol. We set the rel_hash entry for this
6504 reloc to point to the global hash table entry
6505 for this symbol. The symbol index is then
6506 set at the end of elf_bfd_final_link. */
6507 indx
= r_symndx
- extsymoff
;
6508 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6510 /* Setting the index to -2 tells
6511 elf_link_output_extsym that this symbol is
6513 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6514 (*rel_hash
)->indx
= -2;
6519 /* This is a reloc against a local symbol. */
6522 isym
= finfo
->internal_syms
+ r_symndx
;
6523 sec
= finfo
->sections
[r_symndx
];
6524 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6526 /* I suppose the backend ought to fill in the
6527 section of any STT_SECTION symbol against a
6528 processor specific section. */
6529 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6531 else if (sec
== NULL
|| sec
->owner
== NULL
)
6533 bfd_set_error (bfd_error_bad_value
);
6538 r_symndx
= sec
->output_section
->target_index
;
6545 if (finfo
->indices
[r_symndx
] == -1)
6551 if (finfo
->info
->strip
== strip_all
)
6553 /* You can't do ld -r -s. */
6554 bfd_set_error (bfd_error_invalid_operation
);
6558 /* This symbol was skipped earlier, but
6559 since it is needed by a reloc, we
6560 must output it now. */
6561 link
= symtab_hdr
->sh_link
;
6562 name
= elf_string_from_elf_section (input_bfd
,
6568 osec
= sec
->output_section
;
6570 elf_section_from_bfd_section (output_bfd
,
6572 if (isym
->st_shndx
== (unsigned short) -1)
6575 isym
->st_value
+= sec
->output_offset
;
6576 if (! finfo
->info
->relocateable
)
6577 isym
->st_value
+= osec
->vma
;
6579 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6581 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6585 r_symndx
= finfo
->indices
[r_symndx
];
6588 irela
->r_info
= ELF_R_INFO (r_symndx
,
6589 ELF_R_TYPE (irela
->r_info
));
6592 /* Swap out the relocs. */
6593 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6594 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6595 BFD_ASSERT (output_rel_hdr
->sh_entsize
6596 == input_rel_hdr
->sh_entsize
);
6597 irela
= internal_relocs
;
6598 irelaend
= irela
+ o
->reloc_count
;
6599 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6601 Elf_External_Rel
*erel
;
6603 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6604 + o
->output_section
->reloc_count
);
6605 for (; irela
< irelaend
; irela
++, erel
++)
6607 Elf_Internal_Rel irel
;
6609 irel
.r_offset
= irela
->r_offset
;
6610 irel
.r_info
= irela
->r_info
;
6611 BFD_ASSERT (irela
->r_addend
== 0);
6612 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6617 Elf_External_Rela
*erela
;
6619 BFD_ASSERT (input_rel_hdr
->sh_entsize
6620 == sizeof (Elf_External_Rela
));
6621 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6622 + o
->output_section
->reloc_count
);
6623 for (; irela
< irelaend
; irela
++, erela
++)
6624 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6627 o
->output_section
->reloc_count
+= o
->reloc_count
;
6631 /* Write out the modified section contents. */
6632 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6633 finfo
->contents
, o
->output_offset
,
6634 (o
->_cooked_size
!= 0
6643 /* Generate a reloc when linking an ELF file. This is a reloc
6644 requested by the linker, and does come from any input file. This
6645 is used to build constructor and destructor tables when linking
6649 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6651 struct bfd_link_info
*info
;
6652 asection
*output_section
;
6653 struct bfd_link_order
*link_order
;
6655 reloc_howto_type
*howto
;
6658 struct elf_link_hash_entry
**rel_hash_ptr
;
6659 Elf_Internal_Shdr
*rel_hdr
;
6661 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6664 bfd_set_error (bfd_error_bad_value
);
6668 /* If this is an inplace reloc, we must write the addend into the
6670 if (howto
->partial_inplace
6671 && link_order
->u
.reloc
.p
->addend
!= 0)
6674 bfd_reloc_status_type rstat
;
6678 size
= bfd_get_reloc_size (howto
);
6679 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6680 if (buf
== (bfd_byte
*) NULL
)
6682 bfd_set_error (bfd_error_no_memory
);
6685 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6686 link_order
->u
.reloc
.p
->addend
, buf
);
6692 case bfd_reloc_outofrange
:
6694 case bfd_reloc_overflow
:
6695 if (! ((*info
->callbacks
->reloc_overflow
)
6697 (link_order
->type
== bfd_section_reloc_link_order
6698 ? bfd_section_name (output_bfd
,
6699 link_order
->u
.reloc
.p
->u
.section
)
6700 : link_order
->u
.reloc
.p
->u
.name
),
6701 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6702 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6709 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6710 (file_ptr
) link_order
->offset
, size
);
6716 /* Figure out the symbol index. */
6717 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6718 + output_section
->reloc_count
);
6719 if (link_order
->type
== bfd_section_reloc_link_order
)
6721 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6724 *rel_hash_ptr
= NULL
;
6728 struct elf_link_hash_entry
*h
;
6730 h
= elf_link_hash_lookup (elf_hash_table (info
),
6731 link_order
->u
.reloc
.p
->u
.name
,
6732 false, false, true);
6735 /* Setting the index to -2 tells elf_link_output_extsym that
6736 this symbol is used by a reloc. */
6743 if (! ((*info
->callbacks
->unattached_reloc
)
6744 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6745 (asection
*) NULL
, (bfd_vma
) 0)))
6751 /* The address of a reloc is relative to the section in a
6752 relocateable file, and is a virtual address in an executable
6754 offset
= link_order
->offset
;
6755 if (! info
->relocateable
)
6756 offset
+= output_section
->vma
;
6758 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6760 if (rel_hdr
->sh_type
== SHT_REL
)
6762 Elf_Internal_Rel irel
;
6763 Elf_External_Rel
*erel
;
6765 irel
.r_offset
= offset
;
6766 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6767 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6768 + output_section
->reloc_count
);
6769 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6773 Elf_Internal_Rela irela
;
6774 Elf_External_Rela
*erela
;
6776 irela
.r_offset
= offset
;
6777 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6778 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6779 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6780 + output_section
->reloc_count
);
6781 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6784 ++output_section
->reloc_count
;