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
)
2273 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2283 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2284 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2285 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2287 struct bfd_strtab_hash
*shstrtab
;
2289 i_ehdrp
= elf_elfheader (abfd
);
2290 i_shdrp
= elf_elfsections (abfd
);
2292 shstrtab
= elf_stringtab_init ();
2293 if (shstrtab
== NULL
)
2296 elf_shstrtab (abfd
) = shstrtab
;
2298 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2299 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2300 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2301 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2303 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2304 i_ehdrp
->e_ident
[EI_DATA
] =
2305 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2306 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2308 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2309 i_ehdrp
->e_ident
[count
] = 0;
2311 if ((abfd
->flags
& DYNAMIC
) != 0)
2312 i_ehdrp
->e_type
= ET_DYN
;
2313 else if ((abfd
->flags
& EXEC_P
) != 0)
2314 i_ehdrp
->e_type
= ET_EXEC
;
2316 i_ehdrp
->e_type
= ET_REL
;
2318 switch (bfd_get_arch (abfd
))
2320 case bfd_arch_unknown
:
2321 i_ehdrp
->e_machine
= EM_NONE
;
2323 case bfd_arch_sparc
:
2325 i_ehdrp
->e_machine
= EM_SPARC64
;
2327 i_ehdrp
->e_machine
= EM_SPARC
;
2331 i_ehdrp
->e_machine
= EM_386
;
2334 i_ehdrp
->e_machine
= EM_68K
;
2337 i_ehdrp
->e_machine
= EM_88K
;
2340 i_ehdrp
->e_machine
= EM_860
;
2342 case bfd_arch_mips
: /* MIPS Rxxxx */
2343 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2346 i_ehdrp
->e_machine
= EM_PARISC
;
2348 case bfd_arch_powerpc
:
2349 i_ehdrp
->e_machine
= EM_PPC
;
2351 /* start-sanitize-arc */
2353 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2355 /* end-sanitize-arc */
2356 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2358 i_ehdrp
->e_machine
= EM_NONE
;
2360 i_ehdrp
->e_version
= EV_CURRENT
;
2361 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2363 /* no program header, for now. */
2364 i_ehdrp
->e_phoff
= 0;
2365 i_ehdrp
->e_phentsize
= 0;
2366 i_ehdrp
->e_phnum
= 0;
2368 /* each bfd section is section header entry */
2369 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2370 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2372 /* if we're building an executable, we'll need a program header table */
2373 if (abfd
->flags
& EXEC_P
)
2375 /* it all happens later */
2377 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2379 /* elf_build_phdrs() returns a (NULL-terminated) array of
2380 Elf_Internal_Phdrs */
2381 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2382 i_ehdrp
->e_phoff
= outbase
;
2383 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2388 i_ehdrp
->e_phentsize
= 0;
2390 i_ehdrp
->e_phoff
= 0;
2393 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2394 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2395 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2396 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2397 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2398 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2399 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2400 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2401 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2408 swap_out_syms (abfd
, sttp
)
2410 struct bfd_strtab_hash
**sttp
;
2412 if (!elf_map_symbols (abfd
))
2415 /* Dump out the symtabs. */
2417 int symcount
= bfd_get_symcount (abfd
);
2418 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2419 struct bfd_strtab_hash
*stt
;
2420 Elf_Internal_Shdr
*symtab_hdr
;
2421 Elf_Internal_Shdr
*symstrtab_hdr
;
2422 Elf_External_Sym
*outbound_syms
;
2425 stt
= elf_stringtab_init ();
2429 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2430 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2431 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2432 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2433 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2434 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2436 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2437 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2439 outbound_syms
= ((Elf_External_Sym
*)
2441 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2442 if (outbound_syms
== NULL
)
2444 bfd_set_error (bfd_error_no_memory
);
2447 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2449 /* now generate the data (for "contents") */
2451 /* Fill in zeroth symbol and swap it out. */
2452 Elf_Internal_Sym sym
;
2458 sym
.st_shndx
= SHN_UNDEF
;
2459 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2462 for (idx
= 0; idx
< symcount
; idx
++)
2464 Elf_Internal_Sym sym
;
2465 bfd_vma value
= syms
[idx
]->value
;
2466 elf_symbol_type
*type_ptr
;
2468 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2469 /* Section symbols have no names. */
2473 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2476 if (sym
.st_name
== (unsigned long) -1)
2480 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2482 if (bfd_is_com_section (syms
[idx
]->section
))
2484 /* ELF common symbols put the alignment into the `value' field,
2485 and the size into the `size' field. This is backwards from
2486 how BFD handles it, so reverse it here. */
2487 sym
.st_size
= value
;
2488 if (type_ptr
== NULL
2489 || type_ptr
->internal_elf_sym
.st_value
== 0)
2490 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2492 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2493 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2494 syms
[idx
]->section
);
2498 asection
*sec
= syms
[idx
]->section
;
2501 if (sec
->output_section
)
2503 value
+= sec
->output_offset
;
2504 sec
= sec
->output_section
;
2507 sym
.st_value
= value
;
2508 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2509 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2513 /* Writing this would be a hell of a lot easier if we had
2514 some decent documentation on bfd, and knew what to expect
2515 of the library, and what to demand of applications. For
2516 example, it appears that `objcopy' might not set the
2517 section of a symbol to be a section that is actually in
2519 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2520 BFD_ASSERT (sec2
!= 0);
2521 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2522 BFD_ASSERT (shndx
!= -1);
2526 if (bfd_is_com_section (syms
[idx
]->section
))
2527 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2528 else if (bfd_is_und_section (syms
[idx
]->section
))
2529 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2530 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2533 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2534 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2535 else if (syms
[idx
]->flags
& BSF_FILE
)
2536 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2539 int bind
= STB_LOCAL
;
2540 int type
= STT_OBJECT
;
2541 unsigned int flags
= syms
[idx
]->flags
;
2543 if (flags
& BSF_LOCAL
)
2545 else if (flags
& BSF_WEAK
)
2547 else if (flags
& BSF_GLOBAL
)
2550 if (flags
& BSF_FUNCTION
)
2553 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2557 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2562 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2563 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2565 symstrtab_hdr
->sh_flags
= 0;
2566 symstrtab_hdr
->sh_addr
= 0;
2567 symstrtab_hdr
->sh_entsize
= 0;
2568 symstrtab_hdr
->sh_link
= 0;
2569 symstrtab_hdr
->sh_info
= 0;
2570 symstrtab_hdr
->sh_addralign
= 1;
2577 write_shdrs_and_ehdr (abfd
)
2580 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2581 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2582 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2583 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2586 i_ehdrp
= elf_elfheader (abfd
);
2587 i_shdrp
= elf_elfsections (abfd
);
2589 /* swap the header before spitting it out... */
2592 elf_debug_file (i_ehdrp
);
2594 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2595 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2596 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2597 != sizeof (x_ehdr
)))
2600 /* at this point we've concocted all the ELF sections... */
2601 x_shdrp
= (Elf_External_Shdr
*)
2602 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2605 bfd_set_error (bfd_error_no_memory
);
2609 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2612 elf_debug_section (count
, i_shdrp
[count
]);
2614 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2616 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2617 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2618 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2621 /* need to dump the string table too... */
2626 /* Assign file positions for all the reloc sections which are not part
2627 of the loadable file image. */
2630 assign_file_positions_for_relocs (abfd
)
2635 Elf_Internal_Shdr
**shdrpp
;
2637 off
= elf_tdata (abfd
)->next_file_pos
;
2639 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2640 i
< elf_elfheader (abfd
)->e_shnum
;
2643 Elf_Internal_Shdr
*shdrp
;
2646 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2647 && shdrp
->sh_offset
== -1)
2648 off
= assign_file_position_for_section (shdrp
, off
, true);
2651 elf_tdata (abfd
)->next_file_pos
= off
;
2655 NAME(bfd_elf
,write_object_contents
) (abfd
)
2658 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2659 Elf_Internal_Ehdr
*i_ehdrp
;
2660 Elf_Internal_Shdr
**i_shdrp
;
2663 if (! abfd
->output_has_begun
2664 && ! elf_compute_section_file_positions (abfd
,
2665 (struct bfd_link_info
*) NULL
))
2668 i_shdrp
= elf_elfsections (abfd
);
2669 i_ehdrp
= elf_elfheader (abfd
);
2671 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2672 assign_file_positions_for_relocs (abfd
);
2674 /* After writing the headers, we need to write the sections too... */
2675 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2677 if (bed
->elf_backend_section_processing
)
2678 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2679 if (i_shdrp
[count
]->contents
)
2681 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2682 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2684 != i_shdrp
[count
]->sh_size
))
2689 /* Write out the section header names. */
2690 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2691 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2694 if (bed
->elf_backend_final_write_processing
)
2695 (*bed
->elf_backend_final_write_processing
) (abfd
,
2696 elf_tdata (abfd
)->linker
);
2698 return write_shdrs_and_ehdr (abfd
);
2701 /* Given an ELF section number, retrieve the corresponding BFD
2705 section_from_elf_index (abfd
, index
)
2709 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2710 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2712 return elf_elfsections (abfd
)[index
]->bfd_section
;
2715 /* given a section, search the header to find them... */
2717 elf_section_from_bfd_section (abfd
, asect
)
2721 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2722 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2724 Elf_Internal_Shdr
*hdr
;
2725 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2727 for (index
= 0; index
< maxindex
; index
++)
2729 hdr
= i_shdrp
[index
];
2730 if (hdr
->bfd_section
== asect
)
2734 if (bed
->elf_backend_section_from_bfd_section
)
2736 for (index
= 0; index
< maxindex
; index
++)
2740 hdr
= i_shdrp
[index
];
2742 if ((*bed
->elf_backend_section_from_bfd_section
)
2743 (abfd
, hdr
, asect
, &retval
))
2748 if (bfd_is_abs_section (asect
))
2750 if (bfd_is_com_section (asect
))
2752 if (bfd_is_und_section (asect
))
2758 /* given a symbol, return the bfd index for that symbol. */
2760 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2762 struct symbol_cache_entry
**asym_ptr_ptr
;
2764 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2766 flagword flags
= asym_ptr
->flags
;
2768 /* When gas creates relocations against local labels, it creates its
2769 own symbol for the section, but does put the symbol into the
2770 symbol chain, so udata is 0. When the linker is generating
2771 relocatable output, this section symbol may be for one of the
2772 input sections rather than the output section. */
2773 if (asym_ptr
->udata
.i
== 0
2774 && (flags
& BSF_SECTION_SYM
)
2775 && asym_ptr
->section
)
2779 if (asym_ptr
->section
->output_section
!= NULL
)
2780 indx
= asym_ptr
->section
->output_section
->index
;
2782 indx
= asym_ptr
->section
->index
;
2783 if (elf_section_syms (abfd
)[indx
])
2784 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2787 idx
= asym_ptr
->udata
.i
;
2795 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2796 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2805 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2807 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2810 Elf_Internal_Shdr
*hdr
;
2811 long symcount
; /* Number of external ELF symbols */
2812 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2813 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2814 Elf_Internal_Sym i_sym
;
2815 Elf_External_Sym
*x_symp
= NULL
;
2817 /* Read each raw ELF symbol, converting from external ELF form to
2818 internal ELF form, and then using the information to create a
2819 canonical bfd symbol table entry.
2821 Note that we allocate the initial bfd canonical symbol buffer
2822 based on a one-to-one mapping of the ELF symbols to canonical
2823 symbols. We actually use all the ELF symbols, so there will be no
2824 space left over at the end. When we have all the symbols, we
2825 build the caller's pointer vector. */
2828 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2830 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2831 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2834 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2837 sym
= symbase
= NULL
;
2842 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2845 symbase
= ((elf_symbol_type
*)
2846 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2847 if (symbase
== (elf_symbol_type
*) NULL
)
2849 bfd_set_error (bfd_error_no_memory
);
2854 /* Temporarily allocate room for the raw ELF symbols. */
2855 x_symp
= ((Elf_External_Sym
*)
2856 malloc (symcount
* sizeof (Elf_External_Sym
)));
2857 if (x_symp
== NULL
&& symcount
!= 0)
2859 bfd_set_error (bfd_error_no_memory
);
2863 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2864 != symcount
* sizeof (Elf_External_Sym
))
2866 /* Skip first symbol, which is a null dummy. */
2867 for (i
= 1; i
< symcount
; i
++)
2869 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2870 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2871 #ifdef ELF_KEEP_EXTSYM
2872 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2874 sym
->symbol
.the_bfd
= abfd
;
2876 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2879 sym
->symbol
.value
= i_sym
.st_value
;
2881 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2883 sym
->symbol
.section
= section_from_elf_index (abfd
,
2885 if (sym
->symbol
.section
== NULL
)
2887 /* This symbol is in a section for which we did not
2888 create a BFD section. Just use bfd_abs_section,
2889 although it is wrong. FIXME. */
2890 sym
->symbol
.section
= bfd_abs_section_ptr
;
2893 else if (i_sym
.st_shndx
== SHN_ABS
)
2895 sym
->symbol
.section
= bfd_abs_section_ptr
;
2897 else if (i_sym
.st_shndx
== SHN_COMMON
)
2899 sym
->symbol
.section
= bfd_com_section_ptr
;
2900 /* Elf puts the alignment into the `value' field, and
2901 the size into the `size' field. BFD wants to see the
2902 size in the value field, and doesn't care (at the
2903 moment) about the alignment. */
2904 sym
->symbol
.value
= i_sym
.st_size
;
2906 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2908 sym
->symbol
.section
= bfd_und_section_ptr
;
2911 sym
->symbol
.section
= bfd_abs_section_ptr
;
2913 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2915 switch (ELF_ST_BIND (i_sym
.st_info
))
2918 sym
->symbol
.flags
|= BSF_LOCAL
;
2921 if (i_sym
.st_shndx
!= SHN_UNDEF
2922 && i_sym
.st_shndx
!= SHN_COMMON
)
2923 sym
->symbol
.flags
|= BSF_GLOBAL
;
2926 sym
->symbol
.flags
|= BSF_WEAK
;
2930 switch (ELF_ST_TYPE (i_sym
.st_info
))
2933 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2936 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2939 sym
->symbol
.flags
|= BSF_FUNCTION
;
2944 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2946 /* Do some backend-specific processing on this symbol. */
2948 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2949 if (ebd
->elf_backend_symbol_processing
)
2950 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2957 /* Do some backend-specific processing on this symbol table. */
2959 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2960 if (ebd
->elf_backend_symbol_table_processing
)
2961 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2964 /* We rely on the zalloc to clear out the final symbol entry. */
2966 symcount
= sym
- symbase
;
2968 /* Fill in the user's symbol pointer vector if needed. */
2976 *symptrs
++ = &sym
->symbol
;
2979 *symptrs
= 0; /* Final null pointer */
2991 /* Return the number of bytes required to hold the symtab vector.
2993 Note that we base it on the count plus 1, since we will null terminate
2994 the vector allocated based on this size. However, the ELF symbol table
2995 always has a dummy entry as symbol #0, so it ends up even. */
2998 elf_get_symtab_upper_bound (abfd
)
3003 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3005 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3006 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3012 elf_get_dynamic_symtab_upper_bound (abfd
)
3017 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3019 if (elf_dynsymtab (abfd
) == 0)
3021 bfd_set_error (bfd_error_invalid_operation
);
3025 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3026 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3032 elf_get_reloc_upper_bound (abfd
, asect
)
3036 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3039 /* Read in and swap the external relocs. */
3042 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3047 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
3048 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
3049 PTR allocated
= NULL
;
3050 bfd_byte
*native_relocs
;
3056 if (asect
->relocation
!= NULL
3057 || (asect
->flags
& SEC_RELOC
) == 0
3058 || asect
->reloc_count
== 0)
3061 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
3062 && (asect
->reloc_count
3063 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
3065 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
3066 if (allocated
== NULL
)
3068 bfd_set_error (bfd_error_no_memory
);
3072 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
3073 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
3074 != d
->rel_hdr
.sh_size
))
3077 native_relocs
= (bfd_byte
*) allocated
;
3079 relents
= ((arelent
*)
3080 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
3081 if (relents
== NULL
)
3083 bfd_set_error (bfd_error_no_memory
);
3087 entsize
= d
->rel_hdr
.sh_entsize
;
3088 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
3089 || entsize
== sizeof (Elf_External_Rela
));
3091 for (i
= 0, relent
= relents
;
3092 i
< asect
->reloc_count
;
3093 i
++, relent
++, native_relocs
+= entsize
)
3095 Elf_Internal_Rela rela
;
3096 Elf_Internal_Rel rel
;
3098 if (entsize
== sizeof (Elf_External_Rela
))
3099 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
3102 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
3103 rela
.r_offset
= rel
.r_offset
;
3104 rela
.r_info
= rel
.r_info
;
3108 /* The address of an ELF reloc is section relative for an object
3109 file, and absolute for an executable file or shared library.
3110 The address of a BFD reloc is always section relative. */
3111 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3112 relent
->address
= rela
.r_offset
;
3114 relent
->address
= rela
.r_offset
- asect
->vma
;
3116 if (ELF_R_SYM (rela
.r_info
) == 0)
3117 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3122 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3125 /* Canonicalize ELF section symbols. FIXME: Why? */
3126 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3127 relent
->sym_ptr_ptr
= ps
;
3129 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3132 relent
->addend
= rela
.r_addend
;
3134 if (entsize
== sizeof (Elf_External_Rela
))
3135 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3137 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3140 asect
->relocation
= relents
;
3142 if (allocated
!= NULL
)
3148 if (allocated
!= NULL
)
3155 elf_debug_section (num
, hdr
)
3157 Elf_Internal_Shdr
*hdr
;
3159 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3160 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3163 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3164 (long) hdr
->sh_name
,
3165 (long) hdr
->sh_type
,
3166 (long) hdr
->sh_flags
);
3168 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3169 (long) hdr
->sh_addr
,
3170 (long) hdr
->sh_offset
,
3171 (long) hdr
->sh_size
);
3173 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3174 (long) hdr
->sh_link
,
3175 (long) hdr
->sh_info
,
3176 (long) hdr
->sh_addralign
);
3177 fprintf (stderr
, "sh_entsize = %ld\n",
3178 (long) hdr
->sh_entsize
);
3183 elf_debug_file (ehdrp
)
3184 Elf_Internal_Ehdr
*ehdrp
;
3186 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3187 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3188 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3189 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3190 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3191 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3192 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3196 /* Canonicalize the relocs. */
3199 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3208 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3211 tblptr
= section
->relocation
;
3212 for (i
= 0; i
< section
->reloc_count
; i
++)
3213 *relptr
++ = tblptr
++;
3217 return section
->reloc_count
;
3221 elf_get_symtab (abfd
, alocation
)
3223 asymbol
**alocation
;
3225 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3228 bfd_get_symcount (abfd
) = symcount
;
3233 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3235 asymbol
**alocation
;
3237 return elf_slurp_symbol_table (abfd
, alocation
, true);
3241 elf_make_empty_symbol (abfd
)
3244 elf_symbol_type
*newsym
;
3246 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3249 bfd_set_error (bfd_error_no_memory
);
3254 newsym
->symbol
.the_bfd
= abfd
;
3255 return &newsym
->symbol
;
3260 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3265 bfd_symbol_info (symbol
, ret
);
3269 elf_get_lineno (ignore_abfd
, symbol
)
3273 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3280 elf_set_arch_mach (abfd
, arch
, machine
)
3282 enum bfd_architecture arch
;
3283 unsigned long machine
;
3285 /* If this isn't the right architecture for this backend, and this
3286 isn't the generic backend, fail. */
3287 if (arch
!= get_elf_backend_data (abfd
)->arch
3288 && arch
!= bfd_arch_unknown
3289 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3292 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3296 elf_find_nearest_line (abfd
,
3307 CONST
char **filename_ptr
;
3308 CONST
char **functionname_ptr
;
3309 unsigned int *line_ptr
;
3315 elf_sizeof_headers (abfd
, reloc
)
3321 ret
= sizeof (Elf_External_Ehdr
);
3323 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
3329 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3334 bfd_size_type count
;
3336 Elf_Internal_Shdr
*hdr
;
3338 if (! abfd
->output_has_begun
3339 && ! elf_compute_section_file_positions (abfd
,
3340 (struct bfd_link_info
*) NULL
))
3343 hdr
= &elf_section_data (section
)->this_hdr
;
3345 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3347 if (bfd_write (location
, 1, count
, abfd
) != count
)
3354 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3357 Elf_Internal_Rela
*dst
;
3359 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3365 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3368 Elf_Internal_Rel
*dst
;
3370 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3376 /* Core file support */
3378 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3379 #include <sys/procfs.h>
3381 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3382 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3383 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3389 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3396 prstatus_t
*status
= (prstatus_t
*) 0;
3398 if (descsz
== sizeof (prstatus_t
))
3400 newsect
= bfd_make_section (abfd
, ".reg");
3401 if (newsect
== NULL
)
3403 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3404 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3405 newsect
->flags
= SEC_HAS_CONTENTS
;
3406 newsect
->alignment_power
= 2;
3407 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3409 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3415 /* Stash a copy of the prpsinfo structure away for future use. */
3418 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3424 if (descsz
== sizeof (prpsinfo_t
))
3426 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3428 bfd_set_error (bfd_error_no_memory
);
3431 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3437 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3445 newsect
= bfd_make_section (abfd
, ".reg2");
3446 if (newsect
== NULL
)
3448 newsect
->_raw_size
= descsz
;
3449 newsect
->filepos
= filepos
;
3450 newsect
->flags
= SEC_HAS_CONTENTS
;
3451 newsect
->alignment_power
= 2;
3455 #endif /* HAVE_PROCFS */
3457 /* Return a pointer to the args (including the command name) that were
3458 seen by the program that generated the core dump. Note that for
3459 some reason, a spurious space is tacked onto the end of the args
3460 in some (at least one anyway) implementations, so strip it off if
3464 elf_core_file_failing_command (abfd
)
3468 if (core_prpsinfo (abfd
))
3470 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3471 char *scan
= p
->pr_psargs
;
3476 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3480 return p
->pr_psargs
;
3486 /* Return the number of the signal that caused the core dump. Presumably,
3487 since we have a core file, we got a signal of some kind, so don't bother
3488 checking the other process status fields, just return the signal number.
3492 elf_core_file_failing_signal (abfd
)
3496 if (core_prstatus (abfd
))
3498 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3504 /* Check to see if the core file could reasonably be expected to have
3505 come for the current executable file. Note that by default we return
3506 true unless we find something that indicates that there might be a
3511 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3520 /* First, xvecs must match since both are ELF files for the same target. */
3522 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3524 bfd_set_error (bfd_error_system_call
);
3530 /* If no prpsinfo, just return true. Otherwise, grab the last component
3531 of the exec'd pathname from the prpsinfo. */
3533 if (core_prpsinfo (core_bfd
))
3535 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3542 /* Find the last component of the executable pathname. */
3544 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3550 execname
= (char *) exec_bfd
->filename
;
3553 /* See if they match */
3555 return strcmp (execname
, corename
) ? false : true;
3561 #endif /* HAVE_PROCFS */
3564 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3565 the information that would normally be available from the /proc interface
3566 for the process, at the time the process dumped core. Currently this
3567 includes copies of the prstatus, prpsinfo, and fpregset structures.
3569 Since these structures are potentially machine dependent in size and
3570 ordering, bfd provides two levels of support for them. The first level,
3571 available on all machines since it does not require that the host
3572 have /proc support or the relevant include files, is to create a bfd
3573 section for each of the prstatus, prpsinfo, and fpregset structures,
3574 without any interpretation of their contents. With just this support,
3575 the bfd client will have to interpret the structures itself. Even with
3576 /proc support, it might want these full structures for it's own reasons.
3578 In the second level of support, where HAVE_PROCFS is defined, bfd will
3579 pick apart the structures to gather some additional information that
3580 clients may want, such as the general register set, the name of the
3581 exec'ed file and its arguments, the signal (if any) that caused the
3587 elf_corefile_note (abfd
, hdr
)
3589 Elf_Internal_Phdr
*hdr
;
3591 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3592 Elf_Internal_Note i_note
; /* Elf note, internal form */
3593 char *buf
= NULL
; /* Entire note segment contents */
3594 char *namedata
; /* Name portion of the note */
3595 char *descdata
; /* Descriptor portion of the note */
3596 char *sectname
; /* Name to use for new section */
3597 long filepos
; /* File offset to descriptor data */
3600 if (hdr
->p_filesz
> 0
3601 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3602 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3603 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3605 x_note_p
= (Elf_External_Note
*) buf
;
3606 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3608 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3609 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3610 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3611 namedata
= x_note_p
->name
;
3612 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3613 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3614 switch (i_note
.type
)
3617 /* process descdata as prstatus info */
3618 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3620 sectname
= ".prstatus";
3623 /* process descdata as fpregset info */
3624 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3626 sectname
= ".fpregset";
3629 /* process descdata as prpsinfo */
3630 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3632 sectname
= ".prpsinfo";
3635 /* Unknown descriptor, just ignore it. */
3639 if (sectname
!= NULL
)
3641 newsect
= bfd_make_section (abfd
, sectname
);
3642 if (newsect
== NULL
)
3644 newsect
->_raw_size
= i_note
.descsz
;
3645 newsect
->filepos
= filepos
;
3646 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3647 newsect
->alignment_power
= 2;
3649 x_note_p
= (Elf_External_Note
*)
3650 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3657 else if (hdr
->p_filesz
> 0)
3659 bfd_set_error (bfd_error_no_memory
);
3666 /* Core files are simply standard ELF formatted files that partition
3667 the file using the execution view of the file (program header table)
3668 rather than the linking view. In fact, there is no section header
3669 table in a core file.
3671 The process status information (including the contents of the general
3672 register set) and the floating point register set are stored in a
3673 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3674 that allow standard bfd access to the general registers (.reg) and the
3675 floating point registers (.reg2).
3680 elf_core_file_p (abfd
)
3683 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3684 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3685 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3686 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3687 unsigned int phindex
;
3688 struct elf_backend_data
*ebd
;
3690 /* Read in the ELF header in external format. */
3692 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3694 if (bfd_get_error () != bfd_error_system_call
)
3695 bfd_set_error (bfd_error_wrong_format
);
3699 /* Now check to see if we have a valid ELF file, and one that BFD can
3700 make use of. The magic number must match, the address size ('class')
3701 and byte-swapping must match our XVEC entry, and it must have a
3702 program header table (FIXME: See comments re segments at top of this
3705 if (elf_file_p (&x_ehdr
) == false)
3708 bfd_set_error (bfd_error_wrong_format
);
3712 /* FIXME, Check EI_VERSION here ! */
3716 int desired_address_size
= ELFCLASS32
;
3719 int desired_address_size
= ELFCLASS64
;
3722 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3726 /* Switch xvec to match the specified byte order. */
3727 switch (x_ehdr
.e_ident
[EI_DATA
])
3729 case ELFDATA2MSB
: /* Big-endian */
3730 if (abfd
->xvec
->byteorder_big_p
== false)
3733 case ELFDATA2LSB
: /* Little-endian */
3734 if (abfd
->xvec
->byteorder_big_p
== true)
3737 case ELFDATANONE
: /* No data encoding specified */
3738 default: /* Unknown data encoding specified */
3742 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3743 the tdata pointer in the bfd. */
3746 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3747 if (elf_tdata (abfd
) == NULL
)
3749 bfd_set_error (bfd_error_no_memory
);
3753 /* FIXME, `wrong' returns from this point onward, leak memory. */
3755 /* Now that we know the byte order, swap in the rest of the header */
3756 i_ehdrp
= elf_elfheader (abfd
);
3757 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3759 elf_debug_file (i_ehdrp
);
3762 ebd
= get_elf_backend_data (abfd
);
3764 /* Check that the ELF e_machine field matches what this particular
3765 BFD format expects. */
3766 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3768 const bfd_target
* const *target_ptr
;
3770 if (ebd
->elf_machine_code
!= EM_NONE
)
3773 /* This is the generic ELF target. Let it match any ELF target
3774 for which we do not have a specific backend. */
3775 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3777 struct elf_backend_data
*back
;
3779 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3781 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3782 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3784 /* target_ptr is an ELF backend which matches this
3785 object file, so reject the generic ELF target. */
3791 /* If there is no program header, or the type is not a core file, then
3793 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3796 /* Allocate space for a copy of the program header table in
3797 internal form, seek to the program header table in the file,
3798 read it in, and convert it to internal form. As a simple sanity
3799 check, verify that the what BFD thinks is the size of each program
3800 header table entry actually matches the size recorded in the file. */
3802 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3804 i_phdrp
= (Elf_Internal_Phdr
*)
3805 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3808 bfd_set_error (bfd_error_no_memory
);
3811 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3813 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3815 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3818 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3821 /* Once all of the program headers have been read and converted, we
3822 can start processing them. */
3824 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3826 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3827 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3829 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3834 /* Remember the entry point specified in the ELF file header. */
3836 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3841 /* ELF linker code. */
3843 static boolean elf_link_add_object_symbols
3844 PARAMS ((bfd
*, struct bfd_link_info
*));
3845 static boolean elf_link_add_archive_symbols
3846 PARAMS ((bfd
*, struct bfd_link_info
*));
3847 static Elf_Internal_Rela
*elf_link_read_relocs
3848 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3849 static boolean elf_export_symbol
3850 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3851 static boolean elf_adjust_dynamic_symbol
3852 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3854 /* Given an ELF BFD, add symbols to the global hash table as
3858 elf_bfd_link_add_symbols (abfd
, info
)
3860 struct bfd_link_info
*info
;
3864 switch (bfd_get_format (abfd
))
3867 return elf_link_add_object_symbols (abfd
, info
);
3869 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3872 if (! bfd_check_format (first
, bfd_object
))
3874 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3876 /* On Linux, we may have an a.out archive which got
3877 recognized as an ELF archive. Therefore, we treat all
3878 archives as though they were actually of the flavour of
3879 their first element. */
3880 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3882 return elf_link_add_archive_symbols (abfd
, info
);
3884 bfd_set_error (bfd_error_wrong_format
);
3889 /* Add symbols from an ELF archive file to the linker hash table. We
3890 don't use _bfd_generic_link_add_archive_symbols because of a
3891 problem which arises on UnixWare. The UnixWare libc.so is an
3892 archive which includes an entry libc.so.1 which defines a bunch of
3893 symbols. The libc.so archive also includes a number of other
3894 object files, which also define symbols, some of which are the same
3895 as those defined in libc.so.1. Correct linking requires that we
3896 consider each object file in turn, and include it if it defines any
3897 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3898 this; it looks through the list of undefined symbols, and includes
3899 any object file which defines them. When this algorithm is used on
3900 UnixWare, it winds up pulling in libc.so.1 early and defining a
3901 bunch of symbols. This means that some of the other objects in the
3902 archive are not included in the link, which is incorrect since they
3903 precede libc.so.1 in the archive.
3905 Fortunately, ELF archive handling is simpler than that done by
3906 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3907 oddities. In ELF, if we find a symbol in the archive map, and the
3908 symbol is currently undefined, we know that we must pull in that
3911 Unfortunately, we do have to make multiple passes over the symbol
3912 table until nothing further is resolved. */
3915 elf_link_add_archive_symbols (abfd
, info
)
3917 struct bfd_link_info
*info
;
3920 boolean
*defined
= NULL
;
3921 boolean
*included
= NULL
;
3925 if (! bfd_has_map (abfd
))
3927 /* An empty archive is a special case. */
3928 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3930 bfd_set_error (bfd_error_no_symbols
);
3934 /* Keep track of all symbols we know to be already defined, and all
3935 files we know to be already included. This is to speed up the
3936 second and subsequent passes. */
3937 c
= bfd_ardata (abfd
)->symdef_count
;
3940 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3941 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3942 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3944 bfd_set_error (bfd_error_no_memory
);
3947 memset (defined
, 0, c
* sizeof (boolean
));
3948 memset (included
, 0, c
* sizeof (boolean
));
3950 symdefs
= bfd_ardata (abfd
)->symdefs
;
3963 symdefend
= symdef
+ c
;
3964 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3966 struct elf_link_hash_entry
*h
;
3968 struct bfd_link_hash_entry
*undefs_tail
;
3971 if (defined
[i
] || included
[i
])
3973 if (symdef
->file_offset
== last
)
3979 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3980 false, false, false);
3981 if (h
== (struct elf_link_hash_entry
*) NULL
)
3983 if (h
->root
.type
!= bfd_link_hash_undefined
)
3989 /* We need to include this archive member. */
3991 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3992 if (element
== (bfd
*) NULL
)
3995 if (! bfd_check_format (element
, bfd_object
))
3998 /* Doublecheck that we have not included this object
3999 already--it should be impossible, but there may be
4000 something wrong with the archive. */
4001 if (element
->archive_pass
!= 0)
4003 bfd_set_error (bfd_error_bad_value
);
4006 element
->archive_pass
= 1;
4008 undefs_tail
= info
->hash
->undefs_tail
;
4010 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4013 if (! elf_link_add_object_symbols (element
, info
))
4016 /* If there are any new undefined symbols, we need to make
4017 another pass through the archive in order to see whether
4018 they can be defined. FIXME: This isn't perfect, because
4019 common symbols wind up on undefs_tail and because an
4020 undefined symbol which is defined later on in this pass
4021 does not require another pass. This isn't a bug, but it
4022 does make the code less efficient than it could be. */
4023 if (undefs_tail
!= info
->hash
->undefs_tail
)
4026 /* Look backward to mark all symbols from this object file
4027 which we have already seen in this pass. */
4031 included
[mark
] = true;
4036 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4038 /* We mark subsequent symbols from this object file as we go
4039 on through the loop. */
4040 last
= symdef
->file_offset
;
4051 if (defined
!= (boolean
*) NULL
)
4053 if (included
!= (boolean
*) NULL
)
4058 /* Record a new dynamic symbol. We record the dynamic symbols as we
4059 read the input files, since we need to have a list of all of them
4060 before we can determine the final sizes of the output sections.
4061 Note that we may actually call this function even though we are not
4062 going to output any dynamic symbols; in some cases we know that a
4063 symbol should be in the dynamic symbol table, but only if there is
4067 elf_link_record_dynamic_symbol (info
, h
)
4068 struct bfd_link_info
*info
;
4069 struct elf_link_hash_entry
*h
;
4071 if (h
->dynindx
== -1)
4073 struct bfd_strtab_hash
*dynstr
;
4075 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4076 ++elf_hash_table (info
)->dynsymcount
;
4078 dynstr
= elf_hash_table (info
)->dynstr
;
4081 /* Create a strtab to hold the dynamic symbol names. */
4082 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
4087 h
->dynstr_index
= ((unsigned long)
4088 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
4090 if (h
->dynstr_index
== (unsigned long) -1)
4097 /* Add symbols from an ELF object file to the linker hash table. */
4100 elf_link_add_object_symbols (abfd
, info
)
4102 struct bfd_link_info
*info
;
4104 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4105 const Elf_Internal_Sym
*,
4106 const char **, flagword
*,
4107 asection
**, bfd_vma
*));
4108 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4109 asection
*, const Elf_Internal_Rela
*));
4111 Elf_Internal_Shdr
*hdr
;
4115 Elf_External_Sym
*buf
= NULL
;
4116 struct elf_link_hash_entry
**sym_hash
;
4118 Elf_External_Dyn
*dynbuf
= NULL
;
4119 struct elf_link_hash_entry
*weaks
;
4120 Elf_External_Sym
*esym
;
4121 Elf_External_Sym
*esymend
;
4123 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4124 collect
= get_elf_backend_data (abfd
)->collect
;
4126 /* A stripped shared library might only have a dynamic symbol table,
4127 not a regular symbol table. In that case we can still go ahead
4128 and link using the dynamic symbol table. */
4129 if (elf_onesymtab (abfd
) == 0
4130 && elf_dynsymtab (abfd
) != 0)
4132 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4133 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4136 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4137 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4139 /* The sh_info field of the symtab header tells us where the
4140 external symbols start. We don't care about the local symbols at
4142 if (elf_bad_symtab (abfd
))
4144 extsymcount
= symcount
;
4149 extsymcount
= symcount
- hdr
->sh_info
;
4150 extsymoff
= hdr
->sh_info
;
4153 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4154 if (buf
== NULL
&& extsymcount
!= 0)
4156 bfd_set_error (bfd_error_no_memory
);
4160 /* We store a pointer to the hash table entry for each external
4162 sym_hash
= ((struct elf_link_hash_entry
**)
4164 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4165 if (sym_hash
== NULL
)
4167 bfd_set_error (bfd_error_no_memory
);
4170 elf_sym_hashes (abfd
) = sym_hash
;
4172 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4176 /* If we are creating a shared library, create all the dynamic
4177 sections immediately. We need to attach them to something,
4178 so we attach them to this BFD, provided it is the right
4179 format. FIXME: If there are no input BFD's of the same
4180 format as the output, we can't make a shared library. */
4182 && ! elf_hash_table (info
)->dynamic_sections_created
4183 && abfd
->xvec
== info
->hash
->creator
)
4185 if (! elf_link_create_dynamic_sections (abfd
, info
))
4193 bfd_size_type strindex
;
4197 /* You can't use -r against a dynamic object. Also, there's no
4198 hope of using a dynamic object which does not exactly match
4199 the format of the output file. */
4200 if (info
->relocateable
4201 || info
->hash
->creator
!= abfd
->xvec
)
4203 bfd_set_error (bfd_error_invalid_operation
);
4207 /* Find the name to use in a DT_NEEDED entry that refers to this
4208 object. If the object has a DT_SONAME entry, we use it.
4209 Otherwise, if the generic linker stuck something in
4210 elf_dt_needed_name, we use that. Otherwise, we just use the
4212 name
= bfd_get_filename (abfd
);
4213 if (elf_dt_needed_name (abfd
) != NULL
)
4214 name
= elf_dt_needed_name (abfd
);
4215 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4218 Elf_External_Dyn
*extdyn
;
4219 Elf_External_Dyn
*extdynend
;
4221 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4224 bfd_set_error (bfd_error_no_memory
);
4228 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4229 (file_ptr
) 0, s
->_raw_size
))
4233 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4234 for (; extdyn
< extdynend
; extdyn
++)
4236 Elf_Internal_Dyn dyn
;
4238 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4239 if (dyn
.d_tag
== DT_SONAME
)
4244 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4247 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4248 name
= elf_string_from_elf_section (abfd
, link
,
4253 if (dyn
.d_tag
== DT_NEEDED
)
4254 elf_hash_table (info
)->saw_needed
= true;
4261 /* We do not want to include any of the sections in a dynamic
4262 object in the output file. We hack by simply clobbering the
4263 list of sections in the BFD. This could be handled more
4264 cleanly by, say, a new section flag; the existing
4265 SEC_NEVER_LOAD flag is not the one we want, because that one
4266 still implies that the section takes up space in the output
4268 abfd
->sections
= NULL
;
4270 /* If this is the first dynamic object found in the link, create
4271 the special sections required for dynamic linking. */
4272 if (! elf_hash_table (info
)->dynamic_sections_created
)
4274 if (! elf_link_create_dynamic_sections (abfd
, info
))
4278 /* Add a DT_NEEDED entry for this dynamic object. */
4279 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4281 if (strindex
== (bfd_size_type
) -1)
4283 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4288 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4290 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4291 != extsymcount
* sizeof (Elf_External_Sym
)))
4296 esymend
= buf
+ extsymcount
;
4297 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4299 Elf_Internal_Sym sym
;
4305 struct elf_link_hash_entry
*h
= NULL
;
4308 elf_swap_symbol_in (abfd
, esym
, &sym
);
4310 flags
= BSF_NO_FLAGS
;
4312 value
= sym
.st_value
;
4315 bind
= ELF_ST_BIND (sym
.st_info
);
4316 if (bind
== STB_LOCAL
)
4318 /* This should be impossible, since ELF requires that all
4319 global symbols follow all local symbols, and that sh_info
4320 point to the first global symbol. Unfortunatealy, Irix 5
4324 else if (bind
== STB_GLOBAL
)
4326 if (sym
.st_shndx
!= SHN_UNDEF
4327 && sym
.st_shndx
!= SHN_COMMON
)
4332 else if (bind
== STB_WEAK
)
4336 /* Leave it up to the processor backend. */
4339 if (sym
.st_shndx
== SHN_UNDEF
)
4340 sec
= bfd_und_section_ptr
;
4341 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4343 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4347 sec
= bfd_abs_section_ptr
;
4349 else if (sym
.st_shndx
== SHN_ABS
)
4350 sec
= bfd_abs_section_ptr
;
4351 else if (sym
.st_shndx
== SHN_COMMON
)
4353 sec
= bfd_com_section_ptr
;
4354 /* What ELF calls the size we call the value. What ELF
4355 calls the value we call the alignment. */
4356 value
= sym
.st_size
;
4360 /* Leave it up to the processor backend. */
4363 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4364 if (name
== (const char *) NULL
)
4367 if (add_symbol_hook
)
4369 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4373 /* The hook function sets the name to NULL if this symbol
4374 should be skipped for some reason. */
4375 if (name
== (const char *) NULL
)
4379 /* Sanity check that all possibilities were handled. */
4380 if (sec
== (asection
*) NULL
)
4382 bfd_set_error (bfd_error_bad_value
);
4386 if (bfd_is_und_section (sec
)
4387 || bfd_is_com_section (sec
))
4392 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4394 /* We need to look up the symbol now in order to get some of
4395 the dynamic object handling right. We pass the hash
4396 table entry in to _bfd_generic_link_add_one_symbol so
4397 that it does not have to look it up again. */
4398 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4399 true, false, false);
4404 /* If we are looking at a dynamic object, and this is a
4405 definition, we need to see if it has already been defined
4406 by some other object. If it has, we want to use the
4407 existing definition, and we do not want to report a
4408 multiple symbol definition error; we do this by
4409 clobbering sec to be bfd_und_section_ptr. */
4410 if (dynamic
&& definition
)
4412 if (h
->root
.type
== bfd_link_hash_defined
4413 || h
->root
.type
== bfd_link_hash_defweak
)
4414 sec
= bfd_und_section_ptr
;
4417 /* Similarly, if we are not looking at a dynamic object, and
4418 we have a definition, we want to override any definition
4419 we may have from a dynamic object. Symbols from regular
4420 files always take precedence over symbols from dynamic
4421 objects, even if they are defined after the dynamic
4422 object in the link. */
4425 && (h
->root
.type
== bfd_link_hash_defined
4426 || h
->root
.type
== bfd_link_hash_defweak
)
4427 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4428 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4429 == bfd_target_elf_flavour
)
4430 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4433 /* Change the hash table entry to undefined, and let
4434 _bfd_generic_link_add_one_symbol do the right thing
4435 with the new definition. */
4436 h
->root
.type
= bfd_link_hash_undefined
;
4437 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4441 if (! (_bfd_generic_link_add_one_symbol
4442 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4443 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4448 && (flags
& BSF_WEAK
) != 0
4449 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4450 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4451 && (*sym_hash
)->weakdef
== NULL
)
4453 /* Keep a list of all weak defined non function symbols from
4454 a dynamic object, using the weakdef field. Later in this
4455 function we will set the weakdef field to the correct
4456 value. We only put non-function symbols from dynamic
4457 objects on this list, because that happens to be the only
4458 time we need to know the normal symbol corresponding to a
4459 weak symbol, and the information is time consuming to
4460 figure out. If the weakdef field is not already NULL,
4461 then this symbol was already defined by some previous
4462 dynamic object, and we will be using that previous
4463 definition anyhow. */
4465 (*sym_hash
)->weakdef
= weaks
;
4469 /* Get the alignment of a common symbol. */
4470 if (sym
.st_shndx
== SHN_COMMON
4471 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4472 (*sym_hash
)->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4474 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4480 /* Remember the symbol size and type. */
4481 if (sym
.st_size
!= 0)
4483 /* FIXME: We should probably somehow give a warning if
4484 the symbol size changes. */
4485 h
->size
= sym
.st_size
;
4487 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4489 /* FIXME: We should probably somehow give a warning if
4490 the symbol type changes. */
4491 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4494 /* Set a flag in the hash table entry indicating the type of
4495 reference or definition we just found. Keep a count of
4496 the number of dynamic symbols we find. A dynamic symbol
4497 is one which is referenced or defined by both a regular
4498 object and a shared object, or one which is referenced or
4499 defined by more than one shared object. */
4500 old_flags
= h
->elf_link_hash_flags
;
4505 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4507 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4509 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4510 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4516 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4518 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4519 if ((old_flags
& new_flag
) != 0
4520 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4521 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4525 h
->elf_link_hash_flags
|= new_flag
;
4526 if (dynsym
&& h
->dynindx
== -1)
4528 if (! elf_link_record_dynamic_symbol (info
, h
))
4534 /* Now set the weakdefs field correctly for all the weak defined
4535 symbols we found. The only way to do this is to search all the
4536 symbols. Since we only need the information for non functions in
4537 dynamic objects, that's the only time we actually put anything on
4538 the list WEAKS. We need this information so that if a regular
4539 object refers to a symbol defined weakly in a dynamic object, the
4540 real symbol in the dynamic object is also put in the dynamic
4541 symbols; we also must arrange for both symbols to point to the
4542 same memory location. We could handle the general case of symbol
4543 aliasing, but a general symbol alias can only be generated in
4544 assembler code, handling it correctly would be very time
4545 consuming, and other ELF linkers don't handle general aliasing
4547 while (weaks
!= NULL
)
4549 struct elf_link_hash_entry
*hlook
;
4552 struct elf_link_hash_entry
**hpp
;
4553 struct elf_link_hash_entry
**hppend
;
4556 weaks
= hlook
->weakdef
;
4557 hlook
->weakdef
= NULL
;
4559 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4560 || hlook
->root
.type
== bfd_link_hash_defweak
);
4561 slook
= hlook
->root
.u
.def
.section
;
4562 vlook
= hlook
->root
.u
.def
.value
;
4564 hpp
= elf_sym_hashes (abfd
);
4565 hppend
= hpp
+ extsymcount
;
4566 for (; hpp
< hppend
; hpp
++)
4568 struct elf_link_hash_entry
*h
;
4572 && (h
->root
.type
== bfd_link_hash_defined
4573 || h
->root
.type
== bfd_link_hash_defweak
)
4574 && h
->root
.u
.def
.section
== slook
4575 && h
->root
.u
.def
.value
== vlook
)
4579 /* If the weak definition is in the list of dynamic
4580 symbols, make sure the real definition is put there
4582 if (hlook
->dynindx
!= -1
4583 && h
->dynindx
== -1)
4585 if (! elf_link_record_dynamic_symbol (info
, h
))
4600 /* If this object is the same format as the output object, and it is
4601 not a shared library, then let the backend look through the
4604 This is required to build global offset table entries and to
4605 arrange for dynamic relocs. It is not required for the
4606 particular common case of linking non PIC code, even when linking
4607 against shared libraries, but unfortunately there is no way of
4608 knowing whether an object file has been compiled PIC or not.
4609 Looking through the relocs is not particularly time consuming.
4610 The problem is that we must either (1) keep the relocs in memory,
4611 which causes the linker to require additional runtime memory or
4612 (2) read the relocs twice from the input file, which wastes time.
4613 This would be a good case for using mmap.
4615 I have no idea how to handle linking PIC code into a file of a
4616 different format. It probably can't be done. */
4617 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4619 && abfd
->xvec
== info
->hash
->creator
4620 && check_relocs
!= NULL
)
4624 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4626 Elf_Internal_Rela
*internal_relocs
;
4629 if ((o
->flags
& SEC_RELOC
) == 0
4630 || o
->reloc_count
== 0)
4633 /* I believe we can ignore the relocs for any section which
4634 does not form part of the final process image, such as a
4635 debugging section. */
4636 if ((o
->flags
& SEC_ALLOC
) == 0)
4639 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4640 (Elf_Internal_Rela
*) NULL
,
4642 if (internal_relocs
== NULL
)
4645 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4647 if (! info
->keep_memory
)
4648 free (internal_relocs
);
4665 /* Create some sections which will be filled in with dynamic linking
4666 information. ABFD is an input file which requires dynamic sections
4667 to be created. The dynamic sections take up virtual memory space
4668 when the final executable is run, so we need to create them before
4669 addresses are assigned to the output sections. We work out the
4670 actual contents and size of these sections later. */
4673 elf_link_create_dynamic_sections (abfd
, info
)
4675 struct bfd_link_info
*info
;
4678 register asection
*s
;
4679 struct elf_link_hash_entry
*h
;
4680 struct elf_backend_data
*bed
;
4682 if (elf_hash_table (info
)->dynamic_sections_created
)
4685 /* Make sure that all dynamic sections use the same input BFD. */
4686 if (elf_hash_table (info
)->dynobj
== NULL
)
4687 elf_hash_table (info
)->dynobj
= abfd
;
4689 abfd
= elf_hash_table (info
)->dynobj
;
4691 /* Note that we set the SEC_IN_MEMORY flag for all of these
4693 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4695 /* A dynamically linked executable has a .interp section, but a
4696 shared library does not. */
4699 s
= bfd_make_section (abfd
, ".interp");
4701 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4705 s
= bfd_make_section (abfd
, ".dynsym");
4707 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4708 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4711 s
= bfd_make_section (abfd
, ".dynstr");
4713 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4716 /* Create a strtab to hold the dynamic symbol names. */
4717 if (elf_hash_table (info
)->dynstr
== NULL
)
4719 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4720 if (elf_hash_table (info
)->dynstr
== NULL
)
4724 s
= bfd_make_section (abfd
, ".dynamic");
4726 || ! bfd_set_section_flags (abfd
, s
, flags
)
4727 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4730 /* The special symbol _DYNAMIC is always set to the start of the
4731 .dynamic section. This call occurs before we have processed the
4732 symbols for any dynamic object, so we don't have to worry about
4733 overriding a dynamic definition. We could set _DYNAMIC in a
4734 linker script, but we only want to define it if we are, in fact,
4735 creating a .dynamic section. We don't want to define it if there
4736 is no .dynamic section, since on some ELF platforms the start up
4737 code examines it to decide how to initialize the process. */
4739 if (! (_bfd_generic_link_add_one_symbol
4740 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4741 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4742 (struct bfd_link_hash_entry
**) &h
)))
4744 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4745 h
->type
= STT_OBJECT
;
4748 && ! elf_link_record_dynamic_symbol (info
, h
))
4751 s
= bfd_make_section (abfd
, ".hash");
4753 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4754 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4757 /* Let the backend create the rest of the sections. This lets the
4758 backend set the right flags. The backend will normally create
4759 the .got and .plt sections. */
4760 bed
= get_elf_backend_data (abfd
);
4761 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4764 elf_hash_table (info
)->dynamic_sections_created
= true;
4769 /* Add an entry to the .dynamic table. */
4772 elf_add_dynamic_entry (info
, tag
, val
)
4773 struct bfd_link_info
*info
;
4777 Elf_Internal_Dyn dyn
;
4781 bfd_byte
*newcontents
;
4783 dynobj
= elf_hash_table (info
)->dynobj
;
4785 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4786 BFD_ASSERT (s
!= NULL
);
4788 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4789 if (s
->contents
== NULL
)
4790 newcontents
= (bfd_byte
*) malloc (newsize
);
4792 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4793 if (newcontents
== NULL
)
4795 bfd_set_error (bfd_error_no_memory
);
4800 dyn
.d_un
.d_val
= val
;
4801 elf_swap_dyn_out (dynobj
, &dyn
,
4802 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4804 s
->_raw_size
= newsize
;
4805 s
->contents
= newcontents
;
4810 /* Read and swap the relocs for a section. They may have been cached.
4811 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4812 they are used as buffers to read into. They are known to be large
4813 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4814 value is allocated using either malloc or bfd_alloc, according to
4815 the KEEP_MEMORY argument. */
4817 static Elf_Internal_Rela
*
4818 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4821 PTR external_relocs
;
4822 Elf_Internal_Rela
*internal_relocs
;
4823 boolean keep_memory
;
4825 Elf_Internal_Shdr
*rel_hdr
;
4827 Elf_Internal_Rela
*alloc2
= NULL
;
4829 if (elf_section_data (o
)->relocs
!= NULL
)
4830 return elf_section_data (o
)->relocs
;
4832 if (o
->reloc_count
== 0)
4835 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4837 if (internal_relocs
== NULL
)
4841 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4843 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4845 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4846 if (internal_relocs
== NULL
)
4848 bfd_set_error (bfd_error_no_memory
);
4853 if (external_relocs
== NULL
)
4855 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4858 bfd_set_error (bfd_error_no_memory
);
4861 external_relocs
= alloc1
;
4864 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4865 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4866 != rel_hdr
->sh_size
))
4869 /* Swap in the relocs. For convenience, we always produce an
4870 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4872 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4874 Elf_External_Rel
*erel
;
4875 Elf_External_Rel
*erelend
;
4876 Elf_Internal_Rela
*irela
;
4878 erel
= (Elf_External_Rel
*) external_relocs
;
4879 erelend
= erel
+ o
->reloc_count
;
4880 irela
= internal_relocs
;
4881 for (; erel
< erelend
; erel
++, irela
++)
4883 Elf_Internal_Rel irel
;
4885 elf_swap_reloc_in (abfd
, erel
, &irel
);
4886 irela
->r_offset
= irel
.r_offset
;
4887 irela
->r_info
= irel
.r_info
;
4888 irela
->r_addend
= 0;
4893 Elf_External_Rela
*erela
;
4894 Elf_External_Rela
*erelaend
;
4895 Elf_Internal_Rela
*irela
;
4897 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4899 erela
= (Elf_External_Rela
*) external_relocs
;
4900 erelaend
= erela
+ o
->reloc_count
;
4901 irela
= internal_relocs
;
4902 for (; erela
< erelaend
; erela
++, irela
++)
4903 elf_swap_reloca_in (abfd
, erela
, irela
);
4906 /* Cache the results for next time, if we can. */
4908 elf_section_data (o
)->relocs
= internal_relocs
;
4913 /* Don't free alloc2, since if it was allocated we are passing it
4914 back (under the name of internal_relocs). */
4916 return internal_relocs
;
4926 /* Record an assignment to a symbol made by a linker script. We need
4927 this in case some dynamic object refers to this symbol. */
4931 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4933 struct bfd_link_info
*info
;
4936 struct elf_link_hash_entry
*h
;
4938 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4941 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4945 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4946 h
->type
= STT_OBJECT
;
4948 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4949 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4951 && h
->dynindx
== -1)
4953 if (! elf_link_record_dynamic_symbol (info
, h
))
4956 /* If this is a weak defined symbol, and we know a corresponding
4957 real symbol from the same dynamic object, make sure the real
4958 symbol is also made into a dynamic symbol. */
4959 if (h
->weakdef
!= NULL
4960 && h
->weakdef
->dynindx
== -1)
4962 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4970 /* Array used to determine the number of hash table buckets to use
4971 based on the number of symbols there are. If there are fewer than
4972 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4973 fewer than 37 we use 17 buckets, and so forth. We never use more
4974 than 521 buckets. */
4976 static const size_t elf_buckets
[] =
4978 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4981 /* Set up the sizes and contents of the ELF dynamic sections. This is
4982 called by the ELF linker emulation before_allocation routine. We
4983 must set the sizes of the sections before the linker sets the
4984 addresses of the various sections. */
4987 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4988 export_dynamic
, info
, sinterpptr
)
4992 boolean export_dynamic
;
4993 struct bfd_link_info
*info
;
4994 asection
**sinterpptr
;
4998 Elf_Internal_Sym isym
;
5001 struct elf_backend_data
*bed
;
5005 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
5008 dynobj
= elf_hash_table (info
)->dynobj
;
5010 /* If there were no dynamic objects in the link, there is nothing to
5015 /* If we are supposed to export all symbols into the dynamic symbol
5016 table (this is not the normal case), then do so. */
5018 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
5021 if (elf_hash_table (info
)->dynamic_sections_created
)
5023 bfd_size_type strsize
;
5025 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5026 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
5032 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
5034 if (indx
== (bfd_size_type
) -1
5035 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
5043 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5045 if (indx
== (bfd_size_type
) -1
5046 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5050 /* Find all symbols which were defined in a dynamic object and make
5051 the backend pick a reasonable value for them. */
5052 elf_link_hash_traverse (elf_hash_table (info
),
5053 elf_adjust_dynamic_symbol
,
5056 /* Add some entries to the .dynamic section. We fill in some of the
5057 values later, in elf_bfd_final_link, but we must add the entries
5058 now so that we know the final size of the .dynamic section. */
5059 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
5060 false, false) != NULL
)
5062 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
5065 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
5066 false, false) != NULL
)
5068 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
5071 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5072 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
5073 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5074 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5075 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5076 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
5077 sizeof (Elf_External_Sym
)))
5081 /* The backend must work out the sizes of all the other dynamic
5083 bed
= get_elf_backend_data (output_bfd
);
5084 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5087 if (elf_hash_table (info
)->dynamic_sections_created
)
5091 /* Set the size of the .dynsym and .hash sections. We counted
5092 the number of dynamic symbols in elf_link_add_object_symbols.
5093 We will build the contents of .dynsym and .hash when we build
5094 the final symbol table, because until then we do not know the
5095 correct value to give the symbols. We built the .dynstr
5096 section as we went along in elf_link_add_object_symbols. */
5097 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5098 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
5099 BFD_ASSERT (s
!= NULL
);
5100 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
5101 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5102 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5104 bfd_set_error (bfd_error_no_memory
);
5108 /* The first entry in .dynsym is a dummy symbol. */
5115 elf_swap_symbol_out (output_bfd
, &isym
,
5116 (Elf_External_Sym
*) s
->contents
);
5118 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5120 bucketcount
= elf_buckets
[i
];
5121 if (dynsymcount
< elf_buckets
[i
+ 1])
5125 s
= bfd_get_section_by_name (dynobj
, ".hash");
5126 BFD_ASSERT (s
!= NULL
);
5127 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5128 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5129 if (s
->contents
== NULL
)
5131 bfd_set_error (bfd_error_no_memory
);
5134 memset (s
->contents
, 0, s
->_raw_size
);
5136 put_word (output_bfd
, bucketcount
, s
->contents
);
5137 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5139 elf_hash_table (info
)->bucketcount
= bucketcount
;
5141 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5142 BFD_ASSERT (s
!= NULL
);
5143 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5145 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5152 /* This routine is used to export all defined symbols into the dynamic
5153 symbol table. It is called via elf_link_hash_traverse. */
5156 elf_export_symbol (h
, data
)
5157 struct elf_link_hash_entry
*h
;
5160 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5162 if (h
->dynindx
== -1
5163 && (h
->elf_link_hash_flags
5164 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5166 if (! elf_link_record_dynamic_symbol (info
, h
))
5168 /* FIXME: No way to report error. */
5176 /* Make the backend pick a good value for a dynamic symbol. This is
5177 called via elf_link_hash_traverse, and also calls itself
5181 elf_adjust_dynamic_symbol (h
, data
)
5182 struct elf_link_hash_entry
*h
;
5185 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5187 struct elf_backend_data
*bed
;
5189 /* If this symbol does not require a PLT entry, and it is not
5190 defined by a dynamic object, or is not referenced by a regular
5191 object, ignore it. FIXME: Do we need to worry about symbols
5192 which are defined by one dynamic object and referenced by another
5194 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5195 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5196 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5197 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5200 /* If we've already adjusted this symbol, don't do it again. This
5201 can happen via a recursive call. */
5202 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5205 /* Don't look at this symbol again. Note that we must set this
5206 after checking the above conditions, because we may look at a
5207 symbol once, decide not to do anything, and then get called
5208 recursively later after REF_REGULAR is set below. */
5209 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5211 /* If this is a weak definition, and we know a real definition, and
5212 the real symbol is not itself defined by a regular object file,
5213 then get a good value for the real definition. We handle the
5214 real symbol first, for the convenience of the backend routine.
5216 Note that there is a confusing case here. If the real definition
5217 is defined by a regular object file, we don't get the real symbol
5218 from the dynamic object, but we do get the weak symbol. If the
5219 processor backend uses a COPY reloc, then if some routine in the
5220 dynamic object changes the real symbol, we will not see that
5221 change in the corresponding weak symbol. This is the way other
5222 ELF linkers work as well, and seems to be a result of the shared
5225 I will clarify this issue. Most SVR4 shared libraries define the
5226 variable _timezone and define timezone as a weak synonym. The
5227 tzset call changes _timezone. If you write
5228 extern int timezone;
5230 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5231 you might expect that, since timezone is a synonym for _timezone,
5232 the same number will print both times. However, if the processor
5233 backend uses a COPY reloc, then actually timezone will be copied
5234 into your process image, and, since you define _timezone
5235 yourself, _timezone will not. Thus timezone and _timezone will
5236 wind up at different memory locations. The tzset call will set
5237 _timezone, leaving timezone unchanged. */
5239 if (h
->weakdef
!= NULL
)
5241 struct elf_link_hash_entry
*weakdef
;
5243 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5244 || h
->root
.type
== bfd_link_hash_defweak
);
5245 weakdef
= h
->weakdef
;
5246 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
5247 || weakdef
->root
.type
== bfd_link_hash_defweak
);
5248 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5249 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5251 /* This symbol is defined by a regular object file, so we
5252 will not do anything special. Clear weakdef for the
5253 convenience of the processor backend. */
5258 /* There is an implicit reference by a regular object file
5259 via the weak symbol. */
5260 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5261 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5266 dynobj
= elf_hash_table (info
)->dynobj
;
5267 bed
= get_elf_backend_data (dynobj
);
5268 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5270 /* FIXME: No way to return error. */
5277 /* Final phase of ELF linker. */
5279 /* A structure we use to avoid passing large numbers of arguments. */
5281 struct elf_final_link_info
5283 /* General link information. */
5284 struct bfd_link_info
*info
;
5287 /* Symbol string table. */
5288 struct bfd_strtab_hash
*symstrtab
;
5289 /* .dynsym section. */
5290 asection
*dynsym_sec
;
5291 /* .hash section. */
5293 /* Buffer large enough to hold contents of any section. */
5295 /* Buffer large enough to hold external relocs of any section. */
5296 PTR external_relocs
;
5297 /* Buffer large enough to hold internal relocs of any section. */
5298 Elf_Internal_Rela
*internal_relocs
;
5299 /* Buffer large enough to hold external local symbols of any input
5301 Elf_External_Sym
*external_syms
;
5302 /* Buffer large enough to hold internal local symbols of any input
5304 Elf_Internal_Sym
*internal_syms
;
5305 /* Array large enough to hold a symbol index for each local symbol
5306 of any input BFD. */
5308 /* Array large enough to hold a section pointer for each local
5309 symbol of any input BFD. */
5310 asection
**sections
;
5311 /* Buffer to hold swapped out symbols. */
5312 Elf_External_Sym
*symbuf
;
5313 /* Number of swapped out symbols in buffer. */
5314 size_t symbuf_count
;
5315 /* Number of symbols which fit in symbuf. */
5319 static boolean elf_link_output_sym
5320 PARAMS ((struct elf_final_link_info
*, const char *,
5321 Elf_Internal_Sym
*, asection
*));
5322 static boolean elf_link_flush_output_syms
5323 PARAMS ((struct elf_final_link_info
*));
5324 static boolean elf_link_output_extsym
5325 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5326 static boolean elf_link_input_bfd
5327 PARAMS ((struct elf_final_link_info
*, bfd
*));
5328 static boolean elf_reloc_link_order
5329 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5330 struct bfd_link_order
*));
5332 /* Do the final step of an ELF link. */
5335 elf_bfd_final_link (abfd
, info
)
5337 struct bfd_link_info
*info
;
5341 struct elf_final_link_info finfo
;
5342 register asection
*o
;
5343 register struct bfd_link_order
*p
;
5345 size_t max_contents_size
;
5346 size_t max_external_reloc_size
;
5347 size_t max_internal_reloc_count
;
5348 size_t max_sym_count
;
5350 Elf_Internal_Sym elfsym
;
5352 Elf_Internal_Shdr
*symtab_hdr
;
5353 Elf_Internal_Shdr
*symstrtab_hdr
;
5354 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5357 abfd
->flags
|= DYNAMIC
;
5359 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5360 dynobj
= elf_hash_table (info
)->dynobj
;
5363 finfo
.output_bfd
= abfd
;
5364 finfo
.symstrtab
= elf_stringtab_init ();
5365 if (finfo
.symstrtab
== NULL
)
5369 finfo
.dynsym_sec
= NULL
;
5370 finfo
.hash_sec
= NULL
;
5374 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5375 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5376 if (finfo
.dynsym_sec
== NULL
5377 || finfo
.hash_sec
== NULL
)
5380 finfo
.contents
= NULL
;
5381 finfo
.external_relocs
= NULL
;
5382 finfo
.internal_relocs
= NULL
;
5383 finfo
.external_syms
= NULL
;
5384 finfo
.internal_syms
= NULL
;
5385 finfo
.indices
= NULL
;
5386 finfo
.sections
= NULL
;
5387 finfo
.symbuf
= NULL
;
5388 finfo
.symbuf_count
= 0;
5390 /* Count up the number of relocations we will output for each output
5391 section, so that we know the sizes of the reloc sections. We
5392 also figure out some maximum sizes. */
5393 max_contents_size
= 0;
5394 max_external_reloc_size
= 0;
5395 max_internal_reloc_count
= 0;
5397 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5401 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5403 if (p
->type
== bfd_section_reloc_link_order
5404 || p
->type
== bfd_symbol_reloc_link_order
)
5406 else if (p
->type
== bfd_indirect_link_order
)
5410 sec
= p
->u
.indirect
.section
;
5412 if (info
->relocateable
)
5413 o
->reloc_count
+= sec
->reloc_count
;
5415 if (sec
->_raw_size
> max_contents_size
)
5416 max_contents_size
= sec
->_raw_size
;
5417 if (sec
->_cooked_size
> max_contents_size
)
5418 max_contents_size
= sec
->_cooked_size
;
5420 /* We are interested in just local symbols, not all
5422 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5426 if (elf_bad_symtab (sec
->owner
))
5427 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5428 / sizeof (Elf_External_Sym
));
5430 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5432 if (sym_count
> max_sym_count
)
5433 max_sym_count
= sym_count
;
5435 if ((sec
->flags
& SEC_RELOC
) != 0)
5439 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5440 if (ext_size
> max_external_reloc_size
)
5441 max_external_reloc_size
= ext_size
;
5442 if (sec
->reloc_count
> max_internal_reloc_count
)
5443 max_internal_reloc_count
= sec
->reloc_count
;
5449 if (o
->reloc_count
> 0)
5450 o
->flags
|= SEC_RELOC
;
5453 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5454 set it (this is probably a bug) and if it is set
5455 assign_section_numbers will create a reloc section. */
5456 o
->flags
&=~ SEC_RELOC
;
5459 /* If the SEC_ALLOC flag is not set, force the section VMA to
5460 zero. This is done in elf_fake_sections as well, but forcing
5461 the VMA to 0 here will ensure that relocs against these
5462 sections are handled correctly. */
5463 if ((o
->flags
& SEC_ALLOC
) == 0)
5467 /* Figure out the file positions for everything but the symbol table
5468 and the relocs. We set symcount to force assign_section_numbers
5469 to create a symbol table. */
5470 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5471 BFD_ASSERT (! abfd
->output_has_begun
);
5472 if (! elf_compute_section_file_positions (abfd
, info
))
5475 /* That created the reloc sections. Set their sizes, and assign
5476 them file positions, and allocate some buffers. */
5477 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5479 if ((o
->flags
& SEC_RELOC
) != 0)
5481 Elf_Internal_Shdr
*rel_hdr
;
5482 register struct elf_link_hash_entry
**p
, **pend
;
5484 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5486 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5488 /* The contents field must last into write_object_contents,
5489 so we allocate it with bfd_alloc rather than malloc. */
5490 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5491 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5493 bfd_set_error (bfd_error_no_memory
);
5497 p
= ((struct elf_link_hash_entry
**)
5498 malloc (o
->reloc_count
5499 * sizeof (struct elf_link_hash_entry
*)));
5500 if (p
== NULL
&& o
->reloc_count
!= 0)
5502 bfd_set_error (bfd_error_no_memory
);
5505 elf_section_data (o
)->rel_hashes
= p
;
5506 pend
= p
+ o
->reloc_count
;
5507 for (; p
< pend
; p
++)
5510 /* Use the reloc_count field as an index when outputting the
5516 assign_file_positions_for_relocs (abfd
);
5518 /* We have now assigned file positions for all the sections except
5519 .symtab and .strtab. We start the .symtab section at the current
5520 file position, and write directly to it. We build the .strtab
5521 section in memory. When we add .dynsym support, we will build
5522 that in memory as well (.dynsym is smaller than .symtab). */
5524 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5525 /* sh_name is set in prep_headers. */
5526 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5527 symtab_hdr
->sh_flags
= 0;
5528 symtab_hdr
->sh_addr
= 0;
5529 symtab_hdr
->sh_size
= 0;
5530 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5531 /* sh_link is set in assign_section_numbers. */
5532 /* sh_info is set below. */
5533 /* sh_offset is set just below. */
5534 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5536 off
= elf_tdata (abfd
)->next_file_pos
;
5537 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5539 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5540 incorrect. We do not yet know the size of the .symtab section.
5541 We correct next_file_pos below, after we do know the size. */
5543 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5544 continuously seeking to the right position in the file. */
5545 if (! info
->keep_memory
|| max_sym_count
< 20)
5546 finfo
.symbuf_size
= 20;
5548 finfo
.symbuf_size
= max_sym_count
;
5549 finfo
.symbuf
= ((Elf_External_Sym
*)
5550 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5551 if (finfo
.symbuf
== NULL
)
5553 bfd_set_error (bfd_error_no_memory
);
5557 /* Start writing out the symbol table. The first symbol is always a
5559 elfsym
.st_value
= 0;
5562 elfsym
.st_other
= 0;
5563 elfsym
.st_shndx
= SHN_UNDEF
;
5564 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5565 &elfsym
, bfd_und_section_ptr
))
5569 /* Some standard ELF linkers do this, but we don't because it causes
5570 bootstrap comparison failures. */
5571 /* Output a file symbol for the output file as the second symbol.
5572 We output this even if we are discarding local symbols, although
5573 I'm not sure if this is correct. */
5574 elfsym
.st_value
= 0;
5576 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5577 elfsym
.st_other
= 0;
5578 elfsym
.st_shndx
= SHN_ABS
;
5579 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5580 &elfsym
, bfd_abs_section_ptr
))
5584 /* Output a symbol for each section. We output these even if we are
5585 discarding local symbols, since they are used for relocs. These
5586 symbols have no names. We store the index of each one in the
5587 index field of the section, so that we can find it again when
5588 outputting relocs. */
5589 elfsym
.st_value
= 0;
5591 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5592 elfsym
.st_other
= 0;
5593 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5595 o
= section_from_elf_index (abfd
, i
);
5597 o
->target_index
= abfd
->symcount
;
5598 elfsym
.st_shndx
= i
;
5599 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5604 /* Allocate some memory to hold information read in from the input
5606 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5607 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5608 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5609 malloc (max_internal_reloc_count
5610 * sizeof (Elf_Internal_Rela
)));
5611 finfo
.external_syms
= ((Elf_External_Sym
*)
5612 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5613 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5614 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5615 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5616 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5617 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5618 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5619 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5620 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5621 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5622 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5623 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5625 bfd_set_error (bfd_error_no_memory
);
5629 /* Since ELF permits relocations to be against local symbols, we
5630 must have the local symbols available when we do the relocations.
5631 Since we would rather only read the local symbols once, and we
5632 would rather not keep them in memory, we handle all the
5633 relocations for a single input file at the same time.
5635 Unfortunately, there is no way to know the total number of local
5636 symbols until we have seen all of them, and the local symbol
5637 indices precede the global symbol indices. This means that when
5638 we are generating relocateable output, and we see a reloc against
5639 a global symbol, we can not know the symbol index until we have
5640 finished examining all the local symbols to see which ones we are
5641 going to output. To deal with this, we keep the relocations in
5642 memory, and don't output them until the end of the link. This is
5643 an unfortunate waste of memory, but I don't see a good way around
5644 it. Fortunately, it only happens when performing a relocateable
5645 link, which is not the common case. FIXME: If keep_memory is set
5646 we could write the relocs out and then read them again; I don't
5647 know how bad the memory loss will be. */
5649 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5650 sub
->output_has_begun
= false;
5651 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5653 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5655 if (p
->type
== bfd_indirect_link_order
5656 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5657 == bfd_target_elf_flavour
))
5659 sub
= p
->u
.indirect
.section
->owner
;
5660 if (! sub
->output_has_begun
)
5662 if (! elf_link_input_bfd (&finfo
, sub
))
5664 sub
->output_has_begun
= true;
5667 else if (p
->type
== bfd_section_reloc_link_order
5668 || p
->type
== bfd_symbol_reloc_link_order
)
5670 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5675 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5681 /* That wrote out all the local symbols. Finish up the symbol table
5682 with the global symbols. */
5684 /* The sh_info field records the index of the first non local
5686 symtab_hdr
->sh_info
= abfd
->symcount
;
5688 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5690 /* We get the global symbols from the hash table. */
5691 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5694 /* Flush all symbols to the file. */
5695 if (! elf_link_flush_output_syms (&finfo
))
5698 /* Now we know the size of the symtab section. */
5699 off
+= symtab_hdr
->sh_size
;
5701 /* Finish up and write out the symbol string table (.strtab)
5703 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5704 /* sh_name was set in prep_headers. */
5705 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5706 symstrtab_hdr
->sh_flags
= 0;
5707 symstrtab_hdr
->sh_addr
= 0;
5708 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5709 symstrtab_hdr
->sh_entsize
= 0;
5710 symstrtab_hdr
->sh_link
= 0;
5711 symstrtab_hdr
->sh_info
= 0;
5712 /* sh_offset is set just below. */
5713 symstrtab_hdr
->sh_addralign
= 1;
5715 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5716 elf_tdata (abfd
)->next_file_pos
= off
;
5718 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5719 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5722 /* Adjust the relocs to have the correct symbol indices. */
5723 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5725 struct elf_link_hash_entry
**rel_hash
;
5726 Elf_Internal_Shdr
*rel_hdr
;
5728 if ((o
->flags
& SEC_RELOC
) == 0)
5731 rel_hash
= elf_section_data (o
)->rel_hashes
;
5732 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5733 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5735 if (*rel_hash
== NULL
)
5738 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5740 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5742 Elf_External_Rel
*erel
;
5743 Elf_Internal_Rel irel
;
5745 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5746 elf_swap_reloc_in (abfd
, erel
, &irel
);
5747 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5748 ELF_R_TYPE (irel
.r_info
));
5749 elf_swap_reloc_out (abfd
, &irel
, erel
);
5753 Elf_External_Rela
*erela
;
5754 Elf_Internal_Rela irela
;
5756 BFD_ASSERT (rel_hdr
->sh_entsize
5757 == sizeof (Elf_External_Rela
));
5759 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5760 elf_swap_reloca_in (abfd
, erela
, &irela
);
5761 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5762 ELF_R_TYPE (irela
.r_info
));
5763 elf_swap_reloca_out (abfd
, &irela
, erela
);
5767 /* Set the reloc_count field to 0 to prevent write_relocs from
5768 trying to swap the relocs out itself. */
5772 /* If we are linking against a dynamic object, or generating a
5773 shared library, finish up the dynamic linking information. */
5776 Elf_External_Dyn
*dyncon
, *dynconend
;
5778 /* Fix up .dynamic entries. */
5779 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5780 BFD_ASSERT (o
!= NULL
);
5782 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5783 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5784 for (; dyncon
< dynconend
; dyncon
++)
5786 Elf_Internal_Dyn dyn
;
5790 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5797 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5798 magic _init and _fini symbols. This is pretty ugly,
5799 but we are compatible. */
5807 struct elf_link_hash_entry
*h
;
5809 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5810 false, false, true);
5811 BFD_ASSERT (h
!= NULL
);
5812 if (h
->root
.type
== bfd_link_hash_defined
5813 || h
->root
.type
== bfd_link_hash_defweak
)
5815 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5816 o
= h
->root
.u
.def
.section
;
5817 if (o
->output_section
!= NULL
)
5818 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5819 + o
->output_offset
);
5821 dyn
.d_un
.d_val
+= o
->vma
;
5823 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5836 o
= bfd_get_section_by_name (abfd
, name
);
5837 BFD_ASSERT (o
!= NULL
);
5838 dyn
.d_un
.d_ptr
= o
->vma
;
5839 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5846 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5851 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5853 Elf_Internal_Shdr
*hdr
;
5855 hdr
= elf_elfsections (abfd
)[i
];
5856 if (hdr
->sh_type
== type
5857 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5859 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5860 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5863 if (dyn
.d_un
.d_val
== 0
5864 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5865 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5869 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5875 /* If we have created any dynamic sections, then output them. */
5878 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5881 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5883 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5884 || o
->_raw_size
== 0)
5886 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5888 /* At this point, we are only interested in sections
5889 created by elf_link_create_dynamic_sections. FIXME:
5890 This test is fragile. */
5893 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5895 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5897 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5898 o
->contents
, o
->output_offset
,
5906 /* The contents of the .dynstr section are actually in a
5908 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5909 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5910 || ! _bfd_stringtab_emit (abfd
,
5911 elf_hash_table (info
)->dynstr
))
5917 if (finfo
.symstrtab
!= NULL
)
5918 _bfd_stringtab_free (finfo
.symstrtab
);
5919 if (finfo
.contents
!= NULL
)
5920 free (finfo
.contents
);
5921 if (finfo
.external_relocs
!= NULL
)
5922 free (finfo
.external_relocs
);
5923 if (finfo
.internal_relocs
!= NULL
)
5924 free (finfo
.internal_relocs
);
5925 if (finfo
.external_syms
!= NULL
)
5926 free (finfo
.external_syms
);
5927 if (finfo
.internal_syms
!= NULL
)
5928 free (finfo
.internal_syms
);
5929 if (finfo
.indices
!= NULL
)
5930 free (finfo
.indices
);
5931 if (finfo
.sections
!= NULL
)
5932 free (finfo
.sections
);
5933 if (finfo
.symbuf
!= NULL
)
5934 free (finfo
.symbuf
);
5935 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5937 if ((o
->flags
& SEC_RELOC
) != 0
5938 && elf_section_data (o
)->rel_hashes
!= NULL
)
5939 free (elf_section_data (o
)->rel_hashes
);
5942 elf_tdata (abfd
)->linker
= true;
5947 if (finfo
.symstrtab
!= NULL
)
5948 _bfd_stringtab_free (finfo
.symstrtab
);
5949 if (finfo
.contents
!= NULL
)
5950 free (finfo
.contents
);
5951 if (finfo
.external_relocs
!= NULL
)
5952 free (finfo
.external_relocs
);
5953 if (finfo
.internal_relocs
!= NULL
)
5954 free (finfo
.internal_relocs
);
5955 if (finfo
.external_syms
!= NULL
)
5956 free (finfo
.external_syms
);
5957 if (finfo
.internal_syms
!= NULL
)
5958 free (finfo
.internal_syms
);
5959 if (finfo
.indices
!= NULL
)
5960 free (finfo
.indices
);
5961 if (finfo
.sections
!= NULL
)
5962 free (finfo
.sections
);
5963 if (finfo
.symbuf
!= NULL
)
5964 free (finfo
.symbuf
);
5965 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5967 if ((o
->flags
& SEC_RELOC
) != 0
5968 && elf_section_data (o
)->rel_hashes
!= NULL
)
5969 free (elf_section_data (o
)->rel_hashes
);
5975 /* Add a symbol to the output symbol table. */
5978 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5979 struct elf_final_link_info
*finfo
;
5981 Elf_Internal_Sym
*elfsym
;
5982 asection
*input_sec
;
5984 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5985 struct bfd_link_info
*info
,
5990 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5991 elf_backend_link_output_symbol_hook
;
5992 if (output_symbol_hook
!= NULL
)
5994 if (! ((*output_symbol_hook
)
5995 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5999 if (name
== (const char *) NULL
|| *name
== '\0')
6000 elfsym
->st_name
= 0;
6003 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6006 if (elfsym
->st_name
== (unsigned long) -1)
6010 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6012 if (! elf_link_flush_output_syms (finfo
))
6016 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
6017 finfo
->symbuf
+ finfo
->symbuf_count
);
6018 ++finfo
->symbuf_count
;
6020 ++finfo
->output_bfd
->symcount
;
6025 /* Flush the output symbols to the file. */
6028 elf_link_flush_output_syms (finfo
)
6029 struct elf_final_link_info
*finfo
;
6031 Elf_Internal_Shdr
*symtab
;
6033 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6035 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
6037 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
6038 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
6039 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
6042 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
6044 finfo
->symbuf_count
= 0;
6049 /* Add an external symbol to the symbol table. This is called from
6050 the hash table traversal routine. */
6053 elf_link_output_extsym (h
, data
)
6054 struct elf_link_hash_entry
*h
;
6057 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
6059 Elf_Internal_Sym sym
;
6060 asection
*input_sec
;
6062 /* If we are not creating a shared library, and this symbol is
6063 referenced by a shared library but is not defined anywhere, then
6064 warn that it is undefined. If we do not do this, the runtime
6065 linker will complain that the symbol is undefined when the
6066 program is run. We don't have to worry about symbols that are
6067 referenced by regular files, because we will already have issued
6070 FIXME: If we are linking against an object which uses DT_NEEDED,
6071 we don't give this warning, because it might be the case that the
6072 needed dynamic object will define the symbols. Unfortunately,
6073 this makes this type of check much less useful, but the only way
6074 to fix it would be to locate the needed object and read its
6075 symbol table. That seems like a real waste of time just to give
6076 better error messages. */
6077 if (! finfo
->info
->relocateable
6078 && ! finfo
->info
->shared
6079 && ! elf_hash_table (finfo
->info
)->saw_needed
6080 && h
->root
.type
== bfd_link_hash_undefined
6081 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
6082 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6084 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6085 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6086 (asection
*) NULL
, 0)))
6088 /* FIXME: No way to return error. */
6093 /* We don't want to output symbols that have never been mentioned by
6094 a regular file, or that we have been told to strip. However, if
6095 h->indx is set to -2, the symbol is used by a reloc and we must
6099 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6100 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
6101 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
6102 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
6104 else if (finfo
->info
->strip
== strip_all
6105 || (finfo
->info
->strip
== strip_some
6106 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6107 h
->root
.root
.string
,
6108 false, false) == NULL
))
6113 /* If we're stripping it, and it's not a dynamic symbol, there's
6114 nothing else to do. */
6115 if (strip
&& h
->dynindx
== -1)
6119 sym
.st_size
= h
->size
;
6121 if (h
->root
.type
== bfd_link_hash_undefweak
6122 || h
->root
.type
== bfd_link_hash_defweak
)
6123 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6125 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6127 switch (h
->root
.type
)
6130 case bfd_link_hash_new
:
6134 case bfd_link_hash_undefined
:
6135 input_sec
= bfd_und_section_ptr
;
6136 sym
.st_shndx
= SHN_UNDEF
;
6139 case bfd_link_hash_undefweak
:
6140 input_sec
= bfd_und_section_ptr
;
6141 sym
.st_shndx
= SHN_UNDEF
;
6144 case bfd_link_hash_defined
:
6145 case bfd_link_hash_defweak
:
6147 input_sec
= h
->root
.u
.def
.section
;
6148 if (input_sec
->output_section
!= NULL
)
6151 elf_section_from_bfd_section (finfo
->output_bfd
,
6152 input_sec
->output_section
);
6153 if (sym
.st_shndx
== (unsigned short) -1)
6155 /* FIXME: No way to handle errors. */
6159 /* ELF symbols in relocateable files are section relative,
6160 but in nonrelocateable files they are virtual
6162 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6163 if (! finfo
->info
->relocateable
)
6164 sym
.st_value
+= input_sec
->output_section
->vma
;
6168 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6169 == bfd_target_elf_flavour
)
6170 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6171 sym
.st_shndx
= SHN_UNDEF
;
6172 input_sec
= bfd_und_section_ptr
;
6177 case bfd_link_hash_common
:
6178 input_sec
= bfd_com_section_ptr
;
6179 sym
.st_shndx
= SHN_COMMON
;
6180 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6183 case bfd_link_hash_indirect
:
6184 case bfd_link_hash_warning
:
6185 /* I have no idea how these should be handled. */
6189 /* If this symbol should be put in the .dynsym section, then put it
6190 there now. We have already know the symbol index. We also fill
6191 in the entry in the .hash section. */
6192 if (h
->dynindx
!= -1
6193 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6195 struct elf_backend_data
*bed
;
6198 bfd_byte
*bucketpos
;
6201 sym
.st_name
= h
->dynstr_index
;
6203 /* Give the processor backend a chance to tweak the symbol
6204 value, and also to finish up anything that needs to be done
6206 bed
= get_elf_backend_data (finfo
->output_bfd
);
6207 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6208 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6210 /* FIXME: No way to return error. */
6214 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6215 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6218 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6219 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6221 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6222 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6223 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6224 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6225 put_word (finfo
->output_bfd
, chain
,
6226 ((bfd_byte
*) finfo
->hash_sec
->contents
6227 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6230 /* If we're stripping it, then it was just a dynamic symbol, and
6231 there's nothing else to do. */
6235 h
->indx
= finfo
->output_bfd
->symcount
;
6237 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6239 /* FIXME: No way to return error. */
6246 /* Link an input file into the linker output file. This function
6247 handles all the sections and relocations of the input file at once.
6248 This is so that we only have to read the local symbols once, and
6249 don't have to keep them in memory. */
6252 elf_link_input_bfd (finfo
, input_bfd
)
6253 struct elf_final_link_info
*finfo
;
6256 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6257 bfd
*, asection
*, bfd_byte
*,
6258 Elf_Internal_Rela
*,
6259 Elf_Internal_Sym
*, asection
**));
6261 Elf_Internal_Shdr
*symtab_hdr
;
6264 Elf_External_Sym
*esym
;
6265 Elf_External_Sym
*esymend
;
6266 Elf_Internal_Sym
*isym
;
6268 asection
**ppsection
;
6271 output_bfd
= finfo
->output_bfd
;
6273 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6275 /* If this is a dynamic object, we don't want to do anything here:
6276 we don't want the local symbols, and we don't want the section
6278 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6281 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6282 if (elf_bad_symtab (input_bfd
))
6284 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6289 locsymcount
= symtab_hdr
->sh_info
;
6290 extsymoff
= symtab_hdr
->sh_info
;
6293 /* Read the local symbols. */
6295 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6296 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6297 locsymcount
, input_bfd
)
6298 != locsymcount
* sizeof (Elf_External_Sym
))))
6301 /* Swap in the local symbols and write out the ones which we know
6302 are going into the output file. */
6303 esym
= finfo
->external_syms
;
6304 esymend
= esym
+ locsymcount
;
6305 isym
= finfo
->internal_syms
;
6306 pindex
= finfo
->indices
;
6307 ppsection
= finfo
->sections
;
6308 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6312 Elf_Internal_Sym osym
;
6314 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6317 if (elf_bad_symtab (input_bfd
))
6319 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6326 if (isym
->st_shndx
== SHN_UNDEF
)
6327 isec
= bfd_und_section_ptr
;
6328 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6329 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6330 else if (isym
->st_shndx
== SHN_ABS
)
6331 isec
= bfd_abs_section_ptr
;
6332 else if (isym
->st_shndx
== SHN_COMMON
)
6333 isec
= bfd_com_section_ptr
;
6342 /* Don't output the first, undefined, symbol. */
6343 if (esym
== finfo
->external_syms
)
6346 /* If we are stripping all symbols, we don't want to output this
6348 if (finfo
->info
->strip
== strip_all
)
6351 /* We never output section symbols. Instead, we use the section
6352 symbol of the corresponding section in the output file. */
6353 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6356 /* If we are discarding all local symbols, we don't want to
6357 output this one. If we are generating a relocateable output
6358 file, then some of the local symbols may be required by
6359 relocs; we output them below as we discover that they are
6361 if (finfo
->info
->discard
== discard_all
)
6364 /* Get the name of the symbol. */
6365 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6370 /* See if we are discarding symbols with this name. */
6371 if ((finfo
->info
->strip
== strip_some
6372 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6374 || (finfo
->info
->discard
== discard_l
6375 && strncmp (name
, finfo
->info
->lprefix
,
6376 finfo
->info
->lprefix_len
) == 0))
6379 /* If we get here, we are going to output this symbol. */
6383 /* Adjust the section index for the output file. */
6384 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6385 isec
->output_section
);
6386 if (osym
.st_shndx
== (unsigned short) -1)
6389 *pindex
= output_bfd
->symcount
;
6391 /* ELF symbols in relocateable files are section relative, but
6392 in executable files they are virtual addresses. Note that
6393 this code assumes that all ELF sections have an associated
6394 BFD section with a reasonable value for output_offset; below
6395 we assume that they also have a reasonable value for
6396 output_section. Any special sections must be set up to meet
6397 these requirements. */
6398 osym
.st_value
+= isec
->output_offset
;
6399 if (! finfo
->info
->relocateable
)
6400 osym
.st_value
+= isec
->output_section
->vma
;
6402 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6406 /* Relocate the contents of each section. */
6407 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6409 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6412 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6413 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6415 /* Section was created by elf_link_create_dynamic_sections.
6416 FIXME: This test is fragile. */
6420 /* Read the contents of the section. */
6421 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6422 (file_ptr
) 0, o
->_raw_size
))
6425 if ((o
->flags
& SEC_RELOC
) != 0)
6427 Elf_Internal_Rela
*internal_relocs
;
6429 /* Get the swapped relocs. */
6430 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6431 finfo
->external_relocs
,
6432 finfo
->internal_relocs
,
6434 if (internal_relocs
== NULL
6435 && o
->reloc_count
> 0)
6438 /* Relocate the section by invoking a back end routine.
6440 The back end routine is responsible for adjusting the
6441 section contents as necessary, and (if using Rela relocs
6442 and generating a relocateable output file) adjusting the
6443 reloc addend as necessary.
6445 The back end routine does not have to worry about setting
6446 the reloc address or the reloc symbol index.
6448 The back end routine is given a pointer to the swapped in
6449 internal symbols, and can access the hash table entries
6450 for the external symbols via elf_sym_hashes (input_bfd).
6452 When generating relocateable output, the back end routine
6453 must handle STB_LOCAL/STT_SECTION symbols specially. The
6454 output symbol is going to be a section symbol
6455 corresponding to the output section, which will require
6456 the addend to be adjusted. */
6458 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6462 finfo
->internal_syms
,
6466 if (finfo
->info
->relocateable
)
6468 Elf_Internal_Rela
*irela
;
6469 Elf_Internal_Rela
*irelaend
;
6470 struct elf_link_hash_entry
**rel_hash
;
6471 Elf_Internal_Shdr
*input_rel_hdr
;
6472 Elf_Internal_Shdr
*output_rel_hdr
;
6474 /* Adjust the reloc addresses and symbol indices. */
6476 irela
= internal_relocs
;
6477 irelaend
= irela
+ o
->reloc_count
;
6478 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6479 + o
->output_section
->reloc_count
);
6480 for (; irela
< irelaend
; irela
++, rel_hash
++)
6483 Elf_Internal_Sym
*isym
;
6486 irela
->r_offset
+= o
->output_offset
;
6488 r_symndx
= ELF_R_SYM (irela
->r_info
);
6493 if (r_symndx
>= locsymcount
6494 || (elf_bad_symtab (input_bfd
)
6495 && finfo
->sections
[r_symndx
] == NULL
))
6499 /* This is a reloc against a global symbol. We
6500 have not yet output all the local symbols, so
6501 we do not know the symbol index of any global
6502 symbol. We set the rel_hash entry for this
6503 reloc to point to the global hash table entry
6504 for this symbol. The symbol index is then
6505 set at the end of elf_bfd_final_link. */
6506 indx
= r_symndx
- extsymoff
;
6507 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6509 /* Setting the index to -2 tells
6510 elf_link_output_extsym that this symbol is
6512 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6513 (*rel_hash
)->indx
= -2;
6518 /* This is a reloc against a local symbol. */
6521 isym
= finfo
->internal_syms
+ r_symndx
;
6522 sec
= finfo
->sections
[r_symndx
];
6523 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6525 /* I suppose the backend ought to fill in the
6526 section of any STT_SECTION symbol against a
6527 processor specific section. */
6528 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6530 else if (sec
== NULL
|| sec
->owner
== NULL
)
6532 bfd_set_error (bfd_error_bad_value
);
6537 r_symndx
= sec
->output_section
->target_index
;
6544 if (finfo
->indices
[r_symndx
] == -1)
6550 if (finfo
->info
->strip
== strip_all
)
6552 /* You can't do ld -r -s. */
6553 bfd_set_error (bfd_error_invalid_operation
);
6557 /* This symbol was skipped earlier, but
6558 since it is needed by a reloc, we
6559 must output it now. */
6560 link
= symtab_hdr
->sh_link
;
6561 name
= elf_string_from_elf_section (input_bfd
,
6567 osec
= sec
->output_section
;
6569 elf_section_from_bfd_section (output_bfd
,
6571 if (isym
->st_shndx
== (unsigned short) -1)
6574 isym
->st_value
+= sec
->output_offset
;
6575 if (! finfo
->info
->relocateable
)
6576 isym
->st_value
+= osec
->vma
;
6578 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6580 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6584 r_symndx
= finfo
->indices
[r_symndx
];
6587 irela
->r_info
= ELF_R_INFO (r_symndx
,
6588 ELF_R_TYPE (irela
->r_info
));
6591 /* Swap out the relocs. */
6592 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6593 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6594 BFD_ASSERT (output_rel_hdr
->sh_entsize
6595 == input_rel_hdr
->sh_entsize
);
6596 irela
= internal_relocs
;
6597 irelaend
= irela
+ o
->reloc_count
;
6598 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6600 Elf_External_Rel
*erel
;
6602 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6603 + o
->output_section
->reloc_count
);
6604 for (; irela
< irelaend
; irela
++, erel
++)
6606 Elf_Internal_Rel irel
;
6608 irel
.r_offset
= irela
->r_offset
;
6609 irel
.r_info
= irela
->r_info
;
6610 BFD_ASSERT (irela
->r_addend
== 0);
6611 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6616 Elf_External_Rela
*erela
;
6618 BFD_ASSERT (input_rel_hdr
->sh_entsize
6619 == sizeof (Elf_External_Rela
));
6620 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6621 + o
->output_section
->reloc_count
);
6622 for (; irela
< irelaend
; irela
++, erela
++)
6623 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6626 o
->output_section
->reloc_count
+= o
->reloc_count
;
6630 /* Write out the modified section contents. */
6631 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6632 finfo
->contents
, o
->output_offset
,
6633 (o
->_cooked_size
!= 0
6642 /* Generate a reloc when linking an ELF file. This is a reloc
6643 requested by the linker, and does come from any input file. This
6644 is used to build constructor and destructor tables when linking
6648 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6650 struct bfd_link_info
*info
;
6651 asection
*output_section
;
6652 struct bfd_link_order
*link_order
;
6654 reloc_howto_type
*howto
;
6657 struct elf_link_hash_entry
**rel_hash_ptr
;
6658 Elf_Internal_Shdr
*rel_hdr
;
6660 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6663 bfd_set_error (bfd_error_bad_value
);
6667 /* If this is an inplace reloc, we must write the addend into the
6669 if (howto
->partial_inplace
6670 && link_order
->u
.reloc
.p
->addend
!= 0)
6673 bfd_reloc_status_type rstat
;
6677 size
= bfd_get_reloc_size (howto
);
6678 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6679 if (buf
== (bfd_byte
*) NULL
)
6681 bfd_set_error (bfd_error_no_memory
);
6684 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6685 link_order
->u
.reloc
.p
->addend
, buf
);
6691 case bfd_reloc_outofrange
:
6693 case bfd_reloc_overflow
:
6694 if (! ((*info
->callbacks
->reloc_overflow
)
6696 (link_order
->type
== bfd_section_reloc_link_order
6697 ? bfd_section_name (output_bfd
,
6698 link_order
->u
.reloc
.p
->u
.section
)
6699 : link_order
->u
.reloc
.p
->u
.name
),
6700 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6701 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6708 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6709 (file_ptr
) link_order
->offset
, size
);
6715 /* Figure out the symbol index. */
6716 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6717 + output_section
->reloc_count
);
6718 if (link_order
->type
== bfd_section_reloc_link_order
)
6720 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6723 *rel_hash_ptr
= NULL
;
6727 struct elf_link_hash_entry
*h
;
6729 h
= elf_link_hash_lookup (elf_hash_table (info
),
6730 link_order
->u
.reloc
.p
->u
.name
,
6731 false, false, true);
6734 /* Setting the index to -2 tells elf_link_output_extsym that
6735 this symbol is used by a reloc. */
6742 if (! ((*info
->callbacks
->unattached_reloc
)
6743 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6744 (asection
*) NULL
, (bfd_vma
) 0)))
6750 /* The address of a reloc is relative to the section in a
6751 relocateable file, and is a virtual address in an executable
6753 offset
= link_order
->offset
;
6754 if (! info
->relocateable
)
6755 offset
+= output_section
->vma
;
6757 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6759 if (rel_hdr
->sh_type
== SHT_REL
)
6761 Elf_Internal_Rel irel
;
6762 Elf_External_Rel
*erel
;
6764 irel
.r_offset
= offset
;
6765 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6766 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6767 + output_section
->reloc_count
);
6768 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6772 Elf_Internal_Rela irela
;
6773 Elf_External_Rela
*erela
;
6775 irela
.r_offset
= offset
;
6776 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6777 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6778 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6779 + output_section
->reloc_count
);
6780 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6783 ++output_section
->reloc_count
;