1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994 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
);
2122 /* Place the section headers. */
2123 off
= align_file_position (off
);
2124 i_ehdrp
->e_shoff
= off
;
2125 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2127 elf_tdata (abfd
)->next_file_pos
= off
;
2132 /* Sort the ELF headers by VMA. We sort headers which are not
2133 SHF_ALLOC to the end. */
2136 elf_sort_hdrs (arg1
, arg2
)
2140 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2141 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2143 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2145 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2147 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2149 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2156 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2166 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2167 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2168 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2170 struct bfd_strtab_hash
*shstrtab
;
2172 i_ehdrp
= elf_elfheader (abfd
);
2173 i_shdrp
= elf_elfsections (abfd
);
2175 shstrtab
= elf_stringtab_init ();
2176 if (shstrtab
== NULL
)
2179 elf_shstrtab (abfd
) = shstrtab
;
2181 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2182 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2183 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2184 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2186 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2187 i_ehdrp
->e_ident
[EI_DATA
] =
2188 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2189 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2191 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2192 i_ehdrp
->e_ident
[count
] = 0;
2194 if ((abfd
->flags
& DYNAMIC
) != 0)
2195 i_ehdrp
->e_type
= ET_DYN
;
2196 else if ((abfd
->flags
& EXEC_P
) != 0)
2197 i_ehdrp
->e_type
= ET_EXEC
;
2199 i_ehdrp
->e_type
= ET_REL
;
2201 switch (bfd_get_arch (abfd
))
2203 case bfd_arch_unknown
:
2204 i_ehdrp
->e_machine
= EM_NONE
;
2206 case bfd_arch_sparc
:
2208 i_ehdrp
->e_machine
= EM_SPARC64
;
2210 i_ehdrp
->e_machine
= EM_SPARC
;
2214 i_ehdrp
->e_machine
= EM_386
;
2217 i_ehdrp
->e_machine
= EM_68K
;
2220 i_ehdrp
->e_machine
= EM_88K
;
2223 i_ehdrp
->e_machine
= EM_860
;
2225 case bfd_arch_mips
: /* MIPS Rxxxx */
2226 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2229 i_ehdrp
->e_machine
= EM_PARISC
;
2231 case bfd_arch_powerpc
:
2232 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2234 /* start-sanitize-arc */
2236 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2238 /* end-sanitize-arc */
2239 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2241 i_ehdrp
->e_machine
= EM_NONE
;
2243 i_ehdrp
->e_version
= EV_CURRENT
;
2244 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2246 /* no program header, for now. */
2247 i_ehdrp
->e_phoff
= 0;
2248 i_ehdrp
->e_phentsize
= 0;
2249 i_ehdrp
->e_phnum
= 0;
2251 /* each bfd section is section header entry */
2252 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2253 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2255 /* if we're building an executable, we'll need a program header table */
2256 if (abfd
->flags
& EXEC_P
)
2258 /* it all happens later */
2260 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2262 /* elf_build_phdrs() returns a (NULL-terminated) array of
2263 Elf_Internal_Phdrs */
2264 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2265 i_ehdrp
->e_phoff
= outbase
;
2266 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2271 i_ehdrp
->e_phentsize
= 0;
2273 i_ehdrp
->e_phoff
= 0;
2276 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2277 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2278 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2279 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2280 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2281 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2282 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2283 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2284 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2291 swap_out_syms (abfd
, sttp
)
2293 struct bfd_strtab_hash
**sttp
;
2295 if (!elf_map_symbols (abfd
))
2298 /* Dump out the symtabs. */
2300 int symcount
= bfd_get_symcount (abfd
);
2301 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2302 struct bfd_strtab_hash
*stt
;
2303 Elf_Internal_Shdr
*symtab_hdr
;
2304 Elf_Internal_Shdr
*symstrtab_hdr
;
2305 Elf_External_Sym
*outbound_syms
;
2308 stt
= elf_stringtab_init ();
2312 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2313 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2314 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2315 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2316 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2317 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2319 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2320 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2322 outbound_syms
= ((Elf_External_Sym
*)
2324 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2325 if (outbound_syms
== NULL
)
2327 bfd_set_error (bfd_error_no_memory
);
2330 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2332 /* now generate the data (for "contents") */
2334 /* Fill in zeroth symbol and swap it out. */
2335 Elf_Internal_Sym sym
;
2341 sym
.st_shndx
= SHN_UNDEF
;
2342 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2345 for (idx
= 0; idx
< symcount
; idx
++)
2347 Elf_Internal_Sym sym
;
2348 bfd_vma value
= syms
[idx
]->value
;
2349 elf_symbol_type
*type_ptr
;
2351 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2352 /* Section symbols have no names. */
2356 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2359 if (sym
.st_name
== (unsigned long) -1)
2363 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2365 if (bfd_is_com_section (syms
[idx
]->section
))
2367 /* ELF common symbols put the alignment into the `value' field,
2368 and the size into the `size' field. This is backwards from
2369 how BFD handles it, so reverse it here. */
2370 sym
.st_size
= value
;
2371 if (type_ptr
== NULL
2372 || type_ptr
->internal_elf_sym
.st_value
== 0)
2373 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2375 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2376 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2377 syms
[idx
]->section
);
2381 asection
*sec
= syms
[idx
]->section
;
2384 if (sec
->output_section
)
2386 value
+= sec
->output_offset
;
2387 sec
= sec
->output_section
;
2390 sym
.st_value
= value
;
2391 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2392 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2396 /* Writing this would be a hell of a lot easier if we had
2397 some decent documentation on bfd, and knew what to expect
2398 of the library, and what to demand of applications. For
2399 example, it appears that `objcopy' might not set the
2400 section of a symbol to be a section that is actually in
2402 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2403 BFD_ASSERT (sec2
!= 0);
2404 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2405 BFD_ASSERT (shndx
!= -1);
2409 if (bfd_is_com_section (syms
[idx
]->section
))
2410 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2411 else if (bfd_is_und_section (syms
[idx
]->section
))
2412 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2413 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2416 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2417 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2418 else if (syms
[idx
]->flags
& BSF_FILE
)
2419 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2422 int bind
= STB_LOCAL
;
2423 int type
= STT_OBJECT
;
2424 unsigned int flags
= syms
[idx
]->flags
;
2426 if (flags
& BSF_LOCAL
)
2428 else if (flags
& BSF_WEAK
)
2430 else if (flags
& BSF_GLOBAL
)
2433 if (flags
& BSF_FUNCTION
)
2436 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2440 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2445 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2446 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2448 symstrtab_hdr
->sh_flags
= 0;
2449 symstrtab_hdr
->sh_addr
= 0;
2450 symstrtab_hdr
->sh_entsize
= 0;
2451 symstrtab_hdr
->sh_link
= 0;
2452 symstrtab_hdr
->sh_info
= 0;
2453 symstrtab_hdr
->sh_addralign
= 1;
2460 write_shdrs_and_ehdr (abfd
)
2463 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2464 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2465 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2466 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2469 i_ehdrp
= elf_elfheader (abfd
);
2470 i_shdrp
= elf_elfsections (abfd
);
2472 /* swap the header before spitting it out... */
2475 elf_debug_file (i_ehdrp
);
2477 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2478 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2479 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2480 != sizeof (x_ehdr
)))
2483 /* at this point we've concocted all the ELF sections... */
2484 x_shdrp
= (Elf_External_Shdr
*)
2485 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2488 bfd_set_error (bfd_error_no_memory
);
2492 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2495 elf_debug_section (count
, i_shdrp
[count
]);
2497 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2499 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2500 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2501 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2504 /* need to dump the string table too... */
2509 /* Assign file positions for all the reloc sections which are not part
2510 of the loadable file image. */
2513 assign_file_positions_for_relocs (abfd
)
2518 Elf_Internal_Shdr
**shdrpp
;
2520 off
= elf_tdata (abfd
)->next_file_pos
;
2522 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2523 i
< elf_elfheader (abfd
)->e_shnum
;
2526 Elf_Internal_Shdr
*shdrp
;
2529 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2530 && shdrp
->sh_offset
== -1)
2531 off
= assign_file_position_for_section (shdrp
, off
, true);
2534 elf_tdata (abfd
)->next_file_pos
= off
;
2538 NAME(bfd_elf
,write_object_contents
) (abfd
)
2541 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2542 Elf_Internal_Ehdr
*i_ehdrp
;
2543 Elf_Internal_Shdr
**i_shdrp
;
2546 if (! abfd
->output_has_begun
2547 && ! elf_compute_section_file_positions (abfd
,
2548 (struct bfd_link_info
*) NULL
))
2551 i_shdrp
= elf_elfsections (abfd
);
2552 i_ehdrp
= elf_elfheader (abfd
);
2554 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2555 assign_file_positions_for_relocs (abfd
);
2557 /* After writing the headers, we need to write the sections too... */
2558 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2560 if (bed
->elf_backend_section_processing
)
2561 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2562 if (i_shdrp
[count
]->contents
)
2564 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2565 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2567 != i_shdrp
[count
]->sh_size
))
2572 /* Write out the section header names. */
2573 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2574 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2577 if (bed
->elf_backend_final_write_processing
)
2578 (*bed
->elf_backend_final_write_processing
) (abfd
,
2579 elf_tdata (abfd
)->linker
);
2581 return write_shdrs_and_ehdr (abfd
);
2584 /* Given an ELF section number, retrieve the corresponding BFD
2588 section_from_elf_index (abfd
, index
)
2592 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2593 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2595 return elf_elfsections (abfd
)[index
]->bfd_section
;
2598 /* given a section, search the header to find them... */
2600 elf_section_from_bfd_section (abfd
, asect
)
2604 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2605 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2607 Elf_Internal_Shdr
*hdr
;
2608 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2610 for (index
= 0; index
< maxindex
; index
++)
2612 hdr
= i_shdrp
[index
];
2613 if (hdr
->bfd_section
== asect
)
2617 if (bed
->elf_backend_section_from_bfd_section
)
2619 for (index
= 0; index
< maxindex
; index
++)
2623 hdr
= i_shdrp
[index
];
2625 if ((*bed
->elf_backend_section_from_bfd_section
)
2626 (abfd
, hdr
, asect
, &retval
))
2631 if (bfd_is_abs_section (asect
))
2633 if (bfd_is_com_section (asect
))
2635 if (bfd_is_und_section (asect
))
2641 /* given a symbol, return the bfd index for that symbol. */
2643 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2645 struct symbol_cache_entry
**asym_ptr_ptr
;
2647 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2649 flagword flags
= asym_ptr
->flags
;
2651 /* When gas creates relocations against local labels, it creates its
2652 own symbol for the section, but does put the symbol into the
2653 symbol chain, so udata is 0. When the linker is generating
2654 relocatable output, this section symbol may be for one of the
2655 input sections rather than the output section. */
2656 if (asym_ptr
->udata
.i
== 0
2657 && (flags
& BSF_SECTION_SYM
)
2658 && asym_ptr
->section
)
2662 if (asym_ptr
->section
->output_section
!= NULL
)
2663 indx
= asym_ptr
->section
->output_section
->index
;
2665 indx
= asym_ptr
->section
->index
;
2666 if (elf_section_syms (abfd
)[indx
])
2667 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2670 idx
= asym_ptr
->udata
.i
;
2678 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2679 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2688 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2690 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2693 Elf_Internal_Shdr
*hdr
;
2694 long symcount
; /* Number of external ELF symbols */
2695 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2696 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2697 Elf_Internal_Sym i_sym
;
2698 Elf_External_Sym
*x_symp
= NULL
;
2700 /* Read each raw ELF symbol, converting from external ELF form to
2701 internal ELF form, and then using the information to create a
2702 canonical bfd symbol table entry.
2704 Note that we allocate the initial bfd canonical symbol buffer
2705 based on a one-to-one mapping of the ELF symbols to canonical
2706 symbols. We actually use all the ELF symbols, so there will be no
2707 space left over at the end. When we have all the symbols, we
2708 build the caller's pointer vector. */
2711 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2713 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2714 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2717 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2720 sym
= symbase
= NULL
;
2725 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2728 symbase
= ((elf_symbol_type
*)
2729 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2730 if (symbase
== (elf_symbol_type
*) NULL
)
2732 bfd_set_error (bfd_error_no_memory
);
2737 /* Temporarily allocate room for the raw ELF symbols. */
2738 x_symp
= ((Elf_External_Sym
*)
2739 malloc (symcount
* sizeof (Elf_External_Sym
)));
2740 if (x_symp
== NULL
&& symcount
!= 0)
2742 bfd_set_error (bfd_error_no_memory
);
2746 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2747 != symcount
* sizeof (Elf_External_Sym
))
2749 /* Skip first symbol, which is a null dummy. */
2750 for (i
= 1; i
< symcount
; i
++)
2752 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2753 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2754 #ifdef ELF_KEEP_EXTSYM
2755 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2757 sym
->symbol
.the_bfd
= abfd
;
2759 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2762 sym
->symbol
.value
= i_sym
.st_value
;
2764 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2766 sym
->symbol
.section
= section_from_elf_index (abfd
,
2768 if (sym
->symbol
.section
== NULL
)
2770 /* This symbol is in a section for which we did not
2771 create a BFD section. Just use bfd_abs_section,
2772 although it is wrong. FIXME. */
2773 sym
->symbol
.section
= bfd_abs_section_ptr
;
2776 else if (i_sym
.st_shndx
== SHN_ABS
)
2778 sym
->symbol
.section
= bfd_abs_section_ptr
;
2780 else if (i_sym
.st_shndx
== SHN_COMMON
)
2782 sym
->symbol
.section
= bfd_com_section_ptr
;
2783 /* Elf puts the alignment into the `value' field, and
2784 the size into the `size' field. BFD wants to see the
2785 size in the value field, and doesn't care (at the
2786 moment) about the alignment. */
2787 sym
->symbol
.value
= i_sym
.st_size
;
2789 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2791 sym
->symbol
.section
= bfd_und_section_ptr
;
2794 sym
->symbol
.section
= bfd_abs_section_ptr
;
2796 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2798 switch (ELF_ST_BIND (i_sym
.st_info
))
2801 sym
->symbol
.flags
|= BSF_LOCAL
;
2804 sym
->symbol
.flags
|= BSF_GLOBAL
;
2807 sym
->symbol
.flags
|= BSF_WEAK
;
2811 switch (ELF_ST_TYPE (i_sym
.st_info
))
2814 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2817 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2820 sym
->symbol
.flags
|= BSF_FUNCTION
;
2825 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2827 /* Do some backend-specific processing on this symbol. */
2829 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2830 if (ebd
->elf_backend_symbol_processing
)
2831 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2838 /* Do some backend-specific processing on this symbol table. */
2840 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2841 if (ebd
->elf_backend_symbol_table_processing
)
2842 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2845 /* We rely on the zalloc to clear out the final symbol entry. */
2847 symcount
= sym
- symbase
;
2849 /* Fill in the user's symbol pointer vector if needed. */
2857 *symptrs
++ = &sym
->symbol
;
2860 *symptrs
= 0; /* Final null pointer */
2872 /* Return the number of bytes required to hold the symtab vector.
2874 Note that we base it on the count plus 1, since we will null terminate
2875 the vector allocated based on this size. However, the ELF symbol table
2876 always has a dummy entry as symbol #0, so it ends up even. */
2879 elf_get_symtab_upper_bound (abfd
)
2884 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2886 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2887 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2893 elf_get_dynamic_symtab_upper_bound (abfd
)
2898 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2900 if (elf_dynsymtab (abfd
) == 0)
2902 bfd_set_error (bfd_error_invalid_operation
);
2906 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2907 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2913 elf_get_reloc_upper_bound (abfd
, asect
)
2917 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2920 /* Read in and swap the external relocs. */
2923 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2928 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2929 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2930 PTR allocated
= NULL
;
2931 bfd_byte
*native_relocs
;
2937 if (asect
->relocation
!= NULL
2938 || (asect
->flags
& SEC_RELOC
) == 0
2939 || asect
->reloc_count
== 0)
2942 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2943 && (asect
->reloc_count
2944 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2946 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2947 if (allocated
== NULL
)
2949 bfd_set_error (bfd_error_no_memory
);
2953 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2954 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2955 != d
->rel_hdr
.sh_size
))
2958 native_relocs
= (bfd_byte
*) allocated
;
2960 relents
= ((arelent
*)
2961 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2962 if (relents
== NULL
)
2964 bfd_set_error (bfd_error_no_memory
);
2968 entsize
= d
->rel_hdr
.sh_entsize
;
2969 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2970 || entsize
== sizeof (Elf_External_Rela
));
2972 for (i
= 0, relent
= relents
;
2973 i
< asect
->reloc_count
;
2974 i
++, relent
++, native_relocs
+= entsize
)
2976 Elf_Internal_Rela rela
;
2977 Elf_Internal_Rel rel
;
2979 if (entsize
== sizeof (Elf_External_Rela
))
2980 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2983 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2984 rela
.r_offset
= rel
.r_offset
;
2985 rela
.r_info
= rel
.r_info
;
2989 /* The address of an ELF reloc is section relative for an object
2990 file, and absolute for an executable file or shared library.
2991 The address of a BFD reloc is always section relative. */
2992 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2993 relent
->address
= rela
.r_offset
;
2995 relent
->address
= rela
.r_offset
- asect
->vma
;
2997 if (ELF_R_SYM (rela
.r_info
) == 0)
2998 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3003 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3006 /* Canonicalize ELF section symbols. FIXME: Why? */
3007 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3008 relent
->sym_ptr_ptr
= ps
;
3010 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3013 relent
->addend
= rela
.r_addend
;
3015 if (entsize
== sizeof (Elf_External_Rela
))
3016 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3018 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3021 asect
->relocation
= relents
;
3023 if (allocated
!= NULL
)
3029 if (allocated
!= NULL
)
3036 elf_debug_section (num
, hdr
)
3038 Elf_Internal_Shdr
*hdr
;
3040 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3041 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3044 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3045 (long) hdr
->sh_name
,
3046 (long) hdr
->sh_type
,
3047 (long) hdr
->sh_flags
);
3049 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3050 (long) hdr
->sh_addr
,
3051 (long) hdr
->sh_offset
,
3052 (long) hdr
->sh_size
);
3054 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3055 (long) hdr
->sh_link
,
3056 (long) hdr
->sh_info
,
3057 (long) hdr
->sh_addralign
);
3058 fprintf (stderr
, "sh_entsize = %ld\n",
3059 (long) hdr
->sh_entsize
);
3064 elf_debug_file (ehdrp
)
3065 Elf_Internal_Ehdr
*ehdrp
;
3067 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3068 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3069 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3070 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3071 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3072 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3073 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3077 /* Canonicalize the relocs. */
3080 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3089 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3092 tblptr
= section
->relocation
;
3093 for (i
= 0; i
< section
->reloc_count
; i
++)
3094 *relptr
++ = tblptr
++;
3098 return section
->reloc_count
;
3102 elf_get_symtab (abfd
, alocation
)
3104 asymbol
**alocation
;
3106 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3109 bfd_get_symcount (abfd
) = symcount
;
3114 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3116 asymbol
**alocation
;
3118 return elf_slurp_symbol_table (abfd
, alocation
, true);
3122 elf_make_empty_symbol (abfd
)
3125 elf_symbol_type
*newsym
;
3127 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3130 bfd_set_error (bfd_error_no_memory
);
3135 newsym
->symbol
.the_bfd
= abfd
;
3136 return &newsym
->symbol
;
3141 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3146 bfd_symbol_info (symbol
, ret
);
3150 elf_get_lineno (ignore_abfd
, symbol
)
3154 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3161 elf_set_arch_mach (abfd
, arch
, machine
)
3163 enum bfd_architecture arch
;
3164 unsigned long machine
;
3166 /* If this isn't the right architecture for this backend, and this
3167 isn't the generic backend, fail. */
3168 if (arch
!= get_elf_backend_data (abfd
)->arch
3169 && arch
!= bfd_arch_unknown
3170 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3173 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3177 elf_find_nearest_line (abfd
,
3188 CONST
char **filename_ptr
;
3189 CONST
char **functionname_ptr
;
3190 unsigned int *line_ptr
;
3196 elf_sizeof_headers (abfd
, reloc
)
3202 ret
= sizeof (Elf_External_Ehdr
);
3204 ret
+= get_program_header_size (abfd
);
3209 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3214 bfd_size_type count
;
3216 Elf_Internal_Shdr
*hdr
;
3218 if (! abfd
->output_has_begun
3219 && ! elf_compute_section_file_positions (abfd
,
3220 (struct bfd_link_info
*) NULL
))
3223 hdr
= &elf_section_data (section
)->this_hdr
;
3225 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3227 if (bfd_write (location
, 1, count
, abfd
) != count
)
3234 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3237 Elf_Internal_Rela
*dst
;
3239 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3245 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3248 Elf_Internal_Rel
*dst
;
3250 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3256 /* Core file support */
3258 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3259 #include <sys/procfs.h>
3261 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3262 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3263 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3269 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3276 prstatus_t
*status
= (prstatus_t
*) 0;
3278 if (descsz
== sizeof (prstatus_t
))
3280 newsect
= bfd_make_section (abfd
, ".reg");
3281 if (newsect
== NULL
)
3283 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3284 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3285 newsect
->flags
= SEC_HAS_CONTENTS
;
3286 newsect
->alignment_power
= 2;
3287 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3289 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3295 /* Stash a copy of the prpsinfo structure away for future use. */
3298 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3304 if (descsz
== sizeof (prpsinfo_t
))
3306 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3308 bfd_set_error (bfd_error_no_memory
);
3311 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3317 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3325 newsect
= bfd_make_section (abfd
, ".reg2");
3326 if (newsect
== NULL
)
3328 newsect
->_raw_size
= descsz
;
3329 newsect
->filepos
= filepos
;
3330 newsect
->flags
= SEC_HAS_CONTENTS
;
3331 newsect
->alignment_power
= 2;
3335 #endif /* HAVE_PROCFS */
3337 /* Return a pointer to the args (including the command name) that were
3338 seen by the program that generated the core dump. Note that for
3339 some reason, a spurious space is tacked onto the end of the args
3340 in some (at least one anyway) implementations, so strip it off if
3344 elf_core_file_failing_command (abfd
)
3348 if (core_prpsinfo (abfd
))
3350 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3351 char *scan
= p
->pr_psargs
;
3356 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3360 return p
->pr_psargs
;
3366 /* Return the number of the signal that caused the core dump. Presumably,
3367 since we have a core file, we got a signal of some kind, so don't bother
3368 checking the other process status fields, just return the signal number.
3372 elf_core_file_failing_signal (abfd
)
3376 if (core_prstatus (abfd
))
3378 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3384 /* Check to see if the core file could reasonably be expected to have
3385 come for the current executable file. Note that by default we return
3386 true unless we find something that indicates that there might be a
3391 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3400 /* First, xvecs must match since both are ELF files for the same target. */
3402 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3404 bfd_set_error (bfd_error_system_call
);
3410 /* If no prpsinfo, just return true. Otherwise, grab the last component
3411 of the exec'd pathname from the prpsinfo. */
3413 if (core_prpsinfo (core_bfd
))
3415 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3422 /* Find the last component of the executable pathname. */
3424 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3430 execname
= (char *) exec_bfd
->filename
;
3433 /* See if they match */
3435 return strcmp (execname
, corename
) ? false : true;
3441 #endif /* HAVE_PROCFS */
3444 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3445 the information that would normally be available from the /proc interface
3446 for the process, at the time the process dumped core. Currently this
3447 includes copies of the prstatus, prpsinfo, and fpregset structures.
3449 Since these structures are potentially machine dependent in size and
3450 ordering, bfd provides two levels of support for them. The first level,
3451 available on all machines since it does not require that the host
3452 have /proc support or the relevant include files, is to create a bfd
3453 section for each of the prstatus, prpsinfo, and fpregset structures,
3454 without any interpretation of their contents. With just this support,
3455 the bfd client will have to interpret the structures itself. Even with
3456 /proc support, it might want these full structures for it's own reasons.
3458 In the second level of support, where HAVE_PROCFS is defined, bfd will
3459 pick apart the structures to gather some additional information that
3460 clients may want, such as the general register set, the name of the
3461 exec'ed file and its arguments, the signal (if any) that caused the
3467 elf_corefile_note (abfd
, hdr
)
3469 Elf_Internal_Phdr
*hdr
;
3471 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3472 Elf_Internal_Note i_note
; /* Elf note, internal form */
3473 char *buf
= NULL
; /* Entire note segment contents */
3474 char *namedata
; /* Name portion of the note */
3475 char *descdata
; /* Descriptor portion of the note */
3476 char *sectname
; /* Name to use for new section */
3477 long filepos
; /* File offset to descriptor data */
3480 if (hdr
->p_filesz
> 0
3481 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3482 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3483 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3485 x_note_p
= (Elf_External_Note
*) buf
;
3486 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3488 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3489 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3490 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3491 namedata
= x_note_p
->name
;
3492 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3493 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3494 switch (i_note
.type
)
3497 /* process descdata as prstatus info */
3498 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3500 sectname
= ".prstatus";
3503 /* process descdata as fpregset info */
3504 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3506 sectname
= ".fpregset";
3509 /* process descdata as prpsinfo */
3510 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3512 sectname
= ".prpsinfo";
3515 /* Unknown descriptor, just ignore it. */
3519 if (sectname
!= NULL
)
3521 newsect
= bfd_make_section (abfd
, sectname
);
3522 if (newsect
== NULL
)
3524 newsect
->_raw_size
= i_note
.descsz
;
3525 newsect
->filepos
= filepos
;
3526 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3527 newsect
->alignment_power
= 2;
3529 x_note_p
= (Elf_External_Note
*)
3530 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3537 else if (hdr
->p_filesz
> 0)
3539 bfd_set_error (bfd_error_no_memory
);
3546 /* Core files are simply standard ELF formatted files that partition
3547 the file using the execution view of the file (program header table)
3548 rather than the linking view. In fact, there is no section header
3549 table in a core file.
3551 The process status information (including the contents of the general
3552 register set) and the floating point register set are stored in a
3553 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3554 that allow standard bfd access to the general registers (.reg) and the
3555 floating point registers (.reg2).
3560 elf_core_file_p (abfd
)
3563 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3564 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3565 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3566 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3567 unsigned int phindex
;
3568 struct elf_backend_data
*ebd
;
3570 /* Read in the ELF header in external format. */
3572 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3574 if (bfd_get_error () != bfd_error_system_call
)
3575 bfd_set_error (bfd_error_wrong_format
);
3579 /* Now check to see if we have a valid ELF file, and one that BFD can
3580 make use of. The magic number must match, the address size ('class')
3581 and byte-swapping must match our XVEC entry, and it must have a
3582 program header table (FIXME: See comments re segments at top of this
3585 if (elf_file_p (&x_ehdr
) == false)
3588 bfd_set_error (bfd_error_wrong_format
);
3592 /* FIXME, Check EI_VERSION here ! */
3596 int desired_address_size
= ELFCLASS32
;
3599 int desired_address_size
= ELFCLASS64
;
3602 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3606 /* Switch xvec to match the specified byte order. */
3607 switch (x_ehdr
.e_ident
[EI_DATA
])
3609 case ELFDATA2MSB
: /* Big-endian */
3610 if (abfd
->xvec
->byteorder_big_p
== false)
3613 case ELFDATA2LSB
: /* Little-endian */
3614 if (abfd
->xvec
->byteorder_big_p
== true)
3617 case ELFDATANONE
: /* No data encoding specified */
3618 default: /* Unknown data encoding specified */
3622 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3623 the tdata pointer in the bfd. */
3626 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3627 if (elf_tdata (abfd
) == NULL
)
3629 bfd_set_error (bfd_error_no_memory
);
3633 /* FIXME, `wrong' returns from this point onward, leak memory. */
3635 /* Now that we know the byte order, swap in the rest of the header */
3636 i_ehdrp
= elf_elfheader (abfd
);
3637 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3639 elf_debug_file (i_ehdrp
);
3642 ebd
= get_elf_backend_data (abfd
);
3644 /* Check that the ELF e_machine field matches what this particular
3645 BFD format expects. */
3646 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3648 const bfd_target
* const *target_ptr
;
3650 if (ebd
->elf_machine_code
!= EM_NONE
)
3653 /* This is the generic ELF target. Let it match any ELF target
3654 for which we do not have a specific backend. */
3655 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3657 struct elf_backend_data
*back
;
3659 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3661 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3662 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3664 /* target_ptr is an ELF backend which matches this
3665 object file, so reject the generic ELF target. */
3671 /* If there is no program header, or the type is not a core file, then
3673 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3676 /* Allocate space for a copy of the program header table in
3677 internal form, seek to the program header table in the file,
3678 read it in, and convert it to internal form. As a simple sanity
3679 check, verify that the what BFD thinks is the size of each program
3680 header table entry actually matches the size recorded in the file. */
3682 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3684 i_phdrp
= (Elf_Internal_Phdr
*)
3685 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3688 bfd_set_error (bfd_error_no_memory
);
3691 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3693 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3695 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3698 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3701 /* Once all of the program headers have been read and converted, we
3702 can start processing them. */
3704 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3706 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3707 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3709 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3714 /* Remember the entry point specified in the ELF file header. */
3716 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3721 /* ELF linker code. */
3723 static boolean elf_link_add_object_symbols
3724 PARAMS ((bfd
*, struct bfd_link_info
*));
3725 static boolean elf_link_add_archive_symbols
3726 PARAMS ((bfd
*, struct bfd_link_info
*));
3727 static Elf_Internal_Rela
*elf_link_read_relocs
3728 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3729 static boolean elf_export_symbol
3730 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3731 static boolean elf_adjust_dynamic_symbol
3732 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3734 /* Given an ELF BFD, add symbols to the global hash table as
3738 elf_bfd_link_add_symbols (abfd
, info
)
3740 struct bfd_link_info
*info
;
3744 switch (bfd_get_format (abfd
))
3747 return elf_link_add_object_symbols (abfd
, info
);
3749 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3752 if (! bfd_check_format (first
, bfd_object
))
3754 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3756 /* On Linux, we may have an a.out archive which got
3757 recognized as an ELF archive. Therefore, we treat all
3758 archives as though they were actually of the flavour of
3759 their first element. */
3760 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3762 return elf_link_add_archive_symbols (abfd
, info
);
3764 bfd_set_error (bfd_error_wrong_format
);
3769 /* Add symbols from an ELF archive file to the linker hash table. We
3770 don't use _bfd_generic_link_add_archive_symbols because of a
3771 problem which arises on UnixWare. The UnixWare libc.so is an
3772 archive which includes an entry libc.so.1 which defines a bunch of
3773 symbols. The libc.so archive also includes a number of other
3774 object files, which also define symbols, some of which are the same
3775 as those defined in libc.so.1. Correct linking requires that we
3776 consider each object file in turn, and include it if it defines any
3777 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3778 this; it looks through the list of undefined symbols, and includes
3779 any object file which defines them. When this algorithm is used on
3780 UnixWare, it winds up pulling in libc.so.1 early and defining a
3781 bunch of symbols. This means that some of the other objects in the
3782 archive are not included in the link, which is incorrect since they
3783 precede libc.so.1 in the archive.
3785 Fortunately, ELF archive handling is simpler than that done by
3786 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3787 oddities. In ELF, if we find a symbol in the archive map, and the
3788 symbol is currently undefined, we know that we must pull in that
3791 Unfortunately, we do have to make multiple passes over the symbol
3792 table until nothing further is resolved. */
3795 elf_link_add_archive_symbols (abfd
, info
)
3797 struct bfd_link_info
*info
;
3800 boolean
*defined
= NULL
;
3801 boolean
*included
= NULL
;
3805 if (! bfd_has_map (abfd
))
3807 /* An empty archive is a special case. */
3808 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3810 bfd_set_error (bfd_error_no_symbols
);
3814 /* Keep track of all symbols we know to be already defined, and all
3815 files we know to be already included. This is to speed up the
3816 second and subsequent passes. */
3817 c
= bfd_ardata (abfd
)->symdef_count
;
3820 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3821 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3822 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3824 bfd_set_error (bfd_error_no_memory
);
3827 memset (defined
, 0, c
* sizeof (boolean
));
3828 memset (included
, 0, c
* sizeof (boolean
));
3830 symdefs
= bfd_ardata (abfd
)->symdefs
;
3843 symdefend
= symdef
+ c
;
3844 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3846 struct elf_link_hash_entry
*h
;
3848 struct bfd_link_hash_entry
*undefs_tail
;
3851 if (defined
[i
] || included
[i
])
3853 if (symdef
->file_offset
== last
)
3859 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3860 false, false, false);
3861 if (h
== (struct elf_link_hash_entry
*) NULL
)
3863 if (h
->root
.type
!= bfd_link_hash_undefined
)
3869 /* We need to include this archive member. */
3871 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3872 if (element
== (bfd
*) NULL
)
3875 if (! bfd_check_format (element
, bfd_object
))
3878 /* Doublecheck that we have not included this object
3879 already--it should be impossible, but there may be
3880 something wrong with the archive. */
3881 if (element
->archive_pass
!= 0)
3883 bfd_set_error (bfd_error_bad_value
);
3886 element
->archive_pass
= 1;
3888 undefs_tail
= info
->hash
->undefs_tail
;
3890 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3893 if (! elf_link_add_object_symbols (element
, info
))
3896 /* If there are any new undefined symbols, we need to make
3897 another pass through the archive in order to see whether
3898 they can be defined. FIXME: This isn't perfect, because
3899 common symbols wind up on undefs_tail and because an
3900 undefined symbol which is defined later on in this pass
3901 does not require another pass. This isn't a bug, but it
3902 does make the code less efficient than it could be. */
3903 if (undefs_tail
!= info
->hash
->undefs_tail
)
3906 /* Look backward to mark all symbols from this object file
3907 which we have already seen in this pass. */
3911 included
[mark
] = true;
3916 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3918 /* We mark subsequent symbols from this object file as we go
3919 on through the loop. */
3920 last
= symdef
->file_offset
;
3931 if (defined
!= (boolean
*) NULL
)
3933 if (included
!= (boolean
*) NULL
)
3938 /* Record a new dynamic symbol. We record the dynamic symbols as we
3939 read the input files, since we need to have a list of all of them
3940 before we can determine the final sizes of the output sections.
3941 Note that we may actually call this function even though we are not
3942 going to output any dynamic symbols; in some cases we know that a
3943 symbol should be in the dynamic symbol table, but only if there is
3947 elf_link_record_dynamic_symbol (info
, h
)
3948 struct bfd_link_info
*info
;
3949 struct elf_link_hash_entry
*h
;
3951 if (h
->dynindx
== -1)
3953 struct bfd_strtab_hash
*dynstr
;
3955 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3956 ++elf_hash_table (info
)->dynsymcount
;
3958 dynstr
= elf_hash_table (info
)->dynstr
;
3961 /* Create a strtab to hold the dynamic symbol names. */
3962 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3967 h
->dynstr_index
= ((unsigned long)
3968 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3970 if (h
->dynstr_index
== (unsigned long) -1)
3977 /* Add symbols from an ELF object file to the linker hash table. */
3980 elf_link_add_object_symbols (abfd
, info
)
3982 struct bfd_link_info
*info
;
3984 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3985 const Elf_Internal_Sym
*,
3986 const char **, flagword
*,
3987 asection
**, bfd_vma
*));
3988 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3989 asection
*, const Elf_Internal_Rela
*));
3991 Elf_Internal_Shdr
*hdr
;
3995 Elf_External_Sym
*buf
= NULL
;
3996 struct elf_link_hash_entry
**sym_hash
;
3998 Elf_External_Dyn
*dynbuf
= NULL
;
3999 struct elf_link_hash_entry
*weaks
;
4000 Elf_External_Sym
*esym
;
4001 Elf_External_Sym
*esymend
;
4003 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4004 collect
= get_elf_backend_data (abfd
)->collect
;
4006 /* A stripped shared library might only have a dynamic symbol table,
4007 not a regular symbol table. In that case we can still go ahead
4008 and link using the dynamic symbol table. */
4009 if (elf_onesymtab (abfd
) == 0
4010 && elf_dynsymtab (abfd
) != 0)
4012 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4013 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4016 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4017 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4019 /* The sh_info field of the symtab header tells us where the
4020 external symbols start. We don't care about the local symbols at
4022 if (elf_bad_symtab (abfd
))
4024 extsymcount
= symcount
;
4029 extsymcount
= symcount
- hdr
->sh_info
;
4030 extsymoff
= hdr
->sh_info
;
4033 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4034 if (buf
== NULL
&& extsymcount
!= 0)
4036 bfd_set_error (bfd_error_no_memory
);
4040 /* We store a pointer to the hash table entry for each external
4042 sym_hash
= ((struct elf_link_hash_entry
**)
4044 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4045 if (sym_hash
== NULL
)
4047 bfd_set_error (bfd_error_no_memory
);
4050 elf_sym_hashes (abfd
) = sym_hash
;
4052 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4056 /* If we are creating a shared library, create all the dynamic
4057 sections immediately. We need to attach them to something,
4058 so we attach them to this BFD, provided it is the right
4059 format. FIXME: If there are no input BFD's of the same
4060 format as the output, we can't make a shared library. */
4062 && ! elf_hash_table (info
)->dynamic_sections_created
4063 && abfd
->xvec
== info
->hash
->creator
)
4065 if (! elf_link_create_dynamic_sections (abfd
, info
))
4073 bfd_size_type strindex
;
4077 /* You can't use -r against a dynamic object. Also, there's no
4078 hope of using a dynamic object which does not exactly match
4079 the format of the output file. */
4080 if (info
->relocateable
4081 || info
->hash
->creator
!= abfd
->xvec
)
4083 bfd_set_error (bfd_error_invalid_operation
);
4087 /* Find the name to use in a DT_NEEDED entry that refers to this
4088 object. If the object has a DT_SONAME entry, we use it.
4089 Otherwise, if the generic linker stuck something in
4090 elf_dt_needed_name, we use that. Otherwise, we just use the
4092 name
= bfd_get_filename (abfd
);
4093 if (elf_dt_needed_name (abfd
) != NULL
)
4094 name
= elf_dt_needed_name (abfd
);
4095 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4098 Elf_External_Dyn
*extdyn
;
4099 Elf_External_Dyn
*extdynend
;
4101 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4104 bfd_set_error (bfd_error_no_memory
);
4108 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4109 (file_ptr
) 0, s
->_raw_size
))
4113 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4114 for (; extdyn
< extdynend
; extdyn
++)
4116 Elf_Internal_Dyn dyn
;
4118 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4119 if (dyn
.d_tag
== DT_SONAME
)
4124 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4127 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4128 name
= elf_string_from_elf_section (abfd
, link
,
4141 /* We do not want to include any of the sections in a dynamic
4142 object in the output file. We hack by simply clobbering the
4143 list of sections in the BFD. This could be handled more
4144 cleanly by, say, a new section flag; the existing
4145 SEC_NEVER_LOAD flag is not the one we want, because that one
4146 still implies that the section takes up space in the output
4148 abfd
->sections
= NULL
;
4150 /* If this is the first dynamic object found in the link, create
4151 the special sections required for dynamic linking. */
4152 if (! elf_hash_table (info
)->dynamic_sections_created
)
4154 if (! elf_link_create_dynamic_sections (abfd
, info
))
4158 /* Add a DT_NEEDED entry for this dynamic object. */
4159 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4161 if (strindex
== (bfd_size_type
) -1)
4163 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4168 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4170 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4171 != extsymcount
* sizeof (Elf_External_Sym
)))
4176 esymend
= buf
+ extsymcount
;
4177 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4179 Elf_Internal_Sym sym
;
4185 struct elf_link_hash_entry
*h
= NULL
;
4188 elf_swap_symbol_in (abfd
, esym
, &sym
);
4190 flags
= BSF_NO_FLAGS
;
4192 value
= sym
.st_value
;
4195 bind
= ELF_ST_BIND (sym
.st_info
);
4196 if (bind
== STB_LOCAL
)
4198 /* This should be impossible, since ELF requires that all
4199 global symbols follow all local symbols, and that sh_info
4200 point to the first global symbol. Unfortunatealy, Irix 5
4204 else if (bind
== STB_GLOBAL
)
4206 else if (bind
== STB_WEAK
)
4210 /* Leave it up to the processor backend. */
4213 if (sym
.st_shndx
== SHN_UNDEF
)
4214 sec
= bfd_und_section_ptr
;
4215 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4217 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4221 sec
= bfd_abs_section_ptr
;
4223 else if (sym
.st_shndx
== SHN_ABS
)
4224 sec
= bfd_abs_section_ptr
;
4225 else if (sym
.st_shndx
== SHN_COMMON
)
4227 sec
= bfd_com_section_ptr
;
4228 /* What ELF calls the size we call the value. What ELF
4229 calls the value we call the alignment. */
4230 value
= sym
.st_size
;
4234 /* Leave it up to the processor backend. */
4237 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4238 if (name
== (const char *) NULL
)
4241 if (add_symbol_hook
)
4243 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4247 /* The hook function sets the name to NULL if this symbol
4248 should be skipped for some reason. */
4249 if (name
== (const char *) NULL
)
4253 /* Sanity check that all possibilities were handled. */
4254 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4256 bfd_set_error (bfd_error_bad_value
);
4260 if (bfd_is_und_section (sec
)
4261 || bfd_is_com_section (sec
))
4266 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4268 /* We need to look up the symbol now in order to get some of
4269 the dynamic object handling right. We pass the hash
4270 table entry in to _bfd_generic_link_add_one_symbol so
4271 that it does not have to look it up again. */
4272 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4273 true, false, false);
4278 /* If we are looking at a dynamic object, and this is a
4279 definition, we need to see if it has already been defined
4280 by some other object. If it has, we want to use the
4281 existing definition, and we do not want to report a
4282 multiple symbol definition error; we do this by
4283 clobbering sec to be bfd_und_section_ptr. */
4284 if (dynamic
&& definition
)
4286 if (h
->root
.type
== bfd_link_hash_defined
)
4287 sec
= bfd_und_section_ptr
;
4290 /* Similarly, if we are not looking at a dynamic object, and
4291 we have a definition, we want to override any definition
4292 we may have from a dynamic object. Symbols from regular
4293 files always take precedence over symbols from dynamic
4294 objects, even if they are defined after the dynamic
4295 object in the link. */
4298 && h
->root
.type
== bfd_link_hash_defined
4299 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4300 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4301 == bfd_target_elf_flavour
)
4302 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4305 /* Change the hash table entry to undefined, and let
4306 _bfd_generic_link_add_one_symbol do the right thing
4307 with the new definition. */
4308 h
->root
.type
= bfd_link_hash_undefined
;
4309 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4310 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4313 /* If this is a weak definition which we are going to use,
4314 and the symbol is currently undefined, record that the
4315 definition is weak. */
4317 && (flags
& BSF_WEAK
) != 0
4318 && ! bfd_is_und_section (sec
)
4319 && (h
->root
.type
== bfd_link_hash_new
4320 || h
->root
.type
== bfd_link_hash_undefined
4321 || h
->root
.type
== bfd_link_hash_weak
))
4322 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4325 if (! (_bfd_generic_link_add_one_symbol
4326 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4327 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4332 && (flags
& BSF_WEAK
) != 0
4333 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4334 && (*sym_hash
)->weakdef
== NULL
)
4336 /* Keep a list of all weak defined non function symbols from
4337 a dynamic object, using the weakdef field. Later in this
4338 function we will set the weakdef field to the correct
4339 value. We only put non-function symbols from dynamic
4340 objects on this list, because that happens to be the only
4341 time we need to know the normal symbol corresponding to a
4342 weak symbol, and the information is time consuming to
4343 figure out. If the weakdef field is not already NULL,
4344 then this symbol was already defined by some previous
4345 dynamic object, and we will be using that previous
4346 definition anyhow. */
4348 (*sym_hash
)->weakdef
= weaks
;
4352 /* Get the alignment of a common symbol. */
4353 if (sym
.st_shndx
== SHN_COMMON
4354 && h
->root
.type
== bfd_link_hash_common
)
4355 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4357 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4363 /* Remember the symbol size and type. */
4364 if (sym
.st_size
!= 0)
4366 /* FIXME: We should probably somehow give a warning if
4367 the symbol size changes. */
4368 h
->size
= sym
.st_size
;
4370 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4372 /* FIXME: We should probably somehow give a warning if
4373 the symbol type changes. */
4374 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4377 /* Set a flag in the hash table entry indicating the type of
4378 reference or definition we just found. Keep a count of
4379 the number of dynamic symbols we find. A dynamic symbol
4380 is one which is referenced or defined by both a regular
4381 object and a shared object, or one which is referenced or
4382 defined by more than one shared object. */
4383 old_flags
= h
->elf_link_hash_flags
;
4388 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4390 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4392 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4393 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4399 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4401 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4402 if ((old_flags
& new_flag
) != 0
4403 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4404 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4408 h
->elf_link_hash_flags
|= new_flag
;
4409 if (dynsym
&& h
->dynindx
== -1)
4411 if (! elf_link_record_dynamic_symbol (info
, h
))
4417 /* Now set the weakdefs field correctly for all the weak defined
4418 symbols we found. The only way to do this is to search all the
4419 symbols. Since we only need the information for non functions in
4420 dynamic objects, that's the only time we actually put anything on
4421 the list WEAKS. We need this information so that if a regular
4422 object refers to a symbol defined weakly in a dynamic object, the
4423 real symbol in the dynamic object is also put in the dynamic
4424 symbols; we also must arrange for both symbols to point to the
4425 same memory location. We could handle the general case of symbol
4426 aliasing, but a general symbol alias can only be generated in
4427 assembler code, handling it correctly would be very time
4428 consuming, and other ELF linkers don't handle general aliasing
4430 while (weaks
!= NULL
)
4432 struct elf_link_hash_entry
*hlook
;
4435 struct elf_link_hash_entry
**hpp
;
4436 struct elf_link_hash_entry
**hppend
;
4439 weaks
= hlook
->weakdef
;
4440 hlook
->weakdef
= NULL
;
4442 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4443 slook
= hlook
->root
.u
.def
.section
;
4444 vlook
= hlook
->root
.u
.def
.value
;
4446 hpp
= elf_sym_hashes (abfd
);
4447 hppend
= hpp
+ extsymcount
;
4448 for (; hpp
< hppend
; hpp
++)
4450 struct elf_link_hash_entry
*h
;
4454 && h
->root
.type
== bfd_link_hash_defined
4455 && h
->root
.u
.def
.section
== slook
4456 && h
->root
.u
.def
.value
== vlook
)
4460 /* If the weak definition is in the list of dynamic
4461 symbols, make sure the real definition is put there
4463 if (hlook
->dynindx
!= -1
4464 && h
->dynindx
== -1)
4466 if (! elf_link_record_dynamic_symbol (info
, h
))
4481 /* If this object is the same format as the output object, and it is
4482 not a shared library, then let the backend look through the
4485 This is required to build global offset table entries and to
4486 arrange for dynamic relocs. It is not required for the
4487 particular common case of linking non PIC code, even when linking
4488 against shared libraries, but unfortunately there is no way of
4489 knowing whether an object file has been compiled PIC or not.
4490 Looking through the relocs is not particularly time consuming.
4491 The problem is that we must either (1) keep the relocs in memory,
4492 which causes the linker to require additional runtime memory or
4493 (2) read the relocs twice from the input file, which wastes time.
4494 This would be a good case for using mmap.
4496 I have no idea how to handle linking PIC code into a file of a
4497 different format. It probably can't be done. */
4498 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4500 && abfd
->xvec
== info
->hash
->creator
4501 && check_relocs
!= NULL
)
4505 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4507 Elf_Internal_Rela
*internal_relocs
;
4510 if ((o
->flags
& SEC_RELOC
) == 0
4511 || o
->reloc_count
== 0)
4514 /* I believe we can ignore the relocs for any section which
4515 does not form part of the final process image, such as a
4516 debugging section. */
4517 if ((o
->flags
& SEC_ALLOC
) == 0)
4520 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4521 (Elf_Internal_Rela
*) NULL
,
4523 if (internal_relocs
== NULL
)
4526 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4528 if (! info
->keep_memory
)
4529 free (internal_relocs
);
4546 /* Create some sections which will be filled in with dynamic linking
4547 information. ABFD is an input file which requires dynamic sections
4548 to be created. The dynamic sections take up virtual memory space
4549 when the final executable is run, so we need to create them before
4550 addresses are assigned to the output sections. We work out the
4551 actual contents and size of these sections later. */
4554 elf_link_create_dynamic_sections (abfd
, info
)
4556 struct bfd_link_info
*info
;
4559 register asection
*s
;
4560 struct elf_link_hash_entry
*h
;
4561 struct elf_backend_data
*bed
;
4563 if (elf_hash_table (info
)->dynamic_sections_created
)
4566 /* Make sure that all dynamic sections use the same input BFD. */
4567 if (elf_hash_table (info
)->dynobj
== NULL
)
4568 elf_hash_table (info
)->dynobj
= abfd
;
4570 abfd
= elf_hash_table (info
)->dynobj
;
4572 /* Note that we set the SEC_IN_MEMORY flag for all of these
4574 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4576 /* A dynamically linked executable has a .interp section, but a
4577 shared library does not. */
4580 s
= bfd_make_section (abfd
, ".interp");
4582 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4586 s
= bfd_make_section (abfd
, ".dynsym");
4588 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4589 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4592 s
= bfd_make_section (abfd
, ".dynstr");
4594 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4597 /* Create a strtab to hold the dynamic symbol names. */
4598 if (elf_hash_table (info
)->dynstr
== NULL
)
4600 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4601 if (elf_hash_table (info
)->dynstr
== NULL
)
4605 s
= bfd_make_section (abfd
, ".dynamic");
4607 || ! bfd_set_section_flags (abfd
, s
, flags
)
4608 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4611 /* The special symbol _DYNAMIC is always set to the start of the
4612 .dynamic section. This call occurs before we have processed the
4613 symbols for any dynamic object, so we don't have to worry about
4614 overriding a dynamic definition. We could set _DYNAMIC in a
4615 linker script, but we only want to define it if we are, in fact,
4616 creating a .dynamic section. We don't want to define it if there
4617 is no .dynamic section, since on some ELF platforms the start up
4618 code examines it to decide how to initialize the process. */
4620 if (! (_bfd_generic_link_add_one_symbol
4621 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4622 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4623 (struct bfd_link_hash_entry
**) &h
)))
4625 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4626 h
->type
= STT_OBJECT
;
4629 && ! elf_link_record_dynamic_symbol (info
, h
))
4632 s
= bfd_make_section (abfd
, ".hash");
4634 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4635 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4638 /* Let the backend create the rest of the sections. This lets the
4639 backend set the right flags. The backend will normally create
4640 the .got and .plt sections. */
4641 bed
= get_elf_backend_data (abfd
);
4642 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4645 elf_hash_table (info
)->dynamic_sections_created
= true;
4650 /* Add an entry to the .dynamic table. */
4653 elf_add_dynamic_entry (info
, tag
, val
)
4654 struct bfd_link_info
*info
;
4658 Elf_Internal_Dyn dyn
;
4662 bfd_byte
*newcontents
;
4664 dynobj
= elf_hash_table (info
)->dynobj
;
4666 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4667 BFD_ASSERT (s
!= NULL
);
4669 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4670 if (s
->contents
== NULL
)
4671 newcontents
= (bfd_byte
*) malloc (newsize
);
4673 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4674 if (newcontents
== NULL
)
4676 bfd_set_error (bfd_error_no_memory
);
4681 dyn
.d_un
.d_val
= val
;
4682 elf_swap_dyn_out (dynobj
, &dyn
,
4683 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4685 s
->_raw_size
= newsize
;
4686 s
->contents
= newcontents
;
4691 /* Read and swap the relocs for a section. They may have been cached.
4692 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4693 they are used as buffers to read into. They are known to be large
4694 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4695 value is allocated using either malloc or bfd_alloc, according to
4696 the KEEP_MEMORY argument. */
4698 static Elf_Internal_Rela
*
4699 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4702 PTR external_relocs
;
4703 Elf_Internal_Rela
*internal_relocs
;
4704 boolean keep_memory
;
4706 Elf_Internal_Shdr
*rel_hdr
;
4708 Elf_Internal_Rela
*alloc2
= NULL
;
4710 if (elf_section_data (o
)->relocs
!= NULL
)
4711 return elf_section_data (o
)->relocs
;
4713 if (o
->reloc_count
== 0)
4716 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4718 if (internal_relocs
== NULL
)
4722 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4724 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4726 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4727 if (internal_relocs
== NULL
)
4729 bfd_set_error (bfd_error_no_memory
);
4734 if (external_relocs
== NULL
)
4736 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4739 bfd_set_error (bfd_error_no_memory
);
4742 external_relocs
= alloc1
;
4745 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4746 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4747 != rel_hdr
->sh_size
))
4750 /* Swap in the relocs. For convenience, we always produce an
4751 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4753 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4755 Elf_External_Rel
*erel
;
4756 Elf_External_Rel
*erelend
;
4757 Elf_Internal_Rela
*irela
;
4759 erel
= (Elf_External_Rel
*) external_relocs
;
4760 erelend
= erel
+ o
->reloc_count
;
4761 irela
= internal_relocs
;
4762 for (; erel
< erelend
; erel
++, irela
++)
4764 Elf_Internal_Rel irel
;
4766 elf_swap_reloc_in (abfd
, erel
, &irel
);
4767 irela
->r_offset
= irel
.r_offset
;
4768 irela
->r_info
= irel
.r_info
;
4769 irela
->r_addend
= 0;
4774 Elf_External_Rela
*erela
;
4775 Elf_External_Rela
*erelaend
;
4776 Elf_Internal_Rela
*irela
;
4778 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4780 erela
= (Elf_External_Rela
*) external_relocs
;
4781 erelaend
= erela
+ o
->reloc_count
;
4782 irela
= internal_relocs
;
4783 for (; erela
< erelaend
; erela
++, irela
++)
4784 elf_swap_reloca_in (abfd
, erela
, irela
);
4787 /* Cache the results for next time, if we can. */
4789 elf_section_data (o
)->relocs
= internal_relocs
;
4794 /* Don't free alloc2, since if it was allocated we are passing it
4795 back (under the name of internal_relocs). */
4797 return internal_relocs
;
4807 /* Record an assignment to a symbol made by a linker script. We need
4808 this in case some dynamic object refers to this symbol. */
4812 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4814 struct bfd_link_info
*info
;
4817 struct elf_link_hash_entry
*h
;
4819 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4823 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4824 h
->type
= STT_OBJECT
;
4826 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4827 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4829 && h
->dynindx
== -1)
4831 if (! elf_link_record_dynamic_symbol (info
, h
))
4834 /* If this is a weak defined symbol, and we know a corresponding
4835 real symbol from the same dynamic object, make sure the real
4836 symbol is also made into a dynamic symbol. */
4837 if (h
->weakdef
!= NULL
4838 && h
->weakdef
->dynindx
== -1)
4840 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4848 /* Array used to determine the number of hash table buckets to use
4849 based on the number of symbols there are. If there are fewer than
4850 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4851 fewer than 37 we use 17 buckets, and so forth. We never use more
4852 than 521 buckets. */
4854 static const size_t elf_buckets
[] =
4856 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4859 /* Set up the sizes and contents of the ELF dynamic sections. This is
4860 called by the ELF linker emulation before_allocation routine. We
4861 must set the sizes of the sections before the linker sets the
4862 addresses of the various sections. */
4865 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4866 export_dynamic
, info
, sinterpptr
)
4870 boolean export_dynamic
;
4871 struct bfd_link_info
*info
;
4872 asection
**sinterpptr
;
4876 Elf_Internal_Sym isym
;
4879 struct elf_backend_data
*bed
;
4883 dynobj
= elf_hash_table (info
)->dynobj
;
4885 /* If there were no dynamic objects in the link, there is nothing to
4890 /* If we are supposed to export all symbols into the dynamic symbol
4891 table (this is not the normal case), then do so. */
4893 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4896 if (elf_hash_table (info
)->dynamic_sections_created
)
4898 bfd_size_type strsize
;
4900 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4901 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4907 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4909 if (indx
== (bfd_size_type
) -1
4910 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4918 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4920 if (indx
== (bfd_size_type
) -1
4921 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4925 /* Find all symbols which were defined in a dynamic object and make
4926 the backend pick a reasonable value for them. */
4927 elf_link_hash_traverse (elf_hash_table (info
),
4928 elf_adjust_dynamic_symbol
,
4931 /* Add some entries to the .dynamic section. We fill in some of the
4932 values later, in elf_bfd_final_link, but we must add the entries
4933 now so that we know the final size of the .dynamic section. */
4934 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4935 false, false) != NULL
)
4937 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4940 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4941 false, false) != NULL
)
4943 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4946 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4947 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4948 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4949 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4950 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4951 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4952 sizeof (Elf_External_Sym
)))
4956 /* The backend must work out the sizes of all the other dynamic
4958 bed
= get_elf_backend_data (output_bfd
);
4959 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4962 if (elf_hash_table (info
)->dynamic_sections_created
)
4966 /* Set the size of the .dynsym and .hash sections. We counted
4967 the number of dynamic symbols in elf_link_add_object_symbols.
4968 We will build the contents of .dynsym and .hash when we build
4969 the final symbol table, because until then we do not know the
4970 correct value to give the symbols. We built the .dynstr
4971 section as we went along in elf_link_add_object_symbols. */
4972 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4973 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4974 BFD_ASSERT (s
!= NULL
);
4975 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4976 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4977 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4979 bfd_set_error (bfd_error_no_memory
);
4983 /* The first entry in .dynsym is a dummy symbol. */
4990 elf_swap_symbol_out (output_bfd
, &isym
,
4991 (Elf_External_Sym
*) s
->contents
);
4993 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4995 bucketcount
= elf_buckets
[i
];
4996 if (dynsymcount
< elf_buckets
[i
+ 1])
5000 s
= bfd_get_section_by_name (dynobj
, ".hash");
5001 BFD_ASSERT (s
!= NULL
);
5002 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5003 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5004 if (s
->contents
== NULL
)
5006 bfd_set_error (bfd_error_no_memory
);
5009 memset (s
->contents
, 0, s
->_raw_size
);
5011 put_word (output_bfd
, bucketcount
, s
->contents
);
5012 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5014 elf_hash_table (info
)->bucketcount
= bucketcount
;
5016 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5017 BFD_ASSERT (s
!= NULL
);
5018 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5020 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5027 /* This routine is used to export all defined symbols into the dynamic
5028 symbol table. It is called via elf_link_hash_traverse. */
5031 elf_export_symbol (h
, data
)
5032 struct elf_link_hash_entry
*h
;
5035 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5037 if (h
->dynindx
== -1
5038 && (h
->elf_link_hash_flags
5039 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5041 if (! elf_link_record_dynamic_symbol (info
, h
))
5043 /* FIXME: No way to report error. */
5051 /* Make the backend pick a good value for a dynamic symbol. This is
5052 called via elf_link_hash_traverse, and also calls itself
5056 elf_adjust_dynamic_symbol (h
, data
)
5057 struct elf_link_hash_entry
*h
;
5060 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5062 struct elf_backend_data
*bed
;
5064 /* If this symbol does not require a PLT entry, and it is not
5065 defined by a dynamic object, or is not referenced by a regular
5066 object, ignore it. FIXME: Do we need to worry about symbols
5067 which are defined by one dynamic object and referenced by another
5069 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5070 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5071 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5072 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5075 /* If we've already adjusted this symbol, don't do it again. This
5076 can happen via a recursive call. */
5077 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5080 /* Don't look at this symbol again. Note that we must set this
5081 after checking the above conditions, because we may look at a
5082 symbol once, decide not to do anything, and then get called
5083 recursively later after REF_REGULAR is set below. */
5084 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5086 /* If this is a weak definition, and we know a real definition, and
5087 the real symbol is not itself defined by a regular object file,
5088 then get a good value for the real definition. We handle the
5089 real symbol first, for the convenience of the backend routine.
5091 Note that there is a confusing case here. If the real definition
5092 is defined by a regular object file, we don't get the real symbol
5093 from the dynamic object, but we do get the weak symbol. If the
5094 processor backend uses a COPY reloc, then if some routine in the
5095 dynamic object changes the real symbol, we will not see that
5096 change in the corresponding weak symbol. This is the way other
5097 ELF linkers work as well, and seems to be a result of the shared
5100 I will clarify this issue. Most SVR4 shared libraries define the
5101 variable _timezone and define timezone as a weak synonym. The
5102 tzset call changes _timezone. If you write
5103 extern int timezone;
5105 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5106 you might expect that, since timezone is a synonym for _timezone,
5107 the same number will print both times. However, if the processor
5108 backend uses a COPY reloc, then actually timezone will be copied
5109 into your process image, and, since you define _timezone
5110 yourself, _timezone will not. Thus timezone and _timezone will
5111 wind up at different memory locations. The tzset call will set
5112 _timezone, leaving timezone unchanged. */
5114 if (h
->weakdef
!= NULL
)
5116 struct elf_link_hash_entry
*weakdef
;
5118 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5119 weakdef
= h
->weakdef
;
5120 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5121 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5122 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5124 /* This symbol is defined by a regular object file, so we
5125 will not do anything special. Clear weakdef for the
5126 convenience of the processor backend. */
5131 /* There is an implicit reference by a regular object file
5132 via the weak symbol. */
5133 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5134 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5139 dynobj
= elf_hash_table (info
)->dynobj
;
5140 bed
= get_elf_backend_data (dynobj
);
5141 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5143 /* FIXME: No way to return error. */
5150 /* Final phase of ELF linker. */
5152 /* A structure we use to avoid passing large numbers of arguments. */
5154 struct elf_final_link_info
5156 /* General link information. */
5157 struct bfd_link_info
*info
;
5160 /* Symbol string table. */
5161 struct bfd_strtab_hash
*symstrtab
;
5162 /* .dynsym section. */
5163 asection
*dynsym_sec
;
5164 /* .hash section. */
5166 /* Buffer large enough to hold contents of any section. */
5168 /* Buffer large enough to hold external relocs of any section. */
5169 PTR external_relocs
;
5170 /* Buffer large enough to hold internal relocs of any section. */
5171 Elf_Internal_Rela
*internal_relocs
;
5172 /* Buffer large enough to hold external local symbols of any input
5174 Elf_External_Sym
*external_syms
;
5175 /* Buffer large enough to hold internal local symbols of any input
5177 Elf_Internal_Sym
*internal_syms
;
5178 /* Array large enough to hold a symbol index for each local symbol
5179 of any input BFD. */
5181 /* Array large enough to hold a section pointer for each local
5182 symbol of any input BFD. */
5183 asection
**sections
;
5184 /* Buffer to hold swapped out symbols. */
5185 Elf_External_Sym
*symbuf
;
5186 /* Number of swapped out symbols in buffer. */
5187 size_t symbuf_count
;
5188 /* Number of symbols which fit in symbuf. */
5192 static boolean elf_link_output_sym
5193 PARAMS ((struct elf_final_link_info
*, const char *,
5194 Elf_Internal_Sym
*, asection
*));
5195 static boolean elf_link_flush_output_syms
5196 PARAMS ((struct elf_final_link_info
*));
5197 static boolean elf_link_output_extsym
5198 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5199 static boolean elf_link_input_bfd
5200 PARAMS ((struct elf_final_link_info
*, bfd
*));
5201 static boolean elf_reloc_link_order
5202 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5203 struct bfd_link_order
*));
5205 /* Do the final step of an ELF link. */
5208 elf_bfd_final_link (abfd
, info
)
5210 struct bfd_link_info
*info
;
5214 struct elf_final_link_info finfo
;
5215 register asection
*o
;
5216 register struct bfd_link_order
*p
;
5218 size_t max_contents_size
;
5219 size_t max_external_reloc_size
;
5220 size_t max_internal_reloc_count
;
5221 size_t max_sym_count
;
5223 Elf_Internal_Sym elfsym
;
5225 Elf_Internal_Shdr
*symtab_hdr
;
5226 Elf_Internal_Shdr
*symstrtab_hdr
;
5227 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5230 abfd
->flags
|= DYNAMIC
;
5232 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5233 dynobj
= elf_hash_table (info
)->dynobj
;
5236 finfo
.output_bfd
= abfd
;
5237 finfo
.symstrtab
= elf_stringtab_init ();
5238 if (finfo
.symstrtab
== NULL
)
5242 finfo
.dynsym_sec
= NULL
;
5243 finfo
.hash_sec
= NULL
;
5247 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5248 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5249 if (finfo
.dynsym_sec
== NULL
5250 || finfo
.hash_sec
== NULL
)
5253 finfo
.contents
= NULL
;
5254 finfo
.external_relocs
= NULL
;
5255 finfo
.internal_relocs
= NULL
;
5256 finfo
.external_syms
= NULL
;
5257 finfo
.internal_syms
= NULL
;
5258 finfo
.indices
= NULL
;
5259 finfo
.sections
= NULL
;
5260 finfo
.symbuf
= NULL
;
5261 finfo
.symbuf_count
= 0;
5263 /* Count up the number of relocations we will output for each output
5264 section, so that we know the sizes of the reloc sections. We
5265 also figure out some maximum sizes. */
5266 max_contents_size
= 0;
5267 max_external_reloc_size
= 0;
5268 max_internal_reloc_count
= 0;
5270 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5274 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5276 if (p
->type
== bfd_section_reloc_link_order
5277 || p
->type
== bfd_symbol_reloc_link_order
)
5279 else if (p
->type
== bfd_indirect_link_order
)
5283 sec
= p
->u
.indirect
.section
;
5285 if (info
->relocateable
)
5286 o
->reloc_count
+= sec
->reloc_count
;
5288 if (sec
->_raw_size
> max_contents_size
)
5289 max_contents_size
= sec
->_raw_size
;
5290 if (sec
->_cooked_size
> max_contents_size
)
5291 max_contents_size
= sec
->_cooked_size
;
5293 /* We are interested in just local symbols, not all
5295 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5299 if (elf_bad_symtab (sec
->owner
))
5300 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5301 / sizeof (Elf_External_Sym
));
5303 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5305 if (sym_count
> max_sym_count
)
5306 max_sym_count
= sym_count
;
5308 if ((sec
->flags
& SEC_RELOC
) != 0)
5312 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5313 if (ext_size
> max_external_reloc_size
)
5314 max_external_reloc_size
= ext_size
;
5315 if (sec
->reloc_count
> max_internal_reloc_count
)
5316 max_internal_reloc_count
= sec
->reloc_count
;
5322 if (o
->reloc_count
> 0)
5323 o
->flags
|= SEC_RELOC
;
5326 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5327 set it (this is probably a bug) and if it is set
5328 assign_section_numbers will create a reloc section. */
5329 o
->flags
&=~ SEC_RELOC
;
5332 /* If the SEC_ALLOC flag is not set, force the section VMA to
5333 zero. This is done in elf_fake_sections as well, but forcing
5334 the VMA to 0 here will ensure that relocs against these
5335 sections are handled correctly. */
5336 if ((o
->flags
& SEC_ALLOC
) == 0)
5340 /* Figure out the file positions for everything but the symbol table
5341 and the relocs. We set symcount to force assign_section_numbers
5342 to create a symbol table. */
5343 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5344 BFD_ASSERT (! abfd
->output_has_begun
);
5345 if (! elf_compute_section_file_positions (abfd
, info
))
5348 /* That created the reloc sections. Set their sizes, and assign
5349 them file positions, and allocate some buffers. */
5350 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5352 if ((o
->flags
& SEC_RELOC
) != 0)
5354 Elf_Internal_Shdr
*rel_hdr
;
5355 register struct elf_link_hash_entry
**p
, **pend
;
5357 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5359 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5361 /* The contents field must last into write_object_contents,
5362 so we allocate it with bfd_alloc rather than malloc. */
5363 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5364 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5366 bfd_set_error (bfd_error_no_memory
);
5370 p
= ((struct elf_link_hash_entry
**)
5371 malloc (o
->reloc_count
5372 * sizeof (struct elf_link_hash_entry
*)));
5373 if (p
== NULL
&& o
->reloc_count
!= 0)
5375 bfd_set_error (bfd_error_no_memory
);
5378 elf_section_data (o
)->rel_hashes
= p
;
5379 pend
= p
+ o
->reloc_count
;
5380 for (; p
< pend
; p
++)
5383 /* Use the reloc_count field as an index when outputting the
5389 assign_file_positions_for_relocs (abfd
);
5391 /* We have now assigned file positions for all the sections except
5392 .symtab and .strtab. We start the .symtab section at the current
5393 file position, and write directly to it. We build the .strtab
5394 section in memory. When we add .dynsym support, we will build
5395 that in memory as well (.dynsym is smaller than .symtab). */
5397 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5398 /* sh_name is set in prep_headers. */
5399 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5400 symtab_hdr
->sh_flags
= 0;
5401 symtab_hdr
->sh_addr
= 0;
5402 symtab_hdr
->sh_size
= 0;
5403 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5404 /* sh_link is set in assign_section_numbers. */
5405 /* sh_info is set below. */
5406 /* sh_offset is set just below. */
5407 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5409 off
= elf_tdata (abfd
)->next_file_pos
;
5410 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5412 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5413 incorrect. We do not yet know the size of the .symtab section.
5414 We correct next_file_pos below, after we do know the size. */
5416 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5417 continuously seeking to the right position in the file. */
5418 if (! info
->keep_memory
|| max_sym_count
< 20)
5419 finfo
.symbuf_size
= 20;
5421 finfo
.symbuf_size
= max_sym_count
;
5422 finfo
.symbuf
= ((Elf_External_Sym
*)
5423 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5424 if (finfo
.symbuf
== NULL
)
5426 bfd_set_error (bfd_error_no_memory
);
5430 /* Start writing out the symbol table. The first symbol is always a
5432 elfsym
.st_value
= 0;
5435 elfsym
.st_other
= 0;
5436 elfsym
.st_shndx
= SHN_UNDEF
;
5437 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5438 &elfsym
, bfd_und_section_ptr
))
5442 /* Some standard ELF linkers do this, but we don't because it causes
5443 bootstrap comparison failures. */
5444 /* Output a file symbol for the output file as the second symbol.
5445 We output this even if we are discarding local symbols, although
5446 I'm not sure if this is correct. */
5447 elfsym
.st_value
= 0;
5449 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5450 elfsym
.st_other
= 0;
5451 elfsym
.st_shndx
= SHN_ABS
;
5452 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5453 &elfsym
, bfd_abs_section_ptr
))
5457 /* Output a symbol for each section. We output these even if we are
5458 discarding local symbols, since they are used for relocs. These
5459 symbols have no names. We store the index of each one in the
5460 index field of the section, so that we can find it again when
5461 outputting relocs. */
5462 elfsym
.st_value
= 0;
5464 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5465 elfsym
.st_other
= 0;
5466 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5468 o
= section_from_elf_index (abfd
, i
);
5470 o
->target_index
= abfd
->symcount
;
5471 elfsym
.st_shndx
= i
;
5472 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5477 /* Allocate some memory to hold information read in from the input
5479 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5480 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5481 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5482 malloc (max_internal_reloc_count
5483 * sizeof (Elf_Internal_Rela
)));
5484 finfo
.external_syms
= ((Elf_External_Sym
*)
5485 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5486 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5487 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5488 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5489 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5490 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5491 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5492 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5493 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5494 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5495 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5496 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5498 bfd_set_error (bfd_error_no_memory
);
5502 /* Since ELF permits relocations to be against local symbols, we
5503 must have the local symbols available when we do the relocations.
5504 Since we would rather only read the local symbols once, and we
5505 would rather not keep them in memory, we handle all the
5506 relocations for a single input file at the same time.
5508 Unfortunately, there is no way to know the total number of local
5509 symbols until we have seen all of them, and the local symbol
5510 indices precede the global symbol indices. This means that when
5511 we are generating relocateable output, and we see a reloc against
5512 a global symbol, we can not know the symbol index until we have
5513 finished examining all the local symbols to see which ones we are
5514 going to output. To deal with this, we keep the relocations in
5515 memory, and don't output them until the end of the link. This is
5516 an unfortunate waste of memory, but I don't see a good way around
5517 it. Fortunately, it only happens when performing a relocateable
5518 link, which is not the common case. FIXME: If keep_memory is set
5519 we could write the relocs out and then read them again; I don't
5520 know how bad the memory loss will be. */
5522 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5523 sub
->output_has_begun
= false;
5524 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5526 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5528 if (p
->type
== bfd_indirect_link_order
5529 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5530 == bfd_target_elf_flavour
))
5532 sub
= p
->u
.indirect
.section
->owner
;
5533 if (! sub
->output_has_begun
)
5535 if (! elf_link_input_bfd (&finfo
, sub
))
5537 sub
->output_has_begun
= true;
5540 else if (p
->type
== bfd_section_reloc_link_order
5541 || p
->type
== bfd_symbol_reloc_link_order
)
5543 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5548 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5554 /* That wrote out all the local symbols. Finish up the symbol table
5555 with the global symbols. */
5557 /* The sh_info field records the index of the first non local
5559 symtab_hdr
->sh_info
= abfd
->symcount
;
5561 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5563 /* We get the global symbols from the hash table. */
5564 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5567 /* Flush all symbols to the file. */
5568 if (! elf_link_flush_output_syms (&finfo
))
5571 /* Now we know the size of the symtab section. */
5572 off
+= symtab_hdr
->sh_size
;
5574 /* Finish up and write out the symbol string table (.strtab)
5576 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5577 /* sh_name was set in prep_headers. */
5578 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5579 symstrtab_hdr
->sh_flags
= 0;
5580 symstrtab_hdr
->sh_addr
= 0;
5581 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5582 symstrtab_hdr
->sh_entsize
= 0;
5583 symstrtab_hdr
->sh_link
= 0;
5584 symstrtab_hdr
->sh_info
= 0;
5585 /* sh_offset is set just below. */
5586 symstrtab_hdr
->sh_addralign
= 1;
5588 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5589 elf_tdata (abfd
)->next_file_pos
= off
;
5591 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5592 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5595 /* Adjust the relocs to have the correct symbol indices. */
5596 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5598 struct elf_link_hash_entry
**rel_hash
;
5599 Elf_Internal_Shdr
*rel_hdr
;
5601 if ((o
->flags
& SEC_RELOC
) == 0)
5604 rel_hash
= elf_section_data (o
)->rel_hashes
;
5605 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5606 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5608 if (*rel_hash
== NULL
)
5611 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5613 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5615 Elf_External_Rel
*erel
;
5616 Elf_Internal_Rel irel
;
5618 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5619 elf_swap_reloc_in (abfd
, erel
, &irel
);
5620 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5621 ELF_R_TYPE (irel
.r_info
));
5622 elf_swap_reloc_out (abfd
, &irel
, erel
);
5626 Elf_External_Rela
*erela
;
5627 Elf_Internal_Rela irela
;
5629 BFD_ASSERT (rel_hdr
->sh_entsize
5630 == sizeof (Elf_External_Rela
));
5632 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5633 elf_swap_reloca_in (abfd
, erela
, &irela
);
5634 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5635 ELF_R_TYPE (irela
.r_info
));
5636 elf_swap_reloca_out (abfd
, &irela
, erela
);
5640 /* Set the reloc_count field to 0 to prevent write_relocs from
5641 trying to swap the relocs out itself. */
5645 /* If we are linking against a dynamic object, or generating a
5646 shared library, finish up the dynamic linking information. */
5649 Elf_External_Dyn
*dyncon
, *dynconend
;
5651 /* Fix up .dynamic entries. */
5652 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5653 BFD_ASSERT (o
!= NULL
);
5655 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5656 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5657 for (; dyncon
< dynconend
; dyncon
++)
5659 Elf_Internal_Dyn dyn
;
5663 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5670 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5671 magic _init and _fini symbols. This is pretty ugly,
5672 but we are compatible. */
5680 struct elf_link_hash_entry
*h
;
5682 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5683 false, false, true);
5684 BFD_ASSERT (h
!= NULL
);
5685 if (h
->root
.type
== bfd_link_hash_defined
)
5687 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5688 o
= h
->root
.u
.def
.section
;
5689 if (o
->output_section
!= NULL
)
5690 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5691 + o
->output_offset
);
5693 dyn
.d_un
.d_val
+= o
->vma
;
5695 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5708 o
= bfd_get_section_by_name (abfd
, name
);
5709 BFD_ASSERT (o
!= NULL
);
5710 dyn
.d_un
.d_ptr
= o
->vma
;
5711 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5718 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5723 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5725 Elf_Internal_Shdr
*hdr
;
5727 hdr
= elf_elfsections (abfd
)[i
];
5728 if (hdr
->sh_type
== type
5729 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5731 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5732 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5735 if (dyn
.d_un
.d_val
== 0
5736 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5737 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5741 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5747 /* If we have created any dynamic sections, then output them. */
5750 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5753 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5755 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5756 || o
->_raw_size
== 0)
5758 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5760 /* At this point, we are only interested in sections
5761 created by elf_link_create_dynamic_sections. FIXME:
5762 This test is fragile. */
5765 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5767 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5769 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5770 o
->contents
, o
->output_offset
,
5778 /* The contents of the .dynstr section are actually in a
5780 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5781 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5782 || ! _bfd_stringtab_emit (abfd
,
5783 elf_hash_table (info
)->dynstr
))
5789 if (finfo
.symstrtab
!= NULL
)
5790 _bfd_stringtab_free (finfo
.symstrtab
);
5791 if (finfo
.contents
!= NULL
)
5792 free (finfo
.contents
);
5793 if (finfo
.external_relocs
!= NULL
)
5794 free (finfo
.external_relocs
);
5795 if (finfo
.internal_relocs
!= NULL
)
5796 free (finfo
.internal_relocs
);
5797 if (finfo
.external_syms
!= NULL
)
5798 free (finfo
.external_syms
);
5799 if (finfo
.internal_syms
!= NULL
)
5800 free (finfo
.internal_syms
);
5801 if (finfo
.indices
!= NULL
)
5802 free (finfo
.indices
);
5803 if (finfo
.sections
!= NULL
)
5804 free (finfo
.sections
);
5805 if (finfo
.symbuf
!= NULL
)
5806 free (finfo
.symbuf
);
5807 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5809 if ((o
->flags
& SEC_RELOC
) != 0
5810 && elf_section_data (o
)->rel_hashes
!= NULL
)
5811 free (elf_section_data (o
)->rel_hashes
);
5814 elf_tdata (abfd
)->linker
= true;
5819 if (finfo
.symstrtab
!= NULL
)
5820 _bfd_stringtab_free (finfo
.symstrtab
);
5821 if (finfo
.contents
!= NULL
)
5822 free (finfo
.contents
);
5823 if (finfo
.external_relocs
!= NULL
)
5824 free (finfo
.external_relocs
);
5825 if (finfo
.internal_relocs
!= NULL
)
5826 free (finfo
.internal_relocs
);
5827 if (finfo
.external_syms
!= NULL
)
5828 free (finfo
.external_syms
);
5829 if (finfo
.internal_syms
!= NULL
)
5830 free (finfo
.internal_syms
);
5831 if (finfo
.indices
!= NULL
)
5832 free (finfo
.indices
);
5833 if (finfo
.sections
!= NULL
)
5834 free (finfo
.sections
);
5835 if (finfo
.symbuf
!= NULL
)
5836 free (finfo
.symbuf
);
5837 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5839 if ((o
->flags
& SEC_RELOC
) != 0
5840 && elf_section_data (o
)->rel_hashes
!= NULL
)
5841 free (elf_section_data (o
)->rel_hashes
);
5847 /* Add a symbol to the output symbol table. */
5850 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5851 struct elf_final_link_info
*finfo
;
5853 Elf_Internal_Sym
*elfsym
;
5854 asection
*input_sec
;
5856 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5857 struct bfd_link_info
*info
,
5862 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5863 elf_backend_link_output_symbol_hook
;
5864 if (output_symbol_hook
!= NULL
)
5866 if (! ((*output_symbol_hook
)
5867 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5871 if (name
== (const char *) NULL
|| *name
== '\0')
5872 elfsym
->st_name
= 0;
5875 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5878 if (elfsym
->st_name
== (unsigned long) -1)
5882 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5884 if (! elf_link_flush_output_syms (finfo
))
5888 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5889 finfo
->symbuf
+ finfo
->symbuf_count
);
5890 ++finfo
->symbuf_count
;
5892 ++finfo
->output_bfd
->symcount
;
5897 /* Flush the output symbols to the file. */
5900 elf_link_flush_output_syms (finfo
)
5901 struct elf_final_link_info
*finfo
;
5903 Elf_Internal_Shdr
*symtab
;
5905 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5907 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5909 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5910 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5911 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5914 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5916 finfo
->symbuf_count
= 0;
5921 /* Add an external symbol to the symbol table. This is called from
5922 the hash table traversal routine. */
5925 elf_link_output_extsym (h
, data
)
5926 struct elf_link_hash_entry
*h
;
5929 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5931 Elf_Internal_Sym sym
;
5932 asection
*input_sec
;
5934 /* We don't want to output symbols that have never been mentioned by
5935 a regular file, or that we have been told to strip. However, if
5936 h->indx is set to -2, the symbol is used by a reloc and we must
5940 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5941 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5942 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5943 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5945 else if (finfo
->info
->strip
== strip_all
5946 || (finfo
->info
->strip
== strip_some
5947 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5948 h
->root
.root
.string
,
5949 false, false) == NULL
))
5954 /* If we're stripping it, and it's not a dynamic symbol, there's
5955 nothing else to do. */
5956 if (strip
&& h
->dynindx
== -1)
5960 sym
.st_size
= h
->size
;
5962 if (h
->root
.type
== bfd_link_hash_weak
5963 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5964 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5966 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5968 switch (h
->root
.type
)
5971 case bfd_link_hash_new
:
5975 case bfd_link_hash_undefined
:
5976 input_sec
= bfd_und_section_ptr
;
5977 sym
.st_shndx
= SHN_UNDEF
;
5980 case bfd_link_hash_weak
:
5981 input_sec
= bfd_und_section_ptr
;
5982 sym
.st_shndx
= SHN_UNDEF
;
5985 case bfd_link_hash_defined
:
5987 input_sec
= h
->root
.u
.def
.section
;
5988 if (input_sec
->output_section
!= NULL
)
5991 elf_section_from_bfd_section (finfo
->output_bfd
,
5992 input_sec
->output_section
);
5993 if (sym
.st_shndx
== (unsigned short) -1)
5995 /* FIXME: No way to handle errors. */
5999 /* ELF symbols in relocateable files are section relative,
6000 but in nonrelocateable files they are virtual
6002 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6003 if (! finfo
->info
->relocateable
)
6004 sym
.st_value
+= input_sec
->output_section
->vma
;
6008 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6009 == bfd_target_elf_flavour
)
6010 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6011 sym
.st_shndx
= SHN_UNDEF
;
6012 input_sec
= bfd_und_section_ptr
;
6017 case bfd_link_hash_common
:
6018 input_sec
= bfd_com_section_ptr
;
6019 sym
.st_shndx
= SHN_COMMON
;
6020 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6023 case bfd_link_hash_indirect
:
6024 case bfd_link_hash_warning
:
6025 /* I have no idea how these should be handled. */
6029 /* If this symbol should be put in the .dynsym section, then put it
6030 there now. We have already know the symbol index. We also fill
6031 in the entry in the .hash section. */
6032 if (h
->dynindx
!= -1
6033 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6035 struct elf_backend_data
*bed
;
6038 bfd_byte
*bucketpos
;
6041 sym
.st_name
= h
->dynstr_index
;
6043 /* Give the processor backend a chance to tweak the symbol
6044 value, and also to finish up anything that needs to be done
6046 bed
= get_elf_backend_data (finfo
->output_bfd
);
6047 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6048 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6050 /* FIXME: No way to return error. */
6054 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6055 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6058 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6059 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6061 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6062 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6063 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6064 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6065 put_word (finfo
->output_bfd
, chain
,
6066 ((bfd_byte
*) finfo
->hash_sec
->contents
6067 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6070 /* If we're stripping it, then it was just a dynamic symbol, and
6071 there's nothing else to do. */
6075 h
->indx
= finfo
->output_bfd
->symcount
;
6077 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6079 /* FIXME: No way to return error. */
6086 /* Link an input file into the linker output file. This function
6087 handles all the sections and relocations of the input file at once.
6088 This is so that we only have to read the local symbols once, and
6089 don't have to keep them in memory. */
6092 elf_link_input_bfd (finfo
, input_bfd
)
6093 struct elf_final_link_info
*finfo
;
6096 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6097 bfd
*, asection
*, bfd_byte
*,
6098 Elf_Internal_Rela
*,
6099 Elf_Internal_Sym
*, asection
**));
6101 Elf_Internal_Shdr
*symtab_hdr
;
6104 Elf_External_Sym
*esym
;
6105 Elf_External_Sym
*esymend
;
6106 Elf_Internal_Sym
*isym
;
6108 asection
**ppsection
;
6111 output_bfd
= finfo
->output_bfd
;
6113 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6115 /* If this is a dynamic object, we don't want to do anything here:
6116 we don't want the local symbols, and we don't want the section
6118 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6121 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6122 if (elf_bad_symtab (input_bfd
))
6124 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6129 locsymcount
= symtab_hdr
->sh_info
;
6130 extsymoff
= symtab_hdr
->sh_info
;
6133 /* Read the local symbols. */
6135 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6136 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6137 locsymcount
, input_bfd
)
6138 != locsymcount
* sizeof (Elf_External_Sym
))))
6141 /* Swap in the local symbols and write out the ones which we know
6142 are going into the output file. */
6143 esym
= finfo
->external_syms
;
6144 esymend
= esym
+ locsymcount
;
6145 isym
= finfo
->internal_syms
;
6146 pindex
= finfo
->indices
;
6147 ppsection
= finfo
->sections
;
6148 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6152 Elf_Internal_Sym osym
;
6154 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6157 if (elf_bad_symtab (input_bfd
))
6159 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6166 if (isym
->st_shndx
== SHN_UNDEF
)
6167 isec
= bfd_und_section_ptr
;
6168 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6169 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6170 else if (isym
->st_shndx
== SHN_ABS
)
6171 isec
= bfd_abs_section_ptr
;
6172 else if (isym
->st_shndx
== SHN_COMMON
)
6173 isec
= bfd_com_section_ptr
;
6182 /* Don't output the first, undefined, symbol. */
6183 if (esym
== finfo
->external_syms
)
6186 /* If we are stripping all symbols, we don't want to output this
6188 if (finfo
->info
->strip
== strip_all
)
6191 /* We never output section symbols. Instead, we use the section
6192 symbol of the corresponding section in the output file. */
6193 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6196 /* If we are discarding all local symbols, we don't want to
6197 output this one. If we are generating a relocateable output
6198 file, then some of the local symbols may be required by
6199 relocs; we output them below as we discover that they are
6201 if (finfo
->info
->discard
== discard_all
)
6204 /* Get the name of the symbol. */
6205 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6210 /* See if we are discarding symbols with this name. */
6211 if ((finfo
->info
->strip
== strip_some
6212 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6214 || (finfo
->info
->discard
== discard_l
6215 && strncmp (name
, finfo
->info
->lprefix
,
6216 finfo
->info
->lprefix_len
) == 0))
6219 /* If we get here, we are going to output this symbol. */
6223 /* Adjust the section index for the output file. */
6224 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6225 isec
->output_section
);
6226 if (osym
.st_shndx
== (unsigned short) -1)
6229 *pindex
= output_bfd
->symcount
;
6231 /* ELF symbols in relocateable files are section relative, but
6232 in executable files they are virtual addresses. Note that
6233 this code assumes that all ELF sections have an associated
6234 BFD section with a reasonable value for output_offset; below
6235 we assume that they also have a reasonable value for
6236 output_section. Any special sections must be set up to meet
6237 these requirements. */
6238 osym
.st_value
+= isec
->output_offset
;
6239 if (! finfo
->info
->relocateable
)
6240 osym
.st_value
+= isec
->output_section
->vma
;
6242 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6246 /* Relocate the contents of each section. */
6247 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6249 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6252 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6253 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6255 /* Section was created by elf_link_create_dynamic_sections.
6256 FIXME: This test is fragile. */
6260 /* Read the contents of the section. */
6261 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6262 (file_ptr
) 0, o
->_raw_size
))
6265 if ((o
->flags
& SEC_RELOC
) != 0)
6267 Elf_Internal_Rela
*internal_relocs
;
6269 /* Get the swapped relocs. */
6270 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6271 finfo
->external_relocs
,
6272 finfo
->internal_relocs
,
6274 if (internal_relocs
== NULL
6275 && o
->reloc_count
> 0)
6278 /* Relocate the section by invoking a back end routine.
6280 The back end routine is responsible for adjusting the
6281 section contents as necessary, and (if using Rela relocs
6282 and generating a relocateable output file) adjusting the
6283 reloc addend as necessary.
6285 The back end routine does not have to worry about setting
6286 the reloc address or the reloc symbol index.
6288 The back end routine is given a pointer to the swapped in
6289 internal symbols, and can access the hash table entries
6290 for the external symbols via elf_sym_hashes (input_bfd).
6292 When generating relocateable output, the back end routine
6293 must handle STB_LOCAL/STT_SECTION symbols specially. The
6294 output symbol is going to be a section symbol
6295 corresponding to the output section, which will require
6296 the addend to be adjusted. */
6298 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6302 finfo
->internal_syms
,
6306 if (finfo
->info
->relocateable
)
6308 Elf_Internal_Rela
*irela
;
6309 Elf_Internal_Rela
*irelaend
;
6310 struct elf_link_hash_entry
**rel_hash
;
6311 Elf_Internal_Shdr
*input_rel_hdr
;
6312 Elf_Internal_Shdr
*output_rel_hdr
;
6314 /* Adjust the reloc addresses and symbol indices. */
6316 irela
= internal_relocs
;
6317 irelaend
= irela
+ o
->reloc_count
;
6318 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6319 + o
->output_section
->reloc_count
);
6320 for (; irela
< irelaend
; irela
++, rel_hash
++)
6323 Elf_Internal_Sym
*isym
;
6326 irela
->r_offset
+= o
->output_offset
;
6328 r_symndx
= ELF_R_SYM (irela
->r_info
);
6333 if (r_symndx
>= locsymcount
6334 || (elf_bad_symtab (input_bfd
)
6335 && finfo
->sections
[r_symndx
] == NULL
))
6339 /* This is a reloc against a global symbol. We
6340 have not yet output all the local symbols, so
6341 we do not know the symbol index of any global
6342 symbol. We set the rel_hash entry for this
6343 reloc to point to the global hash table entry
6344 for this symbol. The symbol index is then
6345 set at the end of elf_bfd_final_link. */
6346 indx
= r_symndx
- extsymoff
;
6347 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6349 /* Setting the index to -2 tells
6350 elf_link_output_extsym that this symbol is
6352 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6353 (*rel_hash
)->indx
= -2;
6358 /* This is a reloc against a local symbol. */
6361 isym
= finfo
->internal_syms
+ r_symndx
;
6362 sec
= finfo
->sections
[r_symndx
];
6363 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6365 /* I suppose the backend ought to fill in the
6366 section of any STT_SECTION symbol against a
6367 processor specific section. */
6368 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6370 else if (sec
== NULL
|| sec
->owner
== NULL
)
6372 bfd_set_error (bfd_error_bad_value
);
6377 r_symndx
= sec
->output_section
->target_index
;
6384 if (finfo
->indices
[r_symndx
] == -1)
6390 if (finfo
->info
->strip
== strip_all
)
6392 /* You can't do ld -r -s. */
6393 bfd_set_error (bfd_error_invalid_operation
);
6397 /* This symbol was skipped earlier, but
6398 since it is needed by a reloc, we
6399 must output it now. */
6400 link
= symtab_hdr
->sh_link
;
6401 name
= elf_string_from_elf_section (input_bfd
,
6407 osec
= sec
->output_section
;
6409 elf_section_from_bfd_section (output_bfd
,
6411 if (isym
->st_shndx
== (unsigned short) -1)
6414 isym
->st_value
+= sec
->output_offset
;
6415 if (! finfo
->info
->relocateable
)
6416 isym
->st_value
+= osec
->vma
;
6418 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6420 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6424 r_symndx
= finfo
->indices
[r_symndx
];
6427 irela
->r_info
= ELF_R_INFO (r_symndx
,
6428 ELF_R_TYPE (irela
->r_info
));
6431 /* Swap out the relocs. */
6432 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6433 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6434 BFD_ASSERT (output_rel_hdr
->sh_entsize
6435 == input_rel_hdr
->sh_entsize
);
6436 irela
= internal_relocs
;
6437 irelaend
= irela
+ o
->reloc_count
;
6438 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6440 Elf_External_Rel
*erel
;
6442 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6443 + o
->output_section
->reloc_count
);
6444 for (; irela
< irelaend
; irela
++, erel
++)
6446 Elf_Internal_Rel irel
;
6448 irel
.r_offset
= irela
->r_offset
;
6449 irel
.r_info
= irela
->r_info
;
6450 BFD_ASSERT (irela
->r_addend
== 0);
6451 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6456 Elf_External_Rela
*erela
;
6458 BFD_ASSERT (input_rel_hdr
->sh_entsize
6459 == sizeof (Elf_External_Rela
));
6460 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6461 + o
->output_section
->reloc_count
);
6462 for (; irela
< irelaend
; irela
++, erela
++)
6463 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6466 o
->output_section
->reloc_count
+= o
->reloc_count
;
6470 /* Write out the modified section contents. */
6471 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6472 finfo
->contents
, o
->output_offset
,
6473 (o
->_cooked_size
!= 0
6482 /* Generate a reloc when linking an ELF file. This is a reloc
6483 requested by the linker, and does come from any input file. This
6484 is used to build constructor and destructor tables when linking
6488 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6490 struct bfd_link_info
*info
;
6491 asection
*output_section
;
6492 struct bfd_link_order
*link_order
;
6494 const reloc_howto_type
*howto
;
6497 struct elf_link_hash_entry
**rel_hash_ptr
;
6498 Elf_Internal_Shdr
*rel_hdr
;
6500 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6503 bfd_set_error (bfd_error_bad_value
);
6507 /* If this is an inplace reloc, we must write the addend into the
6509 if (howto
->partial_inplace
6510 && link_order
->u
.reloc
.p
->addend
!= 0)
6513 bfd_reloc_status_type rstat
;
6517 size
= bfd_get_reloc_size (howto
);
6518 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6519 if (buf
== (bfd_byte
*) NULL
)
6521 bfd_set_error (bfd_error_no_memory
);
6524 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6525 link_order
->u
.reloc
.p
->addend
, buf
);
6531 case bfd_reloc_outofrange
:
6533 case bfd_reloc_overflow
:
6534 if (! ((*info
->callbacks
->reloc_overflow
)
6536 (link_order
->type
== bfd_section_reloc_link_order
6537 ? bfd_section_name (output_bfd
,
6538 link_order
->u
.reloc
.p
->u
.section
)
6539 : link_order
->u
.reloc
.p
->u
.name
),
6540 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6541 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6548 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6549 (file_ptr
) link_order
->offset
, size
);
6555 /* Figure out the symbol index. */
6556 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6557 + output_section
->reloc_count
);
6558 if (link_order
->type
== bfd_section_reloc_link_order
)
6560 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6563 *rel_hash_ptr
= NULL
;
6567 struct elf_link_hash_entry
*h
;
6569 h
= elf_link_hash_lookup (elf_hash_table (info
),
6570 link_order
->u
.reloc
.p
->u
.name
,
6571 false, false, true);
6574 /* Setting the index to -2 tells elf_link_output_extsym that
6575 this symbol is used by a reloc. */
6582 if (! ((*info
->callbacks
->unattached_reloc
)
6583 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6584 (asection
*) NULL
, (bfd_vma
) 0)))
6590 /* The address of a reloc is relative to the section in a
6591 relocateable file, and is a virtual address in an executable
6593 offset
= link_order
->offset
;
6594 if (! info
->relocateable
)
6595 offset
+= output_section
->vma
;
6597 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6599 if (rel_hdr
->sh_type
== SHT_REL
)
6601 Elf_Internal_Rel irel
;
6602 Elf_External_Rel
*erel
;
6604 irel
.r_offset
= offset
;
6605 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6606 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6607 + output_section
->reloc_count
);
6608 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6612 Elf_Internal_Rela irela
;
6613 Elf_External_Rela
*erela
;
6615 irela
.r_offset
= offset
;
6616 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6617 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6618 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6619 + output_section
->reloc_count
);
6620 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6623 ++output_section
->reloc_count
;