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
== asect
->vma
)
1505 sec
= syms
[idx
]->section
;
1506 if (sec
->owner
!= NULL
)
1508 if (sec
->owner
!= abfd
)
1510 sec
= sec
->output_section
;
1511 BFD_ASSERT (sec
->owner
== abfd
);
1513 sect_syms
[sec
->index
] = syms
[idx
];
1518 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1522 if (sect_syms
[asect
->index
] != NULL
)
1525 sym
= bfd_make_empty_symbol (abfd
);
1528 sym
->the_bfd
= abfd
;
1529 sym
->name
= asect
->name
;
1530 sym
->value
= asect
->vma
;
1531 /* Set the flags to 0 to indicate that this one was newly added. */
1533 sym
->section
= asect
;
1534 sect_syms
[asect
->index
] = sym
;
1538 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1539 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1543 /* Classify all of the symbols. */
1544 for (idx
= 0; idx
< symcount
; idx
++)
1546 if (!sym_is_global (abfd
, syms
[idx
]))
1551 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1553 if (sect_syms
[asect
->index
] != NULL
1554 && sect_syms
[asect
->index
]->flags
== 0)
1556 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1557 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1561 sect_syms
[asect
->index
]->flags
= 0;
1565 /* Now sort the symbols so the local symbols are first. */
1566 new_syms
= ((asymbol
**)
1568 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1569 if (new_syms
== NULL
)
1571 bfd_set_error (bfd_error_no_memory
);
1575 for (idx
= 0; idx
< symcount
; idx
++)
1577 asymbol
*sym
= syms
[idx
];
1580 if (!sym_is_global (abfd
, sym
))
1583 i
= num_locals
+ num_globals2
++;
1585 sym
->udata
.i
= i
+ 1;
1587 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1589 if (sect_syms
[asect
->index
] != NULL
1590 && sect_syms
[asect
->index
]->flags
== 0)
1592 asymbol
*sym
= sect_syms
[asect
->index
];
1595 sym
->flags
= BSF_SECTION_SYM
;
1596 if (!sym_is_global (abfd
, sym
))
1599 i
= num_locals
+ num_globals2
++;
1601 sym
->udata
.i
= i
+ 1;
1605 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1607 elf_num_locals (abfd
) = num_locals
;
1608 elf_num_globals (abfd
) = num_globals
;
1612 /* Compute the file positions we are going to put the sections at, and
1613 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1614 is not NULL, this is being called by the ELF backend linker. */
1617 elf_compute_section_file_positions (abfd
, link_info
)
1619 struct bfd_link_info
*link_info
;
1621 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1623 struct bfd_strtab_hash
*strtab
;
1624 Elf_Internal_Shdr
*shstrtab_hdr
;
1626 if (abfd
->output_has_begun
)
1629 /* Do any elf backend specific processing first. */
1630 if (bed
->elf_backend_begin_write_processing
)
1631 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1633 if (! prep_headers (abfd
))
1637 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1641 if (!assign_section_numbers (abfd
))
1644 /* The backend linker builds symbol table information itself. */
1645 if (link_info
== NULL
)
1647 if (! swap_out_syms (abfd
, &strtab
))
1651 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1652 /* sh_name was set in prep_headers. */
1653 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1654 shstrtab_hdr
->sh_flags
= 0;
1655 shstrtab_hdr
->sh_addr
= 0;
1656 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1657 shstrtab_hdr
->sh_entsize
= 0;
1658 shstrtab_hdr
->sh_link
= 0;
1659 shstrtab_hdr
->sh_info
= 0;
1660 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1661 shstrtab_hdr
->sh_addralign
= 1;
1663 if (!assign_file_positions_except_relocs (abfd
,
1664 link_info
== NULL
? true : false))
1667 if (link_info
== NULL
)
1669 /* Now that we know where the .strtab section goes, write it
1671 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1673 || ! _bfd_stringtab_emit (abfd
, strtab
))
1675 _bfd_stringtab_free (strtab
);
1678 abfd
->output_has_begun
= true;
1684 /* Align to the maximum file alignment that could be required for any
1685 ELF data structure. */
1687 static INLINE file_ptr
1688 align_file_position (off
)
1691 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1694 /* Assign a file position to a section, optionally aligning to the
1695 required section alignment. */
1697 static INLINE file_ptr
1698 assign_file_position_for_section (i_shdrp
, offset
, align
)
1699 Elf_Internal_Shdr
*i_shdrp
;
1707 al
= i_shdrp
->sh_addralign
;
1709 offset
= BFD_ALIGN (offset
, al
);
1711 i_shdrp
->sh_offset
= offset
;
1712 if (i_shdrp
->bfd_section
!= NULL
)
1713 i_shdrp
->bfd_section
->filepos
= offset
;
1714 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1715 offset
+= i_shdrp
->sh_size
;
1719 /* Get the size of the program header. This is called by the linker
1720 before any of the section VMA's are set, so it can't calculate the
1721 correct value for a strange memory layout. */
1723 static bfd_size_type
1724 get_program_header_size (abfd
)
1730 /* Assume we will need exactly two PT_LOAD segments: one for text
1731 and one for data. */
1734 s
= bfd_get_section_by_name (abfd
, ".interp");
1735 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1737 /* If we have a loadable interpreter section, we need a
1738 PT_INTERP segment. In this case, assume we also need a
1739 PT_PHDR segment, although that may not be true for all
1744 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1746 /* We need a PT_DYNAMIC segment. */
1750 return segs
* sizeof (Elf_External_Phdr
);
1753 /* Create the program header. OFF is the file offset where the
1754 program header should be written. FIRST is the first loadable ELF
1755 section. PHDR_SIZE is the size of the program header as returned
1756 by get_program_header_size. */
1759 map_program_segments (abfd
, off
, first
, phdr_size
)
1762 Elf_Internal_Shdr
*first
;
1763 bfd_size_type phdr_size
;
1765 Elf_Internal_Phdr phdrs
[10];
1766 unsigned int phdr_count
;
1767 Elf_Internal_Phdr
*phdr
;
1768 int phdr_size_adjust
;
1770 Elf_Internal_Shdr
**hdrpp
;
1771 asection
*sinterp
, *sdyn
;
1772 unsigned int last_type
;
1773 Elf_Internal_Ehdr
*i_ehdrp
;
1775 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1776 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1777 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1782 phdr_size_adjust
= 0;
1784 /* If we have a loadable .interp section, we must create a PT_INTERP
1785 segment which must precede all PT_LOAD segments. We assume that
1786 we must also create a PT_PHDR segment, although that may not be
1787 true for all targets. */
1788 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1789 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1791 BFD_ASSERT (first
!= NULL
);
1793 phdr
->p_type
= PT_PHDR
;
1795 phdr
->p_offset
= off
;
1797 /* Account for any adjustment made because of the alignment of
1798 the first loadable section. */
1799 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1800 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1802 /* The program header precedes all loadable sections. This lets
1803 us compute its loadable address. This depends on the linker
1805 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1808 phdr
->p_filesz
= phdr_size
;
1809 phdr
->p_memsz
= phdr_size
;
1811 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1812 phdr
->p_flags
= PF_R
| PF_X
;
1814 phdr
->p_align
= FILE_ALIGN
;
1815 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1817 /* Include the ELF header in the first loadable segment. */
1818 phdr_size_adjust
+= off
;
1823 phdr
->p_type
= PT_INTERP
;
1824 phdr
->p_offset
= sinterp
->filepos
;
1825 phdr
->p_vaddr
= sinterp
->vma
;
1827 phdr
->p_filesz
= sinterp
->_raw_size
;
1828 phdr
->p_memsz
= sinterp
->_raw_size
;
1829 phdr
->p_flags
= PF_R
;
1830 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1836 /* Look through the sections to see how they will be divided into
1837 program segments. The sections must be arranged in order by
1838 sh_addr for this to work correctly. */
1839 phdr
->p_type
= PT_NULL
;
1840 last_type
= SHT_PROGBITS
;
1841 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1842 i
< elf_elfheader (abfd
)->e_shnum
;
1845 Elf_Internal_Shdr
*hdr
;
1849 /* Ignore any section which will not be part of the process
1851 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1854 /* If this section fits in the segment we are constructing, add
1856 if (phdr
->p_type
!= PT_NULL
1857 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1858 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1859 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1861 bfd_size_type adjust
;
1863 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1864 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1865 if (hdr
->sh_type
!= SHT_NOBITS
)
1866 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1867 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1868 phdr
->p_flags
|= PF_W
;
1869 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1870 phdr
->p_flags
|= PF_X
;
1871 last_type
= hdr
->sh_type
;
1875 /* If we have a segment, move to the next one. */
1876 if (phdr
->p_type
!= PT_NULL
)
1882 /* Start a new segment. */
1883 phdr
->p_type
= PT_LOAD
;
1884 phdr
->p_offset
= hdr
->sh_offset
;
1885 phdr
->p_vaddr
= hdr
->sh_addr
;
1887 if (hdr
->sh_type
== SHT_NOBITS
)
1890 phdr
->p_filesz
= hdr
->sh_size
;
1891 phdr
->p_memsz
= hdr
->sh_size
;
1892 phdr
->p_flags
= PF_R
;
1893 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1894 phdr
->p_flags
|= PF_W
;
1895 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1896 phdr
->p_flags
|= PF_X
;
1897 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1901 && (sinterp
->flags
& SEC_LOAD
) != 0)
1903 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1904 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1905 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1906 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1909 last_type
= hdr
->sh_type
;
1912 if (phdr
->p_type
!= PT_NULL
)
1918 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1919 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1920 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1922 phdr
->p_type
= PT_DYNAMIC
;
1923 phdr
->p_offset
= sdyn
->filepos
;
1924 phdr
->p_vaddr
= sdyn
->vma
;
1926 phdr
->p_filesz
= sdyn
->_raw_size
;
1927 phdr
->p_memsz
= sdyn
->_raw_size
;
1928 phdr
->p_flags
= PF_R
;
1929 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1930 phdr
->p_flags
|= PF_W
;
1931 if ((sdyn
->flags
& SEC_CODE
) != 0)
1932 phdr
->p_flags
|= PF_X
;
1933 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1939 /* Make sure the return value from get_program_header_size matches
1940 what we computed here. Actually, it's OK if we allocated too
1941 much space in the program header. */
1942 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1945 /* Set up program header information. */
1946 i_ehdrp
= elf_elfheader (abfd
);
1947 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1948 i_ehdrp
->e_phoff
= off
;
1949 i_ehdrp
->e_phnum
= phdr_count
;
1951 /* Save the program headers away. I don't think anybody uses this
1952 information right now. */
1953 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1956 * sizeof (Elf_Internal_Phdr
))));
1957 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1959 bfd_set_error (bfd_error_no_memory
);
1960 return (file_ptr
) -1;
1962 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1963 phdr_count
* sizeof (Elf_Internal_Phdr
));
1965 /* Write out the program headers. */
1966 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1967 return (file_ptr
) -1;
1969 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1971 Elf_External_Phdr extphdr
;
1973 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1974 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1975 != sizeof (Elf_External_Phdr
))
1976 return (file_ptr
) -1;
1979 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1982 /* Work out the file positions of all the sections. This is called by
1983 elf_compute_section_file_positions. All the section sizes and VMAs
1984 must be known before this is called.
1986 We do not consider reloc sections at this point, unless they form
1987 part of the loadable image. Reloc sections are assigned file
1988 positions in assign_file_positions_for_relocs, which is called by
1989 write_object_contents and final_link.
1991 If DOSYMS is false, we do not assign file positions for the symbol
1992 table or the string table. */
1995 assign_file_positions_except_relocs (abfd
, dosyms
)
1999 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2000 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2001 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2004 /* Start after the ELF header. */
2005 off
= i_ehdrp
->e_ehsize
;
2007 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2009 Elf_Internal_Shdr
**hdrpp
;
2012 /* We are not creating an executable, which means that we are
2013 not creating a program header, and that the actual order of
2014 the sections in the file is unimportant. */
2015 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2017 Elf_Internal_Shdr
*hdr
;
2020 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2022 hdr
->sh_offset
= -1;
2026 && (i
== tdata
->symtab_section
2027 || i
== tdata
->strtab_section
))
2029 hdr
->sh_offset
= -1;
2033 off
= assign_file_position_for_section (hdr
, off
, true);
2039 bfd_size_type phdr_size
;
2040 bfd_vma maxpagesize
;
2042 Elf_Internal_Shdr
**sorted_hdrs
;
2043 Elf_Internal_Shdr
**hdrpp
;
2045 Elf_Internal_Shdr
*first
;
2048 /* We are creating an executable. We must create a program
2049 header. We can't actually create the program header until we
2050 have set the file positions for the sections, but we can
2051 figure out how big it is going to be. */
2052 off
= align_file_position (off
);
2053 phdr_size
= get_program_header_size (abfd
);
2054 if (phdr_size
== (file_ptr
) -1)
2059 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2060 if (maxpagesize
== 0)
2063 /* We must sort the sections. The GNU linker will always create
2064 the sections in an appropriate order, but the Irix 5 linker
2065 will not. We don't include the dummy first section in the
2066 sort. We sort sections which are not SHF_ALLOC to the end. */
2067 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2068 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2069 if (sorted_hdrs
== NULL
)
2071 bfd_set_error (bfd_error_no_memory
);
2075 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2076 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2080 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2082 Elf_Internal_Shdr
*hdr
;
2085 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2087 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2089 hdr
->sh_offset
= -1;
2093 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2094 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2096 hdr
->sh_offset
= -1;
2105 /* The section VMA must equal the file position modulo
2106 the page size. This is required by the program
2108 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2111 off
= assign_file_position_for_section (hdr
, off
, false);
2114 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2115 if (phdr_map
== (file_ptr
) -1)
2117 BFD_ASSERT (phdr_map
<= phdr_off
+ phdr_size
);
2120 /* Place the section headers. */
2121 off
= align_file_position (off
);
2122 i_ehdrp
->e_shoff
= off
;
2123 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2125 elf_tdata (abfd
)->next_file_pos
= off
;
2130 /* Sort the ELF headers by VMA. We sort headers which are not
2131 SHF_ALLOC to the end. */
2134 elf_sort_hdrs (arg1
, arg2
)
2138 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2139 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2141 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2143 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2145 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2147 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2154 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2164 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2165 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2166 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2168 struct bfd_strtab_hash
*shstrtab
;
2170 i_ehdrp
= elf_elfheader (abfd
);
2171 i_shdrp
= elf_elfsections (abfd
);
2173 shstrtab
= elf_stringtab_init ();
2174 if (shstrtab
== NULL
)
2177 elf_shstrtab (abfd
) = shstrtab
;
2179 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2180 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2181 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2182 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2184 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2185 i_ehdrp
->e_ident
[EI_DATA
] =
2186 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2187 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2189 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2190 i_ehdrp
->e_ident
[count
] = 0;
2192 if ((abfd
->flags
& DYNAMIC
) != 0)
2193 i_ehdrp
->e_type
= ET_DYN
;
2194 else if ((abfd
->flags
& EXEC_P
) != 0)
2195 i_ehdrp
->e_type
= ET_EXEC
;
2197 i_ehdrp
->e_type
= ET_REL
;
2199 switch (bfd_get_arch (abfd
))
2201 case bfd_arch_unknown
:
2202 i_ehdrp
->e_machine
= EM_NONE
;
2204 case bfd_arch_sparc
:
2206 i_ehdrp
->e_machine
= EM_SPARC64
;
2208 i_ehdrp
->e_machine
= EM_SPARC
;
2212 i_ehdrp
->e_machine
= EM_386
;
2215 i_ehdrp
->e_machine
= EM_68K
;
2218 i_ehdrp
->e_machine
= EM_88K
;
2221 i_ehdrp
->e_machine
= EM_860
;
2223 case bfd_arch_mips
: /* MIPS Rxxxx */
2224 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2227 i_ehdrp
->e_machine
= EM_PARISC
;
2229 case bfd_arch_powerpc
:
2230 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2232 /* start-sanitize-arc */
2234 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2236 /* end-sanitize-arc */
2237 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2239 i_ehdrp
->e_machine
= EM_NONE
;
2241 i_ehdrp
->e_version
= EV_CURRENT
;
2242 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2244 /* no program header, for now. */
2245 i_ehdrp
->e_phoff
= 0;
2246 i_ehdrp
->e_phentsize
= 0;
2247 i_ehdrp
->e_phnum
= 0;
2249 /* each bfd section is section header entry */
2250 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2251 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2253 /* if we're building an executable, we'll need a program header table */
2254 if (abfd
->flags
& EXEC_P
)
2256 /* it all happens later */
2258 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2260 /* elf_build_phdrs() returns a (NULL-terminated) array of
2261 Elf_Internal_Phdrs */
2262 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2263 i_ehdrp
->e_phoff
= outbase
;
2264 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2269 i_ehdrp
->e_phentsize
= 0;
2271 i_ehdrp
->e_phoff
= 0;
2274 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2275 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2276 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2277 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2278 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2279 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2280 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2281 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2282 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2289 swap_out_syms (abfd
, sttp
)
2291 struct bfd_strtab_hash
**sttp
;
2293 if (!elf_map_symbols (abfd
))
2296 /* Dump out the symtabs. */
2298 int symcount
= bfd_get_symcount (abfd
);
2299 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2300 struct bfd_strtab_hash
*stt
;
2301 Elf_Internal_Shdr
*symtab_hdr
;
2302 Elf_Internal_Shdr
*symstrtab_hdr
;
2303 Elf_External_Sym
*outbound_syms
;
2306 stt
= elf_stringtab_init ();
2310 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2311 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2312 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2313 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2314 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2315 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2317 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2318 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2320 outbound_syms
= ((Elf_External_Sym
*)
2322 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2323 if (outbound_syms
== NULL
)
2325 bfd_set_error (bfd_error_no_memory
);
2328 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2330 /* now generate the data (for "contents") */
2332 /* Fill in zeroth symbol and swap it out. */
2333 Elf_Internal_Sym sym
;
2339 sym
.st_shndx
= SHN_UNDEF
;
2340 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2343 for (idx
= 0; idx
< symcount
; idx
++)
2345 Elf_Internal_Sym sym
;
2346 bfd_vma value
= syms
[idx
]->value
;
2347 elf_symbol_type
*type_ptr
;
2349 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2350 /* Section symbols have no names. */
2354 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2357 if (sym
.st_name
== (unsigned long) -1)
2361 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2363 if (bfd_is_com_section (syms
[idx
]->section
))
2365 /* ELF common symbols put the alignment into the `value' field,
2366 and the size into the `size' field. This is backwards from
2367 how BFD handles it, so reverse it here. */
2368 sym
.st_size
= value
;
2369 if (type_ptr
== NULL
2370 || type_ptr
->internal_elf_sym
.st_value
== 0)
2371 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2373 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2374 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2375 syms
[idx
]->section
);
2379 asection
*sec
= syms
[idx
]->section
;
2382 if (sec
->output_section
)
2384 value
+= sec
->output_offset
;
2385 sec
= sec
->output_section
;
2388 sym
.st_value
= value
;
2389 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2390 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2394 /* Writing this would be a hell of a lot easier if we had
2395 some decent documentation on bfd, and knew what to expect
2396 of the library, and what to demand of applications. For
2397 example, it appears that `objcopy' might not set the
2398 section of a symbol to be a section that is actually in
2400 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2401 BFD_ASSERT (sec2
!= 0);
2402 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2403 BFD_ASSERT (shndx
!= -1);
2407 if (bfd_is_com_section (syms
[idx
]->section
))
2408 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2409 else if (bfd_is_und_section (syms
[idx
]->section
))
2410 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2411 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2414 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2415 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2416 else if (syms
[idx
]->flags
& BSF_FILE
)
2417 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2420 int bind
= STB_LOCAL
;
2421 int type
= STT_OBJECT
;
2422 unsigned int flags
= syms
[idx
]->flags
;
2424 if (flags
& BSF_LOCAL
)
2426 else if (flags
& BSF_WEAK
)
2428 else if (flags
& BSF_GLOBAL
)
2431 if (flags
& BSF_FUNCTION
)
2434 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2438 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2443 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2444 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2446 symstrtab_hdr
->sh_flags
= 0;
2447 symstrtab_hdr
->sh_addr
= 0;
2448 symstrtab_hdr
->sh_entsize
= 0;
2449 symstrtab_hdr
->sh_link
= 0;
2450 symstrtab_hdr
->sh_info
= 0;
2451 symstrtab_hdr
->sh_addralign
= 1;
2458 write_shdrs_and_ehdr (abfd
)
2461 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2462 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2463 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2464 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2467 i_ehdrp
= elf_elfheader (abfd
);
2468 i_shdrp
= elf_elfsections (abfd
);
2470 /* swap the header before spitting it out... */
2473 elf_debug_file (i_ehdrp
);
2475 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2476 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2477 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2478 != sizeof (x_ehdr
)))
2481 /* at this point we've concocted all the ELF sections... */
2482 x_shdrp
= (Elf_External_Shdr
*)
2483 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2486 bfd_set_error (bfd_error_no_memory
);
2490 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2493 elf_debug_section (count
, i_shdrp
[count
]);
2495 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2497 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2498 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2499 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2502 /* need to dump the string table too... */
2507 /* Assign file positions for all the reloc sections which are not part
2508 of the loadable file image. */
2511 assign_file_positions_for_relocs (abfd
)
2516 Elf_Internal_Shdr
**shdrpp
;
2518 off
= elf_tdata (abfd
)->next_file_pos
;
2520 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2521 i
< elf_elfheader (abfd
)->e_shnum
;
2524 Elf_Internal_Shdr
*shdrp
;
2527 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2528 && shdrp
->sh_offset
== -1)
2529 off
= assign_file_position_for_section (shdrp
, off
, true);
2532 elf_tdata (abfd
)->next_file_pos
= off
;
2536 NAME(bfd_elf
,write_object_contents
) (abfd
)
2539 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2540 Elf_Internal_Ehdr
*i_ehdrp
;
2541 Elf_Internal_Shdr
**i_shdrp
;
2544 if (! abfd
->output_has_begun
2545 && ! elf_compute_section_file_positions (abfd
,
2546 (struct bfd_link_info
*) NULL
))
2549 i_shdrp
= elf_elfsections (abfd
);
2550 i_ehdrp
= elf_elfheader (abfd
);
2552 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2553 assign_file_positions_for_relocs (abfd
);
2555 /* After writing the headers, we need to write the sections too... */
2556 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2558 if (bed
->elf_backend_section_processing
)
2559 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2560 if (i_shdrp
[count
]->contents
)
2562 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2563 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2565 != i_shdrp
[count
]->sh_size
))
2570 /* Write out the section header names. */
2571 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2572 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2575 if (bed
->elf_backend_final_write_processing
)
2576 (*bed
->elf_backend_final_write_processing
) (abfd
,
2577 elf_tdata (abfd
)->linker
);
2579 return write_shdrs_and_ehdr (abfd
);
2582 /* Given an ELF section number, retrieve the corresponding BFD
2586 section_from_elf_index (abfd
, index
)
2590 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2591 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2593 return elf_elfsections (abfd
)[index
]->bfd_section
;
2596 /* given a section, search the header to find them... */
2598 elf_section_from_bfd_section (abfd
, asect
)
2602 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2603 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2605 Elf_Internal_Shdr
*hdr
;
2606 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2608 if (bfd_is_abs_section (asect
))
2610 if (bfd_is_com_section (asect
))
2612 if (bfd_is_und_section (asect
))
2615 for (index
= 0; index
< maxindex
; index
++)
2617 hdr
= i_shdrp
[index
];
2618 if (hdr
->bfd_section
== asect
)
2622 if (bed
->elf_backend_section_from_bfd_section
)
2624 for (index
= 0; index
< maxindex
; index
++)
2628 hdr
= i_shdrp
[index
];
2630 if ((*bed
->elf_backend_section_from_bfd_section
)
2631 (abfd
, hdr
, asect
, &retval
))
2639 /* given a symbol, return the bfd index for that symbol. */
2641 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2643 struct symbol_cache_entry
**asym_ptr_ptr
;
2645 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2647 flagword flags
= asym_ptr
->flags
;
2649 /* When gas creates relocations against local labels, it creates its
2650 own symbol for the section, but does put the symbol into the
2651 symbol chain, so udata is 0. When the linker is generating
2652 relocatable output, this section symbol may be for one of the
2653 input sections rather than the output section. */
2654 if (asym_ptr
->udata
.i
== 0
2655 && (flags
& BSF_SECTION_SYM
)
2656 && asym_ptr
->section
)
2660 if (asym_ptr
->section
->output_section
!= NULL
)
2661 indx
= asym_ptr
->section
->output_section
->index
;
2663 indx
= asym_ptr
->section
->index
;
2664 if (elf_section_syms (abfd
)[indx
])
2665 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2668 idx
= asym_ptr
->udata
.i
;
2676 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2677 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2686 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2688 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2691 Elf_Internal_Shdr
*hdr
;
2692 long symcount
; /* Number of external ELF symbols */
2693 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2694 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2695 Elf_Internal_Sym i_sym
;
2696 Elf_External_Sym
*x_symp
= NULL
;
2698 /* Read each raw ELF symbol, converting from external ELF form to
2699 internal ELF form, and then using the information to create a
2700 canonical bfd symbol table entry.
2702 Note that we allocate the initial bfd canonical symbol buffer
2703 based on a one-to-one mapping of the ELF symbols to canonical
2704 symbols. We actually use all the ELF symbols, so there will be no
2705 space left over at the end. When we have all the symbols, we
2706 build the caller's pointer vector. */
2709 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2711 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2712 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2715 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2718 sym
= symbase
= NULL
;
2723 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2726 symbase
= ((elf_symbol_type
*)
2727 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2728 if (symbase
== (elf_symbol_type
*) NULL
)
2730 bfd_set_error (bfd_error_no_memory
);
2735 /* Temporarily allocate room for the raw ELF symbols. */
2736 x_symp
= ((Elf_External_Sym
*)
2737 malloc (symcount
* sizeof (Elf_External_Sym
)));
2738 if (x_symp
== NULL
&& symcount
!= 0)
2740 bfd_set_error (bfd_error_no_memory
);
2744 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2745 != symcount
* sizeof (Elf_External_Sym
))
2747 /* Skip first symbol, which is a null dummy. */
2748 for (i
= 1; i
< symcount
; i
++)
2750 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2751 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2752 #ifdef ELF_KEEP_EXTSYM
2753 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2755 sym
->symbol
.the_bfd
= abfd
;
2757 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2760 sym
->symbol
.value
= i_sym
.st_value
;
2762 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2764 sym
->symbol
.section
= section_from_elf_index (abfd
,
2766 if (sym
->symbol
.section
== NULL
)
2768 /* This symbol is in a section for which we did not
2769 create a BFD section. Just use bfd_abs_section,
2770 although it is wrong. FIXME. */
2771 sym
->symbol
.section
= bfd_abs_section_ptr
;
2774 else if (i_sym
.st_shndx
== SHN_ABS
)
2776 sym
->symbol
.section
= bfd_abs_section_ptr
;
2778 else if (i_sym
.st_shndx
== SHN_COMMON
)
2780 sym
->symbol
.section
= bfd_com_section_ptr
;
2781 /* Elf puts the alignment into the `value' field, and
2782 the size into the `size' field. BFD wants to see the
2783 size in the value field, and doesn't care (at the
2784 moment) about the alignment. */
2785 sym
->symbol
.value
= i_sym
.st_size
;
2787 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2789 sym
->symbol
.section
= bfd_und_section_ptr
;
2792 sym
->symbol
.section
= bfd_abs_section_ptr
;
2794 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2796 switch (ELF_ST_BIND (i_sym
.st_info
))
2799 sym
->symbol
.flags
|= BSF_LOCAL
;
2802 sym
->symbol
.flags
|= BSF_GLOBAL
;
2805 sym
->symbol
.flags
|= BSF_WEAK
;
2809 switch (ELF_ST_TYPE (i_sym
.st_info
))
2812 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2815 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2818 sym
->symbol
.flags
|= BSF_FUNCTION
;
2823 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2825 /* Do some backend-specific processing on this symbol. */
2827 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2828 if (ebd
->elf_backend_symbol_processing
)
2829 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2836 /* Do some backend-specific processing on this symbol table. */
2838 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2839 if (ebd
->elf_backend_symbol_table_processing
)
2840 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2843 /* We rely on the zalloc to clear out the final symbol entry. */
2845 symcount
= sym
- symbase
;
2847 /* Fill in the user's symbol pointer vector if needed. */
2855 *symptrs
++ = &sym
->symbol
;
2858 *symptrs
= 0; /* Final null pointer */
2870 /* Return the number of bytes required to hold the symtab vector.
2872 Note that we base it on the count plus 1, since we will null terminate
2873 the vector allocated based on this size. However, the ELF symbol table
2874 always has a dummy entry as symbol #0, so it ends up even. */
2877 elf_get_symtab_upper_bound (abfd
)
2882 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2884 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2885 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2891 elf_get_dynamic_symtab_upper_bound (abfd
)
2896 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2898 if (elf_dynsymtab (abfd
) == 0)
2900 bfd_set_error (bfd_error_invalid_operation
);
2904 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2905 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2911 elf_get_reloc_upper_bound (abfd
, asect
)
2915 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2918 /* Read in and swap the external relocs. */
2921 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2926 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2927 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2928 PTR allocated
= NULL
;
2929 bfd_byte
*native_relocs
;
2935 if (asect
->relocation
!= NULL
2936 || (asect
->flags
& SEC_RELOC
) == 0
2937 || asect
->reloc_count
== 0)
2940 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2941 && (asect
->reloc_count
2942 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2944 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2945 if (allocated
== NULL
)
2947 bfd_set_error (bfd_error_no_memory
);
2951 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2952 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2953 != d
->rel_hdr
.sh_size
))
2956 native_relocs
= (bfd_byte
*) allocated
;
2958 relents
= ((arelent
*)
2959 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2960 if (relents
== NULL
)
2962 bfd_set_error (bfd_error_no_memory
);
2966 entsize
= d
->rel_hdr
.sh_entsize
;
2967 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2968 || entsize
== sizeof (Elf_External_Rela
));
2970 for (i
= 0, relent
= relents
;
2971 i
< asect
->reloc_count
;
2972 i
++, relent
++, native_relocs
+= entsize
)
2974 Elf_Internal_Rela rela
;
2975 Elf_Internal_Rel rel
;
2977 if (entsize
== sizeof (Elf_External_Rela
))
2978 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2981 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2982 rela
.r_offset
= rel
.r_offset
;
2983 rela
.r_info
= rel
.r_info
;
2987 /* The address of an ELF reloc is section relative for an object
2988 file, and absolute for an executable file or shared library.
2989 The address of a BFD reloc is always section relative. */
2990 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2991 relent
->address
= rela
.r_offset
;
2993 relent
->address
= rela
.r_offset
- asect
->vma
;
2995 if (ELF_R_SYM (rela
.r_info
) == 0)
2996 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3001 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3004 /* Canonicalize ELF section symbols. FIXME: Why? */
3005 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3006 relent
->sym_ptr_ptr
= ps
;
3008 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3011 relent
->addend
= rela
.r_addend
;
3013 if (entsize
== sizeof (Elf_External_Rela
))
3014 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3016 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3019 asect
->relocation
= relents
;
3021 if (allocated
!= NULL
)
3027 if (allocated
!= NULL
)
3034 elf_debug_section (num
, hdr
)
3036 Elf_Internal_Shdr
*hdr
;
3038 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3039 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3042 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3043 (long) hdr
->sh_name
,
3044 (long) hdr
->sh_type
,
3045 (long) hdr
->sh_flags
);
3047 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3048 (long) hdr
->sh_addr
,
3049 (long) hdr
->sh_offset
,
3050 (long) hdr
->sh_size
);
3052 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3053 (long) hdr
->sh_link
,
3054 (long) hdr
->sh_info
,
3055 (long) hdr
->sh_addralign
);
3056 fprintf (stderr
, "sh_entsize = %ld\n",
3057 (long) hdr
->sh_entsize
);
3062 elf_debug_file (ehdrp
)
3063 Elf_Internal_Ehdr
*ehdrp
;
3065 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3066 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3067 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3068 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3069 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3070 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3071 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3075 /* Canonicalize the relocs. */
3078 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3087 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3090 tblptr
= section
->relocation
;
3091 for (i
= 0; i
< section
->reloc_count
; i
++)
3092 *relptr
++ = tblptr
++;
3096 return section
->reloc_count
;
3100 elf_get_symtab (abfd
, alocation
)
3102 asymbol
**alocation
;
3104 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3107 bfd_get_symcount (abfd
) = symcount
;
3112 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3114 asymbol
**alocation
;
3116 return elf_slurp_symbol_table (abfd
, alocation
, true);
3120 elf_make_empty_symbol (abfd
)
3123 elf_symbol_type
*newsym
;
3125 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3128 bfd_set_error (bfd_error_no_memory
);
3133 newsym
->symbol
.the_bfd
= abfd
;
3134 return &newsym
->symbol
;
3139 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3144 bfd_symbol_info (symbol
, ret
);
3148 elf_get_lineno (ignore_abfd
, symbol
)
3152 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3159 elf_set_arch_mach (abfd
, arch
, machine
)
3161 enum bfd_architecture arch
;
3162 unsigned long machine
;
3164 /* If this isn't the right architecture for this backend, and this
3165 isn't the generic backend, fail. */
3166 if (arch
!= get_elf_backend_data (abfd
)->arch
3167 && arch
!= bfd_arch_unknown
3168 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3171 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3175 elf_find_nearest_line (abfd
,
3186 CONST
char **filename_ptr
;
3187 CONST
char **functionname_ptr
;
3188 unsigned int *line_ptr
;
3194 elf_sizeof_headers (abfd
, reloc
)
3200 ret
= sizeof (Elf_External_Ehdr
);
3202 ret
+= get_program_header_size (abfd
);
3207 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3212 bfd_size_type count
;
3214 Elf_Internal_Shdr
*hdr
;
3216 if (! abfd
->output_has_begun
3217 && ! elf_compute_section_file_positions (abfd
,
3218 (struct bfd_link_info
*) NULL
))
3221 hdr
= &elf_section_data (section
)->this_hdr
;
3223 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3225 if (bfd_write (location
, 1, count
, abfd
) != count
)
3232 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3235 Elf_Internal_Rela
*dst
;
3237 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3243 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3246 Elf_Internal_Rel
*dst
;
3248 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3254 /* Core file support */
3256 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3257 #include <sys/procfs.h>
3259 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3260 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3261 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3267 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3274 prstatus_t
*status
= (prstatus_t
*) 0;
3276 if (descsz
== sizeof (prstatus_t
))
3278 newsect
= bfd_make_section (abfd
, ".reg");
3279 if (newsect
== NULL
)
3281 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3282 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3283 newsect
->flags
= SEC_HAS_CONTENTS
;
3284 newsect
->alignment_power
= 2;
3285 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3287 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3293 /* Stash a copy of the prpsinfo structure away for future use. */
3296 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3302 if (descsz
== sizeof (prpsinfo_t
))
3304 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3306 bfd_set_error (bfd_error_no_memory
);
3309 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3315 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3323 newsect
= bfd_make_section (abfd
, ".reg2");
3324 if (newsect
== NULL
)
3326 newsect
->_raw_size
= descsz
;
3327 newsect
->filepos
= filepos
;
3328 newsect
->flags
= SEC_HAS_CONTENTS
;
3329 newsect
->alignment_power
= 2;
3333 #endif /* HAVE_PROCFS */
3335 /* Return a pointer to the args (including the command name) that were
3336 seen by the program that generated the core dump. Note that for
3337 some reason, a spurious space is tacked onto the end of the args
3338 in some (at least one anyway) implementations, so strip it off if
3342 elf_core_file_failing_command (abfd
)
3346 if (core_prpsinfo (abfd
))
3348 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3349 char *scan
= p
->pr_psargs
;
3354 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3358 return p
->pr_psargs
;
3364 /* Return the number of the signal that caused the core dump. Presumably,
3365 since we have a core file, we got a signal of some kind, so don't bother
3366 checking the other process status fields, just return the signal number.
3370 elf_core_file_failing_signal (abfd
)
3374 if (core_prstatus (abfd
))
3376 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3382 /* Check to see if the core file could reasonably be expected to have
3383 come for the current executable file. Note that by default we return
3384 true unless we find something that indicates that there might be a
3389 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3398 /* First, xvecs must match since both are ELF files for the same target. */
3400 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3402 bfd_set_error (bfd_error_system_call
);
3408 /* If no prpsinfo, just return true. Otherwise, grab the last component
3409 of the exec'd pathname from the prpsinfo. */
3411 if (core_prpsinfo (core_bfd
))
3413 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3420 /* Find the last component of the executable pathname. */
3422 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3428 execname
= (char *) exec_bfd
->filename
;
3431 /* See if they match */
3433 return strcmp (execname
, corename
) ? false : true;
3439 #endif /* HAVE_PROCFS */
3442 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3443 the information that would normally be available from the /proc interface
3444 for the process, at the time the process dumped core. Currently this
3445 includes copies of the prstatus, prpsinfo, and fpregset structures.
3447 Since these structures are potentially machine dependent in size and
3448 ordering, bfd provides two levels of support for them. The first level,
3449 available on all machines since it does not require that the host
3450 have /proc support or the relevant include files, is to create a bfd
3451 section for each of the prstatus, prpsinfo, and fpregset structures,
3452 without any interpretation of their contents. With just this support,
3453 the bfd client will have to interpret the structures itself. Even with
3454 /proc support, it might want these full structures for it's own reasons.
3456 In the second level of support, where HAVE_PROCFS is defined, bfd will
3457 pick apart the structures to gather some additional information that
3458 clients may want, such as the general register set, the name of the
3459 exec'ed file and its arguments, the signal (if any) that caused the
3465 elf_corefile_note (abfd
, hdr
)
3467 Elf_Internal_Phdr
*hdr
;
3469 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3470 Elf_Internal_Note i_note
; /* Elf note, internal form */
3471 char *buf
= NULL
; /* Entire note segment contents */
3472 char *namedata
; /* Name portion of the note */
3473 char *descdata
; /* Descriptor portion of the note */
3474 char *sectname
; /* Name to use for new section */
3475 long filepos
; /* File offset to descriptor data */
3478 if (hdr
->p_filesz
> 0
3479 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3480 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3481 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3483 x_note_p
= (Elf_External_Note
*) buf
;
3484 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3486 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3487 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3488 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3489 namedata
= x_note_p
->name
;
3490 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3491 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3492 switch (i_note
.type
)
3495 /* process descdata as prstatus info */
3496 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3498 sectname
= ".prstatus";
3501 /* process descdata as fpregset info */
3502 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3504 sectname
= ".fpregset";
3507 /* process descdata as prpsinfo */
3508 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3510 sectname
= ".prpsinfo";
3513 /* Unknown descriptor, just ignore it. */
3517 if (sectname
!= NULL
)
3519 newsect
= bfd_make_section (abfd
, sectname
);
3520 if (newsect
== NULL
)
3522 newsect
->_raw_size
= i_note
.descsz
;
3523 newsect
->filepos
= filepos
;
3524 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3525 newsect
->alignment_power
= 2;
3527 x_note_p
= (Elf_External_Note
*)
3528 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3535 else if (hdr
->p_filesz
> 0)
3537 bfd_set_error (bfd_error_no_memory
);
3544 /* Core files are simply standard ELF formatted files that partition
3545 the file using the execution view of the file (program header table)
3546 rather than the linking view. In fact, there is no section header
3547 table in a core file.
3549 The process status information (including the contents of the general
3550 register set) and the floating point register set are stored in a
3551 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3552 that allow standard bfd access to the general registers (.reg) and the
3553 floating point registers (.reg2).
3558 elf_core_file_p (abfd
)
3561 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3562 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3563 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3564 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3565 unsigned int phindex
;
3566 struct elf_backend_data
*ebd
;
3568 /* Read in the ELF header in external format. */
3570 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3572 if (bfd_get_error () != bfd_error_system_call
)
3573 bfd_set_error (bfd_error_wrong_format
);
3577 /* Now check to see if we have a valid ELF file, and one that BFD can
3578 make use of. The magic number must match, the address size ('class')
3579 and byte-swapping must match our XVEC entry, and it must have a
3580 program header table (FIXME: See comments re segments at top of this
3583 if (elf_file_p (&x_ehdr
) == false)
3586 bfd_set_error (bfd_error_wrong_format
);
3590 /* FIXME, Check EI_VERSION here ! */
3594 int desired_address_size
= ELFCLASS32
;
3597 int desired_address_size
= ELFCLASS64
;
3600 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3604 /* Switch xvec to match the specified byte order. */
3605 switch (x_ehdr
.e_ident
[EI_DATA
])
3607 case ELFDATA2MSB
: /* Big-endian */
3608 if (abfd
->xvec
->byteorder_big_p
== false)
3611 case ELFDATA2LSB
: /* Little-endian */
3612 if (abfd
->xvec
->byteorder_big_p
== true)
3615 case ELFDATANONE
: /* No data encoding specified */
3616 default: /* Unknown data encoding specified */
3620 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3621 the tdata pointer in the bfd. */
3624 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3625 if (elf_tdata (abfd
) == NULL
)
3627 bfd_set_error (bfd_error_no_memory
);
3631 /* FIXME, `wrong' returns from this point onward, leak memory. */
3633 /* Now that we know the byte order, swap in the rest of the header */
3634 i_ehdrp
= elf_elfheader (abfd
);
3635 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3637 elf_debug_file (i_ehdrp
);
3640 ebd
= get_elf_backend_data (abfd
);
3642 /* Check that the ELF e_machine field matches what this particular
3643 BFD format expects. */
3644 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3646 const bfd_target
* const *target_ptr
;
3648 if (ebd
->elf_machine_code
!= EM_NONE
)
3651 /* This is the generic ELF target. Let it match any ELF target
3652 for which we do not have a specific backend. */
3653 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3655 struct elf_backend_data
*back
;
3657 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3659 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3660 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3662 /* target_ptr is an ELF backend which matches this
3663 object file, so reject the generic ELF target. */
3669 /* If there is no program header, or the type is not a core file, then
3671 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3674 /* Allocate space for a copy of the program header table in
3675 internal form, seek to the program header table in the file,
3676 read it in, and convert it to internal form. As a simple sanity
3677 check, verify that the what BFD thinks is the size of each program
3678 header table entry actually matches the size recorded in the file. */
3680 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3682 i_phdrp
= (Elf_Internal_Phdr
*)
3683 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3686 bfd_set_error (bfd_error_no_memory
);
3689 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3691 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3693 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3696 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3699 /* Once all of the program headers have been read and converted, we
3700 can start processing them. */
3702 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3704 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3705 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3707 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3712 /* Remember the entry point specified in the ELF file header. */
3714 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3719 /* ELF linker code. */
3721 static boolean elf_link_add_object_symbols
3722 PARAMS ((bfd
*, struct bfd_link_info
*));
3723 static boolean elf_link_add_archive_symbols
3724 PARAMS ((bfd
*, struct bfd_link_info
*));
3725 static Elf_Internal_Rela
*elf_link_read_relocs
3726 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3727 static boolean elf_export_symbol
3728 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3729 static boolean elf_adjust_dynamic_symbol
3730 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3732 /* Given an ELF BFD, add symbols to the global hash table as
3736 elf_bfd_link_add_symbols (abfd
, info
)
3738 struct bfd_link_info
*info
;
3742 switch (bfd_get_format (abfd
))
3745 return elf_link_add_object_symbols (abfd
, info
);
3747 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3750 if (! bfd_check_format (first
, bfd_object
))
3752 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3754 /* On Linux, we may have an a.out archive which got
3755 recognized as an ELF archive. Therefore, we treat all
3756 archives as though they were actually of the flavour of
3757 their first element. */
3758 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3760 return elf_link_add_archive_symbols (abfd
, info
);
3762 bfd_set_error (bfd_error_wrong_format
);
3767 /* Add symbols from an ELF archive file to the linker hash table. We
3768 don't use _bfd_generic_link_add_archive_symbols because of a
3769 problem which arises on UnixWare. The UnixWare libc.so is an
3770 archive which includes an entry libc.so.1 which defines a bunch of
3771 symbols. The libc.so archive also includes a number of other
3772 object files, which also define symbols, some of which are the same
3773 as those defined in libc.so.1. Correct linking requires that we
3774 consider each object file in turn, and include it if it defines any
3775 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3776 this; it looks through the list of undefined symbols, and includes
3777 any object file which defines them. When this algorithm is used on
3778 UnixWare, it winds up pulling in libc.so.1 early and defining a
3779 bunch of symbols. This means that some of the other objects in the
3780 archive are not included in the link, which is incorrect since they
3781 precede libc.so.1 in the archive.
3783 Fortunately, ELF archive handling is simpler than that done by
3784 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3785 oddities. In ELF, if we find a symbol in the archive map, and the
3786 symbol is currently undefined, we know that we must pull in that
3789 Unfortunately, we do have to make multiple passes over the symbol
3790 table until nothing further is resolved. */
3793 elf_link_add_archive_symbols (abfd
, info
)
3795 struct bfd_link_info
*info
;
3798 boolean
*defined
= NULL
;
3799 boolean
*included
= NULL
;
3803 if (! bfd_has_map (abfd
))
3805 /* An empty archive is a special case. */
3806 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3808 bfd_set_error (bfd_error_no_symbols
);
3812 /* Keep track of all symbols we know to be already defined, and all
3813 files we know to be already included. This is to speed up the
3814 second and subsequent passes. */
3815 c
= bfd_ardata (abfd
)->symdef_count
;
3818 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3819 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3820 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3822 bfd_set_error (bfd_error_no_memory
);
3825 memset (defined
, 0, c
* sizeof (boolean
));
3826 memset (included
, 0, c
* sizeof (boolean
));
3828 symdefs
= bfd_ardata (abfd
)->symdefs
;
3841 symdefend
= symdef
+ c
;
3842 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3844 struct elf_link_hash_entry
*h
;
3846 struct bfd_link_hash_entry
*undefs_tail
;
3849 if (defined
[i
] || included
[i
])
3851 if (symdef
->file_offset
== last
)
3857 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3858 false, false, false);
3859 if (h
== (struct elf_link_hash_entry
*) NULL
)
3861 if (h
->root
.type
!= bfd_link_hash_undefined
)
3867 /* We need to include this archive member. */
3869 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3870 if (element
== (bfd
*) NULL
)
3873 if (! bfd_check_format (element
, bfd_object
))
3876 /* Doublecheck that we have not included this object
3877 already--it should be impossible, but there may be
3878 something wrong with the archive. */
3879 if (element
->archive_pass
!= 0)
3881 bfd_set_error (bfd_error_bad_value
);
3884 element
->archive_pass
= 1;
3886 undefs_tail
= info
->hash
->undefs_tail
;
3888 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3891 if (! elf_link_add_object_symbols (element
, info
))
3894 /* If there are any new undefined symbols, we need to make
3895 another pass through the archive in order to see whether
3896 they can be defined. FIXME: This isn't perfect, because
3897 common symbols wind up on undefs_tail and because an
3898 undefined symbol which is defined later on in this pass
3899 does not require another pass. This isn't a bug, but it
3900 does make the code less efficient than it could be. */
3901 if (undefs_tail
!= info
->hash
->undefs_tail
)
3904 /* Look backward to mark all symbols from this object file
3905 which we have already seen in this pass. */
3909 included
[mark
] = true;
3914 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3916 /* We mark subsequent symbols from this object file as we go
3917 on through the loop. */
3918 last
= symdef
->file_offset
;
3929 if (defined
!= (boolean
*) NULL
)
3931 if (included
!= (boolean
*) NULL
)
3936 /* Record a new dynamic symbol. We record the dynamic symbols as we
3937 read the input files, since we need to have a list of all of them
3938 before we can determine the final sizes of the output sections.
3939 Note that we may actually call this function even though we are not
3940 going to output any dynamic symbols; in some cases we know that a
3941 symbol should be in the dynamic symbol table, but only if there is
3945 elf_link_record_dynamic_symbol (info
, h
)
3946 struct bfd_link_info
*info
;
3947 struct elf_link_hash_entry
*h
;
3949 if (h
->dynindx
== -1)
3951 struct bfd_strtab_hash
*dynstr
;
3953 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3954 ++elf_hash_table (info
)->dynsymcount
;
3956 dynstr
= elf_hash_table (info
)->dynstr
;
3959 /* Create a strtab to hold the dynamic symbol names. */
3960 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3965 h
->dynstr_index
= ((unsigned long)
3966 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3968 if (h
->dynstr_index
== (unsigned long) -1)
3975 /* Add symbols from an ELF object file to the linker hash table. */
3978 elf_link_add_object_symbols (abfd
, info
)
3980 struct bfd_link_info
*info
;
3982 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3983 const Elf_Internal_Sym
*,
3984 const char **, flagword
*,
3985 asection
**, bfd_vma
*));
3986 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3987 asection
*, const Elf_Internal_Rela
*));
3989 Elf_Internal_Shdr
*hdr
;
3993 Elf_External_Sym
*buf
= NULL
;
3994 struct elf_link_hash_entry
**sym_hash
;
3996 Elf_External_Dyn
*dynbuf
= NULL
;
3997 struct elf_link_hash_entry
*weaks
;
3998 Elf_External_Sym
*esym
;
3999 Elf_External_Sym
*esymend
;
4001 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4002 collect
= get_elf_backend_data (abfd
)->collect
;
4004 /* A stripped shared library might only have a dynamic symbol table,
4005 not a regular symbol table. In that case we can still go ahead
4006 and link using the dynamic symbol table. */
4007 if (elf_onesymtab (abfd
) == 0
4008 && elf_dynsymtab (abfd
) != 0)
4010 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4011 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4014 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4015 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4017 /* The sh_info field of the symtab header tells us where the
4018 external symbols start. We don't care about the local symbols at
4020 if (elf_bad_symtab (abfd
))
4022 extsymcount
= symcount
;
4027 extsymcount
= symcount
- hdr
->sh_info
;
4028 extsymoff
= hdr
->sh_info
;
4031 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4032 if (buf
== NULL
&& extsymcount
!= 0)
4034 bfd_set_error (bfd_error_no_memory
);
4038 /* We store a pointer to the hash table entry for each external
4040 sym_hash
= ((struct elf_link_hash_entry
**)
4042 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4043 if (sym_hash
== NULL
)
4045 bfd_set_error (bfd_error_no_memory
);
4048 elf_sym_hashes (abfd
) = sym_hash
;
4050 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4054 /* If we are creating a shared library, create all the dynamic
4055 sections immediately. We need to attach them to something,
4056 so we attach them to this BFD, provided it is the right
4057 format. FIXME: If there are no input BFD's of the same
4058 format as the output, we can't make a shared library. */
4060 && ! elf_hash_table (info
)->dynamic_sections_created
4061 && abfd
->xvec
== info
->hash
->creator
)
4063 if (! elf_link_create_dynamic_sections (abfd
, info
))
4071 bfd_size_type strindex
;
4075 /* You can't use -r against a dynamic object. Also, there's no
4076 hope of using a dynamic object which does not exactly match
4077 the format of the output file. */
4078 if (info
->relocateable
4079 || info
->hash
->creator
!= abfd
->xvec
)
4081 bfd_set_error (bfd_error_invalid_operation
);
4085 /* Find the name to use in a DT_NEEDED entry that refers to this
4086 object. If the object has a DT_SONAME entry, we use it.
4087 Otherwise, if the generic linker stuck something in
4088 elf_dt_needed_name, we use that. Otherwise, we just use the
4090 name
= bfd_get_filename (abfd
);
4091 if (elf_dt_needed_name (abfd
) != NULL
)
4092 name
= elf_dt_needed_name (abfd
);
4093 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4096 Elf_External_Dyn
*extdyn
;
4097 Elf_External_Dyn
*extdynend
;
4099 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4102 bfd_set_error (bfd_error_no_memory
);
4106 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4107 (file_ptr
) 0, s
->_raw_size
))
4111 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4112 for (; extdyn
< extdynend
; extdyn
++)
4114 Elf_Internal_Dyn dyn
;
4116 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4117 if (dyn
.d_tag
== DT_SONAME
)
4122 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4125 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4126 name
= elf_string_from_elf_section (abfd
, link
,
4139 /* We do not want to include any of the sections in a dynamic
4140 object in the output file. We hack by simply clobbering the
4141 list of sections in the BFD. This could be handled more
4142 cleanly by, say, a new section flag; the existing
4143 SEC_NEVER_LOAD flag is not the one we want, because that one
4144 still implies that the section takes up space in the output
4146 abfd
->sections
= NULL
;
4148 /* If this is the first dynamic object found in the link, create
4149 the special sections required for dynamic linking. */
4150 if (! elf_hash_table (info
)->dynamic_sections_created
)
4152 if (! elf_link_create_dynamic_sections (abfd
, info
))
4156 /* Add a DT_NEEDED entry for this dynamic object. */
4157 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4159 if (strindex
== (bfd_size_type
) -1)
4161 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4166 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4168 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4169 != extsymcount
* sizeof (Elf_External_Sym
)))
4174 esymend
= buf
+ extsymcount
;
4175 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4177 Elf_Internal_Sym sym
;
4183 struct elf_link_hash_entry
*h
= NULL
;
4186 elf_swap_symbol_in (abfd
, esym
, &sym
);
4188 flags
= BSF_NO_FLAGS
;
4190 value
= sym
.st_value
;
4193 bind
= ELF_ST_BIND (sym
.st_info
);
4194 if (bind
== STB_LOCAL
)
4196 /* This should be impossible, since ELF requires that all
4197 global symbols follow all local symbols, and that sh_info
4198 point to the first global symbol. Unfortunatealy, Irix 5
4202 else if (bind
== STB_GLOBAL
)
4204 else if (bind
== STB_WEAK
)
4208 /* Leave it up to the processor backend. */
4211 if (sym
.st_shndx
== SHN_UNDEF
)
4212 sec
= bfd_und_section_ptr
;
4213 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4215 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4219 sec
= bfd_abs_section_ptr
;
4221 else if (sym
.st_shndx
== SHN_ABS
)
4222 sec
= bfd_abs_section_ptr
;
4223 else if (sym
.st_shndx
== SHN_COMMON
)
4225 sec
= bfd_com_section_ptr
;
4226 /* What ELF calls the size we call the value. What ELF
4227 calls the value we call the alignment. */
4228 value
= sym
.st_size
;
4232 /* Leave it up to the processor backend. */
4235 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4236 if (name
== (const char *) NULL
)
4239 if (add_symbol_hook
)
4241 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4245 /* The hook function sets the name to NULL if this symbol
4246 should be skipped for some reason. */
4247 if (name
== (const char *) NULL
)
4251 /* Sanity check that all possibilities were handled. */
4252 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4254 bfd_set_error (bfd_error_bad_value
);
4258 if (bfd_is_und_section (sec
)
4259 || bfd_is_com_section (sec
))
4264 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4266 /* We need to look up the symbol now in order to get some of
4267 the dynamic object handling right. We pass the hash
4268 table entry in to _bfd_generic_link_add_one_symbol so
4269 that it does not have to look it up again. */
4270 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4271 true, false, false);
4276 /* If we are looking at a dynamic object, and this is a
4277 definition, we need to see if it has already been defined
4278 by some other object. If it has, we want to use the
4279 existing definition, and we do not want to report a
4280 multiple symbol definition error; we do this by
4281 clobbering sec to be bfd_und_section_ptr. */
4282 if (dynamic
&& definition
)
4284 if (h
->root
.type
== bfd_link_hash_defined
)
4285 sec
= bfd_und_section_ptr
;
4288 /* Similarly, if we are not looking at a dynamic object, and
4289 we have a definition, we want to override any definition
4290 we may have from a dynamic object. Symbols from regular
4291 files always take precedence over symbols from dynamic
4292 objects, even if they are defined after the dynamic
4293 object in the link. */
4296 && h
->root
.type
== bfd_link_hash_defined
4297 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4298 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4299 == bfd_target_elf_flavour
)
4300 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4303 /* Change the hash table entry to undefined, and let
4304 _bfd_generic_link_add_one_symbol do the right thing
4305 with the new definition. */
4306 h
->root
.type
= bfd_link_hash_undefined
;
4307 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4308 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4311 /* If this is a weak definition which we are going to use,
4312 and the symbol is currently undefined, record that the
4313 definition is weak. */
4315 && (flags
& BSF_WEAK
) != 0
4316 && ! bfd_is_und_section (sec
)
4317 && (h
->root
.type
== bfd_link_hash_new
4318 || h
->root
.type
== bfd_link_hash_undefined
4319 || h
->root
.type
== bfd_link_hash_weak
))
4320 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4323 if (! (_bfd_generic_link_add_one_symbol
4324 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4325 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4330 && (flags
& BSF_WEAK
) != 0
4331 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4332 && (*sym_hash
)->weakdef
== NULL
)
4334 /* Keep a list of all weak defined non function symbols from
4335 a dynamic object, using the weakdef field. Later in this
4336 function we will set the weakdef field to the correct
4337 value. We only put non-function symbols from dynamic
4338 objects on this list, because that happens to be the only
4339 time we need to know the normal symbol corresponding to a
4340 weak symbol, and the information is time consuming to
4341 figure out. If the weakdef field is not already NULL,
4342 then this symbol was already defined by some previous
4343 dynamic object, and we will be using that previous
4344 definition anyhow. */
4346 (*sym_hash
)->weakdef
= weaks
;
4350 /* Get the alignment of a common symbol. */
4351 if (sym
.st_shndx
== SHN_COMMON
4352 && h
->root
.type
== bfd_link_hash_common
)
4353 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4355 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4361 /* Remember the symbol size and type. */
4362 if (sym
.st_size
!= 0)
4364 /* FIXME: We should probably somehow give a warning if
4365 the symbol size changes. */
4366 h
->size
= sym
.st_size
;
4368 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4370 /* FIXME: We should probably somehow give a warning if
4371 the symbol type changes. */
4372 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4375 /* Set a flag in the hash table entry indicating the type of
4376 reference or definition we just found. Keep a count of
4377 the number of dynamic symbols we find. A dynamic symbol
4378 is one which is referenced or defined by both a regular
4379 object and a shared object, or one which is referenced or
4380 defined by more than one shared object. */
4381 old_flags
= h
->elf_link_hash_flags
;
4386 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4388 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4390 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4391 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4397 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4399 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4400 if ((old_flags
& new_flag
) != 0
4401 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4402 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4406 h
->elf_link_hash_flags
|= new_flag
;
4407 if (dynsym
&& h
->dynindx
== -1)
4409 if (! elf_link_record_dynamic_symbol (info
, h
))
4415 /* Now set the weakdefs field correctly for all the weak defined
4416 symbols we found. The only way to do this is to search all the
4417 symbols. Since we only need the information for non functions in
4418 dynamic objects, that's the only time we actually put anything on
4419 the list WEAKS. We need this information so that if a regular
4420 object refers to a symbol defined weakly in a dynamic object, the
4421 real symbol in the dynamic object is also put in the dynamic
4422 symbols; we also must arrange for both symbols to point to the
4423 same memory location. We could handle the general case of symbol
4424 aliasing, but a general symbol alias can only be generated in
4425 assembler code, handling it correctly would be very time
4426 consuming, and other ELF linkers don't handle general aliasing
4428 while (weaks
!= NULL
)
4430 struct elf_link_hash_entry
*hlook
;
4433 struct elf_link_hash_entry
**hpp
;
4434 struct elf_link_hash_entry
**hppend
;
4437 weaks
= hlook
->weakdef
;
4438 hlook
->weakdef
= NULL
;
4440 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4441 slook
= hlook
->root
.u
.def
.section
;
4442 vlook
= hlook
->root
.u
.def
.value
;
4444 hpp
= elf_sym_hashes (abfd
);
4445 hppend
= hpp
+ extsymcount
;
4446 for (; hpp
< hppend
; hpp
++)
4448 struct elf_link_hash_entry
*h
;
4452 && h
->root
.type
== bfd_link_hash_defined
4453 && h
->root
.u
.def
.section
== slook
4454 && h
->root
.u
.def
.value
== vlook
)
4458 /* If the weak definition is in the list of dynamic
4459 symbols, make sure the real definition is put there
4461 if (hlook
->dynindx
!= -1
4462 && h
->dynindx
== -1)
4464 if (! elf_link_record_dynamic_symbol (info
, h
))
4479 /* If this object is the same format as the output object, and it is
4480 not a shared library, then let the backend look through the
4483 This is required to build global offset table entries and to
4484 arrange for dynamic relocs. It is not required for the
4485 particular common case of linking non PIC code, even when linking
4486 against shared libraries, but unfortunately there is no way of
4487 knowing whether an object file has been compiled PIC or not.
4488 Looking through the relocs is not particularly time consuming.
4489 The problem is that we must either (1) keep the relocs in memory,
4490 which causes the linker to require additional runtime memory or
4491 (2) read the relocs twice from the input file, which wastes time.
4492 This would be a good case for using mmap.
4494 I have no idea how to handle linking PIC code into a file of a
4495 different format. It probably can't be done. */
4496 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4498 && abfd
->xvec
== info
->hash
->creator
4499 && check_relocs
!= NULL
)
4503 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4505 Elf_Internal_Rela
*internal_relocs
;
4508 if ((o
->flags
& SEC_RELOC
) == 0
4509 || o
->reloc_count
== 0)
4512 /* I believe we can ignore the relocs for any section which
4513 does not form part of the final process image, such as a
4514 debugging section. */
4515 if ((o
->flags
& SEC_ALLOC
) == 0)
4518 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4519 (Elf_Internal_Rela
*) NULL
,
4521 if (internal_relocs
== NULL
)
4524 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4526 if (! info
->keep_memory
)
4527 free (internal_relocs
);
4544 /* Create some sections which will be filled in with dynamic linking
4545 information. ABFD is an input file which requires dynamic sections
4546 to be created. The dynamic sections take up virtual memory space
4547 when the final executable is run, so we need to create them before
4548 addresses are assigned to the output sections. We work out the
4549 actual contents and size of these sections later. */
4552 elf_link_create_dynamic_sections (abfd
, info
)
4554 struct bfd_link_info
*info
;
4557 register asection
*s
;
4558 struct elf_link_hash_entry
*h
;
4559 struct elf_backend_data
*bed
;
4561 if (elf_hash_table (info
)->dynamic_sections_created
)
4564 /* Make sure that all dynamic sections use the same input BFD. */
4565 if (elf_hash_table (info
)->dynobj
== NULL
)
4566 elf_hash_table (info
)->dynobj
= abfd
;
4568 abfd
= elf_hash_table (info
)->dynobj
;
4570 /* Note that we set the SEC_IN_MEMORY flag for all of these
4572 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4574 /* A dynamically linked executable has a .interp section, but a
4575 shared library does not. */
4578 s
= bfd_make_section (abfd
, ".interp");
4580 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4584 s
= bfd_make_section (abfd
, ".dynsym");
4586 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4587 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4590 s
= bfd_make_section (abfd
, ".dynstr");
4592 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4595 /* Create a strtab to hold the dynamic symbol names. */
4596 if (elf_hash_table (info
)->dynstr
== NULL
)
4598 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4599 if (elf_hash_table (info
)->dynstr
== NULL
)
4603 s
= bfd_make_section (abfd
, ".dynamic");
4605 || ! bfd_set_section_flags (abfd
, s
, flags
)
4606 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4609 /* The special symbol _DYNAMIC is always set to the start of the
4610 .dynamic section. This call occurs before we have processed the
4611 symbols for any dynamic object, so we don't have to worry about
4612 overriding a dynamic definition. We could set _DYNAMIC in a
4613 linker script, but we only want to define it if we are, in fact,
4614 creating a .dynamic section. We don't want to define it if there
4615 is no .dynamic section, since on some ELF platforms the start up
4616 code examines it to decide how to initialize the process. */
4618 if (! (_bfd_generic_link_add_one_symbol
4619 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4620 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4621 (struct bfd_link_hash_entry
**) &h
)))
4623 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4624 h
->type
= STT_OBJECT
;
4627 && ! elf_link_record_dynamic_symbol (info
, h
))
4630 s
= bfd_make_section (abfd
, ".hash");
4632 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4633 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4636 /* Let the backend create the rest of the sections. This lets the
4637 backend set the right flags. The backend will normally create
4638 the .got and .plt sections. */
4639 bed
= get_elf_backend_data (abfd
);
4640 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4643 elf_hash_table (info
)->dynamic_sections_created
= true;
4648 /* Add an entry to the .dynamic table. */
4651 elf_add_dynamic_entry (info
, tag
, val
)
4652 struct bfd_link_info
*info
;
4656 Elf_Internal_Dyn dyn
;
4660 bfd_byte
*newcontents
;
4662 dynobj
= elf_hash_table (info
)->dynobj
;
4664 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4665 BFD_ASSERT (s
!= NULL
);
4667 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4668 if (s
->contents
== NULL
)
4669 newcontents
= (bfd_byte
*) malloc (newsize
);
4671 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4672 if (newcontents
== NULL
)
4674 bfd_set_error (bfd_error_no_memory
);
4679 dyn
.d_un
.d_val
= val
;
4680 elf_swap_dyn_out (dynobj
, &dyn
,
4681 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4683 s
->_raw_size
= newsize
;
4684 s
->contents
= newcontents
;
4689 /* Read and swap the relocs for a section. They may have been cached.
4690 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4691 they are used as buffers to read into. They are known to be large
4692 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4693 value is allocated using either malloc or bfd_alloc, according to
4694 the KEEP_MEMORY argument. */
4696 static Elf_Internal_Rela
*
4697 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4700 PTR external_relocs
;
4701 Elf_Internal_Rela
*internal_relocs
;
4702 boolean keep_memory
;
4704 Elf_Internal_Shdr
*rel_hdr
;
4706 Elf_Internal_Rela
*alloc2
= NULL
;
4708 if (elf_section_data (o
)->relocs
!= NULL
)
4709 return elf_section_data (o
)->relocs
;
4711 if (o
->reloc_count
== 0)
4714 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4716 if (internal_relocs
== NULL
)
4720 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4722 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4724 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4725 if (internal_relocs
== NULL
)
4727 bfd_set_error (bfd_error_no_memory
);
4732 if (external_relocs
== NULL
)
4734 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4737 bfd_set_error (bfd_error_no_memory
);
4740 external_relocs
= alloc1
;
4743 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4744 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4745 != rel_hdr
->sh_size
))
4748 /* Swap in the relocs. For convenience, we always produce an
4749 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4751 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4753 Elf_External_Rel
*erel
;
4754 Elf_External_Rel
*erelend
;
4755 Elf_Internal_Rela
*irela
;
4757 erel
= (Elf_External_Rel
*) external_relocs
;
4758 erelend
= erel
+ o
->reloc_count
;
4759 irela
= internal_relocs
;
4760 for (; erel
< erelend
; erel
++, irela
++)
4762 Elf_Internal_Rel irel
;
4764 elf_swap_reloc_in (abfd
, erel
, &irel
);
4765 irela
->r_offset
= irel
.r_offset
;
4766 irela
->r_info
= irel
.r_info
;
4767 irela
->r_addend
= 0;
4772 Elf_External_Rela
*erela
;
4773 Elf_External_Rela
*erelaend
;
4774 Elf_Internal_Rela
*irela
;
4776 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4778 erela
= (Elf_External_Rela
*) external_relocs
;
4779 erelaend
= erela
+ o
->reloc_count
;
4780 irela
= internal_relocs
;
4781 for (; erela
< erelaend
; erela
++, irela
++)
4782 elf_swap_reloca_in (abfd
, erela
, irela
);
4785 /* Cache the results for next time, if we can. */
4787 elf_section_data (o
)->relocs
= internal_relocs
;
4792 /* Don't free alloc2, since if it was allocated we are passing it
4793 back (under the name of internal_relocs). */
4795 return internal_relocs
;
4805 /* Record an assignment to a symbol made by a linker script. We need
4806 this in case some dynamic object refers to this symbol. */
4810 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4812 struct bfd_link_info
*info
;
4815 struct elf_link_hash_entry
*h
;
4817 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4821 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4822 h
->type
= STT_OBJECT
;
4824 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4825 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4827 && h
->dynindx
== -1)
4829 if (! elf_link_record_dynamic_symbol (info
, h
))
4832 /* If this is a weak defined symbol, and we know a corresponding
4833 real symbol from the same dynamic object, make sure the real
4834 symbol is also made into a dynamic symbol. */
4835 if (h
->weakdef
!= NULL
4836 && h
->weakdef
->dynindx
== -1)
4838 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4846 /* Array used to determine the number of hash table buckets to use
4847 based on the number of symbols there are. If there are fewer than
4848 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4849 fewer than 37 we use 17 buckets, and so forth. We never use more
4850 than 521 buckets. */
4852 static const size_t elf_buckets
[] =
4854 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4857 /* Set up the sizes and contents of the ELF dynamic sections. This is
4858 called by the ELF linker emulation before_allocation routine. We
4859 must set the sizes of the sections before the linker sets the
4860 addresses of the various sections. */
4863 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4864 export_dynamic
, info
, sinterpptr
)
4868 boolean export_dynamic
;
4869 struct bfd_link_info
*info
;
4870 asection
**sinterpptr
;
4874 Elf_Internal_Sym isym
;
4877 struct elf_backend_data
*bed
;
4881 dynobj
= elf_hash_table (info
)->dynobj
;
4883 /* If there were no dynamic objects in the link, there is nothing to
4888 /* If we are supposed to export all symbols into the dynamic symbol
4889 table (this is not the normal case), then do so. */
4891 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4894 if (elf_hash_table (info
)->dynamic_sections_created
)
4896 bfd_size_type strsize
;
4898 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4899 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4905 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4907 if (indx
== (bfd_size_type
) -1
4908 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4916 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4918 if (indx
== (bfd_size_type
) -1
4919 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4923 /* Find all symbols which were defined in a dynamic object and make
4924 the backend pick a reasonable value for them. */
4925 elf_link_hash_traverse (elf_hash_table (info
),
4926 elf_adjust_dynamic_symbol
,
4929 /* Add some entries to the .dynamic section. We fill in some of the
4930 values later, in elf_bfd_final_link, but we must add the entries
4931 now so that we know the final size of the .dynamic section. */
4932 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4933 false, false) != NULL
)
4935 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4938 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4939 false, false) != NULL
)
4941 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4944 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4945 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4946 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4947 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4948 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4949 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4950 sizeof (Elf_External_Sym
)))
4954 /* The backend must work out the sizes of all the other dynamic
4956 bed
= get_elf_backend_data (output_bfd
);
4957 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4960 if (elf_hash_table (info
)->dynamic_sections_created
)
4964 /* Set the size of the .dynsym and .hash sections. We counted
4965 the number of dynamic symbols in elf_link_add_object_symbols.
4966 We will build the contents of .dynsym and .hash when we build
4967 the final symbol table, because until then we do not know the
4968 correct value to give the symbols. We built the .dynstr
4969 section as we went along in elf_link_add_object_symbols. */
4970 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4971 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4972 BFD_ASSERT (s
!= NULL
);
4973 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4974 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4975 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4977 bfd_set_error (bfd_error_no_memory
);
4981 /* The first entry in .dynsym is a dummy symbol. */
4988 elf_swap_symbol_out (output_bfd
, &isym
,
4989 (Elf_External_Sym
*) s
->contents
);
4991 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4993 bucketcount
= elf_buckets
[i
];
4994 if (dynsymcount
< elf_buckets
[i
+ 1])
4998 s
= bfd_get_section_by_name (dynobj
, ".hash");
4999 BFD_ASSERT (s
!= NULL
);
5000 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5001 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5002 if (s
->contents
== NULL
)
5004 bfd_set_error (bfd_error_no_memory
);
5007 memset (s
->contents
, 0, s
->_raw_size
);
5009 put_word (output_bfd
, bucketcount
, s
->contents
);
5010 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5012 elf_hash_table (info
)->bucketcount
= bucketcount
;
5014 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5015 BFD_ASSERT (s
!= NULL
);
5016 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5018 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5025 /* This routine is used to export all defined symbols into the dynamic
5026 symbol table. It is called via elf_link_hash_traverse. */
5029 elf_export_symbol (h
, data
)
5030 struct elf_link_hash_entry
*h
;
5033 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5035 if (h
->dynindx
== -1
5036 && (h
->elf_link_hash_flags
5037 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5039 if (! elf_link_record_dynamic_symbol (info
, h
))
5041 /* FIXME: No way to report error. */
5049 /* Make the backend pick a good value for a dynamic symbol. This is
5050 called via elf_link_hash_traverse, and also calls itself
5054 elf_adjust_dynamic_symbol (h
, data
)
5055 struct elf_link_hash_entry
*h
;
5058 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5060 struct elf_backend_data
*bed
;
5062 /* If this symbol does not require a PLT entry, and it is not
5063 defined by a dynamic object, or is not referenced by a regular
5064 object, ignore it. FIXME: Do we need to worry about symbols
5065 which are defined by one dynamic object and referenced by another
5067 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5068 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5069 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5070 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5073 /* If we've already adjusted this symbol, don't do it again. This
5074 can happen via a recursive call. */
5075 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5078 /* Don't look at this symbol again. Note that we must set this
5079 after checking the above conditions, because we may look at a
5080 symbol once, decide not to do anything, and then get called
5081 recursively later after REF_REGULAR is set below. */
5082 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5084 /* If this is a weak definition, and we know a real definition, and
5085 the real symbol is not itself defined by a regular object file,
5086 then get a good value for the real definition. We handle the
5087 real symbol first, for the convenience of the backend routine.
5089 Note that there is a confusing case here. If the real definition
5090 is defined by a regular object file, we don't get the real symbol
5091 from the dynamic object, but we do get the weak symbol. If the
5092 processor backend uses a COPY reloc, then if some routine in the
5093 dynamic object changes the real symbol, we will not see that
5094 change in the corresponding weak symbol. This is the way other
5095 ELF linkers work as well, and seems to be a result of the shared
5098 I will clarify this issue. Most SVR4 shared libraries define the
5099 variable _timezone and define timezone as a weak synonym. The
5100 tzset call changes _timezone. If you write
5101 extern int timezone;
5103 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5104 you might expect that, since timezone is a synonym for _timezone,
5105 the same number will print both times. However, if the processor
5106 backend uses a COPY reloc, then actually timezone will be copied
5107 into your process image, and, since you define _timezone
5108 yourself, _timezone will not. Thus timezone and _timezone will
5109 wind up at different memory locations. The tzset call will set
5110 _timezone, leaving timezone unchanged. */
5112 if (h
->weakdef
!= NULL
)
5114 struct elf_link_hash_entry
*weakdef
;
5116 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5117 weakdef
= h
->weakdef
;
5118 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5119 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5120 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5122 /* This symbol is defined by a regular object file, so we
5123 will not do anything special. Clear weakdef for the
5124 convenience of the processor backend. */
5129 /* There is an implicit reference by a regular object file
5130 via the weak symbol. */
5131 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5132 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5137 dynobj
= elf_hash_table (info
)->dynobj
;
5138 bed
= get_elf_backend_data (dynobj
);
5139 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5141 /* FIXME: No way to return error. */
5148 /* Final phase of ELF linker. */
5150 /* A structure we use to avoid passing large numbers of arguments. */
5152 struct elf_final_link_info
5154 /* General link information. */
5155 struct bfd_link_info
*info
;
5158 /* Symbol string table. */
5159 struct bfd_strtab_hash
*symstrtab
;
5160 /* .dynsym section. */
5161 asection
*dynsym_sec
;
5162 /* .hash section. */
5164 /* Buffer large enough to hold contents of any section. */
5166 /* Buffer large enough to hold external relocs of any section. */
5167 PTR external_relocs
;
5168 /* Buffer large enough to hold internal relocs of any section. */
5169 Elf_Internal_Rela
*internal_relocs
;
5170 /* Buffer large enough to hold external local symbols of any input
5172 Elf_External_Sym
*external_syms
;
5173 /* Buffer large enough to hold internal local symbols of any input
5175 Elf_Internal_Sym
*internal_syms
;
5176 /* Array large enough to hold a symbol index for each local symbol
5177 of any input BFD. */
5179 /* Array large enough to hold a section pointer for each local
5180 symbol of any input BFD. */
5181 asection
**sections
;
5182 /* Buffer to hold swapped out symbols. */
5183 Elf_External_Sym
*symbuf
;
5184 /* Number of swapped out symbols in buffer. */
5185 size_t symbuf_count
;
5186 /* Number of symbols which fit in symbuf. */
5190 static boolean elf_link_output_sym
5191 PARAMS ((struct elf_final_link_info
*, const char *,
5192 Elf_Internal_Sym
*, asection
*));
5193 static boolean elf_link_flush_output_syms
5194 PARAMS ((struct elf_final_link_info
*));
5195 static boolean elf_link_output_extsym
5196 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5197 static boolean elf_link_input_bfd
5198 PARAMS ((struct elf_final_link_info
*, bfd
*));
5199 static boolean elf_reloc_link_order
5200 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5201 struct bfd_link_order
*));
5203 /* Do the final step of an ELF link. */
5206 elf_bfd_final_link (abfd
, info
)
5208 struct bfd_link_info
*info
;
5212 struct elf_final_link_info finfo
;
5213 register asection
*o
;
5214 register struct bfd_link_order
*p
;
5216 size_t max_contents_size
;
5217 size_t max_external_reloc_size
;
5218 size_t max_internal_reloc_count
;
5219 size_t max_sym_count
;
5221 Elf_Internal_Sym elfsym
;
5223 Elf_Internal_Shdr
*symtab_hdr
;
5224 Elf_Internal_Shdr
*symstrtab_hdr
;
5225 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5228 abfd
->flags
|= DYNAMIC
;
5230 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5231 dynobj
= elf_hash_table (info
)->dynobj
;
5234 finfo
.output_bfd
= abfd
;
5235 finfo
.symstrtab
= elf_stringtab_init ();
5236 if (finfo
.symstrtab
== NULL
)
5240 finfo
.dynsym_sec
= NULL
;
5241 finfo
.hash_sec
= NULL
;
5245 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5246 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5247 if (finfo
.dynsym_sec
== NULL
5248 || finfo
.hash_sec
== NULL
)
5251 finfo
.contents
= NULL
;
5252 finfo
.external_relocs
= NULL
;
5253 finfo
.internal_relocs
= NULL
;
5254 finfo
.external_syms
= NULL
;
5255 finfo
.internal_syms
= NULL
;
5256 finfo
.indices
= NULL
;
5257 finfo
.sections
= NULL
;
5258 finfo
.symbuf
= NULL
;
5259 finfo
.symbuf_count
= 0;
5261 /* Count up the number of relocations we will output for each output
5262 section, so that we know the sizes of the reloc sections. We
5263 also figure out some maximum sizes. */
5264 max_contents_size
= 0;
5265 max_external_reloc_size
= 0;
5266 max_internal_reloc_count
= 0;
5268 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5272 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5274 if (p
->type
== bfd_section_reloc_link_order
5275 || p
->type
== bfd_symbol_reloc_link_order
)
5277 else if (p
->type
== bfd_indirect_link_order
)
5281 sec
= p
->u
.indirect
.section
;
5283 if (info
->relocateable
)
5284 o
->reloc_count
+= sec
->reloc_count
;
5286 if (sec
->_raw_size
> max_contents_size
)
5287 max_contents_size
= sec
->_raw_size
;
5288 if (sec
->_cooked_size
> max_contents_size
)
5289 max_contents_size
= sec
->_cooked_size
;
5291 /* We are interested in just local symbols, not all
5293 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5297 if (elf_bad_symtab (sec
->owner
))
5298 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5299 / sizeof (Elf_External_Sym
));
5301 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5303 if (sym_count
> max_sym_count
)
5304 max_sym_count
= sym_count
;
5306 if ((sec
->flags
& SEC_RELOC
) != 0)
5310 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5311 if (ext_size
> max_external_reloc_size
)
5312 max_external_reloc_size
= ext_size
;
5313 if (sec
->reloc_count
> max_internal_reloc_count
)
5314 max_internal_reloc_count
= sec
->reloc_count
;
5320 if (o
->reloc_count
> 0)
5321 o
->flags
|= SEC_RELOC
;
5324 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5325 set it (this is probably a bug) and if it is set
5326 assign_section_numbers will create a reloc section. */
5327 o
->flags
&=~ SEC_RELOC
;
5330 /* If the SEC_ALLOC flag is not set, force the section VMA to
5331 zero. This is done in elf_fake_sections as well, but forcing
5332 the VMA to 0 here will ensure that relocs against these
5333 sections are handled correctly. */
5334 if ((o
->flags
& SEC_ALLOC
) == 0)
5338 /* Figure out the file positions for everything but the symbol table
5339 and the relocs. We set symcount to force assign_section_numbers
5340 to create a symbol table. */
5341 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5342 BFD_ASSERT (! abfd
->output_has_begun
);
5343 if (! elf_compute_section_file_positions (abfd
, info
))
5346 /* That created the reloc sections. Set their sizes, and assign
5347 them file positions, and allocate some buffers. */
5348 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5350 if ((o
->flags
& SEC_RELOC
) != 0)
5352 Elf_Internal_Shdr
*rel_hdr
;
5353 register struct elf_link_hash_entry
**p
, **pend
;
5355 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5357 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5359 /* The contents field must last into write_object_contents,
5360 so we allocate it with bfd_alloc rather than malloc. */
5361 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5362 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5364 bfd_set_error (bfd_error_no_memory
);
5368 p
= ((struct elf_link_hash_entry
**)
5369 malloc (o
->reloc_count
5370 * sizeof (struct elf_link_hash_entry
*)));
5371 if (p
== NULL
&& o
->reloc_count
!= 0)
5373 bfd_set_error (bfd_error_no_memory
);
5376 elf_section_data (o
)->rel_hashes
= p
;
5377 pend
= p
+ o
->reloc_count
;
5378 for (; p
< pend
; p
++)
5381 /* Use the reloc_count field as an index when outputting the
5387 assign_file_positions_for_relocs (abfd
);
5389 /* We have now assigned file positions for all the sections except
5390 .symtab and .strtab. We start the .symtab section at the current
5391 file position, and write directly to it. We build the .strtab
5392 section in memory. When we add .dynsym support, we will build
5393 that in memory as well (.dynsym is smaller than .symtab). */
5395 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5396 /* sh_name is set in prep_headers. */
5397 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5398 symtab_hdr
->sh_flags
= 0;
5399 symtab_hdr
->sh_addr
= 0;
5400 symtab_hdr
->sh_size
= 0;
5401 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5402 /* sh_link is set in assign_section_numbers. */
5403 /* sh_info is set below. */
5404 /* sh_offset is set just below. */
5405 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5407 off
= elf_tdata (abfd
)->next_file_pos
;
5408 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5410 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5411 incorrect. We do not yet know the size of the .symtab section.
5412 We correct next_file_pos below, after we do know the size. */
5414 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5415 continuously seeking to the right position in the file. */
5416 if (! info
->keep_memory
|| max_sym_count
< 20)
5417 finfo
.symbuf_size
= 20;
5419 finfo
.symbuf_size
= max_sym_count
;
5420 finfo
.symbuf
= ((Elf_External_Sym
*)
5421 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5422 if (finfo
.symbuf
== NULL
)
5424 bfd_set_error (bfd_error_no_memory
);
5428 /* Start writing out the symbol table. The first symbol is always a
5430 elfsym
.st_value
= 0;
5433 elfsym
.st_other
= 0;
5434 elfsym
.st_shndx
= SHN_UNDEF
;
5435 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5436 &elfsym
, bfd_und_section_ptr
))
5440 /* Some standard ELF linkers do this, but we don't because it causes
5441 bootstrap comparison failures. */
5442 /* Output a file symbol for the output file as the second symbol.
5443 We output this even if we are discarding local symbols, although
5444 I'm not sure if this is correct. */
5445 elfsym
.st_value
= 0;
5447 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5448 elfsym
.st_other
= 0;
5449 elfsym
.st_shndx
= SHN_ABS
;
5450 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5451 &elfsym
, bfd_abs_section_ptr
))
5455 /* Output a symbol for each section. We output these even if we are
5456 discarding local symbols, since they are used for relocs. These
5457 symbols have no names. We store the index of each one in the
5458 index field of the section, so that we can find it again when
5459 outputting relocs. */
5460 elfsym
.st_value
= 0;
5462 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5463 elfsym
.st_other
= 0;
5464 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5466 o
= section_from_elf_index (abfd
, i
);
5468 o
->target_index
= abfd
->symcount
;
5469 elfsym
.st_shndx
= i
;
5470 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5475 /* Allocate some memory to hold information read in from the input
5477 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5478 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5479 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5480 malloc (max_internal_reloc_count
5481 * sizeof (Elf_Internal_Rela
)));
5482 finfo
.external_syms
= ((Elf_External_Sym
*)
5483 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5484 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5485 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5486 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5487 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5488 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5489 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5490 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5491 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5492 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5493 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5494 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5496 bfd_set_error (bfd_error_no_memory
);
5500 /* Since ELF permits relocations to be against local symbols, we
5501 must have the local symbols available when we do the relocations.
5502 Since we would rather only read the local symbols once, and we
5503 would rather not keep them in memory, we handle all the
5504 relocations for a single input file at the same time.
5506 Unfortunately, there is no way to know the total number of local
5507 symbols until we have seen all of them, and the local symbol
5508 indices precede the global symbol indices. This means that when
5509 we are generating relocateable output, and we see a reloc against
5510 a global symbol, we can not know the symbol index until we have
5511 finished examining all the local symbols to see which ones we are
5512 going to output. To deal with this, we keep the relocations in
5513 memory, and don't output them until the end of the link. This is
5514 an unfortunate waste of memory, but I don't see a good way around
5515 it. Fortunately, it only happens when performing a relocateable
5516 link, which is not the common case. FIXME: If keep_memory is set
5517 we could write the relocs out and then read them again; I don't
5518 know how bad the memory loss will be. */
5520 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5521 sub
->output_has_begun
= false;
5522 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5524 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5526 if (p
->type
== bfd_indirect_link_order
5527 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5528 == bfd_target_elf_flavour
))
5530 sub
= p
->u
.indirect
.section
->owner
;
5531 if (! sub
->output_has_begun
)
5533 if (! elf_link_input_bfd (&finfo
, sub
))
5535 sub
->output_has_begun
= true;
5538 else if (p
->type
== bfd_section_reloc_link_order
5539 || p
->type
== bfd_symbol_reloc_link_order
)
5541 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5546 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5552 /* That wrote out all the local symbols. Finish up the symbol table
5553 with the global symbols. */
5555 /* The sh_info field records the index of the first non local
5557 symtab_hdr
->sh_info
= abfd
->symcount
;
5559 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5561 /* We get the global symbols from the hash table. */
5562 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5565 /* Flush all symbols to the file. */
5566 if (! elf_link_flush_output_syms (&finfo
))
5569 /* Now we know the size of the symtab section. */
5570 off
+= symtab_hdr
->sh_size
;
5572 /* Finish up and write out the symbol string table (.strtab)
5574 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5575 /* sh_name was set in prep_headers. */
5576 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5577 symstrtab_hdr
->sh_flags
= 0;
5578 symstrtab_hdr
->sh_addr
= 0;
5579 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5580 symstrtab_hdr
->sh_entsize
= 0;
5581 symstrtab_hdr
->sh_link
= 0;
5582 symstrtab_hdr
->sh_info
= 0;
5583 /* sh_offset is set just below. */
5584 symstrtab_hdr
->sh_addralign
= 1;
5586 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5587 elf_tdata (abfd
)->next_file_pos
= off
;
5589 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5590 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5593 /* Adjust the relocs to have the correct symbol indices. */
5594 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5596 struct elf_link_hash_entry
**rel_hash
;
5597 Elf_Internal_Shdr
*rel_hdr
;
5599 if ((o
->flags
& SEC_RELOC
) == 0)
5602 rel_hash
= elf_section_data (o
)->rel_hashes
;
5603 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5604 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5606 if (*rel_hash
== NULL
)
5609 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5611 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5613 Elf_External_Rel
*erel
;
5614 Elf_Internal_Rel irel
;
5616 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5617 elf_swap_reloc_in (abfd
, erel
, &irel
);
5618 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5619 ELF_R_TYPE (irel
.r_info
));
5620 elf_swap_reloc_out (abfd
, &irel
, erel
);
5624 Elf_External_Rela
*erela
;
5625 Elf_Internal_Rela irela
;
5627 BFD_ASSERT (rel_hdr
->sh_entsize
5628 == sizeof (Elf_External_Rela
));
5630 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5631 elf_swap_reloca_in (abfd
, erela
, &irela
);
5632 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5633 ELF_R_TYPE (irela
.r_info
));
5634 elf_swap_reloca_out (abfd
, &irela
, erela
);
5638 /* Set the reloc_count field to 0 to prevent write_relocs from
5639 trying to swap the relocs out itself. */
5643 /* If we are linking against a dynamic object, or generating a
5644 shared library, finish up the dynamic linking information. */
5647 Elf_External_Dyn
*dyncon
, *dynconend
;
5649 /* Fix up .dynamic entries. */
5650 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5651 BFD_ASSERT (o
!= NULL
);
5653 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5654 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5655 for (; dyncon
< dynconend
; dyncon
++)
5657 Elf_Internal_Dyn dyn
;
5661 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5668 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5669 magic _init and _fini symbols. This is pretty ugly,
5670 but we are compatible. */
5678 struct elf_link_hash_entry
*h
;
5680 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5681 false, false, true);
5682 BFD_ASSERT (h
!= NULL
);
5683 if (h
->root
.type
== bfd_link_hash_defined
)
5685 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5686 o
= h
->root
.u
.def
.section
;
5687 if (o
->output_section
!= NULL
)
5688 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5689 + o
->output_offset
);
5691 dyn
.d_un
.d_val
+= o
->vma
;
5693 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5706 o
= bfd_get_section_by_name (abfd
, name
);
5707 BFD_ASSERT (o
!= NULL
);
5708 dyn
.d_un
.d_ptr
= o
->vma
;
5709 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5716 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5721 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5723 Elf_Internal_Shdr
*hdr
;
5725 hdr
= elf_elfsections (abfd
)[i
];
5726 if (hdr
->sh_type
== type
5727 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5729 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5730 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5733 if (dyn
.d_un
.d_val
== 0
5734 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5735 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5739 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5745 /* If we have created any dynamic sections, then output them. */
5748 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5751 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5753 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5754 || o
->_raw_size
== 0)
5756 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5758 /* At this point, we are only interested in sections
5759 created by elf_link_create_dynamic_sections. FIXME:
5760 This test is fragile. */
5763 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5765 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5767 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5768 o
->contents
, o
->output_offset
,
5776 /* The contents of the .dynstr section are actually in a
5778 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5779 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5780 || ! _bfd_stringtab_emit (abfd
,
5781 elf_hash_table (info
)->dynstr
))
5787 if (finfo
.symstrtab
!= NULL
)
5788 _bfd_stringtab_free (finfo
.symstrtab
);
5789 if (finfo
.contents
!= NULL
)
5790 free (finfo
.contents
);
5791 if (finfo
.external_relocs
!= NULL
)
5792 free (finfo
.external_relocs
);
5793 if (finfo
.internal_relocs
!= NULL
)
5794 free (finfo
.internal_relocs
);
5795 if (finfo
.external_syms
!= NULL
)
5796 free (finfo
.external_syms
);
5797 if (finfo
.internal_syms
!= NULL
)
5798 free (finfo
.internal_syms
);
5799 if (finfo
.indices
!= NULL
)
5800 free (finfo
.indices
);
5801 if (finfo
.sections
!= NULL
)
5802 free (finfo
.sections
);
5803 if (finfo
.symbuf
!= NULL
)
5804 free (finfo
.symbuf
);
5805 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5807 if ((o
->flags
& SEC_RELOC
) != 0
5808 && elf_section_data (o
)->rel_hashes
!= NULL
)
5809 free (elf_section_data (o
)->rel_hashes
);
5812 elf_tdata (abfd
)->linker
= true;
5817 if (finfo
.symstrtab
!= NULL
)
5818 _bfd_stringtab_free (finfo
.symstrtab
);
5819 if (finfo
.contents
!= NULL
)
5820 free (finfo
.contents
);
5821 if (finfo
.external_relocs
!= NULL
)
5822 free (finfo
.external_relocs
);
5823 if (finfo
.internal_relocs
!= NULL
)
5824 free (finfo
.internal_relocs
);
5825 if (finfo
.external_syms
!= NULL
)
5826 free (finfo
.external_syms
);
5827 if (finfo
.internal_syms
!= NULL
)
5828 free (finfo
.internal_syms
);
5829 if (finfo
.indices
!= NULL
)
5830 free (finfo
.indices
);
5831 if (finfo
.sections
!= NULL
)
5832 free (finfo
.sections
);
5833 if (finfo
.symbuf
!= NULL
)
5834 free (finfo
.symbuf
);
5835 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5837 if ((o
->flags
& SEC_RELOC
) != 0
5838 && elf_section_data (o
)->rel_hashes
!= NULL
)
5839 free (elf_section_data (o
)->rel_hashes
);
5845 /* Add a symbol to the output symbol table. */
5848 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5849 struct elf_final_link_info
*finfo
;
5851 Elf_Internal_Sym
*elfsym
;
5852 asection
*input_sec
;
5854 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5855 struct bfd_link_info
*info
,
5860 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5861 elf_backend_link_output_symbol_hook
;
5862 if (output_symbol_hook
!= NULL
)
5864 if (! ((*output_symbol_hook
)
5865 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5869 if (name
== (const char *) NULL
|| *name
== '\0')
5870 elfsym
->st_name
= 0;
5873 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5876 if (elfsym
->st_name
== (unsigned long) -1)
5880 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5882 if (! elf_link_flush_output_syms (finfo
))
5886 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5887 finfo
->symbuf
+ finfo
->symbuf_count
);
5888 ++finfo
->symbuf_count
;
5890 ++finfo
->output_bfd
->symcount
;
5895 /* Flush the output symbols to the file. */
5898 elf_link_flush_output_syms (finfo
)
5899 struct elf_final_link_info
*finfo
;
5901 Elf_Internal_Shdr
*symtab
;
5903 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5905 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5907 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5908 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5909 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5912 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5914 finfo
->symbuf_count
= 0;
5919 /* Add an external symbol to the symbol table. This is called from
5920 the hash table traversal routine. */
5923 elf_link_output_extsym (h
, data
)
5924 struct elf_link_hash_entry
*h
;
5927 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5929 Elf_Internal_Sym sym
;
5930 asection
*input_sec
;
5932 /* We don't want to output symbols that have never been mentioned by
5933 a regular file, or that we have been told to strip. However, if
5934 h->indx is set to -2, the symbol is used by a reloc and we must
5938 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5939 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5940 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5941 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5943 else if (finfo
->info
->strip
== strip_all
5944 || (finfo
->info
->strip
== strip_some
5945 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5946 h
->root
.root
.string
,
5947 false, false) == NULL
))
5952 /* If we're stripping it, and it's not a dynamic symbol, there's
5953 nothing else to do. */
5954 if (strip
&& h
->dynindx
== -1)
5958 sym
.st_size
= h
->size
;
5960 if (h
->root
.type
== bfd_link_hash_weak
5961 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5962 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5964 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5966 switch (h
->root
.type
)
5969 case bfd_link_hash_new
:
5973 case bfd_link_hash_undefined
:
5974 input_sec
= bfd_und_section_ptr
;
5975 sym
.st_shndx
= SHN_UNDEF
;
5978 case bfd_link_hash_weak
:
5979 input_sec
= bfd_und_section_ptr
;
5980 sym
.st_shndx
= SHN_UNDEF
;
5983 case bfd_link_hash_defined
:
5985 input_sec
= h
->root
.u
.def
.section
;
5986 if (input_sec
->output_section
!= NULL
)
5989 elf_section_from_bfd_section (finfo
->output_bfd
,
5990 input_sec
->output_section
);
5991 if (sym
.st_shndx
== (unsigned short) -1)
5993 /* FIXME: No way to handle errors. */
5997 /* ELF symbols in relocateable files are section relative,
5998 but in nonrelocateable files they are virtual
6000 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6001 if (! finfo
->info
->relocateable
)
6002 sym
.st_value
+= input_sec
->output_section
->vma
;
6006 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6007 == bfd_target_elf_flavour
)
6008 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6009 sym
.st_shndx
= SHN_UNDEF
;
6010 input_sec
= bfd_und_section_ptr
;
6015 case bfd_link_hash_common
:
6016 input_sec
= bfd_com_section_ptr
;
6017 sym
.st_shndx
= SHN_COMMON
;
6018 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6021 case bfd_link_hash_indirect
:
6022 case bfd_link_hash_warning
:
6023 /* I have no idea how these should be handled. */
6027 /* If this symbol should be put in the .dynsym section, then put it
6028 there now. We have already know the symbol index. We also fill
6029 in the entry in the .hash section. */
6030 if (h
->dynindx
!= -1
6031 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6033 struct elf_backend_data
*bed
;
6036 bfd_byte
*bucketpos
;
6039 sym
.st_name
= h
->dynstr_index
;
6041 /* Give the processor backend a chance to tweak the symbol
6042 value, and also to finish up anything that needs to be done
6044 bed
= get_elf_backend_data (finfo
->output_bfd
);
6045 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6046 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6048 /* FIXME: No way to return error. */
6052 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6053 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6056 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6057 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6059 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6060 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6061 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6062 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6063 put_word (finfo
->output_bfd
, chain
,
6064 ((bfd_byte
*) finfo
->hash_sec
->contents
6065 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6068 /* If we're stripping it, then it was just a dynamic symbol, and
6069 there's nothing else to do. */
6073 h
->indx
= finfo
->output_bfd
->symcount
;
6075 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6077 /* FIXME: No way to return error. */
6084 /* Link an input file into the linker output file. This function
6085 handles all the sections and relocations of the input file at once.
6086 This is so that we only have to read the local symbols once, and
6087 don't have to keep them in memory. */
6090 elf_link_input_bfd (finfo
, input_bfd
)
6091 struct elf_final_link_info
*finfo
;
6094 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6095 bfd
*, asection
*, bfd_byte
*,
6096 Elf_Internal_Rela
*,
6097 Elf_Internal_Sym
*, asection
**));
6099 Elf_Internal_Shdr
*symtab_hdr
;
6102 Elf_External_Sym
*esym
;
6103 Elf_External_Sym
*esymend
;
6104 Elf_Internal_Sym
*isym
;
6106 asection
**ppsection
;
6109 output_bfd
= finfo
->output_bfd
;
6111 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6113 /* If this is a dynamic object, we don't want to do anything here:
6114 we don't want the local symbols, and we don't want the section
6116 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6119 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6120 if (elf_bad_symtab (input_bfd
))
6122 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6127 locsymcount
= symtab_hdr
->sh_info
;
6128 extsymoff
= symtab_hdr
->sh_info
;
6131 /* Read the local symbols. */
6133 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6134 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6135 locsymcount
, input_bfd
)
6136 != locsymcount
* sizeof (Elf_External_Sym
))))
6139 /* Swap in the local symbols and write out the ones which we know
6140 are going into the output file. */
6141 esym
= finfo
->external_syms
;
6142 esymend
= esym
+ locsymcount
;
6143 isym
= finfo
->internal_syms
;
6144 pindex
= finfo
->indices
;
6145 ppsection
= finfo
->sections
;
6146 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6150 Elf_Internal_Sym osym
;
6152 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6155 if (elf_bad_symtab (input_bfd
))
6157 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6164 if (isym
->st_shndx
== SHN_UNDEF
)
6165 isec
= bfd_und_section_ptr
;
6166 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6167 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6168 else if (isym
->st_shndx
== SHN_ABS
)
6169 isec
= bfd_abs_section_ptr
;
6170 else if (isym
->st_shndx
== SHN_COMMON
)
6171 isec
= bfd_com_section_ptr
;
6180 /* Don't output the first, undefined, symbol. */
6181 if (esym
== finfo
->external_syms
)
6184 /* If we are stripping all symbols, we don't want to output this
6186 if (finfo
->info
->strip
== strip_all
)
6189 /* We never output section symbols. Instead, we use the section
6190 symbol of the corresponding section in the output file. */
6191 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6194 /* If we are discarding all local symbols, we don't want to
6195 output this one. If we are generating a relocateable output
6196 file, then some of the local symbols may be required by
6197 relocs; we output them below as we discover that they are
6199 if (finfo
->info
->discard
== discard_all
)
6202 /* Get the name of the symbol. */
6203 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6208 /* See if we are discarding symbols with this name. */
6209 if ((finfo
->info
->strip
== strip_some
6210 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6212 || (finfo
->info
->discard
== discard_l
6213 && strncmp (name
, finfo
->info
->lprefix
,
6214 finfo
->info
->lprefix_len
) == 0))
6217 /* If we get here, we are going to output this symbol. */
6221 /* Adjust the section index for the output file. */
6222 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6223 isec
->output_section
);
6224 if (osym
.st_shndx
== (unsigned short) -1)
6227 *pindex
= output_bfd
->symcount
;
6229 /* ELF symbols in relocateable files are section relative, but
6230 in executable files they are virtual addresses. Note that
6231 this code assumes that all ELF sections have an associated
6232 BFD section with a reasonable value for output_offset; below
6233 we assume that they also have a reasonable value for
6234 output_section. Any special sections must be set up to meet
6235 these requirements. */
6236 osym
.st_value
+= isec
->output_offset
;
6237 if (! finfo
->info
->relocateable
)
6238 osym
.st_value
+= isec
->output_section
->vma
;
6240 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6244 /* Relocate the contents of each section. */
6245 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6247 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6250 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6251 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6253 /* Section was created by elf_link_create_dynamic_sections.
6254 FIXME: This test is fragile. */
6258 /* Read the contents of the section. */
6259 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6260 (file_ptr
) 0, o
->_raw_size
))
6263 if ((o
->flags
& SEC_RELOC
) != 0)
6265 Elf_Internal_Rela
*internal_relocs
;
6267 /* Get the swapped relocs. */
6268 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6269 finfo
->external_relocs
,
6270 finfo
->internal_relocs
,
6272 if (internal_relocs
== NULL
6273 && o
->reloc_count
> 0)
6276 /* Relocate the section by invoking a back end routine.
6278 The back end routine is responsible for adjusting the
6279 section contents as necessary, and (if using Rela relocs
6280 and generating a relocateable output file) adjusting the
6281 reloc addend as necessary.
6283 The back end routine does not have to worry about setting
6284 the reloc address or the reloc symbol index.
6286 The back end routine is given a pointer to the swapped in
6287 internal symbols, and can access the hash table entries
6288 for the external symbols via elf_sym_hashes (input_bfd).
6290 When generating relocateable output, the back end routine
6291 must handle STB_LOCAL/STT_SECTION symbols specially. The
6292 output symbol is going to be a section symbol
6293 corresponding to the output section, which will require
6294 the addend to be adjusted. */
6296 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6300 finfo
->internal_syms
,
6304 if (finfo
->info
->relocateable
)
6306 Elf_Internal_Rela
*irela
;
6307 Elf_Internal_Rela
*irelaend
;
6308 struct elf_link_hash_entry
**rel_hash
;
6309 Elf_Internal_Shdr
*input_rel_hdr
;
6310 Elf_Internal_Shdr
*output_rel_hdr
;
6312 /* Adjust the reloc addresses and symbol indices. */
6314 irela
= internal_relocs
;
6315 irelaend
= irela
+ o
->reloc_count
;
6316 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6317 + o
->output_section
->reloc_count
);
6318 for (; irela
< irelaend
; irela
++, rel_hash
++)
6321 Elf_Internal_Sym
*isym
;
6324 irela
->r_offset
+= o
->output_offset
;
6326 r_symndx
= ELF_R_SYM (irela
->r_info
);
6331 if (r_symndx
>= locsymcount
6332 || (elf_bad_symtab (input_bfd
)
6333 && finfo
->sections
[r_symndx
] == NULL
))
6337 /* This is a reloc against a global symbol. We
6338 have not yet output all the local symbols, so
6339 we do not know the symbol index of any global
6340 symbol. We set the rel_hash entry for this
6341 reloc to point to the global hash table entry
6342 for this symbol. The symbol index is then
6343 set at the end of elf_bfd_final_link. */
6344 indx
= r_symndx
- extsymoff
;
6345 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6347 /* Setting the index to -2 tells
6348 elf_link_output_extsym that this symbol is
6350 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6351 (*rel_hash
)->indx
= -2;
6356 /* This is a reloc against a local symbol. */
6359 isym
= finfo
->internal_syms
+ r_symndx
;
6360 sec
= finfo
->sections
[r_symndx
];
6361 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6363 /* I suppose the backend ought to fill in the
6364 section of any STT_SECTION symbol against a
6365 processor specific section. */
6366 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6368 else if (sec
== NULL
|| sec
->owner
== NULL
)
6370 bfd_set_error (bfd_error_bad_value
);
6375 r_symndx
= sec
->output_section
->target_index
;
6382 if (finfo
->indices
[r_symndx
] == -1)
6388 if (finfo
->info
->strip
== strip_all
)
6390 /* You can't do ld -r -s. */
6391 bfd_set_error (bfd_error_invalid_operation
);
6395 /* This symbol was skipped earlier, but
6396 since it is needed by a reloc, we
6397 must output it now. */
6398 link
= symtab_hdr
->sh_link
;
6399 name
= elf_string_from_elf_section (input_bfd
,
6405 osec
= sec
->output_section
;
6407 elf_section_from_bfd_section (output_bfd
,
6409 if (isym
->st_shndx
== (unsigned short) -1)
6412 isym
->st_value
+= sec
->output_offset
;
6413 if (! finfo
->info
->relocateable
)
6414 isym
->st_value
+= osec
->vma
;
6416 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6418 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6422 r_symndx
= finfo
->indices
[r_symndx
];
6425 irela
->r_info
= ELF_R_INFO (r_symndx
,
6426 ELF_R_TYPE (irela
->r_info
));
6429 /* Swap out the relocs. */
6430 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6431 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6432 BFD_ASSERT (output_rel_hdr
->sh_entsize
6433 == input_rel_hdr
->sh_entsize
);
6434 irela
= internal_relocs
;
6435 irelaend
= irela
+ o
->reloc_count
;
6436 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6438 Elf_External_Rel
*erel
;
6440 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6441 + o
->output_section
->reloc_count
);
6442 for (; irela
< irelaend
; irela
++, erel
++)
6444 Elf_Internal_Rel irel
;
6446 irel
.r_offset
= irela
->r_offset
;
6447 irel
.r_info
= irela
->r_info
;
6448 BFD_ASSERT (irela
->r_addend
== 0);
6449 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6454 Elf_External_Rela
*erela
;
6456 BFD_ASSERT (input_rel_hdr
->sh_entsize
6457 == sizeof (Elf_External_Rela
));
6458 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6459 + o
->output_section
->reloc_count
);
6460 for (; irela
< irelaend
; irela
++, erela
++)
6461 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6464 o
->output_section
->reloc_count
+= o
->reloc_count
;
6468 /* Write out the modified section contents. */
6469 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6470 finfo
->contents
, o
->output_offset
,
6471 (o
->_cooked_size
!= 0
6480 /* Generate a reloc when linking an ELF file. This is a reloc
6481 requested by the linker, and does come from any input file. This
6482 is used to build constructor and destructor tables when linking
6486 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6488 struct bfd_link_info
*info
;
6489 asection
*output_section
;
6490 struct bfd_link_order
*link_order
;
6492 const reloc_howto_type
*howto
;
6495 struct elf_link_hash_entry
**rel_hash_ptr
;
6496 Elf_Internal_Shdr
*rel_hdr
;
6498 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6501 bfd_set_error (bfd_error_bad_value
);
6505 /* If this is an inplace reloc, we must write the addend into the
6507 if (howto
->partial_inplace
6508 && link_order
->u
.reloc
.p
->addend
!= 0)
6511 bfd_reloc_status_type rstat
;
6515 size
= bfd_get_reloc_size (howto
);
6516 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6517 if (buf
== (bfd_byte
*) NULL
)
6519 bfd_set_error (bfd_error_no_memory
);
6522 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6523 link_order
->u
.reloc
.p
->addend
, buf
);
6529 case bfd_reloc_outofrange
:
6531 case bfd_reloc_overflow
:
6532 if (! ((*info
->callbacks
->reloc_overflow
)
6534 (link_order
->type
== bfd_section_reloc_link_order
6535 ? bfd_section_name (output_bfd
,
6536 link_order
->u
.reloc
.p
->u
.section
)
6537 : link_order
->u
.reloc
.p
->u
.name
),
6538 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6539 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6546 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6547 (file_ptr
) link_order
->offset
, size
);
6553 /* Figure out the symbol index. */
6554 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6555 + output_section
->reloc_count
);
6556 if (link_order
->type
== bfd_section_reloc_link_order
)
6558 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6561 *rel_hash_ptr
= NULL
;
6565 struct elf_link_hash_entry
*h
;
6567 h
= elf_link_hash_lookup (elf_hash_table (info
),
6568 link_order
->u
.reloc
.p
->u
.name
,
6569 false, false, true);
6572 /* Setting the index to -2 tells elf_link_output_extsym that
6573 this symbol is used by a reloc. */
6580 if (! ((*info
->callbacks
->unattached_reloc
)
6581 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6582 (asection
*) NULL
, (bfd_vma
) 0)))
6588 /* The address of a reloc is relative to the section in a
6589 relocateable file, and is a virtual address in an executable
6591 offset
= link_order
->offset
;
6592 if (! info
->relocateable
)
6593 offset
+= output_section
->vma
;
6595 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6597 if (rel_hdr
->sh_type
== SHT_REL
)
6599 Elf_Internal_Rel irel
;
6600 Elf_External_Rel
*erel
;
6602 irel
.r_offset
= offset
;
6603 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6604 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6605 + output_section
->reloc_count
);
6606 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6610 Elf_Internal_Rela irela
;
6611 Elf_External_Rela
*erela
;
6613 irela
.r_offset
= offset
;
6614 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6615 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6616 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6617 + output_section
->reloc_count
);
6618 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6621 ++output_section
->reloc_count
;