1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
98 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
99 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
100 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
101 #define elf_get_symtab NAME(bfd_elf,get_symtab)
102 #define elf_canonicalize_dynamic_symtab \
103 NAME(bfd_elf,canonicalize_dynamic_symtab)
104 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
105 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
106 #define elf_get_lineno NAME(bfd_elf,get_lineno)
107 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
108 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
109 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
110 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
111 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
112 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
113 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
114 #define write_relocs NAME(bfd_elf,_write_relocs)
115 #define elf_find_section NAME(bfd_elf,find_section)
116 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
117 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
118 #define elf_link_create_dynamic_sections \
119 NAME(bfd_elf,link_create_dynamic_sections)
120 #define elf_link_record_dynamic_symbol \
121 NAME(bfd_elf,link_record_dynamic_symbol)
122 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
125 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
126 #define ELF_R_SYM(X) ELF64_R_SYM(X)
127 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
128 #define ELFCLASS ELFCLASS64
130 #define LOG_FILE_ALIGN 3
133 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
134 #define ELF_R_SYM(X) ELF32_R_SYM(X)
135 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
136 #define ELFCLASS ELFCLASS32
138 #define LOG_FILE_ALIGN 2
141 /* Forward declarations of static functions */
143 static struct bfd_strtab_hash
*elf_stringtab_init
PARAMS ((void));
144 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
146 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
148 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
150 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
152 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
153 struct symbol_cache_entry
**));
155 static boolean elf_compute_section_file_positions
156 PARAMS ((bfd
*, struct bfd_link_info
*));
157 static boolean prep_headers
PARAMS ((bfd
*));
158 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
159 static boolean assign_section_numbers
PARAMS ((bfd
*));
160 static file_ptr align_file_position
PARAMS ((file_ptr
));
161 static file_ptr assign_file_position_for_section
162 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
163 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
164 static int elf_sort_hdrs
PARAMS ((const PTR
, const PTR
));
165 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
166 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
167 static file_ptr map_program_segments
168 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
170 static boolean elf_map_symbols
PARAMS ((bfd
*));
171 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
173 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
176 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
177 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
180 #define elf_string_from_elf_strtab(abfd,strindex) \
181 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
183 /* Structure swapping routines */
185 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
186 can be handled by explicitly specifying 32 bits or "the long type". */
188 #define put_word bfd_h_put_64
189 #define get_word bfd_h_get_64
192 #define put_word bfd_h_put_32
193 #define get_word bfd_h_get_32
196 /* Translate an ELF symbol in external format into an ELF symbol in internal
200 elf_swap_symbol_in (abfd
, src
, dst
)
202 Elf_External_Sym
*src
;
203 Elf_Internal_Sym
*dst
;
205 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
206 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
207 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
208 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
209 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
210 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
213 /* Translate an ELF symbol in internal format into an ELF symbol in external
217 elf_swap_symbol_out (abfd
, src
, dst
)
219 Elf_Internal_Sym
*src
;
220 Elf_External_Sym
*dst
;
222 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
223 put_word (abfd
, src
->st_value
, dst
->st_value
);
224 put_word (abfd
, src
->st_size
, dst
->st_size
);
225 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
226 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
227 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
231 /* Translate an ELF file header in external format into an ELF file header in
235 elf_swap_ehdr_in (abfd
, src
, dst
)
237 Elf_External_Ehdr
*src
;
238 Elf_Internal_Ehdr
*dst
;
240 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
241 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
242 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
243 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
244 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
245 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
246 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
247 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
248 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
249 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
250 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
251 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
252 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
253 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
256 /* Translate an ELF file header in internal format into an ELF file header in
260 elf_swap_ehdr_out (abfd
, src
, dst
)
262 Elf_Internal_Ehdr
*src
;
263 Elf_External_Ehdr
*dst
;
265 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
266 /* note that all elements of dst are *arrays of unsigned char* already... */
267 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
268 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
269 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
270 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
271 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
272 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
273 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
274 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
275 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
276 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
277 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
278 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
279 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
283 /* Translate an ELF section header table entry in external format into an
284 ELF section header table entry in internal format. */
287 elf_swap_shdr_in (abfd
, src
, dst
)
289 Elf_External_Shdr
*src
;
290 Elf_Internal_Shdr
*dst
;
292 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
293 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
294 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
295 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
296 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
297 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
298 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
299 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
300 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
301 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
302 dst
->bfd_section
= NULL
;
303 dst
->contents
= NULL
;
306 /* Translate an ELF section header table entry in internal format into an
307 ELF section header table entry in external format. */
310 elf_swap_shdr_out (abfd
, src
, dst
)
312 Elf_Internal_Shdr
*src
;
313 Elf_External_Shdr
*dst
;
315 /* note that all elements of dst are *arrays of unsigned char* already... */
316 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
317 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
318 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
319 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
320 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
321 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
322 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
323 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
324 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
325 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
329 /* Translate an ELF program header table entry in external format into an
330 ELF program header table entry in internal format. */
333 elf_swap_phdr_in (abfd
, src
, dst
)
335 Elf_External_Phdr
*src
;
336 Elf_Internal_Phdr
*dst
;
338 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
339 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
340 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
341 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
342 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
343 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
344 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
345 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
349 elf_swap_phdr_out (abfd
, src
, dst
)
351 Elf_Internal_Phdr
*src
;
352 Elf_External_Phdr
*dst
;
354 /* note that all elements of dst are *arrays of unsigned char* already... */
355 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
356 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
357 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
358 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
359 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
360 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
361 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
362 put_word (abfd
, src
->p_align
, dst
->p_align
);
365 /* Translate an ELF reloc from external format to internal format. */
367 elf_swap_reloc_in (abfd
, src
, dst
)
369 Elf_External_Rel
*src
;
370 Elf_Internal_Rel
*dst
;
372 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
373 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
377 elf_swap_reloca_in (abfd
, src
, dst
)
379 Elf_External_Rela
*src
;
380 Elf_Internal_Rela
*dst
;
382 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
383 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
384 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
387 /* Translate an ELF reloc from internal format to external format. */
389 elf_swap_reloc_out (abfd
, src
, dst
)
391 Elf_Internal_Rel
*src
;
392 Elf_External_Rel
*dst
;
394 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
395 put_word (abfd
, src
->r_info
, dst
->r_info
);
399 elf_swap_reloca_out (abfd
, src
, dst
)
401 Elf_Internal_Rela
*src
;
402 Elf_External_Rela
*dst
;
404 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
405 put_word (abfd
, src
->r_info
, dst
->r_info
);
406 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
410 elf_swap_dyn_in (abfd
, src
, dst
)
412 const Elf_External_Dyn
*src
;
413 Elf_Internal_Dyn
*dst
;
415 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
416 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
420 elf_swap_dyn_out (abfd
, src
, dst
)
422 const Elf_Internal_Dyn
*src
;
423 Elf_External_Dyn
*dst
;
425 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
426 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
429 /* Allocate an ELF string table--force the first byte to be zero. */
431 static struct bfd_strtab_hash
*
432 elf_stringtab_init ()
434 struct bfd_strtab_hash
*ret
;
436 ret
= _bfd_stringtab_init ();
441 loc
= _bfd_stringtab_add (ret
, "", true, false);
442 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
443 if (loc
== (bfd_size_type
) -1)
445 _bfd_stringtab_free (ret
);
452 /* ELF .o/exec file reading */
454 /* Create a new bfd section from an ELF section header. */
457 bfd_section_from_shdr (abfd
, shindex
)
459 unsigned int shindex
;
461 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
462 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
465 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
467 switch (hdr
->sh_type
)
470 /* Inactive section. Throw it away. */
473 case SHT_PROGBITS
: /* Normal section with contents. */
474 case SHT_DYNAMIC
: /* Dynamic linking information. */
475 case SHT_NOBITS
: /* .bss section. */
476 case SHT_HASH
: /* .hash section. */
477 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
479 case SHT_SYMTAB
: /* A symbol table */
480 if (elf_onesymtab (abfd
) == shindex
)
483 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
484 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
485 elf_onesymtab (abfd
) = shindex
;
486 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
487 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
488 abfd
->flags
|= HAS_SYMS
;
490 /* Sometimes a shared object will map in the symbol table. If
491 SHF_ALLOC is set, and this is a shared object, then we also
492 treat this section as a BFD section. We can not base the
493 decision purely on SHF_ALLOC, because that flag is sometimes
494 set in a relocateable object file, which would confuse the
496 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
497 && (abfd
->flags
& DYNAMIC
) != 0
498 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
503 case SHT_DYNSYM
: /* A dynamic symbol table */
504 if (elf_dynsymtab (abfd
) == shindex
)
507 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
508 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
509 elf_dynsymtab (abfd
) = shindex
;
510 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
511 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
512 abfd
->flags
|= HAS_SYMS
;
514 /* Besides being a symbol table, we also treat this as a regular
515 section, so that objcopy can handle it. */
516 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
518 case SHT_STRTAB
: /* A string table */
519 if (hdr
->bfd_section
!= NULL
)
521 if (ehdr
->e_shstrndx
== shindex
)
523 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
524 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
530 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
532 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
533 if (hdr2
->sh_link
== shindex
)
535 if (! bfd_section_from_shdr (abfd
, i
))
537 if (elf_onesymtab (abfd
) == i
)
539 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
540 elf_elfsections (abfd
)[shindex
] =
541 &elf_tdata (abfd
)->strtab_hdr
;
544 if (elf_dynsymtab (abfd
) == i
)
546 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
547 elf_elfsections (abfd
)[shindex
] =
548 &elf_tdata (abfd
)->dynstrtab_hdr
;
549 /* We also treat this as a regular section, so
550 that objcopy can handle it. */
553 #if 0 /* Not handling other string tables specially right now. */
554 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
555 /* We have a strtab for some random other section. */
556 newsect
= (asection
*) hdr2
->bfd_section
;
559 hdr
->bfd_section
= newsect
;
560 hdr2
= &elf_section_data (newsect
)->str_hdr
;
562 elf_elfsections (abfd
)[shindex
] = hdr2
;
568 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
572 /* *These* do a lot of work -- but build no sections! */
574 asection
*target_sect
;
575 Elf_Internal_Shdr
*hdr2
;
576 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
578 /* Get the symbol table. */
579 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
582 /* If this reloc section does not use the main symbol table we
583 don't treat it as a reloc section. BFD can't adequately
584 represent such a section, so at least for now, we don't
585 try. We just present it as a normal section. */
586 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
587 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
589 /* Don't allow REL relocations on a machine that uses RELA and
591 /* @@ Actually, the generic ABI does suggest that both might be
592 used in one file. But the four ABI Processor Supplements I
593 have access to right now all specify that only one is used on
594 each of those architectures. It's conceivable that, e.g., a
595 bunch of absolute 32-bit relocs might be more compact in REL
596 form even on a RELA machine... */
597 BFD_ASSERT (use_rela_p
598 ? (hdr
->sh_type
== SHT_RELA
599 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
600 : (hdr
->sh_type
== SHT_REL
601 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
603 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
605 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
606 if (target_sect
== NULL
)
609 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
611 elf_elfsections (abfd
)[shindex
] = hdr2
;
612 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
613 target_sect
->flags
|= SEC_RELOC
;
614 target_sect
->relocation
= NULL
;
615 target_sect
->rel_filepos
= hdr
->sh_offset
;
616 abfd
->flags
|= HAS_RELOC
;
623 fprintf (stderr
, "Note Sections not yet supported.\n");
630 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
635 /* Check for any processor-specific section types. */
637 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
639 if (bed
->elf_backend_section_from_shdr
)
640 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
649 elf_new_section_hook (abfd
, sec
)
654 struct bfd_elf_section_data
*sdata
;
656 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
659 bfd_set_error (bfd_error_no_memory
);
662 sec
->used_by_bfd
= (PTR
) sdata
;
663 memset (sdata
, 0, sizeof (*sdata
));
667 /* Create a new bfd section from an ELF program header.
669 Since program segments have no names, we generate a synthetic name
670 of the form segment<NUM>, where NUM is generally the index in the
671 program header table. For segments that are split (see below) we
672 generate the names segment<NUM>a and segment<NUM>b.
674 Note that some program segments may have a file size that is different than
675 (less than) the memory size. All this means is that at execution the
676 system must allocate the amount of memory specified by the memory size,
677 but only initialize it with the first "file size" bytes read from the
678 file. This would occur for example, with program segments consisting
679 of combined data+bss.
681 To handle the above situation, this routine generates TWO bfd sections
682 for the single program segment. The first has the length specified by
683 the file size of the segment, and the second has the length specified
684 by the difference between the two sizes. In effect, the segment is split
685 into it's initialized and uninitialized parts.
690 bfd_section_from_phdr (abfd
, hdr
, index
)
692 Elf_Internal_Phdr
*hdr
;
700 split
= ((hdr
->p_memsz
> 0) &&
701 (hdr
->p_filesz
> 0) &&
702 (hdr
->p_memsz
> hdr
->p_filesz
));
703 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
704 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
707 bfd_set_error (bfd_error_no_memory
);
710 strcpy (name
, namebuf
);
711 newsect
= bfd_make_section (abfd
, name
);
714 newsect
->vma
= hdr
->p_vaddr
;
715 newsect
->_raw_size
= hdr
->p_filesz
;
716 newsect
->filepos
= hdr
->p_offset
;
717 newsect
->flags
|= SEC_HAS_CONTENTS
;
718 if (hdr
->p_type
== PT_LOAD
)
720 newsect
->flags
|= SEC_ALLOC
;
721 newsect
->flags
|= SEC_LOAD
;
722 if (hdr
->p_flags
& PF_X
)
724 /* FIXME: all we known is that it has execute PERMISSION,
726 newsect
->flags
|= SEC_CODE
;
729 if (!(hdr
->p_flags
& PF_W
))
731 newsect
->flags
|= SEC_READONLY
;
736 sprintf (namebuf
, "segment%db", index
);
737 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
740 bfd_set_error (bfd_error_no_memory
);
743 strcpy (name
, namebuf
);
744 newsect
= bfd_make_section (abfd
, name
);
747 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
748 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
749 if (hdr
->p_type
== PT_LOAD
)
751 newsect
->flags
|= SEC_ALLOC
;
752 if (hdr
->p_flags
& PF_X
)
753 newsect
->flags
|= SEC_CODE
;
755 if (!(hdr
->p_flags
& PF_W
))
756 newsect
->flags
|= SEC_READONLY
;
762 /* Begin processing a given object.
764 First we validate the file by reading in the ELF header and checking
767 static INLINE boolean
769 Elf_External_Ehdr
*x_ehdrp
;
771 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
772 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
773 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
774 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
777 /* Check to see if the file associated with ABFD matches the target vector
780 Note that we may be called several times with the same ABFD, but different
781 target vectors, most of which will not match. We have to avoid leaving
782 any side effects in ABFD, or any data it points to (like tdata), if the
783 file does not match the target vector. */
789 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
790 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
791 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
792 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
793 unsigned int shindex
;
794 char *shstrtab
; /* Internal copy of section header stringtab */
795 struct elf_backend_data
*ebd
;
796 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
797 struct elf_obj_tdata
*new_tdata
= NULL
;
799 /* Read in the ELF header in external format. */
801 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
803 if (bfd_get_error () != bfd_error_system_call
)
804 goto got_wrong_format_error
;
809 /* Now check to see if we have a valid ELF file, and one that BFD can
810 make use of. The magic number must match, the address size ('class')
811 and byte-swapping must match our XVEC entry, and it must have a
812 section header table (FIXME: See comments re sections at top of this
815 if ((elf_file_p (&x_ehdr
) == false) ||
816 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
817 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
818 goto got_wrong_format_error
;
820 /* Check that file's byte order matches xvec's */
821 switch (x_ehdr
.e_ident
[EI_DATA
])
823 case ELFDATA2MSB
: /* Big-endian */
824 if (!abfd
->xvec
->header_byteorder_big_p
)
825 goto got_wrong_format_error
;
827 case ELFDATA2LSB
: /* Little-endian */
828 if (abfd
->xvec
->header_byteorder_big_p
)
829 goto got_wrong_format_error
;
831 case ELFDATANONE
: /* No data encoding specified */
832 default: /* Unknown data encoding specified */
833 goto got_wrong_format_error
;
836 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
837 the tdata pointer in the bfd. */
839 new_tdata
= ((struct elf_obj_tdata
*)
840 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
841 if (new_tdata
== NULL
)
842 goto got_no_memory_error
;
843 elf_tdata (abfd
) = new_tdata
;
845 /* Now that we know the byte order, swap in the rest of the header */
846 i_ehdrp
= elf_elfheader (abfd
);
847 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
849 elf_debug_file (i_ehdrp
);
852 /* If there is no section header table, we're hosed. */
853 if (i_ehdrp
->e_shoff
== 0)
854 goto got_wrong_format_error
;
856 /* As a simple sanity check, verify that the what BFD thinks is the
857 size of each section header table entry actually matches the size
858 recorded in the file. */
859 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
860 goto got_wrong_format_error
;
862 ebd
= get_elf_backend_data (abfd
);
864 /* Check that the ELF e_machine field matches what this particular
865 BFD format expects. */
866 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
868 const bfd_target
* const *target_ptr
;
870 if (ebd
->elf_machine_code
!= EM_NONE
)
871 goto got_wrong_format_error
;
873 /* This is the generic ELF target. Let it match any ELF target
874 for which we do not have a specific backend. */
875 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
877 struct elf_backend_data
*back
;
879 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
881 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
882 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
884 /* target_ptr is an ELF backend which matches this
885 object file, so reject the generic ELF target. */
886 goto got_wrong_format_error
;
891 if (i_ehdrp
->e_type
== ET_EXEC
)
892 abfd
->flags
|= EXEC_P
;
893 else if (i_ehdrp
->e_type
== ET_DYN
)
894 abfd
->flags
|= DYNAMIC
;
896 if (i_ehdrp
->e_phnum
> 0)
897 abfd
->flags
|= D_PAGED
;
899 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
902 /* Remember the entry point specified in the ELF file header. */
903 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
905 /* Allocate space for a copy of the section header table in
906 internal form, seek to the section header table in the file,
907 read it in, and convert it to internal form. */
908 i_shdrp
= ((Elf_Internal_Shdr
*)
909 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
910 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
912 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
913 if (!i_shdrp
|| !elf_elfsections (abfd
))
914 goto got_no_memory_error
;
915 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
917 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
919 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
921 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
922 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
924 if (i_ehdrp
->e_shstrndx
)
926 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
930 /* Read in the string table containing the names of the sections. We
931 will need the base pointer to this table later. */
932 /* We read this inline now, so that we don't have to go through
933 bfd_section_from_shdr with it (since this particular strtab is
934 used to find all of the ELF section names.) */
936 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
940 /* Once all of the section headers have been read and converted, we
941 can start processing them. Note that the first section header is
942 a dummy placeholder entry, so we ignore it. */
944 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
946 if (! bfd_section_from_shdr (abfd
, shindex
))
950 /* Let the backend double check the format and override global
952 if (ebd
->elf_backend_object_p
)
954 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
955 goto got_wrong_format_error
;
960 got_wrong_format_error
:
961 bfd_set_error (bfd_error_wrong_format
);
964 bfd_set_error (bfd_error_no_memory
);
967 if (new_tdata
!= NULL
968 && new_tdata
->elf_sect_ptr
!= NULL
)
969 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
971 bfd_release (abfd
, i_shdrp
);
972 if (new_tdata
!= NULL
)
973 bfd_release (abfd
, new_tdata
);
974 elf_tdata (abfd
) = preserved_tdata
;
979 /* ELF .o/exec file writing */
981 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
982 of the symbol if there is one. */
983 static INLINE elf_symbol_type
*
984 elf_symbol_from (ignore_abfd
, symbol
)
988 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
991 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
994 return (elf_symbol_type
*) symbol
;
998 write_relocs (abfd
, sec
, xxx
)
1003 Elf_Internal_Shdr
*rela_hdr
;
1004 Elf_External_Rela
*outbound_relocas
;
1005 Elf_External_Rel
*outbound_relocs
;
1007 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1008 asymbol
*last_sym
= 0;
1009 int last_sym_idx
= 9999999; /* should always be written before use */
1011 if ((sec
->flags
& SEC_RELOC
) == 0)
1014 /* The linker backend writes the relocs out itself, and sets the
1015 reloc_count field to zero to inhibit writing them here. Also,
1016 sometimes the SEC_RELOC flag gets set even when there aren't any
1018 if (sec
->reloc_count
== 0)
1021 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1023 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1024 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1025 if (!rela_hdr
->contents
)
1027 bfd_set_error (bfd_error_no_memory
);
1028 abort (); /* FIXME */
1031 /* orelocation has the data, reloc_count has the count... */
1034 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1036 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1038 Elf_Internal_Rela dst_rela
;
1039 Elf_External_Rela
*src_rela
;
1044 ptr
= sec
->orelocation
[idx
];
1045 src_rela
= outbound_relocas
+ idx
;
1047 /* The address of an ELF reloc is section relative for an object
1048 file, and absolute for an executable file or shared library.
1049 The address of a BFD reloc is always section relative. */
1050 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1051 dst_rela
.r_offset
= ptr
->address
;
1053 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
1055 sym
= *ptr
->sym_ptr_ptr
;
1056 if (sym
== last_sym
)
1061 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1063 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1065 dst_rela
.r_addend
= ptr
->addend
;
1066 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1070 /* REL relocations */
1072 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1074 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1076 Elf_Internal_Rel dst_rel
;
1077 Elf_External_Rel
*src_rel
;
1082 ptr
= sec
->orelocation
[idx
];
1083 sym
= *ptr
->sym_ptr_ptr
;
1084 src_rel
= outbound_relocs
+ idx
;
1086 /* The address of an ELF reloc is section relative for an object
1087 file, and absolute for an executable file or shared library.
1088 The address of a BFD reloc is always section relative. */
1089 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1090 dst_rel
.r_offset
= ptr
->address
;
1092 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1094 if (sym
== last_sym
)
1099 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1101 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1103 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1108 /* Set up an ELF internal section header for a section. */
1112 elf_fake_sections (abfd
, asect
, failedptrarg
)
1117 boolean
*failedptr
= (boolean
*) failedptrarg
;
1118 Elf_Internal_Shdr
*this_hdr
;
1122 /* We already failed; just get out of the bfd_map_over_sections
1127 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1129 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1132 if (this_hdr
->sh_name
== (unsigned long) -1)
1138 this_hdr
->sh_flags
= 0;
1139 if ((asect
->flags
& SEC_ALLOC
) != 0)
1140 this_hdr
->sh_addr
= asect
->vma
;
1142 this_hdr
->sh_addr
= 0;
1143 this_hdr
->sh_offset
= 0;
1144 this_hdr
->sh_size
= asect
->_raw_size
;
1145 this_hdr
->sh_link
= 0;
1146 this_hdr
->sh_info
= 0;
1147 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1148 this_hdr
->sh_entsize
= 0;
1150 this_hdr
->bfd_section
= asect
;
1151 this_hdr
->contents
= NULL
;
1153 /* FIXME: This should not be based on section names. */
1154 if (strcmp (asect
->name
, ".dynstr") == 0)
1155 this_hdr
->sh_type
= SHT_STRTAB
;
1156 else if (strcmp (asect
->name
, ".hash") == 0)
1158 this_hdr
->sh_type
= SHT_HASH
;
1159 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1161 else if (strcmp (asect
->name
, ".dynsym") == 0)
1163 this_hdr
->sh_type
= SHT_DYNSYM
;
1164 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1166 else if (strcmp (asect
->name
, ".dynamic") == 0)
1168 this_hdr
->sh_type
= SHT_DYNAMIC
;
1169 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1171 else if (strncmp (asect
->name
, ".rela", 5) == 0
1172 && get_elf_backend_data (abfd
)->use_rela_p
)
1174 this_hdr
->sh_type
= SHT_RELA
;
1175 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1177 else if (strncmp (asect
->name
, ".rel", 4) == 0
1178 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1180 this_hdr
->sh_type
= SHT_REL
;
1181 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1183 else if (strcmp (asect
->name
, ".note") == 0)
1184 this_hdr
->sh_type
= SHT_NOTE
;
1185 else if (strncmp (asect
->name
, ".stab", 5) == 0
1186 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1187 this_hdr
->sh_type
= SHT_STRTAB
;
1188 else if ((asect
->flags
& SEC_ALLOC
) != 0
1189 && (asect
->flags
& SEC_LOAD
) != 0)
1190 this_hdr
->sh_type
= SHT_PROGBITS
;
1191 else if ((asect
->flags
& SEC_ALLOC
) != 0
1192 && ((asect
->flags
& SEC_LOAD
) == 0))
1194 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1195 || strcmp (asect
->name
, ".sbss") == 0);
1196 this_hdr
->sh_type
= SHT_NOBITS
;
1201 this_hdr
->sh_type
= SHT_PROGBITS
;
1204 if ((asect
->flags
& SEC_ALLOC
) != 0)
1205 this_hdr
->sh_flags
|= SHF_ALLOC
;
1206 if ((asect
->flags
& SEC_READONLY
) == 0)
1207 this_hdr
->sh_flags
|= SHF_WRITE
;
1208 if ((asect
->flags
& SEC_CODE
) != 0)
1209 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1211 /* Check for processor-specific section types. */
1213 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1215 if (bed
->elf_backend_fake_sections
)
1216 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1219 /* If the section has relocs, set up a section header for the
1220 SHT_REL[A] section. */
1221 if ((asect
->flags
& SEC_RELOC
) != 0)
1223 Elf_Internal_Shdr
*rela_hdr
;
1224 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1227 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1228 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1231 bfd_set_error (bfd_error_no_memory
);
1235 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1237 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1239 if (rela_hdr
->sh_name
== (unsigned int) -1)
1244 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1245 rela_hdr
->sh_entsize
= (use_rela_p
1246 ? sizeof (Elf_External_Rela
)
1247 : sizeof (Elf_External_Rel
));
1248 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1249 rela_hdr
->sh_flags
= 0;
1250 rela_hdr
->sh_addr
= 0;
1251 rela_hdr
->sh_size
= 0;
1252 rela_hdr
->sh_offset
= 0;
1256 /* Assign all ELF section numbers. The dummy first section is handled here
1257 too. The link/info pointers for the standard section types are filled
1258 in here too, while we're at it. */
1261 assign_section_numbers (abfd
)
1264 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1266 unsigned int section_number
;
1267 Elf_Internal_Shdr
**i_shdrp
;
1271 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1273 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1275 d
->this_idx
= section_number
++;
1276 if ((sec
->flags
& SEC_RELOC
) == 0)
1279 d
->rel_idx
= section_number
++;
1282 t
->shstrtab_section
= section_number
++;
1283 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1284 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1286 if (abfd
->symcount
> 0)
1288 t
->symtab_section
= section_number
++;
1289 t
->strtab_section
= section_number
++;
1292 elf_elfheader (abfd
)->e_shnum
= section_number
;
1294 /* Set up the list of section header pointers, in agreement with the
1296 i_shdrp
= ((Elf_Internal_Shdr
**)
1297 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1298 if (i_shdrp
== NULL
)
1300 bfd_set_error (bfd_error_no_memory
);
1304 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1305 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1306 if (i_shdrp
[0] == NULL
)
1308 bfd_release (abfd
, i_shdrp
);
1309 bfd_set_error (bfd_error_no_memory
);
1312 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1314 elf_elfsections (abfd
) = i_shdrp
;
1316 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1317 if (abfd
->symcount
> 0)
1319 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1320 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1321 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1323 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1325 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1329 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1330 if (d
->rel_idx
!= 0)
1331 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1333 /* Fill in the sh_link and sh_info fields while we're at it. */
1335 /* sh_link of a reloc section is the section index of the symbol
1336 table. sh_info is the section index of the section to which
1337 the relocation entries apply. */
1338 if (d
->rel_idx
!= 0)
1340 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1341 d
->rel_hdr
.sh_info
= d
->this_idx
;
1344 switch (d
->this_hdr
.sh_type
)
1348 /* A reloc section which we are treating as a normal BFD
1349 section. sh_link is the section index of the symbol
1350 table. sh_info is the section index of the section to
1351 which the relocation entries apply. We assume that an
1352 allocated reloc section uses the dynamic symbol table.
1353 FIXME: How can we be sure? */
1354 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1356 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1358 /* We look up the section the relocs apply to by name. */
1360 if (d
->this_hdr
.sh_type
== SHT_REL
)
1364 s
= bfd_get_section_by_name (abfd
, name
);
1366 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1370 /* We assume that a section named .stab*str is a stabs
1371 string section. We look for a section with the same name
1372 but without the trailing ``str'', and set its sh_link
1373 field to point to this section. */
1374 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1375 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1380 len
= strlen (sec
->name
);
1381 alc
= (char *) malloc (len
- 2);
1384 bfd_set_error (bfd_error_no_memory
);
1387 strncpy (alc
, sec
->name
, len
- 3);
1388 alc
[len
- 3] = '\0';
1389 s
= bfd_get_section_by_name (abfd
, alc
);
1393 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1395 /* This is a .stab section. */
1396 elf_section_data (s
)->this_hdr
.sh_entsize
=
1397 4 + 2 * (ARCH_SIZE
/ 8);
1404 /* sh_link is the section header index of the string table
1405 used for the dynamic entries or symbol table. */
1406 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1408 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1412 /* sh_link is the section header index of the symbol table
1413 this hash table is for. */
1414 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1416 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1424 /* Map symbol from it's internal number to the external number, moving
1425 all local symbols to be at the head of the list. */
1428 sym_is_global (abfd
, sym
)
1432 /* If the backend has a special mapping, use it. */
1433 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1434 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1437 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1439 if (sym
->flags
& BSF_LOCAL
)
1443 if (sym
->section
== 0)
1445 /* Is this valid? */
1450 if (bfd_is_und_section (sym
->section
))
1452 if (bfd_is_com_section (sym
->section
))
1454 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1460 elf_map_symbols (abfd
)
1463 int symcount
= bfd_get_symcount (abfd
);
1464 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1465 asymbol
**sect_syms
;
1467 int num_globals
= 0;
1468 int num_locals2
= 0;
1469 int num_globals2
= 0;
1471 int num_sections
= 0;
1477 fprintf (stderr
, "elf_map_symbols\n");
1481 /* Add a section symbol for each BFD section. FIXME: Is this really
1483 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1485 if (max_index
< asect
->index
)
1486 max_index
= asect
->index
;
1490 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1491 if (sect_syms
== NULL
)
1493 bfd_set_error (bfd_error_no_memory
);
1496 elf_section_syms (abfd
) = sect_syms
;
1498 for (idx
= 0; idx
< symcount
; idx
++)
1500 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1501 && syms
[idx
]->value
== 0)
1505 sec
= syms
[idx
]->section
;
1506 if (sec
->owner
!= NULL
)
1508 if (sec
->owner
!= abfd
)
1510 if (sec
->output_offset
!= 0)
1512 sec
= sec
->output_section
;
1513 BFD_ASSERT (sec
->owner
== abfd
);
1515 sect_syms
[sec
->index
] = syms
[idx
];
1520 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1524 if (sect_syms
[asect
->index
] != NULL
)
1527 sym
= bfd_make_empty_symbol (abfd
);
1530 sym
->the_bfd
= abfd
;
1531 sym
->name
= asect
->name
;
1533 /* Set the flags to 0 to indicate that this one was newly added. */
1535 sym
->section
= asect
;
1536 sect_syms
[asect
->index
] = sym
;
1540 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1541 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1545 /* Classify all of the symbols. */
1546 for (idx
= 0; idx
< symcount
; idx
++)
1548 if (!sym_is_global (abfd
, syms
[idx
]))
1553 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1555 if (sect_syms
[asect
->index
] != NULL
1556 && sect_syms
[asect
->index
]->flags
== 0)
1558 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1559 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1563 sect_syms
[asect
->index
]->flags
= 0;
1567 /* Now sort the symbols so the local symbols are first. */
1568 new_syms
= ((asymbol
**)
1570 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1571 if (new_syms
== NULL
)
1573 bfd_set_error (bfd_error_no_memory
);
1577 for (idx
= 0; idx
< symcount
; idx
++)
1579 asymbol
*sym
= syms
[idx
];
1582 if (!sym_is_global (abfd
, sym
))
1585 i
= num_locals
+ num_globals2
++;
1587 sym
->udata
.i
= i
+ 1;
1589 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1591 if (sect_syms
[asect
->index
] != NULL
1592 && sect_syms
[asect
->index
]->flags
== 0)
1594 asymbol
*sym
= sect_syms
[asect
->index
];
1597 sym
->flags
= BSF_SECTION_SYM
;
1598 if (!sym_is_global (abfd
, sym
))
1601 i
= num_locals
+ num_globals2
++;
1603 sym
->udata
.i
= i
+ 1;
1607 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1609 elf_num_locals (abfd
) = num_locals
;
1610 elf_num_globals (abfd
) = num_globals
;
1614 /* Compute the file positions we are going to put the sections at, and
1615 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1616 is not NULL, this is being called by the ELF backend linker. */
1619 elf_compute_section_file_positions (abfd
, link_info
)
1621 struct bfd_link_info
*link_info
;
1623 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1625 struct bfd_strtab_hash
*strtab
;
1626 Elf_Internal_Shdr
*shstrtab_hdr
;
1628 if (abfd
->output_has_begun
)
1631 /* Do any elf backend specific processing first. */
1632 if (bed
->elf_backend_begin_write_processing
)
1633 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1635 if (! prep_headers (abfd
))
1639 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1643 if (!assign_section_numbers (abfd
))
1646 /* The backend linker builds symbol table information itself. */
1647 if (link_info
== NULL
)
1649 if (! swap_out_syms (abfd
, &strtab
))
1653 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1654 /* sh_name was set in prep_headers. */
1655 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1656 shstrtab_hdr
->sh_flags
= 0;
1657 shstrtab_hdr
->sh_addr
= 0;
1658 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1659 shstrtab_hdr
->sh_entsize
= 0;
1660 shstrtab_hdr
->sh_link
= 0;
1661 shstrtab_hdr
->sh_info
= 0;
1662 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1663 shstrtab_hdr
->sh_addralign
= 1;
1665 if (!assign_file_positions_except_relocs (abfd
,
1666 link_info
== NULL
? true : false))
1669 if (link_info
== NULL
)
1671 /* Now that we know where the .strtab section goes, write it
1673 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1675 || ! _bfd_stringtab_emit (abfd
, strtab
))
1677 _bfd_stringtab_free (strtab
);
1680 abfd
->output_has_begun
= true;
1686 /* Align to the maximum file alignment that could be required for any
1687 ELF data structure. */
1689 static INLINE file_ptr
1690 align_file_position (off
)
1693 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1696 /* Assign a file position to a section, optionally aligning to the
1697 required section alignment. */
1699 static INLINE file_ptr
1700 assign_file_position_for_section (i_shdrp
, offset
, align
)
1701 Elf_Internal_Shdr
*i_shdrp
;
1709 al
= i_shdrp
->sh_addralign
;
1711 offset
= BFD_ALIGN (offset
, al
);
1713 i_shdrp
->sh_offset
= offset
;
1714 if (i_shdrp
->bfd_section
!= NULL
)
1715 i_shdrp
->bfd_section
->filepos
= offset
;
1716 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1717 offset
+= i_shdrp
->sh_size
;
1721 /* Get the size of the program header. This is called by the linker
1722 before any of the section VMA's are set, so it can't calculate the
1723 correct value for a strange memory layout. */
1725 static bfd_size_type
1726 get_program_header_size (abfd
)
1732 /* Assume we will need exactly two PT_LOAD segments: one for text
1733 and one for data. */
1736 s
= bfd_get_section_by_name (abfd
, ".interp");
1737 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1739 /* If we have a loadable interpreter section, we need a
1740 PT_INTERP segment. In this case, assume we also need a
1741 PT_PHDR segment, although that may not be true for all
1746 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1748 /* We need a PT_DYNAMIC segment. */
1752 return segs
* sizeof (Elf_External_Phdr
);
1755 /* Create the program header. OFF is the file offset where the
1756 program header should be written. FIRST is the first loadable ELF
1757 section. PHDR_SIZE is the size of the program header as returned
1758 by get_program_header_size. */
1761 map_program_segments (abfd
, off
, first
, phdr_size
)
1764 Elf_Internal_Shdr
*first
;
1765 bfd_size_type phdr_size
;
1767 Elf_Internal_Phdr phdrs
[10];
1768 unsigned int phdr_count
;
1769 Elf_Internal_Phdr
*phdr
;
1770 int phdr_size_adjust
;
1772 Elf_Internal_Shdr
**hdrpp
;
1773 asection
*sinterp
, *sdyn
;
1774 unsigned int last_type
;
1775 Elf_Internal_Ehdr
*i_ehdrp
;
1777 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1778 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1779 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1784 phdr_size_adjust
= 0;
1786 /* If we have a loadable .interp section, we must create a PT_INTERP
1787 segment which must precede all PT_LOAD segments. We assume that
1788 we must also create a PT_PHDR segment, although that may not be
1789 true for all targets. */
1790 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1791 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1793 BFD_ASSERT (first
!= NULL
);
1795 phdr
->p_type
= PT_PHDR
;
1797 phdr
->p_offset
= off
;
1799 /* Account for any adjustment made because of the alignment of
1800 the first loadable section. */
1801 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1802 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1804 /* The program header precedes all loadable sections. This lets
1805 us compute its loadable address. This depends on the linker
1807 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1810 phdr
->p_filesz
= phdr_size
;
1811 phdr
->p_memsz
= phdr_size
;
1813 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1814 phdr
->p_flags
= PF_R
| PF_X
;
1816 phdr
->p_align
= FILE_ALIGN
;
1817 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1819 /* Include the ELF header in the first loadable segment. */
1820 phdr_size_adjust
+= off
;
1825 phdr
->p_type
= PT_INTERP
;
1826 phdr
->p_offset
= sinterp
->filepos
;
1827 phdr
->p_vaddr
= sinterp
->vma
;
1829 phdr
->p_filesz
= sinterp
->_raw_size
;
1830 phdr
->p_memsz
= sinterp
->_raw_size
;
1831 phdr
->p_flags
= PF_R
;
1832 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1838 /* Look through the sections to see how they will be divided into
1839 program segments. The sections must be arranged in order by
1840 sh_addr for this to work correctly. */
1841 phdr
->p_type
= PT_NULL
;
1842 last_type
= SHT_PROGBITS
;
1843 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1844 i
< elf_elfheader (abfd
)->e_shnum
;
1847 Elf_Internal_Shdr
*hdr
;
1851 /* Ignore any section which will not be part of the process
1853 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1856 /* If this section fits in the segment we are constructing, add
1858 if (phdr
->p_type
!= PT_NULL
1859 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1860 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1861 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1863 bfd_size_type adjust
;
1865 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1866 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1867 if (hdr
->sh_type
!= SHT_NOBITS
)
1868 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1869 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1870 phdr
->p_flags
|= PF_W
;
1871 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1872 phdr
->p_flags
|= PF_X
;
1873 last_type
= hdr
->sh_type
;
1877 /* If we have a segment, move to the next one. */
1878 if (phdr
->p_type
!= PT_NULL
)
1884 /* Start a new segment. */
1885 phdr
->p_type
= PT_LOAD
;
1886 phdr
->p_offset
= hdr
->sh_offset
;
1887 phdr
->p_vaddr
= hdr
->sh_addr
;
1889 if (hdr
->sh_type
== SHT_NOBITS
)
1892 phdr
->p_filesz
= hdr
->sh_size
;
1893 phdr
->p_memsz
= hdr
->sh_size
;
1894 phdr
->p_flags
= PF_R
;
1895 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1896 phdr
->p_flags
|= PF_W
;
1897 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1898 phdr
->p_flags
|= PF_X
;
1899 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1903 && (sinterp
->flags
& SEC_LOAD
) != 0)
1905 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1906 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1907 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1908 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1911 last_type
= hdr
->sh_type
;
1914 if (phdr
->p_type
!= PT_NULL
)
1920 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1921 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1922 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1924 phdr
->p_type
= PT_DYNAMIC
;
1925 phdr
->p_offset
= sdyn
->filepos
;
1926 phdr
->p_vaddr
= sdyn
->vma
;
1928 phdr
->p_filesz
= sdyn
->_raw_size
;
1929 phdr
->p_memsz
= sdyn
->_raw_size
;
1930 phdr
->p_flags
= PF_R
;
1931 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1932 phdr
->p_flags
|= PF_W
;
1933 if ((sdyn
->flags
& SEC_CODE
) != 0)
1934 phdr
->p_flags
|= PF_X
;
1935 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1941 /* Make sure the return value from get_program_header_size matches
1942 what we computed here. Actually, it's OK if we allocated too
1943 much space in the program header. */
1944 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1947 /* Set up program header information. */
1948 i_ehdrp
= elf_elfheader (abfd
);
1949 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1950 i_ehdrp
->e_phoff
= off
;
1951 i_ehdrp
->e_phnum
= phdr_count
;
1953 /* Save the program headers away. I don't think anybody uses this
1954 information right now. */
1955 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1958 * sizeof (Elf_Internal_Phdr
))));
1959 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1961 bfd_set_error (bfd_error_no_memory
);
1962 return (file_ptr
) -1;
1964 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1965 phdr_count
* sizeof (Elf_Internal_Phdr
));
1967 /* Write out the program headers. */
1968 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1969 return (file_ptr
) -1;
1971 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1973 Elf_External_Phdr extphdr
;
1975 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1976 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1977 != sizeof (Elf_External_Phdr
))
1978 return (file_ptr
) -1;
1981 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1984 /* Work out the file positions of all the sections. This is called by
1985 elf_compute_section_file_positions. All the section sizes and VMAs
1986 must be known before this is called.
1988 We do not consider reloc sections at this point, unless they form
1989 part of the loadable image. Reloc sections are assigned file
1990 positions in assign_file_positions_for_relocs, which is called by
1991 write_object_contents and final_link.
1993 If DOSYMS is false, we do not assign file positions for the symbol
1994 table or the string table. */
1997 assign_file_positions_except_relocs (abfd
, dosyms
)
2001 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2002 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2003 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2006 /* Start after the ELF header. */
2007 off
= i_ehdrp
->e_ehsize
;
2009 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2011 Elf_Internal_Shdr
**hdrpp
;
2014 /* We are not creating an executable, which means that we are
2015 not creating a program header, and that the actual order of
2016 the sections in the file is unimportant. */
2017 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2019 Elf_Internal_Shdr
*hdr
;
2022 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2024 hdr
->sh_offset
= -1;
2028 && (i
== tdata
->symtab_section
2029 || i
== tdata
->strtab_section
))
2031 hdr
->sh_offset
= -1;
2035 off
= assign_file_position_for_section (hdr
, off
, true);
2041 bfd_size_type phdr_size
;
2042 bfd_vma maxpagesize
;
2044 Elf_Internal_Shdr
**sorted_hdrs
;
2045 Elf_Internal_Shdr
**hdrpp
;
2047 Elf_Internal_Shdr
*first
;
2050 /* We are creating an executable. We must create a program
2051 header. We can't actually create the program header until we
2052 have set the file positions for the sections, but we can
2053 figure out how big it is going to be. */
2054 off
= align_file_position (off
);
2055 phdr_size
= get_program_header_size (abfd
);
2056 if (phdr_size
== (file_ptr
) -1)
2061 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2062 if (maxpagesize
== 0)
2065 /* We must sort the sections. The GNU linker will always create
2066 the sections in an appropriate order, but the Irix 5 linker
2067 will not. We don't include the dummy first section in the
2068 sort. We sort sections which are not SHF_ALLOC to the end. */
2069 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2070 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2071 if (sorted_hdrs
== NULL
)
2073 bfd_set_error (bfd_error_no_memory
);
2077 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2078 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2082 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2084 Elf_Internal_Shdr
*hdr
;
2087 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2089 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2091 hdr
->sh_offset
= -1;
2095 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2096 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2098 hdr
->sh_offset
= -1;
2107 /* The section VMA must equal the file position modulo
2108 the page size. This is required by the program
2110 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2113 off
= assign_file_position_for_section (hdr
, off
, false);
2116 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2117 if (phdr_map
== (file_ptr
) -1)
2119 BFD_ASSERT ((bfd_size_type
) phdr_map
<= (bfd_size_type
) phdr_off
+ phdr_size
);
2124 /* Place the section headers. */
2125 off
= align_file_position (off
);
2126 i_ehdrp
->e_shoff
= off
;
2127 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2129 elf_tdata (abfd
)->next_file_pos
= off
;
2134 /* Sort the ELF headers by VMA. We sort headers which are not
2135 SHF_ALLOC to the end. */
2138 elf_sort_hdrs (arg1
, arg2
)
2142 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2143 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2145 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2147 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2149 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2151 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2158 if ((hdr2
->sh_flags
& SHF_ALLOC
) != 0)
2168 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2169 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2170 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2172 struct bfd_strtab_hash
*shstrtab
;
2174 i_ehdrp
= elf_elfheader (abfd
);
2175 i_shdrp
= elf_elfsections (abfd
);
2177 shstrtab
= elf_stringtab_init ();
2178 if (shstrtab
== NULL
)
2181 elf_shstrtab (abfd
) = shstrtab
;
2183 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2184 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2185 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2186 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2188 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2189 i_ehdrp
->e_ident
[EI_DATA
] =
2190 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2191 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2193 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2194 i_ehdrp
->e_ident
[count
] = 0;
2196 if ((abfd
->flags
& DYNAMIC
) != 0)
2197 i_ehdrp
->e_type
= ET_DYN
;
2198 else if ((abfd
->flags
& EXEC_P
) != 0)
2199 i_ehdrp
->e_type
= ET_EXEC
;
2201 i_ehdrp
->e_type
= ET_REL
;
2203 switch (bfd_get_arch (abfd
))
2205 case bfd_arch_unknown
:
2206 i_ehdrp
->e_machine
= EM_NONE
;
2208 case bfd_arch_sparc
:
2210 i_ehdrp
->e_machine
= EM_SPARC64
;
2212 i_ehdrp
->e_machine
= EM_SPARC
;
2216 i_ehdrp
->e_machine
= EM_386
;
2219 i_ehdrp
->e_machine
= EM_68K
;
2222 i_ehdrp
->e_machine
= EM_88K
;
2225 i_ehdrp
->e_machine
= EM_860
;
2227 case bfd_arch_mips
: /* MIPS Rxxxx */
2228 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2231 i_ehdrp
->e_machine
= EM_PARISC
;
2233 case bfd_arch_powerpc
:
2234 i_ehdrp
->e_machine
= EM_PPC
;
2236 /* start-sanitize-arc */
2238 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2240 /* end-sanitize-arc */
2241 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2243 i_ehdrp
->e_machine
= EM_NONE
;
2245 i_ehdrp
->e_version
= EV_CURRENT
;
2246 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2248 /* no program header, for now. */
2249 i_ehdrp
->e_phoff
= 0;
2250 i_ehdrp
->e_phentsize
= 0;
2251 i_ehdrp
->e_phnum
= 0;
2253 /* each bfd section is section header entry */
2254 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2255 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2257 /* if we're building an executable, we'll need a program header table */
2258 if (abfd
->flags
& EXEC_P
)
2260 /* it all happens later */
2262 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2264 /* elf_build_phdrs() returns a (NULL-terminated) array of
2265 Elf_Internal_Phdrs */
2266 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2267 i_ehdrp
->e_phoff
= outbase
;
2268 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2273 i_ehdrp
->e_phentsize
= 0;
2275 i_ehdrp
->e_phoff
= 0;
2278 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2279 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2280 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2281 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2282 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2283 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2284 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2285 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2286 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2293 swap_out_syms (abfd
, sttp
)
2295 struct bfd_strtab_hash
**sttp
;
2297 if (!elf_map_symbols (abfd
))
2300 /* Dump out the symtabs. */
2302 int symcount
= bfd_get_symcount (abfd
);
2303 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2304 struct bfd_strtab_hash
*stt
;
2305 Elf_Internal_Shdr
*symtab_hdr
;
2306 Elf_Internal_Shdr
*symstrtab_hdr
;
2307 Elf_External_Sym
*outbound_syms
;
2310 stt
= elf_stringtab_init ();
2314 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2315 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2316 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2317 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2318 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2319 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2321 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2322 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2324 outbound_syms
= ((Elf_External_Sym
*)
2326 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2327 if (outbound_syms
== NULL
)
2329 bfd_set_error (bfd_error_no_memory
);
2332 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2334 /* now generate the data (for "contents") */
2336 /* Fill in zeroth symbol and swap it out. */
2337 Elf_Internal_Sym sym
;
2343 sym
.st_shndx
= SHN_UNDEF
;
2344 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2347 for (idx
= 0; idx
< symcount
; idx
++)
2349 Elf_Internal_Sym sym
;
2350 bfd_vma value
= syms
[idx
]->value
;
2351 elf_symbol_type
*type_ptr
;
2353 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2354 /* Section symbols have no names. */
2358 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2361 if (sym
.st_name
== (unsigned long) -1)
2365 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2367 if (bfd_is_com_section (syms
[idx
]->section
))
2369 /* ELF common symbols put the alignment into the `value' field,
2370 and the size into the `size' field. This is backwards from
2371 how BFD handles it, so reverse it here. */
2372 sym
.st_size
= value
;
2373 if (type_ptr
== NULL
2374 || type_ptr
->internal_elf_sym
.st_value
== 0)
2375 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2377 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2378 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2379 syms
[idx
]->section
);
2383 asection
*sec
= syms
[idx
]->section
;
2386 if (sec
->output_section
)
2388 value
+= sec
->output_offset
;
2389 sec
= sec
->output_section
;
2392 sym
.st_value
= value
;
2393 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2394 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2398 /* Writing this would be a hell of a lot easier if we had
2399 some decent documentation on bfd, and knew what to expect
2400 of the library, and what to demand of applications. For
2401 example, it appears that `objcopy' might not set the
2402 section of a symbol to be a section that is actually in
2404 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2405 BFD_ASSERT (sec2
!= 0);
2406 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2407 BFD_ASSERT (shndx
!= -1);
2411 if (bfd_is_com_section (syms
[idx
]->section
))
2412 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2413 else if (bfd_is_und_section (syms
[idx
]->section
))
2414 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2415 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2418 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2419 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2420 else if (syms
[idx
]->flags
& BSF_FILE
)
2421 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2424 int bind
= STB_LOCAL
;
2425 int type
= STT_OBJECT
;
2426 unsigned int flags
= syms
[idx
]->flags
;
2428 if (flags
& BSF_LOCAL
)
2430 else if (flags
& BSF_WEAK
)
2432 else if (flags
& BSF_GLOBAL
)
2435 if (flags
& BSF_FUNCTION
)
2438 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2442 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2447 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2448 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2450 symstrtab_hdr
->sh_flags
= 0;
2451 symstrtab_hdr
->sh_addr
= 0;
2452 symstrtab_hdr
->sh_entsize
= 0;
2453 symstrtab_hdr
->sh_link
= 0;
2454 symstrtab_hdr
->sh_info
= 0;
2455 symstrtab_hdr
->sh_addralign
= 1;
2462 write_shdrs_and_ehdr (abfd
)
2465 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2466 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2467 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2468 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2471 i_ehdrp
= elf_elfheader (abfd
);
2472 i_shdrp
= elf_elfsections (abfd
);
2474 /* swap the header before spitting it out... */
2477 elf_debug_file (i_ehdrp
);
2479 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2480 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2481 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2482 != sizeof (x_ehdr
)))
2485 /* at this point we've concocted all the ELF sections... */
2486 x_shdrp
= (Elf_External_Shdr
*)
2487 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2490 bfd_set_error (bfd_error_no_memory
);
2494 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2497 elf_debug_section (count
, i_shdrp
[count
]);
2499 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2501 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2502 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2503 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2506 /* need to dump the string table too... */
2511 /* Assign file positions for all the reloc sections which are not part
2512 of the loadable file image. */
2515 assign_file_positions_for_relocs (abfd
)
2520 Elf_Internal_Shdr
**shdrpp
;
2522 off
= elf_tdata (abfd
)->next_file_pos
;
2524 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2525 i
< elf_elfheader (abfd
)->e_shnum
;
2528 Elf_Internal_Shdr
*shdrp
;
2531 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2532 && shdrp
->sh_offset
== -1)
2533 off
= assign_file_position_for_section (shdrp
, off
, true);
2536 elf_tdata (abfd
)->next_file_pos
= off
;
2540 NAME(bfd_elf
,write_object_contents
) (abfd
)
2543 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2544 Elf_Internal_Ehdr
*i_ehdrp
;
2545 Elf_Internal_Shdr
**i_shdrp
;
2548 if (! abfd
->output_has_begun
2549 && ! elf_compute_section_file_positions (abfd
,
2550 (struct bfd_link_info
*) NULL
))
2553 i_shdrp
= elf_elfsections (abfd
);
2554 i_ehdrp
= elf_elfheader (abfd
);
2556 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2557 assign_file_positions_for_relocs (abfd
);
2559 /* After writing the headers, we need to write the sections too... */
2560 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2562 if (bed
->elf_backend_section_processing
)
2563 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2564 if (i_shdrp
[count
]->contents
)
2566 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2567 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2569 != i_shdrp
[count
]->sh_size
))
2574 /* Write out the section header names. */
2575 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2576 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2579 if (bed
->elf_backend_final_write_processing
)
2580 (*bed
->elf_backend_final_write_processing
) (abfd
,
2581 elf_tdata (abfd
)->linker
);
2583 return write_shdrs_and_ehdr (abfd
);
2586 /* Given an ELF section number, retrieve the corresponding BFD
2590 section_from_elf_index (abfd
, index
)
2594 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2595 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2597 return elf_elfsections (abfd
)[index
]->bfd_section
;
2600 /* given a section, search the header to find them... */
2602 elf_section_from_bfd_section (abfd
, asect
)
2606 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2607 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2609 Elf_Internal_Shdr
*hdr
;
2610 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2612 for (index
= 0; index
< maxindex
; index
++)
2614 hdr
= i_shdrp
[index
];
2615 if (hdr
->bfd_section
== asect
)
2619 if (bed
->elf_backend_section_from_bfd_section
)
2621 for (index
= 0; index
< maxindex
; index
++)
2625 hdr
= i_shdrp
[index
];
2627 if ((*bed
->elf_backend_section_from_bfd_section
)
2628 (abfd
, hdr
, asect
, &retval
))
2633 if (bfd_is_abs_section (asect
))
2635 if (bfd_is_com_section (asect
))
2637 if (bfd_is_und_section (asect
))
2643 /* given a symbol, return the bfd index for that symbol. */
2645 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2647 struct symbol_cache_entry
**asym_ptr_ptr
;
2649 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2651 flagword flags
= asym_ptr
->flags
;
2653 /* When gas creates relocations against local labels, it creates its
2654 own symbol for the section, but does put the symbol into the
2655 symbol chain, so udata is 0. When the linker is generating
2656 relocatable output, this section symbol may be for one of the
2657 input sections rather than the output section. */
2658 if (asym_ptr
->udata
.i
== 0
2659 && (flags
& BSF_SECTION_SYM
)
2660 && asym_ptr
->section
)
2664 if (asym_ptr
->section
->output_section
!= NULL
)
2665 indx
= asym_ptr
->section
->output_section
->index
;
2667 indx
= asym_ptr
->section
->index
;
2668 if (elf_section_syms (abfd
)[indx
])
2669 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2672 idx
= asym_ptr
->udata
.i
;
2680 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2681 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2690 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2692 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2695 Elf_Internal_Shdr
*hdr
;
2696 long symcount
; /* Number of external ELF symbols */
2697 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2698 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2699 Elf_Internal_Sym i_sym
;
2700 Elf_External_Sym
*x_symp
= NULL
;
2702 /* Read each raw ELF symbol, converting from external ELF form to
2703 internal ELF form, and then using the information to create a
2704 canonical bfd symbol table entry.
2706 Note that we allocate the initial bfd canonical symbol buffer
2707 based on a one-to-one mapping of the ELF symbols to canonical
2708 symbols. We actually use all the ELF symbols, so there will be no
2709 space left over at the end. When we have all the symbols, we
2710 build the caller's pointer vector. */
2713 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2715 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2716 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2719 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2722 sym
= symbase
= NULL
;
2727 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2730 symbase
= ((elf_symbol_type
*)
2731 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2732 if (symbase
== (elf_symbol_type
*) NULL
)
2734 bfd_set_error (bfd_error_no_memory
);
2739 /* Temporarily allocate room for the raw ELF symbols. */
2740 x_symp
= ((Elf_External_Sym
*)
2741 malloc (symcount
* sizeof (Elf_External_Sym
)));
2742 if (x_symp
== NULL
&& symcount
!= 0)
2744 bfd_set_error (bfd_error_no_memory
);
2748 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2749 != symcount
* sizeof (Elf_External_Sym
))
2751 /* Skip first symbol, which is a null dummy. */
2752 for (i
= 1; i
< symcount
; i
++)
2754 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2755 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2756 #ifdef ELF_KEEP_EXTSYM
2757 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2759 sym
->symbol
.the_bfd
= abfd
;
2761 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2764 sym
->symbol
.value
= i_sym
.st_value
;
2766 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2768 sym
->symbol
.section
= section_from_elf_index (abfd
,
2770 if (sym
->symbol
.section
== NULL
)
2772 /* This symbol is in a section for which we did not
2773 create a BFD section. Just use bfd_abs_section,
2774 although it is wrong. FIXME. */
2775 sym
->symbol
.section
= bfd_abs_section_ptr
;
2778 else if (i_sym
.st_shndx
== SHN_ABS
)
2780 sym
->symbol
.section
= bfd_abs_section_ptr
;
2782 else if (i_sym
.st_shndx
== SHN_COMMON
)
2784 sym
->symbol
.section
= bfd_com_section_ptr
;
2785 /* Elf puts the alignment into the `value' field, and
2786 the size into the `size' field. BFD wants to see the
2787 size in the value field, and doesn't care (at the
2788 moment) about the alignment. */
2789 sym
->symbol
.value
= i_sym
.st_size
;
2791 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2793 sym
->symbol
.section
= bfd_und_section_ptr
;
2796 sym
->symbol
.section
= bfd_abs_section_ptr
;
2798 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2800 switch (ELF_ST_BIND (i_sym
.st_info
))
2803 sym
->symbol
.flags
|= BSF_LOCAL
;
2806 if (i_sym
.st_shndx
!= SHN_UNDEF
2807 && i_sym
.st_shndx
!= SHN_COMMON
)
2808 sym
->symbol
.flags
|= BSF_GLOBAL
;
2811 sym
->symbol
.flags
|= BSF_WEAK
;
2815 switch (ELF_ST_TYPE (i_sym
.st_info
))
2818 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2821 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2824 sym
->symbol
.flags
|= BSF_FUNCTION
;
2829 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2831 /* Do some backend-specific processing on this symbol. */
2833 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2834 if (ebd
->elf_backend_symbol_processing
)
2835 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2842 /* Do some backend-specific processing on this symbol table. */
2844 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2845 if (ebd
->elf_backend_symbol_table_processing
)
2846 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2849 /* We rely on the zalloc to clear out the final symbol entry. */
2851 symcount
= sym
- symbase
;
2853 /* Fill in the user's symbol pointer vector if needed. */
2861 *symptrs
++ = &sym
->symbol
;
2864 *symptrs
= 0; /* Final null pointer */
2876 /* Return the number of bytes required to hold the symtab vector.
2878 Note that we base it on the count plus 1, since we will null terminate
2879 the vector allocated based on this size. However, the ELF symbol table
2880 always has a dummy entry as symbol #0, so it ends up even. */
2883 elf_get_symtab_upper_bound (abfd
)
2888 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2890 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2891 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2897 elf_get_dynamic_symtab_upper_bound (abfd
)
2902 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2904 if (elf_dynsymtab (abfd
) == 0)
2906 bfd_set_error (bfd_error_invalid_operation
);
2910 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2911 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2917 elf_get_reloc_upper_bound (abfd
, asect
)
2921 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2924 /* Read in and swap the external relocs. */
2927 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2932 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2933 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2934 PTR allocated
= NULL
;
2935 bfd_byte
*native_relocs
;
2941 if (asect
->relocation
!= NULL
2942 || (asect
->flags
& SEC_RELOC
) == 0
2943 || asect
->reloc_count
== 0)
2946 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2947 && (asect
->reloc_count
2948 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2950 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2951 if (allocated
== NULL
)
2953 bfd_set_error (bfd_error_no_memory
);
2957 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2958 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2959 != d
->rel_hdr
.sh_size
))
2962 native_relocs
= (bfd_byte
*) allocated
;
2964 relents
= ((arelent
*)
2965 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2966 if (relents
== NULL
)
2968 bfd_set_error (bfd_error_no_memory
);
2972 entsize
= d
->rel_hdr
.sh_entsize
;
2973 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2974 || entsize
== sizeof (Elf_External_Rela
));
2976 for (i
= 0, relent
= relents
;
2977 i
< asect
->reloc_count
;
2978 i
++, relent
++, native_relocs
+= entsize
)
2980 Elf_Internal_Rela rela
;
2981 Elf_Internal_Rel rel
;
2983 if (entsize
== sizeof (Elf_External_Rela
))
2984 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2987 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2988 rela
.r_offset
= rel
.r_offset
;
2989 rela
.r_info
= rel
.r_info
;
2993 /* The address of an ELF reloc is section relative for an object
2994 file, and absolute for an executable file or shared library.
2995 The address of a BFD reloc is always section relative. */
2996 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2997 relent
->address
= rela
.r_offset
;
2999 relent
->address
= rela
.r_offset
- asect
->vma
;
3001 if (ELF_R_SYM (rela
.r_info
) == 0)
3002 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3007 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3010 /* Canonicalize ELF section symbols. FIXME: Why? */
3011 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3012 relent
->sym_ptr_ptr
= ps
;
3014 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3017 relent
->addend
= rela
.r_addend
;
3019 if (entsize
== sizeof (Elf_External_Rela
))
3020 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3022 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3025 asect
->relocation
= relents
;
3027 if (allocated
!= NULL
)
3033 if (allocated
!= NULL
)
3040 elf_debug_section (num
, hdr
)
3042 Elf_Internal_Shdr
*hdr
;
3044 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3045 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3048 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3049 (long) hdr
->sh_name
,
3050 (long) hdr
->sh_type
,
3051 (long) hdr
->sh_flags
);
3053 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3054 (long) hdr
->sh_addr
,
3055 (long) hdr
->sh_offset
,
3056 (long) hdr
->sh_size
);
3058 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3059 (long) hdr
->sh_link
,
3060 (long) hdr
->sh_info
,
3061 (long) hdr
->sh_addralign
);
3062 fprintf (stderr
, "sh_entsize = %ld\n",
3063 (long) hdr
->sh_entsize
);
3068 elf_debug_file (ehdrp
)
3069 Elf_Internal_Ehdr
*ehdrp
;
3071 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3072 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3073 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3074 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3075 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3076 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3077 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3081 /* Canonicalize the relocs. */
3084 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3093 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3096 tblptr
= section
->relocation
;
3097 for (i
= 0; i
< section
->reloc_count
; i
++)
3098 *relptr
++ = tblptr
++;
3102 return section
->reloc_count
;
3106 elf_get_symtab (abfd
, alocation
)
3108 asymbol
**alocation
;
3110 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3113 bfd_get_symcount (abfd
) = symcount
;
3118 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3120 asymbol
**alocation
;
3122 return elf_slurp_symbol_table (abfd
, alocation
, true);
3126 elf_make_empty_symbol (abfd
)
3129 elf_symbol_type
*newsym
;
3131 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3134 bfd_set_error (bfd_error_no_memory
);
3139 newsym
->symbol
.the_bfd
= abfd
;
3140 return &newsym
->symbol
;
3145 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3150 bfd_symbol_info (symbol
, ret
);
3154 elf_get_lineno (ignore_abfd
, symbol
)
3158 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3165 elf_set_arch_mach (abfd
, arch
, machine
)
3167 enum bfd_architecture arch
;
3168 unsigned long machine
;
3170 /* If this isn't the right architecture for this backend, and this
3171 isn't the generic backend, fail. */
3172 if (arch
!= get_elf_backend_data (abfd
)->arch
3173 && arch
!= bfd_arch_unknown
3174 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3177 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3181 elf_find_nearest_line (abfd
,
3192 CONST
char **filename_ptr
;
3193 CONST
char **functionname_ptr
;
3194 unsigned int *line_ptr
;
3200 elf_sizeof_headers (abfd
, reloc
)
3206 ret
= sizeof (Elf_External_Ehdr
);
3208 ret
+= get_program_header_size (abfd
);
3213 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3218 bfd_size_type count
;
3220 Elf_Internal_Shdr
*hdr
;
3222 if (! abfd
->output_has_begun
3223 && ! elf_compute_section_file_positions (abfd
,
3224 (struct bfd_link_info
*) NULL
))
3227 hdr
= &elf_section_data (section
)->this_hdr
;
3229 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3231 if (bfd_write (location
, 1, count
, abfd
) != count
)
3238 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3241 Elf_Internal_Rela
*dst
;
3243 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3249 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3252 Elf_Internal_Rel
*dst
;
3254 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3260 /* Core file support */
3262 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3263 #include <sys/procfs.h>
3265 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3266 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3267 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3273 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3280 prstatus_t
*status
= (prstatus_t
*) 0;
3282 if (descsz
== sizeof (prstatus_t
))
3284 newsect
= bfd_make_section (abfd
, ".reg");
3285 if (newsect
== NULL
)
3287 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3288 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3289 newsect
->flags
= SEC_HAS_CONTENTS
;
3290 newsect
->alignment_power
= 2;
3291 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3293 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3299 /* Stash a copy of the prpsinfo structure away for future use. */
3302 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3308 if (descsz
== sizeof (prpsinfo_t
))
3310 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3312 bfd_set_error (bfd_error_no_memory
);
3315 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3321 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3329 newsect
= bfd_make_section (abfd
, ".reg2");
3330 if (newsect
== NULL
)
3332 newsect
->_raw_size
= descsz
;
3333 newsect
->filepos
= filepos
;
3334 newsect
->flags
= SEC_HAS_CONTENTS
;
3335 newsect
->alignment_power
= 2;
3339 #endif /* HAVE_PROCFS */
3341 /* Return a pointer to the args (including the command name) that were
3342 seen by the program that generated the core dump. Note that for
3343 some reason, a spurious space is tacked onto the end of the args
3344 in some (at least one anyway) implementations, so strip it off if
3348 elf_core_file_failing_command (abfd
)
3352 if (core_prpsinfo (abfd
))
3354 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3355 char *scan
= p
->pr_psargs
;
3360 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3364 return p
->pr_psargs
;
3370 /* Return the number of the signal that caused the core dump. Presumably,
3371 since we have a core file, we got a signal of some kind, so don't bother
3372 checking the other process status fields, just return the signal number.
3376 elf_core_file_failing_signal (abfd
)
3380 if (core_prstatus (abfd
))
3382 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3388 /* Check to see if the core file could reasonably be expected to have
3389 come for the current executable file. Note that by default we return
3390 true unless we find something that indicates that there might be a
3395 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3404 /* First, xvecs must match since both are ELF files for the same target. */
3406 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3408 bfd_set_error (bfd_error_system_call
);
3414 /* If no prpsinfo, just return true. Otherwise, grab the last component
3415 of the exec'd pathname from the prpsinfo. */
3417 if (core_prpsinfo (core_bfd
))
3419 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3426 /* Find the last component of the executable pathname. */
3428 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3434 execname
= (char *) exec_bfd
->filename
;
3437 /* See if they match */
3439 return strcmp (execname
, corename
) ? false : true;
3445 #endif /* HAVE_PROCFS */
3448 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3449 the information that would normally be available from the /proc interface
3450 for the process, at the time the process dumped core. Currently this
3451 includes copies of the prstatus, prpsinfo, and fpregset structures.
3453 Since these structures are potentially machine dependent in size and
3454 ordering, bfd provides two levels of support for them. The first level,
3455 available on all machines since it does not require that the host
3456 have /proc support or the relevant include files, is to create a bfd
3457 section for each of the prstatus, prpsinfo, and fpregset structures,
3458 without any interpretation of their contents. With just this support,
3459 the bfd client will have to interpret the structures itself. Even with
3460 /proc support, it might want these full structures for it's own reasons.
3462 In the second level of support, where HAVE_PROCFS is defined, bfd will
3463 pick apart the structures to gather some additional information that
3464 clients may want, such as the general register set, the name of the
3465 exec'ed file and its arguments, the signal (if any) that caused the
3471 elf_corefile_note (abfd
, hdr
)
3473 Elf_Internal_Phdr
*hdr
;
3475 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3476 Elf_Internal_Note i_note
; /* Elf note, internal form */
3477 char *buf
= NULL
; /* Entire note segment contents */
3478 char *namedata
; /* Name portion of the note */
3479 char *descdata
; /* Descriptor portion of the note */
3480 char *sectname
; /* Name to use for new section */
3481 long filepos
; /* File offset to descriptor data */
3484 if (hdr
->p_filesz
> 0
3485 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3486 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3487 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3489 x_note_p
= (Elf_External_Note
*) buf
;
3490 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3492 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3493 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3494 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3495 namedata
= x_note_p
->name
;
3496 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3497 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3498 switch (i_note
.type
)
3501 /* process descdata as prstatus info */
3502 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3504 sectname
= ".prstatus";
3507 /* process descdata as fpregset info */
3508 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3510 sectname
= ".fpregset";
3513 /* process descdata as prpsinfo */
3514 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3516 sectname
= ".prpsinfo";
3519 /* Unknown descriptor, just ignore it. */
3523 if (sectname
!= NULL
)
3525 newsect
= bfd_make_section (abfd
, sectname
);
3526 if (newsect
== NULL
)
3528 newsect
->_raw_size
= i_note
.descsz
;
3529 newsect
->filepos
= filepos
;
3530 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3531 newsect
->alignment_power
= 2;
3533 x_note_p
= (Elf_External_Note
*)
3534 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3541 else if (hdr
->p_filesz
> 0)
3543 bfd_set_error (bfd_error_no_memory
);
3550 /* Core files are simply standard ELF formatted files that partition
3551 the file using the execution view of the file (program header table)
3552 rather than the linking view. In fact, there is no section header
3553 table in a core file.
3555 The process status information (including the contents of the general
3556 register set) and the floating point register set are stored in a
3557 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3558 that allow standard bfd access to the general registers (.reg) and the
3559 floating point registers (.reg2).
3564 elf_core_file_p (abfd
)
3567 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3568 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3569 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3570 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3571 unsigned int phindex
;
3572 struct elf_backend_data
*ebd
;
3574 /* Read in the ELF header in external format. */
3576 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3578 if (bfd_get_error () != bfd_error_system_call
)
3579 bfd_set_error (bfd_error_wrong_format
);
3583 /* Now check to see if we have a valid ELF file, and one that BFD can
3584 make use of. The magic number must match, the address size ('class')
3585 and byte-swapping must match our XVEC entry, and it must have a
3586 program header table (FIXME: See comments re segments at top of this
3589 if (elf_file_p (&x_ehdr
) == false)
3592 bfd_set_error (bfd_error_wrong_format
);
3596 /* FIXME, Check EI_VERSION here ! */
3600 int desired_address_size
= ELFCLASS32
;
3603 int desired_address_size
= ELFCLASS64
;
3606 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3610 /* Switch xvec to match the specified byte order. */
3611 switch (x_ehdr
.e_ident
[EI_DATA
])
3613 case ELFDATA2MSB
: /* Big-endian */
3614 if (abfd
->xvec
->byteorder_big_p
== false)
3617 case ELFDATA2LSB
: /* Little-endian */
3618 if (abfd
->xvec
->byteorder_big_p
== true)
3621 case ELFDATANONE
: /* No data encoding specified */
3622 default: /* Unknown data encoding specified */
3626 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3627 the tdata pointer in the bfd. */
3630 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3631 if (elf_tdata (abfd
) == NULL
)
3633 bfd_set_error (bfd_error_no_memory
);
3637 /* FIXME, `wrong' returns from this point onward, leak memory. */
3639 /* Now that we know the byte order, swap in the rest of the header */
3640 i_ehdrp
= elf_elfheader (abfd
);
3641 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3643 elf_debug_file (i_ehdrp
);
3646 ebd
= get_elf_backend_data (abfd
);
3648 /* Check that the ELF e_machine field matches what this particular
3649 BFD format expects. */
3650 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3652 const bfd_target
* const *target_ptr
;
3654 if (ebd
->elf_machine_code
!= EM_NONE
)
3657 /* This is the generic ELF target. Let it match any ELF target
3658 for which we do not have a specific backend. */
3659 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3661 struct elf_backend_data
*back
;
3663 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3665 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3666 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3668 /* target_ptr is an ELF backend which matches this
3669 object file, so reject the generic ELF target. */
3675 /* If there is no program header, or the type is not a core file, then
3677 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3680 /* Allocate space for a copy of the program header table in
3681 internal form, seek to the program header table in the file,
3682 read it in, and convert it to internal form. As a simple sanity
3683 check, verify that the what BFD thinks is the size of each program
3684 header table entry actually matches the size recorded in the file. */
3686 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3688 i_phdrp
= (Elf_Internal_Phdr
*)
3689 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3692 bfd_set_error (bfd_error_no_memory
);
3695 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3697 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3699 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3702 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3705 /* Once all of the program headers have been read and converted, we
3706 can start processing them. */
3708 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3710 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3711 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3713 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3718 /* Remember the entry point specified in the ELF file header. */
3720 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3725 /* ELF linker code. */
3727 static boolean elf_link_add_object_symbols
3728 PARAMS ((bfd
*, struct bfd_link_info
*));
3729 static boolean elf_link_add_archive_symbols
3730 PARAMS ((bfd
*, struct bfd_link_info
*));
3731 static Elf_Internal_Rela
*elf_link_read_relocs
3732 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3733 static boolean elf_export_symbol
3734 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3735 static boolean elf_adjust_dynamic_symbol
3736 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3738 /* Given an ELF BFD, add symbols to the global hash table as
3742 elf_bfd_link_add_symbols (abfd
, info
)
3744 struct bfd_link_info
*info
;
3748 switch (bfd_get_format (abfd
))
3751 return elf_link_add_object_symbols (abfd
, info
);
3753 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3756 if (! bfd_check_format (first
, bfd_object
))
3758 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3760 /* On Linux, we may have an a.out archive which got
3761 recognized as an ELF archive. Therefore, we treat all
3762 archives as though they were actually of the flavour of
3763 their first element. */
3764 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3766 return elf_link_add_archive_symbols (abfd
, info
);
3768 bfd_set_error (bfd_error_wrong_format
);
3773 /* Add symbols from an ELF archive file to the linker hash table. We
3774 don't use _bfd_generic_link_add_archive_symbols because of a
3775 problem which arises on UnixWare. The UnixWare libc.so is an
3776 archive which includes an entry libc.so.1 which defines a bunch of
3777 symbols. The libc.so archive also includes a number of other
3778 object files, which also define symbols, some of which are the same
3779 as those defined in libc.so.1. Correct linking requires that we
3780 consider each object file in turn, and include it if it defines any
3781 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3782 this; it looks through the list of undefined symbols, and includes
3783 any object file which defines them. When this algorithm is used on
3784 UnixWare, it winds up pulling in libc.so.1 early and defining a
3785 bunch of symbols. This means that some of the other objects in the
3786 archive are not included in the link, which is incorrect since they
3787 precede libc.so.1 in the archive.
3789 Fortunately, ELF archive handling is simpler than that done by
3790 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3791 oddities. In ELF, if we find a symbol in the archive map, and the
3792 symbol is currently undefined, we know that we must pull in that
3795 Unfortunately, we do have to make multiple passes over the symbol
3796 table until nothing further is resolved. */
3799 elf_link_add_archive_symbols (abfd
, info
)
3801 struct bfd_link_info
*info
;
3804 boolean
*defined
= NULL
;
3805 boolean
*included
= NULL
;
3809 if (! bfd_has_map (abfd
))
3811 /* An empty archive is a special case. */
3812 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3814 bfd_set_error (bfd_error_no_symbols
);
3818 /* Keep track of all symbols we know to be already defined, and all
3819 files we know to be already included. This is to speed up the
3820 second and subsequent passes. */
3821 c
= bfd_ardata (abfd
)->symdef_count
;
3824 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3825 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3826 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3828 bfd_set_error (bfd_error_no_memory
);
3831 memset (defined
, 0, c
* sizeof (boolean
));
3832 memset (included
, 0, c
* sizeof (boolean
));
3834 symdefs
= bfd_ardata (abfd
)->symdefs
;
3847 symdefend
= symdef
+ c
;
3848 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3850 struct elf_link_hash_entry
*h
;
3852 struct bfd_link_hash_entry
*undefs_tail
;
3855 if (defined
[i
] || included
[i
])
3857 if (symdef
->file_offset
== last
)
3863 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3864 false, false, false);
3865 if (h
== (struct elf_link_hash_entry
*) NULL
)
3867 if (h
->root
.type
!= bfd_link_hash_undefined
)
3873 /* We need to include this archive member. */
3875 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3876 if (element
== (bfd
*) NULL
)
3879 if (! bfd_check_format (element
, bfd_object
))
3882 /* Doublecheck that we have not included this object
3883 already--it should be impossible, but there may be
3884 something wrong with the archive. */
3885 if (element
->archive_pass
!= 0)
3887 bfd_set_error (bfd_error_bad_value
);
3890 element
->archive_pass
= 1;
3892 undefs_tail
= info
->hash
->undefs_tail
;
3894 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3897 if (! elf_link_add_object_symbols (element
, info
))
3900 /* If there are any new undefined symbols, we need to make
3901 another pass through the archive in order to see whether
3902 they can be defined. FIXME: This isn't perfect, because
3903 common symbols wind up on undefs_tail and because an
3904 undefined symbol which is defined later on in this pass
3905 does not require another pass. This isn't a bug, but it
3906 does make the code less efficient than it could be. */
3907 if (undefs_tail
!= info
->hash
->undefs_tail
)
3910 /* Look backward to mark all symbols from this object file
3911 which we have already seen in this pass. */
3915 included
[mark
] = true;
3920 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3922 /* We mark subsequent symbols from this object file as we go
3923 on through the loop. */
3924 last
= symdef
->file_offset
;
3935 if (defined
!= (boolean
*) NULL
)
3937 if (included
!= (boolean
*) NULL
)
3942 /* Record a new dynamic symbol. We record the dynamic symbols as we
3943 read the input files, since we need to have a list of all of them
3944 before we can determine the final sizes of the output sections.
3945 Note that we may actually call this function even though we are not
3946 going to output any dynamic symbols; in some cases we know that a
3947 symbol should be in the dynamic symbol table, but only if there is
3951 elf_link_record_dynamic_symbol (info
, h
)
3952 struct bfd_link_info
*info
;
3953 struct elf_link_hash_entry
*h
;
3955 if (h
->dynindx
== -1)
3957 struct bfd_strtab_hash
*dynstr
;
3959 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3960 ++elf_hash_table (info
)->dynsymcount
;
3962 dynstr
= elf_hash_table (info
)->dynstr
;
3965 /* Create a strtab to hold the dynamic symbol names. */
3966 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3971 h
->dynstr_index
= ((unsigned long)
3972 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3974 if (h
->dynstr_index
== (unsigned long) -1)
3981 /* Add symbols from an ELF object file to the linker hash table. */
3984 elf_link_add_object_symbols (abfd
, info
)
3986 struct bfd_link_info
*info
;
3988 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3989 const Elf_Internal_Sym
*,
3990 const char **, flagword
*,
3991 asection
**, bfd_vma
*));
3992 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3993 asection
*, const Elf_Internal_Rela
*));
3995 Elf_Internal_Shdr
*hdr
;
3999 Elf_External_Sym
*buf
= NULL
;
4000 struct elf_link_hash_entry
**sym_hash
;
4002 Elf_External_Dyn
*dynbuf
= NULL
;
4003 struct elf_link_hash_entry
*weaks
;
4004 Elf_External_Sym
*esym
;
4005 Elf_External_Sym
*esymend
;
4007 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4008 collect
= get_elf_backend_data (abfd
)->collect
;
4010 /* A stripped shared library might only have a dynamic symbol table,
4011 not a regular symbol table. In that case we can still go ahead
4012 and link using the dynamic symbol table. */
4013 if (elf_onesymtab (abfd
) == 0
4014 && elf_dynsymtab (abfd
) != 0)
4016 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4017 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4020 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4021 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4023 /* The sh_info field of the symtab header tells us where the
4024 external symbols start. We don't care about the local symbols at
4026 if (elf_bad_symtab (abfd
))
4028 extsymcount
= symcount
;
4033 extsymcount
= symcount
- hdr
->sh_info
;
4034 extsymoff
= hdr
->sh_info
;
4037 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4038 if (buf
== NULL
&& extsymcount
!= 0)
4040 bfd_set_error (bfd_error_no_memory
);
4044 /* We store a pointer to the hash table entry for each external
4046 sym_hash
= ((struct elf_link_hash_entry
**)
4048 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4049 if (sym_hash
== NULL
)
4051 bfd_set_error (bfd_error_no_memory
);
4054 elf_sym_hashes (abfd
) = sym_hash
;
4056 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4060 /* If we are creating a shared library, create all the dynamic
4061 sections immediately. We need to attach them to something,
4062 so we attach them to this BFD, provided it is the right
4063 format. FIXME: If there are no input BFD's of the same
4064 format as the output, we can't make a shared library. */
4066 && ! elf_hash_table (info
)->dynamic_sections_created
4067 && abfd
->xvec
== info
->hash
->creator
)
4069 if (! elf_link_create_dynamic_sections (abfd
, info
))
4077 bfd_size_type strindex
;
4081 /* You can't use -r against a dynamic object. Also, there's no
4082 hope of using a dynamic object which does not exactly match
4083 the format of the output file. */
4084 if (info
->relocateable
4085 || info
->hash
->creator
!= abfd
->xvec
)
4087 bfd_set_error (bfd_error_invalid_operation
);
4091 /* Find the name to use in a DT_NEEDED entry that refers to this
4092 object. If the object has a DT_SONAME entry, we use it.
4093 Otherwise, if the generic linker stuck something in
4094 elf_dt_needed_name, we use that. Otherwise, we just use the
4096 name
= bfd_get_filename (abfd
);
4097 if (elf_dt_needed_name (abfd
) != NULL
)
4098 name
= elf_dt_needed_name (abfd
);
4099 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4102 Elf_External_Dyn
*extdyn
;
4103 Elf_External_Dyn
*extdynend
;
4105 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4108 bfd_set_error (bfd_error_no_memory
);
4112 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4113 (file_ptr
) 0, s
->_raw_size
))
4117 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4118 for (; extdyn
< extdynend
; extdyn
++)
4120 Elf_Internal_Dyn dyn
;
4122 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4123 if (dyn
.d_tag
== DT_SONAME
)
4128 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4131 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4132 name
= elf_string_from_elf_section (abfd
, link
,
4145 /* We do not want to include any of the sections in a dynamic
4146 object in the output file. We hack by simply clobbering the
4147 list of sections in the BFD. This could be handled more
4148 cleanly by, say, a new section flag; the existing
4149 SEC_NEVER_LOAD flag is not the one we want, because that one
4150 still implies that the section takes up space in the output
4152 abfd
->sections
= NULL
;
4154 /* If this is the first dynamic object found in the link, create
4155 the special sections required for dynamic linking. */
4156 if (! elf_hash_table (info
)->dynamic_sections_created
)
4158 if (! elf_link_create_dynamic_sections (abfd
, info
))
4162 /* Add a DT_NEEDED entry for this dynamic object. */
4163 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4165 if (strindex
== (bfd_size_type
) -1)
4167 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4172 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4174 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4175 != extsymcount
* sizeof (Elf_External_Sym
)))
4180 esymend
= buf
+ extsymcount
;
4181 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4183 Elf_Internal_Sym sym
;
4189 struct elf_link_hash_entry
*h
= NULL
;
4192 elf_swap_symbol_in (abfd
, esym
, &sym
);
4194 flags
= BSF_NO_FLAGS
;
4196 value
= sym
.st_value
;
4199 bind
= ELF_ST_BIND (sym
.st_info
);
4200 if (bind
== STB_LOCAL
)
4202 /* This should be impossible, since ELF requires that all
4203 global symbols follow all local symbols, and that sh_info
4204 point to the first global symbol. Unfortunatealy, Irix 5
4208 else if (bind
== STB_GLOBAL
)
4210 if (sym
.st_shndx
!= SHN_UNDEF
4211 && sym
.st_shndx
!= SHN_COMMON
)
4216 else if (bind
== STB_WEAK
)
4220 /* Leave it up to the processor backend. */
4223 if (sym
.st_shndx
== SHN_UNDEF
)
4224 sec
= bfd_und_section_ptr
;
4225 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4227 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4231 sec
= bfd_abs_section_ptr
;
4233 else if (sym
.st_shndx
== SHN_ABS
)
4234 sec
= bfd_abs_section_ptr
;
4235 else if (sym
.st_shndx
== SHN_COMMON
)
4237 sec
= bfd_com_section_ptr
;
4238 /* What ELF calls the size we call the value. What ELF
4239 calls the value we call the alignment. */
4240 value
= sym
.st_size
;
4244 /* Leave it up to the processor backend. */
4247 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4248 if (name
== (const char *) NULL
)
4251 if (add_symbol_hook
)
4253 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4257 /* The hook function sets the name to NULL if this symbol
4258 should be skipped for some reason. */
4259 if (name
== (const char *) NULL
)
4263 /* Sanity check that all possibilities were handled. */
4264 if (sec
== (asection
*) NULL
)
4266 bfd_set_error (bfd_error_bad_value
);
4270 if (bfd_is_und_section (sec
)
4271 || bfd_is_com_section (sec
))
4276 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4278 /* We need to look up the symbol now in order to get some of
4279 the dynamic object handling right. We pass the hash
4280 table entry in to _bfd_generic_link_add_one_symbol so
4281 that it does not have to look it up again. */
4282 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4283 true, false, false);
4288 /* If we are looking at a dynamic object, and this is a
4289 definition, we need to see if it has already been defined
4290 by some other object. If it has, we want to use the
4291 existing definition, and we do not want to report a
4292 multiple symbol definition error; we do this by
4293 clobbering sec to be bfd_und_section_ptr. */
4294 if (dynamic
&& definition
)
4296 if (h
->root
.type
== bfd_link_hash_defined
)
4297 sec
= bfd_und_section_ptr
;
4300 /* Similarly, if we are not looking at a dynamic object, and
4301 we have a definition, we want to override any definition
4302 we may have from a dynamic object. Symbols from regular
4303 files always take precedence over symbols from dynamic
4304 objects, even if they are defined after the dynamic
4305 object in the link. */
4308 && h
->root
.type
== bfd_link_hash_defined
4309 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4310 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4311 == bfd_target_elf_flavour
)
4312 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4315 /* Change the hash table entry to undefined, and let
4316 _bfd_generic_link_add_one_symbol do the right thing
4317 with the new definition. */
4318 h
->root
.type
= bfd_link_hash_undefined
;
4319 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4320 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4323 /* If this is a weak definition which we are going to use,
4324 and the symbol is currently undefined, record that the
4325 definition is weak. */
4327 && (flags
& BSF_WEAK
) != 0
4328 && ! bfd_is_und_section (sec
)
4329 && (h
->root
.type
== bfd_link_hash_new
4330 || h
->root
.type
== bfd_link_hash_undefined
4331 || h
->root
.type
== bfd_link_hash_weak
))
4332 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4335 if (! (_bfd_generic_link_add_one_symbol
4336 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4337 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4342 && (flags
& BSF_WEAK
) != 0
4343 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4344 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
4345 && (*sym_hash
)->weakdef
== NULL
)
4347 /* Keep a list of all weak defined non function symbols from
4348 a dynamic object, using the weakdef field. Later in this
4349 function we will set the weakdef field to the correct
4350 value. We only put non-function symbols from dynamic
4351 objects on this list, because that happens to be the only
4352 time we need to know the normal symbol corresponding to a
4353 weak symbol, and the information is time consuming to
4354 figure out. If the weakdef field is not already NULL,
4355 then this symbol was already defined by some previous
4356 dynamic object, and we will be using that previous
4357 definition anyhow. */
4359 (*sym_hash
)->weakdef
= weaks
;
4363 /* Get the alignment of a common symbol. */
4364 if (sym
.st_shndx
== SHN_COMMON
4365 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
4366 (*sym_hash
)->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4368 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4374 /* Remember the symbol size and type. */
4375 if (sym
.st_size
!= 0)
4377 /* FIXME: We should probably somehow give a warning if
4378 the symbol size changes. */
4379 h
->size
= sym
.st_size
;
4381 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4383 /* FIXME: We should probably somehow give a warning if
4384 the symbol type changes. */
4385 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4388 /* Set a flag in the hash table entry indicating the type of
4389 reference or definition we just found. Keep a count of
4390 the number of dynamic symbols we find. A dynamic symbol
4391 is one which is referenced or defined by both a regular
4392 object and a shared object, or one which is referenced or
4393 defined by more than one shared object. */
4394 old_flags
= h
->elf_link_hash_flags
;
4399 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4401 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4403 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4404 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4410 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4412 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4413 if ((old_flags
& new_flag
) != 0
4414 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4415 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4419 h
->elf_link_hash_flags
|= new_flag
;
4420 if (dynsym
&& h
->dynindx
== -1)
4422 if (! elf_link_record_dynamic_symbol (info
, h
))
4428 /* Now set the weakdefs field correctly for all the weak defined
4429 symbols we found. The only way to do this is to search all the
4430 symbols. Since we only need the information for non functions in
4431 dynamic objects, that's the only time we actually put anything on
4432 the list WEAKS. We need this information so that if a regular
4433 object refers to a symbol defined weakly in a dynamic object, the
4434 real symbol in the dynamic object is also put in the dynamic
4435 symbols; we also must arrange for both symbols to point to the
4436 same memory location. We could handle the general case of symbol
4437 aliasing, but a general symbol alias can only be generated in
4438 assembler code, handling it correctly would be very time
4439 consuming, and other ELF linkers don't handle general aliasing
4441 while (weaks
!= NULL
)
4443 struct elf_link_hash_entry
*hlook
;
4446 struct elf_link_hash_entry
**hpp
;
4447 struct elf_link_hash_entry
**hppend
;
4450 weaks
= hlook
->weakdef
;
4451 hlook
->weakdef
= NULL
;
4453 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4454 slook
= hlook
->root
.u
.def
.section
;
4455 vlook
= hlook
->root
.u
.def
.value
;
4457 hpp
= elf_sym_hashes (abfd
);
4458 hppend
= hpp
+ extsymcount
;
4459 for (; hpp
< hppend
; hpp
++)
4461 struct elf_link_hash_entry
*h
;
4465 && h
->root
.type
== bfd_link_hash_defined
4466 && h
->root
.u
.def
.section
== slook
4467 && h
->root
.u
.def
.value
== vlook
)
4471 /* If the weak definition is in the list of dynamic
4472 symbols, make sure the real definition is put there
4474 if (hlook
->dynindx
!= -1
4475 && h
->dynindx
== -1)
4477 if (! elf_link_record_dynamic_symbol (info
, h
))
4492 /* If this object is the same format as the output object, and it is
4493 not a shared library, then let the backend look through the
4496 This is required to build global offset table entries and to
4497 arrange for dynamic relocs. It is not required for the
4498 particular common case of linking non PIC code, even when linking
4499 against shared libraries, but unfortunately there is no way of
4500 knowing whether an object file has been compiled PIC or not.
4501 Looking through the relocs is not particularly time consuming.
4502 The problem is that we must either (1) keep the relocs in memory,
4503 which causes the linker to require additional runtime memory or
4504 (2) read the relocs twice from the input file, which wastes time.
4505 This would be a good case for using mmap.
4507 I have no idea how to handle linking PIC code into a file of a
4508 different format. It probably can't be done. */
4509 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4511 && abfd
->xvec
== info
->hash
->creator
4512 && check_relocs
!= NULL
)
4516 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4518 Elf_Internal_Rela
*internal_relocs
;
4521 if ((o
->flags
& SEC_RELOC
) == 0
4522 || o
->reloc_count
== 0)
4525 /* I believe we can ignore the relocs for any section which
4526 does not form part of the final process image, such as a
4527 debugging section. */
4528 if ((o
->flags
& SEC_ALLOC
) == 0)
4531 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4532 (Elf_Internal_Rela
*) NULL
,
4534 if (internal_relocs
== NULL
)
4537 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4539 if (! info
->keep_memory
)
4540 free (internal_relocs
);
4557 /* Create some sections which will be filled in with dynamic linking
4558 information. ABFD is an input file which requires dynamic sections
4559 to be created. The dynamic sections take up virtual memory space
4560 when the final executable is run, so we need to create them before
4561 addresses are assigned to the output sections. We work out the
4562 actual contents and size of these sections later. */
4565 elf_link_create_dynamic_sections (abfd
, info
)
4567 struct bfd_link_info
*info
;
4570 register asection
*s
;
4571 struct elf_link_hash_entry
*h
;
4572 struct elf_backend_data
*bed
;
4574 if (elf_hash_table (info
)->dynamic_sections_created
)
4577 /* Make sure that all dynamic sections use the same input BFD. */
4578 if (elf_hash_table (info
)->dynobj
== NULL
)
4579 elf_hash_table (info
)->dynobj
= abfd
;
4581 abfd
= elf_hash_table (info
)->dynobj
;
4583 /* Note that we set the SEC_IN_MEMORY flag for all of these
4585 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4587 /* A dynamically linked executable has a .interp section, but a
4588 shared library does not. */
4591 s
= bfd_make_section (abfd
, ".interp");
4593 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4597 s
= bfd_make_section (abfd
, ".dynsym");
4599 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4600 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4603 s
= bfd_make_section (abfd
, ".dynstr");
4605 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4608 /* Create a strtab to hold the dynamic symbol names. */
4609 if (elf_hash_table (info
)->dynstr
== NULL
)
4611 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4612 if (elf_hash_table (info
)->dynstr
== NULL
)
4616 s
= bfd_make_section (abfd
, ".dynamic");
4618 || ! bfd_set_section_flags (abfd
, s
, flags
)
4619 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4622 /* The special symbol _DYNAMIC is always set to the start of the
4623 .dynamic section. This call occurs before we have processed the
4624 symbols for any dynamic object, so we don't have to worry about
4625 overriding a dynamic definition. We could set _DYNAMIC in a
4626 linker script, but we only want to define it if we are, in fact,
4627 creating a .dynamic section. We don't want to define it if there
4628 is no .dynamic section, since on some ELF platforms the start up
4629 code examines it to decide how to initialize the process. */
4631 if (! (_bfd_generic_link_add_one_symbol
4632 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4633 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4634 (struct bfd_link_hash_entry
**) &h
)))
4636 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4637 h
->type
= STT_OBJECT
;
4640 && ! elf_link_record_dynamic_symbol (info
, h
))
4643 s
= bfd_make_section (abfd
, ".hash");
4645 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4646 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4649 /* Let the backend create the rest of the sections. This lets the
4650 backend set the right flags. The backend will normally create
4651 the .got and .plt sections. */
4652 bed
= get_elf_backend_data (abfd
);
4653 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4656 elf_hash_table (info
)->dynamic_sections_created
= true;
4661 /* Add an entry to the .dynamic table. */
4664 elf_add_dynamic_entry (info
, tag
, val
)
4665 struct bfd_link_info
*info
;
4669 Elf_Internal_Dyn dyn
;
4673 bfd_byte
*newcontents
;
4675 dynobj
= elf_hash_table (info
)->dynobj
;
4677 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4678 BFD_ASSERT (s
!= NULL
);
4680 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4681 if (s
->contents
== NULL
)
4682 newcontents
= (bfd_byte
*) malloc (newsize
);
4684 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4685 if (newcontents
== NULL
)
4687 bfd_set_error (bfd_error_no_memory
);
4692 dyn
.d_un
.d_val
= val
;
4693 elf_swap_dyn_out (dynobj
, &dyn
,
4694 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4696 s
->_raw_size
= newsize
;
4697 s
->contents
= newcontents
;
4702 /* Read and swap the relocs for a section. They may have been cached.
4703 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4704 they are used as buffers to read into. They are known to be large
4705 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4706 value is allocated using either malloc or bfd_alloc, according to
4707 the KEEP_MEMORY argument. */
4709 static Elf_Internal_Rela
*
4710 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4713 PTR external_relocs
;
4714 Elf_Internal_Rela
*internal_relocs
;
4715 boolean keep_memory
;
4717 Elf_Internal_Shdr
*rel_hdr
;
4719 Elf_Internal_Rela
*alloc2
= NULL
;
4721 if (elf_section_data (o
)->relocs
!= NULL
)
4722 return elf_section_data (o
)->relocs
;
4724 if (o
->reloc_count
== 0)
4727 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4729 if (internal_relocs
== NULL
)
4733 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4735 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4737 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4738 if (internal_relocs
== NULL
)
4740 bfd_set_error (bfd_error_no_memory
);
4745 if (external_relocs
== NULL
)
4747 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4750 bfd_set_error (bfd_error_no_memory
);
4753 external_relocs
= alloc1
;
4756 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4757 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4758 != rel_hdr
->sh_size
))
4761 /* Swap in the relocs. For convenience, we always produce an
4762 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4764 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4766 Elf_External_Rel
*erel
;
4767 Elf_External_Rel
*erelend
;
4768 Elf_Internal_Rela
*irela
;
4770 erel
= (Elf_External_Rel
*) external_relocs
;
4771 erelend
= erel
+ o
->reloc_count
;
4772 irela
= internal_relocs
;
4773 for (; erel
< erelend
; erel
++, irela
++)
4775 Elf_Internal_Rel irel
;
4777 elf_swap_reloc_in (abfd
, erel
, &irel
);
4778 irela
->r_offset
= irel
.r_offset
;
4779 irela
->r_info
= irel
.r_info
;
4780 irela
->r_addend
= 0;
4785 Elf_External_Rela
*erela
;
4786 Elf_External_Rela
*erelaend
;
4787 Elf_Internal_Rela
*irela
;
4789 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4791 erela
= (Elf_External_Rela
*) external_relocs
;
4792 erelaend
= erela
+ o
->reloc_count
;
4793 irela
= internal_relocs
;
4794 for (; erela
< erelaend
; erela
++, irela
++)
4795 elf_swap_reloca_in (abfd
, erela
, irela
);
4798 /* Cache the results for next time, if we can. */
4800 elf_section_data (o
)->relocs
= internal_relocs
;
4805 /* Don't free alloc2, since if it was allocated we are passing it
4806 back (under the name of internal_relocs). */
4808 return internal_relocs
;
4818 /* Record an assignment to a symbol made by a linker script. We need
4819 this in case some dynamic object refers to this symbol. */
4823 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4825 struct bfd_link_info
*info
;
4828 struct elf_link_hash_entry
*h
;
4830 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4834 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4835 h
->type
= STT_OBJECT
;
4837 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4838 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4840 && h
->dynindx
== -1)
4842 if (! elf_link_record_dynamic_symbol (info
, h
))
4845 /* If this is a weak defined symbol, and we know a corresponding
4846 real symbol from the same dynamic object, make sure the real
4847 symbol is also made into a dynamic symbol. */
4848 if (h
->weakdef
!= NULL
4849 && h
->weakdef
->dynindx
== -1)
4851 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4859 /* Array used to determine the number of hash table buckets to use
4860 based on the number of symbols there are. If there are fewer than
4861 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4862 fewer than 37 we use 17 buckets, and so forth. We never use more
4863 than 521 buckets. */
4865 static const size_t elf_buckets
[] =
4867 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4870 /* Set up the sizes and contents of the ELF dynamic sections. This is
4871 called by the ELF linker emulation before_allocation routine. We
4872 must set the sizes of the sections before the linker sets the
4873 addresses of the various sections. */
4876 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4877 export_dynamic
, info
, sinterpptr
)
4881 boolean export_dynamic
;
4882 struct bfd_link_info
*info
;
4883 asection
**sinterpptr
;
4887 Elf_Internal_Sym isym
;
4890 struct elf_backend_data
*bed
;
4894 dynobj
= elf_hash_table (info
)->dynobj
;
4896 /* If there were no dynamic objects in the link, there is nothing to
4901 /* If we are supposed to export all symbols into the dynamic symbol
4902 table (this is not the normal case), then do so. */
4904 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4907 if (elf_hash_table (info
)->dynamic_sections_created
)
4909 bfd_size_type strsize
;
4911 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4912 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4918 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4920 if (indx
== (bfd_size_type
) -1
4921 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4929 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4931 if (indx
== (bfd_size_type
) -1
4932 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4936 /* Find all symbols which were defined in a dynamic object and make
4937 the backend pick a reasonable value for them. */
4938 elf_link_hash_traverse (elf_hash_table (info
),
4939 elf_adjust_dynamic_symbol
,
4942 /* Add some entries to the .dynamic section. We fill in some of the
4943 values later, in elf_bfd_final_link, but we must add the entries
4944 now so that we know the final size of the .dynamic section. */
4945 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4946 false, false) != NULL
)
4948 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4951 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4952 false, false) != NULL
)
4954 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4957 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4958 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4959 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4960 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4961 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4962 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4963 sizeof (Elf_External_Sym
)))
4967 /* The backend must work out the sizes of all the other dynamic
4969 bed
= get_elf_backend_data (output_bfd
);
4970 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4973 if (elf_hash_table (info
)->dynamic_sections_created
)
4977 /* Set the size of the .dynsym and .hash sections. We counted
4978 the number of dynamic symbols in elf_link_add_object_symbols.
4979 We will build the contents of .dynsym and .hash when we build
4980 the final symbol table, because until then we do not know the
4981 correct value to give the symbols. We built the .dynstr
4982 section as we went along in elf_link_add_object_symbols. */
4983 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4984 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4985 BFD_ASSERT (s
!= NULL
);
4986 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4987 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4988 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4990 bfd_set_error (bfd_error_no_memory
);
4994 /* The first entry in .dynsym is a dummy symbol. */
5001 elf_swap_symbol_out (output_bfd
, &isym
,
5002 (Elf_External_Sym
*) s
->contents
);
5004 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5006 bucketcount
= elf_buckets
[i
];
5007 if (dynsymcount
< elf_buckets
[i
+ 1])
5011 s
= bfd_get_section_by_name (dynobj
, ".hash");
5012 BFD_ASSERT (s
!= NULL
);
5013 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5014 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5015 if (s
->contents
== NULL
)
5017 bfd_set_error (bfd_error_no_memory
);
5020 memset (s
->contents
, 0, s
->_raw_size
);
5022 put_word (output_bfd
, bucketcount
, s
->contents
);
5023 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5025 elf_hash_table (info
)->bucketcount
= bucketcount
;
5027 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5028 BFD_ASSERT (s
!= NULL
);
5029 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5031 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5038 /* This routine is used to export all defined symbols into the dynamic
5039 symbol table. It is called via elf_link_hash_traverse. */
5042 elf_export_symbol (h
, data
)
5043 struct elf_link_hash_entry
*h
;
5046 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5048 if (h
->dynindx
== -1
5049 && (h
->elf_link_hash_flags
5050 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5052 if (! elf_link_record_dynamic_symbol (info
, h
))
5054 /* FIXME: No way to report error. */
5062 /* Make the backend pick a good value for a dynamic symbol. This is
5063 called via elf_link_hash_traverse, and also calls itself
5067 elf_adjust_dynamic_symbol (h
, data
)
5068 struct elf_link_hash_entry
*h
;
5071 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5073 struct elf_backend_data
*bed
;
5075 /* If this symbol does not require a PLT entry, and it is not
5076 defined by a dynamic object, or is not referenced by a regular
5077 object, ignore it. FIXME: Do we need to worry about symbols
5078 which are defined by one dynamic object and referenced by another
5080 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5081 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5082 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5083 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5086 /* If we've already adjusted this symbol, don't do it again. This
5087 can happen via a recursive call. */
5088 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5091 /* Don't look at this symbol again. Note that we must set this
5092 after checking the above conditions, because we may look at a
5093 symbol once, decide not to do anything, and then get called
5094 recursively later after REF_REGULAR is set below. */
5095 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5097 /* If this is a weak definition, and we know a real definition, and
5098 the real symbol is not itself defined by a regular object file,
5099 then get a good value for the real definition. We handle the
5100 real symbol first, for the convenience of the backend routine.
5102 Note that there is a confusing case here. If the real definition
5103 is defined by a regular object file, we don't get the real symbol
5104 from the dynamic object, but we do get the weak symbol. If the
5105 processor backend uses a COPY reloc, then if some routine in the
5106 dynamic object changes the real symbol, we will not see that
5107 change in the corresponding weak symbol. This is the way other
5108 ELF linkers work as well, and seems to be a result of the shared
5111 I will clarify this issue. Most SVR4 shared libraries define the
5112 variable _timezone and define timezone as a weak synonym. The
5113 tzset call changes _timezone. If you write
5114 extern int timezone;
5116 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5117 you might expect that, since timezone is a synonym for _timezone,
5118 the same number will print both times. However, if the processor
5119 backend uses a COPY reloc, then actually timezone will be copied
5120 into your process image, and, since you define _timezone
5121 yourself, _timezone will not. Thus timezone and _timezone will
5122 wind up at different memory locations. The tzset call will set
5123 _timezone, leaving timezone unchanged. */
5125 if (h
->weakdef
!= NULL
)
5127 struct elf_link_hash_entry
*weakdef
;
5129 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5130 weakdef
= h
->weakdef
;
5131 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5132 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5133 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5135 /* This symbol is defined by a regular object file, so we
5136 will not do anything special. Clear weakdef for the
5137 convenience of the processor backend. */
5142 /* There is an implicit reference by a regular object file
5143 via the weak symbol. */
5144 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5145 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5150 dynobj
= elf_hash_table (info
)->dynobj
;
5151 bed
= get_elf_backend_data (dynobj
);
5152 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5154 /* FIXME: No way to return error. */
5161 /* Final phase of ELF linker. */
5163 /* A structure we use to avoid passing large numbers of arguments. */
5165 struct elf_final_link_info
5167 /* General link information. */
5168 struct bfd_link_info
*info
;
5171 /* Symbol string table. */
5172 struct bfd_strtab_hash
*symstrtab
;
5173 /* .dynsym section. */
5174 asection
*dynsym_sec
;
5175 /* .hash section. */
5177 /* Buffer large enough to hold contents of any section. */
5179 /* Buffer large enough to hold external relocs of any section. */
5180 PTR external_relocs
;
5181 /* Buffer large enough to hold internal relocs of any section. */
5182 Elf_Internal_Rela
*internal_relocs
;
5183 /* Buffer large enough to hold external local symbols of any input
5185 Elf_External_Sym
*external_syms
;
5186 /* Buffer large enough to hold internal local symbols of any input
5188 Elf_Internal_Sym
*internal_syms
;
5189 /* Array large enough to hold a symbol index for each local symbol
5190 of any input BFD. */
5192 /* Array large enough to hold a section pointer for each local
5193 symbol of any input BFD. */
5194 asection
**sections
;
5195 /* Buffer to hold swapped out symbols. */
5196 Elf_External_Sym
*symbuf
;
5197 /* Number of swapped out symbols in buffer. */
5198 size_t symbuf_count
;
5199 /* Number of symbols which fit in symbuf. */
5203 static boolean elf_link_output_sym
5204 PARAMS ((struct elf_final_link_info
*, const char *,
5205 Elf_Internal_Sym
*, asection
*));
5206 static boolean elf_link_flush_output_syms
5207 PARAMS ((struct elf_final_link_info
*));
5208 static boolean elf_link_output_extsym
5209 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5210 static boolean elf_link_input_bfd
5211 PARAMS ((struct elf_final_link_info
*, bfd
*));
5212 static boolean elf_reloc_link_order
5213 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5214 struct bfd_link_order
*));
5216 /* Do the final step of an ELF link. */
5219 elf_bfd_final_link (abfd
, info
)
5221 struct bfd_link_info
*info
;
5225 struct elf_final_link_info finfo
;
5226 register asection
*o
;
5227 register struct bfd_link_order
*p
;
5229 size_t max_contents_size
;
5230 size_t max_external_reloc_size
;
5231 size_t max_internal_reloc_count
;
5232 size_t max_sym_count
;
5234 Elf_Internal_Sym elfsym
;
5236 Elf_Internal_Shdr
*symtab_hdr
;
5237 Elf_Internal_Shdr
*symstrtab_hdr
;
5238 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5241 abfd
->flags
|= DYNAMIC
;
5243 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5244 dynobj
= elf_hash_table (info
)->dynobj
;
5247 finfo
.output_bfd
= abfd
;
5248 finfo
.symstrtab
= elf_stringtab_init ();
5249 if (finfo
.symstrtab
== NULL
)
5253 finfo
.dynsym_sec
= NULL
;
5254 finfo
.hash_sec
= NULL
;
5258 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5259 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5260 if (finfo
.dynsym_sec
== NULL
5261 || finfo
.hash_sec
== NULL
)
5264 finfo
.contents
= NULL
;
5265 finfo
.external_relocs
= NULL
;
5266 finfo
.internal_relocs
= NULL
;
5267 finfo
.external_syms
= NULL
;
5268 finfo
.internal_syms
= NULL
;
5269 finfo
.indices
= NULL
;
5270 finfo
.sections
= NULL
;
5271 finfo
.symbuf
= NULL
;
5272 finfo
.symbuf_count
= 0;
5274 /* Count up the number of relocations we will output for each output
5275 section, so that we know the sizes of the reloc sections. We
5276 also figure out some maximum sizes. */
5277 max_contents_size
= 0;
5278 max_external_reloc_size
= 0;
5279 max_internal_reloc_count
= 0;
5281 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5285 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5287 if (p
->type
== bfd_section_reloc_link_order
5288 || p
->type
== bfd_symbol_reloc_link_order
)
5290 else if (p
->type
== bfd_indirect_link_order
)
5294 sec
= p
->u
.indirect
.section
;
5296 if (info
->relocateable
)
5297 o
->reloc_count
+= sec
->reloc_count
;
5299 if (sec
->_raw_size
> max_contents_size
)
5300 max_contents_size
= sec
->_raw_size
;
5301 if (sec
->_cooked_size
> max_contents_size
)
5302 max_contents_size
= sec
->_cooked_size
;
5304 /* We are interested in just local symbols, not all
5306 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5310 if (elf_bad_symtab (sec
->owner
))
5311 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5312 / sizeof (Elf_External_Sym
));
5314 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5316 if (sym_count
> max_sym_count
)
5317 max_sym_count
= sym_count
;
5319 if ((sec
->flags
& SEC_RELOC
) != 0)
5323 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5324 if (ext_size
> max_external_reloc_size
)
5325 max_external_reloc_size
= ext_size
;
5326 if (sec
->reloc_count
> max_internal_reloc_count
)
5327 max_internal_reloc_count
= sec
->reloc_count
;
5333 if (o
->reloc_count
> 0)
5334 o
->flags
|= SEC_RELOC
;
5337 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5338 set it (this is probably a bug) and if it is set
5339 assign_section_numbers will create a reloc section. */
5340 o
->flags
&=~ SEC_RELOC
;
5343 /* If the SEC_ALLOC flag is not set, force the section VMA to
5344 zero. This is done in elf_fake_sections as well, but forcing
5345 the VMA to 0 here will ensure that relocs against these
5346 sections are handled correctly. */
5347 if ((o
->flags
& SEC_ALLOC
) == 0)
5351 /* Figure out the file positions for everything but the symbol table
5352 and the relocs. We set symcount to force assign_section_numbers
5353 to create a symbol table. */
5354 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5355 BFD_ASSERT (! abfd
->output_has_begun
);
5356 if (! elf_compute_section_file_positions (abfd
, info
))
5359 /* That created the reloc sections. Set their sizes, and assign
5360 them file positions, and allocate some buffers. */
5361 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5363 if ((o
->flags
& SEC_RELOC
) != 0)
5365 Elf_Internal_Shdr
*rel_hdr
;
5366 register struct elf_link_hash_entry
**p
, **pend
;
5368 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5370 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5372 /* The contents field must last into write_object_contents,
5373 so we allocate it with bfd_alloc rather than malloc. */
5374 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5375 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5377 bfd_set_error (bfd_error_no_memory
);
5381 p
= ((struct elf_link_hash_entry
**)
5382 malloc (o
->reloc_count
5383 * sizeof (struct elf_link_hash_entry
*)));
5384 if (p
== NULL
&& o
->reloc_count
!= 0)
5386 bfd_set_error (bfd_error_no_memory
);
5389 elf_section_data (o
)->rel_hashes
= p
;
5390 pend
= p
+ o
->reloc_count
;
5391 for (; p
< pend
; p
++)
5394 /* Use the reloc_count field as an index when outputting the
5400 assign_file_positions_for_relocs (abfd
);
5402 /* We have now assigned file positions for all the sections except
5403 .symtab and .strtab. We start the .symtab section at the current
5404 file position, and write directly to it. We build the .strtab
5405 section in memory. When we add .dynsym support, we will build
5406 that in memory as well (.dynsym is smaller than .symtab). */
5408 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5409 /* sh_name is set in prep_headers. */
5410 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5411 symtab_hdr
->sh_flags
= 0;
5412 symtab_hdr
->sh_addr
= 0;
5413 symtab_hdr
->sh_size
= 0;
5414 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5415 /* sh_link is set in assign_section_numbers. */
5416 /* sh_info is set below. */
5417 /* sh_offset is set just below. */
5418 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5420 off
= elf_tdata (abfd
)->next_file_pos
;
5421 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5423 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5424 incorrect. We do not yet know the size of the .symtab section.
5425 We correct next_file_pos below, after we do know the size. */
5427 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5428 continuously seeking to the right position in the file. */
5429 if (! info
->keep_memory
|| max_sym_count
< 20)
5430 finfo
.symbuf_size
= 20;
5432 finfo
.symbuf_size
= max_sym_count
;
5433 finfo
.symbuf
= ((Elf_External_Sym
*)
5434 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5435 if (finfo
.symbuf
== NULL
)
5437 bfd_set_error (bfd_error_no_memory
);
5441 /* Start writing out the symbol table. The first symbol is always a
5443 elfsym
.st_value
= 0;
5446 elfsym
.st_other
= 0;
5447 elfsym
.st_shndx
= SHN_UNDEF
;
5448 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5449 &elfsym
, bfd_und_section_ptr
))
5453 /* Some standard ELF linkers do this, but we don't because it causes
5454 bootstrap comparison failures. */
5455 /* Output a file symbol for the output file as the second symbol.
5456 We output this even if we are discarding local symbols, although
5457 I'm not sure if this is correct. */
5458 elfsym
.st_value
= 0;
5460 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5461 elfsym
.st_other
= 0;
5462 elfsym
.st_shndx
= SHN_ABS
;
5463 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5464 &elfsym
, bfd_abs_section_ptr
))
5468 /* Output a symbol for each section. We output these even if we are
5469 discarding local symbols, since they are used for relocs. These
5470 symbols have no names. We store the index of each one in the
5471 index field of the section, so that we can find it again when
5472 outputting relocs. */
5473 elfsym
.st_value
= 0;
5475 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5476 elfsym
.st_other
= 0;
5477 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5479 o
= section_from_elf_index (abfd
, i
);
5481 o
->target_index
= abfd
->symcount
;
5482 elfsym
.st_shndx
= i
;
5483 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5488 /* Allocate some memory to hold information read in from the input
5490 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5491 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5492 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5493 malloc (max_internal_reloc_count
5494 * sizeof (Elf_Internal_Rela
)));
5495 finfo
.external_syms
= ((Elf_External_Sym
*)
5496 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5497 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5498 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5499 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5500 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5501 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5502 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5503 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5504 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5505 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5506 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5507 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5509 bfd_set_error (bfd_error_no_memory
);
5513 /* Since ELF permits relocations to be against local symbols, we
5514 must have the local symbols available when we do the relocations.
5515 Since we would rather only read the local symbols once, and we
5516 would rather not keep them in memory, we handle all the
5517 relocations for a single input file at the same time.
5519 Unfortunately, there is no way to know the total number of local
5520 symbols until we have seen all of them, and the local symbol
5521 indices precede the global symbol indices. This means that when
5522 we are generating relocateable output, and we see a reloc against
5523 a global symbol, we can not know the symbol index until we have
5524 finished examining all the local symbols to see which ones we are
5525 going to output. To deal with this, we keep the relocations in
5526 memory, and don't output them until the end of the link. This is
5527 an unfortunate waste of memory, but I don't see a good way around
5528 it. Fortunately, it only happens when performing a relocateable
5529 link, which is not the common case. FIXME: If keep_memory is set
5530 we could write the relocs out and then read them again; I don't
5531 know how bad the memory loss will be. */
5533 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5534 sub
->output_has_begun
= false;
5535 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5537 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5539 if (p
->type
== bfd_indirect_link_order
5540 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5541 == bfd_target_elf_flavour
))
5543 sub
= p
->u
.indirect
.section
->owner
;
5544 if (! sub
->output_has_begun
)
5546 if (! elf_link_input_bfd (&finfo
, sub
))
5548 sub
->output_has_begun
= true;
5551 else if (p
->type
== bfd_section_reloc_link_order
5552 || p
->type
== bfd_symbol_reloc_link_order
)
5554 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5559 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5565 /* That wrote out all the local symbols. Finish up the symbol table
5566 with the global symbols. */
5568 /* The sh_info field records the index of the first non local
5570 symtab_hdr
->sh_info
= abfd
->symcount
;
5572 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5574 /* We get the global symbols from the hash table. */
5575 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5578 /* Flush all symbols to the file. */
5579 if (! elf_link_flush_output_syms (&finfo
))
5582 /* Now we know the size of the symtab section. */
5583 off
+= symtab_hdr
->sh_size
;
5585 /* Finish up and write out the symbol string table (.strtab)
5587 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5588 /* sh_name was set in prep_headers. */
5589 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5590 symstrtab_hdr
->sh_flags
= 0;
5591 symstrtab_hdr
->sh_addr
= 0;
5592 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5593 symstrtab_hdr
->sh_entsize
= 0;
5594 symstrtab_hdr
->sh_link
= 0;
5595 symstrtab_hdr
->sh_info
= 0;
5596 /* sh_offset is set just below. */
5597 symstrtab_hdr
->sh_addralign
= 1;
5599 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5600 elf_tdata (abfd
)->next_file_pos
= off
;
5602 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5603 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5606 /* Adjust the relocs to have the correct symbol indices. */
5607 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5609 struct elf_link_hash_entry
**rel_hash
;
5610 Elf_Internal_Shdr
*rel_hdr
;
5612 if ((o
->flags
& SEC_RELOC
) == 0)
5615 rel_hash
= elf_section_data (o
)->rel_hashes
;
5616 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5617 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5619 if (*rel_hash
== NULL
)
5622 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5624 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5626 Elf_External_Rel
*erel
;
5627 Elf_Internal_Rel irel
;
5629 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5630 elf_swap_reloc_in (abfd
, erel
, &irel
);
5631 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5632 ELF_R_TYPE (irel
.r_info
));
5633 elf_swap_reloc_out (abfd
, &irel
, erel
);
5637 Elf_External_Rela
*erela
;
5638 Elf_Internal_Rela irela
;
5640 BFD_ASSERT (rel_hdr
->sh_entsize
5641 == sizeof (Elf_External_Rela
));
5643 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5644 elf_swap_reloca_in (abfd
, erela
, &irela
);
5645 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5646 ELF_R_TYPE (irela
.r_info
));
5647 elf_swap_reloca_out (abfd
, &irela
, erela
);
5651 /* Set the reloc_count field to 0 to prevent write_relocs from
5652 trying to swap the relocs out itself. */
5656 /* If we are linking against a dynamic object, or generating a
5657 shared library, finish up the dynamic linking information. */
5660 Elf_External_Dyn
*dyncon
, *dynconend
;
5662 /* Fix up .dynamic entries. */
5663 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5664 BFD_ASSERT (o
!= NULL
);
5666 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5667 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5668 for (; dyncon
< dynconend
; dyncon
++)
5670 Elf_Internal_Dyn dyn
;
5674 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5681 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5682 magic _init and _fini symbols. This is pretty ugly,
5683 but we are compatible. */
5691 struct elf_link_hash_entry
*h
;
5693 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5694 false, false, true);
5695 BFD_ASSERT (h
!= NULL
);
5696 if (h
->root
.type
== bfd_link_hash_defined
)
5698 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5699 o
= h
->root
.u
.def
.section
;
5700 if (o
->output_section
!= NULL
)
5701 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5702 + o
->output_offset
);
5704 dyn
.d_un
.d_val
+= o
->vma
;
5706 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5719 o
= bfd_get_section_by_name (abfd
, name
);
5720 BFD_ASSERT (o
!= NULL
);
5721 dyn
.d_un
.d_ptr
= o
->vma
;
5722 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5729 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5734 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5736 Elf_Internal_Shdr
*hdr
;
5738 hdr
= elf_elfsections (abfd
)[i
];
5739 if (hdr
->sh_type
== type
5740 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5742 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5743 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5746 if (dyn
.d_un
.d_val
== 0
5747 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5748 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5752 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5758 /* If we have created any dynamic sections, then output them. */
5761 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5764 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5766 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5767 || o
->_raw_size
== 0)
5769 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5771 /* At this point, we are only interested in sections
5772 created by elf_link_create_dynamic_sections. FIXME:
5773 This test is fragile. */
5776 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5778 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5780 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5781 o
->contents
, o
->output_offset
,
5789 /* The contents of the .dynstr section are actually in a
5791 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5792 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5793 || ! _bfd_stringtab_emit (abfd
,
5794 elf_hash_table (info
)->dynstr
))
5800 if (finfo
.symstrtab
!= NULL
)
5801 _bfd_stringtab_free (finfo
.symstrtab
);
5802 if (finfo
.contents
!= NULL
)
5803 free (finfo
.contents
);
5804 if (finfo
.external_relocs
!= NULL
)
5805 free (finfo
.external_relocs
);
5806 if (finfo
.internal_relocs
!= NULL
)
5807 free (finfo
.internal_relocs
);
5808 if (finfo
.external_syms
!= NULL
)
5809 free (finfo
.external_syms
);
5810 if (finfo
.internal_syms
!= NULL
)
5811 free (finfo
.internal_syms
);
5812 if (finfo
.indices
!= NULL
)
5813 free (finfo
.indices
);
5814 if (finfo
.sections
!= NULL
)
5815 free (finfo
.sections
);
5816 if (finfo
.symbuf
!= NULL
)
5817 free (finfo
.symbuf
);
5818 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5820 if ((o
->flags
& SEC_RELOC
) != 0
5821 && elf_section_data (o
)->rel_hashes
!= NULL
)
5822 free (elf_section_data (o
)->rel_hashes
);
5825 elf_tdata (abfd
)->linker
= true;
5830 if (finfo
.symstrtab
!= NULL
)
5831 _bfd_stringtab_free (finfo
.symstrtab
);
5832 if (finfo
.contents
!= NULL
)
5833 free (finfo
.contents
);
5834 if (finfo
.external_relocs
!= NULL
)
5835 free (finfo
.external_relocs
);
5836 if (finfo
.internal_relocs
!= NULL
)
5837 free (finfo
.internal_relocs
);
5838 if (finfo
.external_syms
!= NULL
)
5839 free (finfo
.external_syms
);
5840 if (finfo
.internal_syms
!= NULL
)
5841 free (finfo
.internal_syms
);
5842 if (finfo
.indices
!= NULL
)
5843 free (finfo
.indices
);
5844 if (finfo
.sections
!= NULL
)
5845 free (finfo
.sections
);
5846 if (finfo
.symbuf
!= NULL
)
5847 free (finfo
.symbuf
);
5848 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5850 if ((o
->flags
& SEC_RELOC
) != 0
5851 && elf_section_data (o
)->rel_hashes
!= NULL
)
5852 free (elf_section_data (o
)->rel_hashes
);
5858 /* Add a symbol to the output symbol table. */
5861 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5862 struct elf_final_link_info
*finfo
;
5864 Elf_Internal_Sym
*elfsym
;
5865 asection
*input_sec
;
5867 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5868 struct bfd_link_info
*info
,
5873 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5874 elf_backend_link_output_symbol_hook
;
5875 if (output_symbol_hook
!= NULL
)
5877 if (! ((*output_symbol_hook
)
5878 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5882 if (name
== (const char *) NULL
|| *name
== '\0')
5883 elfsym
->st_name
= 0;
5886 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5889 if (elfsym
->st_name
== (unsigned long) -1)
5893 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5895 if (! elf_link_flush_output_syms (finfo
))
5899 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5900 finfo
->symbuf
+ finfo
->symbuf_count
);
5901 ++finfo
->symbuf_count
;
5903 ++finfo
->output_bfd
->symcount
;
5908 /* Flush the output symbols to the file. */
5911 elf_link_flush_output_syms (finfo
)
5912 struct elf_final_link_info
*finfo
;
5914 Elf_Internal_Shdr
*symtab
;
5916 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5918 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5920 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5921 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5922 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5925 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5927 finfo
->symbuf_count
= 0;
5932 /* Add an external symbol to the symbol table. This is called from
5933 the hash table traversal routine. */
5936 elf_link_output_extsym (h
, data
)
5937 struct elf_link_hash_entry
*h
;
5940 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5942 Elf_Internal_Sym sym
;
5943 asection
*input_sec
;
5945 /* We don't want to output symbols that have never been mentioned by
5946 a regular file, or that we have been told to strip. However, if
5947 h->indx is set to -2, the symbol is used by a reloc and we must
5951 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5952 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5953 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5954 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5956 else if (finfo
->info
->strip
== strip_all
5957 || (finfo
->info
->strip
== strip_some
5958 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5959 h
->root
.root
.string
,
5960 false, false) == NULL
))
5965 /* If we're stripping it, and it's not a dynamic symbol, there's
5966 nothing else to do. */
5967 if (strip
&& h
->dynindx
== -1)
5971 sym
.st_size
= h
->size
;
5973 if (h
->root
.type
== bfd_link_hash_weak
5974 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5975 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5977 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5979 switch (h
->root
.type
)
5982 case bfd_link_hash_new
:
5986 case bfd_link_hash_undefined
:
5987 input_sec
= bfd_und_section_ptr
;
5988 sym
.st_shndx
= SHN_UNDEF
;
5991 case bfd_link_hash_weak
:
5992 input_sec
= bfd_und_section_ptr
;
5993 sym
.st_shndx
= SHN_UNDEF
;
5996 case bfd_link_hash_defined
:
5998 input_sec
= h
->root
.u
.def
.section
;
5999 if (input_sec
->output_section
!= NULL
)
6002 elf_section_from_bfd_section (finfo
->output_bfd
,
6003 input_sec
->output_section
);
6004 if (sym
.st_shndx
== (unsigned short) -1)
6006 /* FIXME: No way to handle errors. */
6010 /* ELF symbols in relocateable files are section relative,
6011 but in nonrelocateable files they are virtual
6013 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6014 if (! finfo
->info
->relocateable
)
6015 sym
.st_value
+= input_sec
->output_section
->vma
;
6019 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6020 == bfd_target_elf_flavour
)
6021 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6022 sym
.st_shndx
= SHN_UNDEF
;
6023 input_sec
= bfd_und_section_ptr
;
6028 case bfd_link_hash_common
:
6029 input_sec
= bfd_com_section_ptr
;
6030 sym
.st_shndx
= SHN_COMMON
;
6031 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6034 case bfd_link_hash_indirect
:
6035 case bfd_link_hash_warning
:
6036 /* I have no idea how these should be handled. */
6040 /* If this symbol should be put in the .dynsym section, then put it
6041 there now. We have already know the symbol index. We also fill
6042 in the entry in the .hash section. */
6043 if (h
->dynindx
!= -1
6044 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6046 struct elf_backend_data
*bed
;
6049 bfd_byte
*bucketpos
;
6052 sym
.st_name
= h
->dynstr_index
;
6054 /* Give the processor backend a chance to tweak the symbol
6055 value, and also to finish up anything that needs to be done
6057 bed
= get_elf_backend_data (finfo
->output_bfd
);
6058 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6059 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6061 /* FIXME: No way to return error. */
6065 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6066 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6069 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6070 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6072 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6073 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6074 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6075 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6076 put_word (finfo
->output_bfd
, chain
,
6077 ((bfd_byte
*) finfo
->hash_sec
->contents
6078 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6081 /* If we're stripping it, then it was just a dynamic symbol, and
6082 there's nothing else to do. */
6086 h
->indx
= finfo
->output_bfd
->symcount
;
6088 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6090 /* FIXME: No way to return error. */
6097 /* Link an input file into the linker output file. This function
6098 handles all the sections and relocations of the input file at once.
6099 This is so that we only have to read the local symbols once, and
6100 don't have to keep them in memory. */
6103 elf_link_input_bfd (finfo
, input_bfd
)
6104 struct elf_final_link_info
*finfo
;
6107 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6108 bfd
*, asection
*, bfd_byte
*,
6109 Elf_Internal_Rela
*,
6110 Elf_Internal_Sym
*, asection
**));
6112 Elf_Internal_Shdr
*symtab_hdr
;
6115 Elf_External_Sym
*esym
;
6116 Elf_External_Sym
*esymend
;
6117 Elf_Internal_Sym
*isym
;
6119 asection
**ppsection
;
6122 output_bfd
= finfo
->output_bfd
;
6124 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6126 /* If this is a dynamic object, we don't want to do anything here:
6127 we don't want the local symbols, and we don't want the section
6129 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6132 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6133 if (elf_bad_symtab (input_bfd
))
6135 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6140 locsymcount
= symtab_hdr
->sh_info
;
6141 extsymoff
= symtab_hdr
->sh_info
;
6144 /* Read the local symbols. */
6146 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6147 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6148 locsymcount
, input_bfd
)
6149 != locsymcount
* sizeof (Elf_External_Sym
))))
6152 /* Swap in the local symbols and write out the ones which we know
6153 are going into the output file. */
6154 esym
= finfo
->external_syms
;
6155 esymend
= esym
+ locsymcount
;
6156 isym
= finfo
->internal_syms
;
6157 pindex
= finfo
->indices
;
6158 ppsection
= finfo
->sections
;
6159 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6163 Elf_Internal_Sym osym
;
6165 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6168 if (elf_bad_symtab (input_bfd
))
6170 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6177 if (isym
->st_shndx
== SHN_UNDEF
)
6178 isec
= bfd_und_section_ptr
;
6179 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6180 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6181 else if (isym
->st_shndx
== SHN_ABS
)
6182 isec
= bfd_abs_section_ptr
;
6183 else if (isym
->st_shndx
== SHN_COMMON
)
6184 isec
= bfd_com_section_ptr
;
6193 /* Don't output the first, undefined, symbol. */
6194 if (esym
== finfo
->external_syms
)
6197 /* If we are stripping all symbols, we don't want to output this
6199 if (finfo
->info
->strip
== strip_all
)
6202 /* We never output section symbols. Instead, we use the section
6203 symbol of the corresponding section in the output file. */
6204 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6207 /* If we are discarding all local symbols, we don't want to
6208 output this one. If we are generating a relocateable output
6209 file, then some of the local symbols may be required by
6210 relocs; we output them below as we discover that they are
6212 if (finfo
->info
->discard
== discard_all
)
6215 /* Get the name of the symbol. */
6216 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6221 /* See if we are discarding symbols with this name. */
6222 if ((finfo
->info
->strip
== strip_some
6223 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6225 || (finfo
->info
->discard
== discard_l
6226 && strncmp (name
, finfo
->info
->lprefix
,
6227 finfo
->info
->lprefix_len
) == 0))
6230 /* If we get here, we are going to output this symbol. */
6234 /* Adjust the section index for the output file. */
6235 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6236 isec
->output_section
);
6237 if (osym
.st_shndx
== (unsigned short) -1)
6240 *pindex
= output_bfd
->symcount
;
6242 /* ELF symbols in relocateable files are section relative, but
6243 in executable files they are virtual addresses. Note that
6244 this code assumes that all ELF sections have an associated
6245 BFD section with a reasonable value for output_offset; below
6246 we assume that they also have a reasonable value for
6247 output_section. Any special sections must be set up to meet
6248 these requirements. */
6249 osym
.st_value
+= isec
->output_offset
;
6250 if (! finfo
->info
->relocateable
)
6251 osym
.st_value
+= isec
->output_section
->vma
;
6253 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6257 /* Relocate the contents of each section. */
6258 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6260 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6263 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6264 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6266 /* Section was created by elf_link_create_dynamic_sections.
6267 FIXME: This test is fragile. */
6271 /* Read the contents of the section. */
6272 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6273 (file_ptr
) 0, o
->_raw_size
))
6276 if ((o
->flags
& SEC_RELOC
) != 0)
6278 Elf_Internal_Rela
*internal_relocs
;
6280 /* Get the swapped relocs. */
6281 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6282 finfo
->external_relocs
,
6283 finfo
->internal_relocs
,
6285 if (internal_relocs
== NULL
6286 && o
->reloc_count
> 0)
6289 /* Relocate the section by invoking a back end routine.
6291 The back end routine is responsible for adjusting the
6292 section contents as necessary, and (if using Rela relocs
6293 and generating a relocateable output file) adjusting the
6294 reloc addend as necessary.
6296 The back end routine does not have to worry about setting
6297 the reloc address or the reloc symbol index.
6299 The back end routine is given a pointer to the swapped in
6300 internal symbols, and can access the hash table entries
6301 for the external symbols via elf_sym_hashes (input_bfd).
6303 When generating relocateable output, the back end routine
6304 must handle STB_LOCAL/STT_SECTION symbols specially. The
6305 output symbol is going to be a section symbol
6306 corresponding to the output section, which will require
6307 the addend to be adjusted. */
6309 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6313 finfo
->internal_syms
,
6317 if (finfo
->info
->relocateable
)
6319 Elf_Internal_Rela
*irela
;
6320 Elf_Internal_Rela
*irelaend
;
6321 struct elf_link_hash_entry
**rel_hash
;
6322 Elf_Internal_Shdr
*input_rel_hdr
;
6323 Elf_Internal_Shdr
*output_rel_hdr
;
6325 /* Adjust the reloc addresses and symbol indices. */
6327 irela
= internal_relocs
;
6328 irelaend
= irela
+ o
->reloc_count
;
6329 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6330 + o
->output_section
->reloc_count
);
6331 for (; irela
< irelaend
; irela
++, rel_hash
++)
6334 Elf_Internal_Sym
*isym
;
6337 irela
->r_offset
+= o
->output_offset
;
6339 r_symndx
= ELF_R_SYM (irela
->r_info
);
6344 if (r_symndx
>= locsymcount
6345 || (elf_bad_symtab (input_bfd
)
6346 && finfo
->sections
[r_symndx
] == NULL
))
6350 /* This is a reloc against a global symbol. We
6351 have not yet output all the local symbols, so
6352 we do not know the symbol index of any global
6353 symbol. We set the rel_hash entry for this
6354 reloc to point to the global hash table entry
6355 for this symbol. The symbol index is then
6356 set at the end of elf_bfd_final_link. */
6357 indx
= r_symndx
- extsymoff
;
6358 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6360 /* Setting the index to -2 tells
6361 elf_link_output_extsym that this symbol is
6363 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6364 (*rel_hash
)->indx
= -2;
6369 /* This is a reloc against a local symbol. */
6372 isym
= finfo
->internal_syms
+ r_symndx
;
6373 sec
= finfo
->sections
[r_symndx
];
6374 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6376 /* I suppose the backend ought to fill in the
6377 section of any STT_SECTION symbol against a
6378 processor specific section. */
6379 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6381 else if (sec
== NULL
|| sec
->owner
== NULL
)
6383 bfd_set_error (bfd_error_bad_value
);
6388 r_symndx
= sec
->output_section
->target_index
;
6395 if (finfo
->indices
[r_symndx
] == -1)
6401 if (finfo
->info
->strip
== strip_all
)
6403 /* You can't do ld -r -s. */
6404 bfd_set_error (bfd_error_invalid_operation
);
6408 /* This symbol was skipped earlier, but
6409 since it is needed by a reloc, we
6410 must output it now. */
6411 link
= symtab_hdr
->sh_link
;
6412 name
= elf_string_from_elf_section (input_bfd
,
6418 osec
= sec
->output_section
;
6420 elf_section_from_bfd_section (output_bfd
,
6422 if (isym
->st_shndx
== (unsigned short) -1)
6425 isym
->st_value
+= sec
->output_offset
;
6426 if (! finfo
->info
->relocateable
)
6427 isym
->st_value
+= osec
->vma
;
6429 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6431 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6435 r_symndx
= finfo
->indices
[r_symndx
];
6438 irela
->r_info
= ELF_R_INFO (r_symndx
,
6439 ELF_R_TYPE (irela
->r_info
));
6442 /* Swap out the relocs. */
6443 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6444 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6445 BFD_ASSERT (output_rel_hdr
->sh_entsize
6446 == input_rel_hdr
->sh_entsize
);
6447 irela
= internal_relocs
;
6448 irelaend
= irela
+ o
->reloc_count
;
6449 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6451 Elf_External_Rel
*erel
;
6453 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6454 + o
->output_section
->reloc_count
);
6455 for (; irela
< irelaend
; irela
++, erel
++)
6457 Elf_Internal_Rel irel
;
6459 irel
.r_offset
= irela
->r_offset
;
6460 irel
.r_info
= irela
->r_info
;
6461 BFD_ASSERT (irela
->r_addend
== 0);
6462 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6467 Elf_External_Rela
*erela
;
6469 BFD_ASSERT (input_rel_hdr
->sh_entsize
6470 == sizeof (Elf_External_Rela
));
6471 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6472 + o
->output_section
->reloc_count
);
6473 for (; irela
< irelaend
; irela
++, erela
++)
6474 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6477 o
->output_section
->reloc_count
+= o
->reloc_count
;
6481 /* Write out the modified section contents. */
6482 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6483 finfo
->contents
, o
->output_offset
,
6484 (o
->_cooked_size
!= 0
6493 /* Generate a reloc when linking an ELF file. This is a reloc
6494 requested by the linker, and does come from any input file. This
6495 is used to build constructor and destructor tables when linking
6499 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6501 struct bfd_link_info
*info
;
6502 asection
*output_section
;
6503 struct bfd_link_order
*link_order
;
6505 reloc_howto_type
*howto
;
6508 struct elf_link_hash_entry
**rel_hash_ptr
;
6509 Elf_Internal_Shdr
*rel_hdr
;
6511 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6514 bfd_set_error (bfd_error_bad_value
);
6518 /* If this is an inplace reloc, we must write the addend into the
6520 if (howto
->partial_inplace
6521 && link_order
->u
.reloc
.p
->addend
!= 0)
6524 bfd_reloc_status_type rstat
;
6528 size
= bfd_get_reloc_size (howto
);
6529 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6530 if (buf
== (bfd_byte
*) NULL
)
6532 bfd_set_error (bfd_error_no_memory
);
6535 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6536 link_order
->u
.reloc
.p
->addend
, buf
);
6542 case bfd_reloc_outofrange
:
6544 case bfd_reloc_overflow
:
6545 if (! ((*info
->callbacks
->reloc_overflow
)
6547 (link_order
->type
== bfd_section_reloc_link_order
6548 ? bfd_section_name (output_bfd
,
6549 link_order
->u
.reloc
.p
->u
.section
)
6550 : link_order
->u
.reloc
.p
->u
.name
),
6551 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6552 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6559 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6560 (file_ptr
) link_order
->offset
, size
);
6566 /* Figure out the symbol index. */
6567 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6568 + output_section
->reloc_count
);
6569 if (link_order
->type
== bfd_section_reloc_link_order
)
6571 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6574 *rel_hash_ptr
= NULL
;
6578 struct elf_link_hash_entry
*h
;
6580 h
= elf_link_hash_lookup (elf_hash_table (info
),
6581 link_order
->u
.reloc
.p
->u
.name
,
6582 false, false, true);
6585 /* Setting the index to -2 tells elf_link_output_extsym that
6586 this symbol is used by a reloc. */
6593 if (! ((*info
->callbacks
->unattached_reloc
)
6594 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6595 (asection
*) NULL
, (bfd_vma
) 0)))
6601 /* The address of a reloc is relative to the section in a
6602 relocateable file, and is a virtual address in an executable
6604 offset
= link_order
->offset
;
6605 if (! info
->relocateable
)
6606 offset
+= output_section
->vma
;
6608 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6610 if (rel_hdr
->sh_type
== SHT_REL
)
6612 Elf_Internal_Rel irel
;
6613 Elf_External_Rel
*erel
;
6615 irel
.r_offset
= offset
;
6616 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6617 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6618 + output_section
->reloc_count
);
6619 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6623 Elf_Internal_Rela irela
;
6624 Elf_External_Rela
*erela
;
6626 irela
.r_offset
= offset
;
6627 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6628 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6629 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6630 + output_section
->reloc_count
);
6631 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6634 ++output_section
->reloc_count
;