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)
1504 sec
= syms
[idx
]->section
;
1505 if (sec
->owner
!= NULL
)
1507 if (sec
->owner
!= abfd
)
1509 sec
= sec
->output_section
;
1510 BFD_ASSERT (sec
->owner
== abfd
);
1512 sect_syms
[sec
->index
] = syms
[idx
];
1517 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1521 if (sect_syms
[asect
->index
] != NULL
)
1524 sym
= bfd_make_empty_symbol (abfd
);
1527 sym
->the_bfd
= abfd
;
1528 sym
->name
= asect
->name
;
1529 sym
->value
= asect
->vma
;
1530 /* Set the flags to 0 to indicate that this one was newly added. */
1532 sym
->section
= asect
;
1533 sect_syms
[asect
->index
] = sym
;
1537 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1538 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1542 /* Classify all of the symbols. */
1543 for (idx
= 0; idx
< symcount
; idx
++)
1545 if (!sym_is_global (abfd
, syms
[idx
]))
1550 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1552 if (sect_syms
[asect
->index
] != NULL
1553 && sect_syms
[asect
->index
]->flags
== 0)
1555 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1556 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1560 sect_syms
[asect
->index
]->flags
= 0;
1564 /* Now sort the symbols so the local symbols are first. */
1565 new_syms
= ((asymbol
**)
1567 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1568 if (new_syms
== NULL
)
1570 bfd_set_error (bfd_error_no_memory
);
1574 for (idx
= 0; idx
< symcount
; idx
++)
1576 asymbol
*sym
= syms
[idx
];
1579 if (!sym_is_global (abfd
, sym
))
1582 i
= num_locals
+ num_globals2
++;
1584 sym
->udata
.i
= i
+ 1;
1586 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1588 if (sect_syms
[asect
->index
] != NULL
1589 && sect_syms
[asect
->index
]->flags
== 0)
1591 asymbol
*sym
= sect_syms
[asect
->index
];
1594 sym
->flags
= BSF_SECTION_SYM
;
1595 if (!sym_is_global (abfd
, sym
))
1598 i
= num_locals
+ num_globals2
++;
1600 sym
->udata
.i
= i
+ 1;
1604 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1606 elf_num_locals (abfd
) = num_locals
;
1607 elf_num_globals (abfd
) = num_globals
;
1611 /* Compute the file positions we are going to put the sections at, and
1612 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1613 is not NULL, this is being called by the ELF backend linker. */
1616 elf_compute_section_file_positions (abfd
, link_info
)
1618 struct bfd_link_info
*link_info
;
1620 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1622 struct bfd_strtab_hash
*strtab
;
1623 Elf_Internal_Shdr
*shstrtab_hdr
;
1625 if (abfd
->output_has_begun
)
1628 /* Do any elf backend specific processing first. */
1629 if (bed
->elf_backend_begin_write_processing
)
1630 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1632 if (! prep_headers (abfd
))
1636 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1640 if (!assign_section_numbers (abfd
))
1643 /* The backend linker builds symbol table information itself. */
1644 if (link_info
== NULL
)
1646 if (! swap_out_syms (abfd
, &strtab
))
1650 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1651 /* sh_name was set in prep_headers. */
1652 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1653 shstrtab_hdr
->sh_flags
= 0;
1654 shstrtab_hdr
->sh_addr
= 0;
1655 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1656 shstrtab_hdr
->sh_entsize
= 0;
1657 shstrtab_hdr
->sh_link
= 0;
1658 shstrtab_hdr
->sh_info
= 0;
1659 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1660 shstrtab_hdr
->sh_addralign
= 1;
1662 if (!assign_file_positions_except_relocs (abfd
,
1663 link_info
== NULL
? true : false))
1666 if (link_info
== NULL
)
1668 /* Now that we know where the .strtab section goes, write it
1670 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1672 || ! _bfd_stringtab_emit (abfd
, strtab
))
1674 _bfd_stringtab_free (strtab
);
1677 abfd
->output_has_begun
= true;
1683 /* Align to the maximum file alignment that could be required for any
1684 ELF data structure. */
1686 static INLINE file_ptr
1687 align_file_position (off
)
1690 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1693 /* Assign a file position to a section, optionally aligning to the
1694 required section alignment. */
1696 static INLINE file_ptr
1697 assign_file_position_for_section (i_shdrp
, offset
, align
)
1698 Elf_Internal_Shdr
*i_shdrp
;
1706 al
= i_shdrp
->sh_addralign
;
1708 offset
= BFD_ALIGN (offset
, al
);
1710 i_shdrp
->sh_offset
= offset
;
1711 if (i_shdrp
->bfd_section
!= NULL
)
1712 i_shdrp
->bfd_section
->filepos
= offset
;
1713 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1714 offset
+= i_shdrp
->sh_size
;
1718 /* Get the size of the program header. This is called by the linker
1719 before any of the section VMA's are set, so it can't calculate the
1720 correct value for a strange memory layout. */
1722 static bfd_size_type
1723 get_program_header_size (abfd
)
1729 /* Assume we will need exactly two PT_LOAD segments: one for text
1730 and one for data. */
1733 s
= bfd_get_section_by_name (abfd
, ".interp");
1734 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1736 /* If we have a loadable interpreter section, we need a
1737 PT_INTERP segment. In this case, assume we also need a
1738 PT_PHDR segment, although that may not be true for all
1743 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1745 /* We need a PT_DYNAMIC segment. */
1749 return segs
* sizeof (Elf_External_Phdr
);
1752 /* Create the program header. OFF is the file offset where the
1753 program header should be written. FIRST is the first loadable ELF
1754 section. PHDR_SIZE is the size of the program header as returned
1755 by get_program_header_size. */
1758 map_program_segments (abfd
, off
, first
, phdr_size
)
1761 Elf_Internal_Shdr
*first
;
1762 bfd_size_type phdr_size
;
1764 Elf_Internal_Phdr phdrs
[10];
1765 unsigned int phdr_count
;
1766 Elf_Internal_Phdr
*phdr
;
1767 int phdr_size_adjust
;
1769 Elf_Internal_Shdr
**hdrpp
;
1770 asection
*sinterp
, *sdyn
;
1771 unsigned int last_type
;
1772 Elf_Internal_Ehdr
*i_ehdrp
;
1774 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1775 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1776 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1781 phdr_size_adjust
= 0;
1783 /* If we have a loadable .interp section, we must create a PT_INTERP
1784 segment which must precede all PT_LOAD segments. We assume that
1785 we must also create a PT_PHDR segment, although that may not be
1786 true for all targets. */
1787 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1788 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1790 BFD_ASSERT (first
!= NULL
);
1792 phdr
->p_type
= PT_PHDR
;
1794 phdr
->p_offset
= off
;
1796 /* Account for any adjustment made because of the alignment of
1797 the first loadable section. */
1798 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1799 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1801 /* The program header precedes all loadable sections. This lets
1802 us compute its loadable address. This depends on the linker
1804 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1807 phdr
->p_filesz
= phdr_size
;
1808 phdr
->p_memsz
= phdr_size
;
1810 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1811 phdr
->p_flags
= PF_R
| PF_X
;
1813 phdr
->p_align
= FILE_ALIGN
;
1814 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1816 /* Include the ELF header in the first loadable segment. */
1817 phdr_size_adjust
+= off
;
1822 phdr
->p_type
= PT_INTERP
;
1823 phdr
->p_offset
= sinterp
->filepos
;
1824 phdr
->p_vaddr
= sinterp
->vma
;
1826 phdr
->p_filesz
= sinterp
->_raw_size
;
1827 phdr
->p_memsz
= sinterp
->_raw_size
;
1828 phdr
->p_flags
= PF_R
;
1829 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1835 /* Look through the sections to see how they will be divided into
1836 program segments. The sections must be arranged in order by
1837 sh_addr for this to work correctly. */
1838 phdr
->p_type
= PT_NULL
;
1839 last_type
= SHT_PROGBITS
;
1840 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1841 i
< elf_elfheader (abfd
)->e_shnum
;
1844 Elf_Internal_Shdr
*hdr
;
1848 /* Ignore any section which will not be part of the process
1850 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1853 /* If this section fits in the segment we are constructing, add
1855 if (phdr
->p_type
!= PT_NULL
1856 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1857 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1858 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1860 bfd_size_type adjust
;
1862 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1863 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1864 if (hdr
->sh_type
!= SHT_NOBITS
)
1865 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1866 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1867 phdr
->p_flags
|= PF_W
;
1868 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1869 phdr
->p_flags
|= PF_X
;
1870 last_type
= hdr
->sh_type
;
1874 /* If we have a segment, move to the next one. */
1875 if (phdr
->p_type
!= PT_NULL
)
1881 /* Start a new segment. */
1882 phdr
->p_type
= PT_LOAD
;
1883 phdr
->p_offset
= hdr
->sh_offset
;
1884 phdr
->p_vaddr
= hdr
->sh_addr
;
1886 if (hdr
->sh_type
== SHT_NOBITS
)
1889 phdr
->p_filesz
= hdr
->sh_size
;
1890 phdr
->p_memsz
= hdr
->sh_size
;
1891 phdr
->p_flags
= PF_R
;
1892 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1893 phdr
->p_flags
|= PF_W
;
1894 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1895 phdr
->p_flags
|= PF_X
;
1896 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1900 && (sinterp
->flags
& SEC_LOAD
) != 0)
1902 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1903 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1904 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1905 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1908 last_type
= hdr
->sh_type
;
1911 if (phdr
->p_type
!= PT_NULL
)
1917 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1918 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1919 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1921 phdr
->p_type
= PT_DYNAMIC
;
1922 phdr
->p_offset
= sdyn
->filepos
;
1923 phdr
->p_vaddr
= sdyn
->vma
;
1925 phdr
->p_filesz
= sdyn
->_raw_size
;
1926 phdr
->p_memsz
= sdyn
->_raw_size
;
1927 phdr
->p_flags
= PF_R
;
1928 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1929 phdr
->p_flags
|= PF_W
;
1930 if ((sdyn
->flags
& SEC_CODE
) != 0)
1931 phdr
->p_flags
|= PF_X
;
1932 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1938 /* Make sure the return value from get_program_header_size matches
1939 what we computed here. Actually, it's OK if we allocated too
1940 much space in the program header. */
1941 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1944 /* Set up program header information. */
1945 i_ehdrp
= elf_elfheader (abfd
);
1946 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1947 i_ehdrp
->e_phoff
= off
;
1948 i_ehdrp
->e_phnum
= phdr_count
;
1950 /* Save the program headers away. I don't think anybody uses this
1951 information right now. */
1952 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1955 * sizeof (Elf_Internal_Phdr
))));
1956 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1958 bfd_set_error (bfd_error_no_memory
);
1959 return (file_ptr
) -1;
1961 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1962 phdr_count
* sizeof (Elf_Internal_Phdr
));
1964 /* Write out the program headers. */
1965 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1966 return (file_ptr
) -1;
1968 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1970 Elf_External_Phdr extphdr
;
1972 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1973 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1974 != sizeof (Elf_External_Phdr
))
1975 return (file_ptr
) -1;
1978 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1981 /* Work out the file positions of all the sections. This is called by
1982 elf_compute_section_file_positions. All the section sizes and VMAs
1983 must be known before this is called.
1985 We do not consider reloc sections at this point, unless they form
1986 part of the loadable image. Reloc sections are assigned file
1987 positions in assign_file_positions_for_relocs, which is called by
1988 write_object_contents and final_link.
1990 If DOSYMS is false, we do not assign file positions for the symbol
1991 table or the string table. */
1994 assign_file_positions_except_relocs (abfd
, dosyms
)
1998 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1999 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2000 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2003 /* Start after the ELF header. */
2004 off
= i_ehdrp
->e_ehsize
;
2006 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2008 Elf_Internal_Shdr
**hdrpp
;
2011 /* We are not creating an executable, which means that we are
2012 not creating a program header, and that the actual order of
2013 the sections in the file is unimportant. */
2014 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2016 Elf_Internal_Shdr
*hdr
;
2019 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2021 hdr
->sh_offset
= -1;
2025 && (i
== tdata
->symtab_section
2026 || i
== tdata
->strtab_section
))
2028 hdr
->sh_offset
= -1;
2032 off
= assign_file_position_for_section (hdr
, off
, true);
2038 bfd_size_type phdr_size
;
2039 bfd_vma maxpagesize
;
2041 Elf_Internal_Shdr
**sorted_hdrs
;
2042 Elf_Internal_Shdr
**hdrpp
;
2044 Elf_Internal_Shdr
*first
;
2047 /* We are creating an executable. We must create a program
2048 header. We can't actually create the program header until we
2049 have set the file positions for the sections, but we can
2050 figure out how big it is going to be. */
2051 off
= align_file_position (off
);
2052 phdr_size
= get_program_header_size (abfd
);
2053 if (phdr_size
== (file_ptr
) -1)
2058 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2059 if (maxpagesize
== 0)
2062 /* We must sort the sections. The GNU linker will always create
2063 the sections in an appropriate order, but the Irix 5 linker
2064 will not. We don't include the dummy first section in the
2065 sort. We sort sections which are not SHF_ALLOC to the end. */
2066 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2067 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2068 if (sorted_hdrs
== NULL
)
2070 bfd_set_error (bfd_error_no_memory
);
2074 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2075 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2079 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2081 Elf_Internal_Shdr
*hdr
;
2084 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2086 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2088 hdr
->sh_offset
= -1;
2092 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2093 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2095 hdr
->sh_offset
= -1;
2104 /* The section VMA must equal the file position modulo
2105 the page size. This is required by the program
2107 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2110 off
= assign_file_position_for_section (hdr
, off
, false);
2113 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2114 if (phdr_map
== (file_ptr
) -1)
2116 BFD_ASSERT (phdr_map
<= phdr_off
+ phdr_size
);
2119 /* Place the section headers. */
2120 off
= align_file_position (off
);
2121 i_ehdrp
->e_shoff
= off
;
2122 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2124 elf_tdata (abfd
)->next_file_pos
= off
;
2129 /* Sort the ELF headers by VMA. We sort headers which are not
2130 SHF_ALLOC to the end. */
2133 elf_sort_hdrs (arg1
, arg2
)
2137 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2138 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2140 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2142 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2144 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2146 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2153 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2163 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2164 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2165 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2167 struct bfd_strtab_hash
*shstrtab
;
2169 i_ehdrp
= elf_elfheader (abfd
);
2170 i_shdrp
= elf_elfsections (abfd
);
2172 shstrtab
= elf_stringtab_init ();
2173 if (shstrtab
== NULL
)
2176 elf_shstrtab (abfd
) = shstrtab
;
2178 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2179 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2180 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2181 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2183 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2184 i_ehdrp
->e_ident
[EI_DATA
] =
2185 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2186 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2188 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2189 i_ehdrp
->e_ident
[count
] = 0;
2191 if ((abfd
->flags
& DYNAMIC
) != 0)
2192 i_ehdrp
->e_type
= ET_DYN
;
2193 else if ((abfd
->flags
& EXEC_P
) != 0)
2194 i_ehdrp
->e_type
= ET_EXEC
;
2196 i_ehdrp
->e_type
= ET_REL
;
2198 switch (bfd_get_arch (abfd
))
2200 case bfd_arch_unknown
:
2201 i_ehdrp
->e_machine
= EM_NONE
;
2203 case bfd_arch_sparc
:
2205 i_ehdrp
->e_machine
= EM_SPARC64
;
2207 i_ehdrp
->e_machine
= EM_SPARC
;
2211 i_ehdrp
->e_machine
= EM_386
;
2214 i_ehdrp
->e_machine
= EM_68K
;
2217 i_ehdrp
->e_machine
= EM_88K
;
2220 i_ehdrp
->e_machine
= EM_860
;
2222 case bfd_arch_mips
: /* MIPS Rxxxx */
2223 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2226 i_ehdrp
->e_machine
= EM_PARISC
;
2228 case bfd_arch_powerpc
:
2229 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2231 /* start-sanitize-arc */
2233 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2235 /* end-sanitize-arc */
2236 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2238 i_ehdrp
->e_machine
= EM_NONE
;
2240 i_ehdrp
->e_version
= EV_CURRENT
;
2241 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2243 /* no program header, for now. */
2244 i_ehdrp
->e_phoff
= 0;
2245 i_ehdrp
->e_phentsize
= 0;
2246 i_ehdrp
->e_phnum
= 0;
2248 /* each bfd section is section header entry */
2249 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2250 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2252 /* if we're building an executable, we'll need a program header table */
2253 if (abfd
->flags
& EXEC_P
)
2255 /* it all happens later */
2257 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2259 /* elf_build_phdrs() returns a (NULL-terminated) array of
2260 Elf_Internal_Phdrs */
2261 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2262 i_ehdrp
->e_phoff
= outbase
;
2263 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2268 i_ehdrp
->e_phentsize
= 0;
2270 i_ehdrp
->e_phoff
= 0;
2273 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2274 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2275 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2276 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2277 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2278 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2279 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2280 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2281 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2288 swap_out_syms (abfd
, sttp
)
2290 struct bfd_strtab_hash
**sttp
;
2292 if (!elf_map_symbols (abfd
))
2295 /* Dump out the symtabs. */
2297 int symcount
= bfd_get_symcount (abfd
);
2298 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2299 struct bfd_strtab_hash
*stt
;
2300 Elf_Internal_Shdr
*symtab_hdr
;
2301 Elf_Internal_Shdr
*symstrtab_hdr
;
2302 Elf_External_Sym
*outbound_syms
;
2305 stt
= elf_stringtab_init ();
2309 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2310 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2311 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2312 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2313 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2314 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2316 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2317 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2319 outbound_syms
= ((Elf_External_Sym
*)
2321 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2322 if (outbound_syms
== NULL
)
2324 bfd_set_error (bfd_error_no_memory
);
2327 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2329 /* now generate the data (for "contents") */
2331 /* Fill in zeroth symbol and swap it out. */
2332 Elf_Internal_Sym sym
;
2338 sym
.st_shndx
= SHN_UNDEF
;
2339 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2342 for (idx
= 0; idx
< symcount
; idx
++)
2344 Elf_Internal_Sym sym
;
2345 bfd_vma value
= syms
[idx
]->value
;
2346 elf_symbol_type
*type_ptr
;
2348 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2349 /* Section symbols have no names. */
2353 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2356 if (sym
.st_name
== (unsigned long) -1)
2360 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2362 if (bfd_is_com_section (syms
[idx
]->section
))
2364 /* ELF common symbols put the alignment into the `value' field,
2365 and the size into the `size' field. This is backwards from
2366 how BFD handles it, so reverse it here. */
2367 sym
.st_size
= value
;
2368 if (type_ptr
== NULL
2369 || type_ptr
->internal_elf_sym
.st_value
== 0)
2370 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2372 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2373 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2374 syms
[idx
]->section
);
2378 asection
*sec
= syms
[idx
]->section
;
2381 if (sec
->output_section
)
2383 value
+= sec
->output_offset
;
2384 sec
= sec
->output_section
;
2387 sym
.st_value
= value
;
2388 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2389 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2393 /* Writing this would be a hell of a lot easier if we had
2394 some decent documentation on bfd, and knew what to expect
2395 of the library, and what to demand of applications. For
2396 example, it appears that `objcopy' might not set the
2397 section of a symbol to be a section that is actually in
2399 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2400 BFD_ASSERT (sec2
!= 0);
2401 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2402 BFD_ASSERT (shndx
!= -1);
2406 if (bfd_is_com_section (syms
[idx
]->section
))
2407 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2408 else if (bfd_is_und_section (syms
[idx
]->section
))
2409 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2410 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2413 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2414 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2415 else if (syms
[idx
]->flags
& BSF_FILE
)
2416 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2419 int bind
= STB_LOCAL
;
2420 int type
= STT_OBJECT
;
2421 unsigned int flags
= syms
[idx
]->flags
;
2423 if (flags
& BSF_LOCAL
)
2425 else if (flags
& BSF_WEAK
)
2427 else if (flags
& BSF_GLOBAL
)
2430 if (flags
& BSF_FUNCTION
)
2433 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2437 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2442 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2443 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2445 symstrtab_hdr
->sh_flags
= 0;
2446 symstrtab_hdr
->sh_addr
= 0;
2447 symstrtab_hdr
->sh_entsize
= 0;
2448 symstrtab_hdr
->sh_link
= 0;
2449 symstrtab_hdr
->sh_info
= 0;
2450 symstrtab_hdr
->sh_addralign
= 1;
2457 write_shdrs_and_ehdr (abfd
)
2460 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2461 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2462 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2463 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2466 i_ehdrp
= elf_elfheader (abfd
);
2467 i_shdrp
= elf_elfsections (abfd
);
2469 /* swap the header before spitting it out... */
2472 elf_debug_file (i_ehdrp
);
2474 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2475 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2476 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2477 != sizeof (x_ehdr
)))
2480 /* at this point we've concocted all the ELF sections... */
2481 x_shdrp
= (Elf_External_Shdr
*)
2482 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2485 bfd_set_error (bfd_error_no_memory
);
2489 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2492 elf_debug_section (count
, i_shdrp
[count
]);
2494 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2496 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2497 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2498 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2501 /* need to dump the string table too... */
2506 /* Assign file positions for all the reloc sections which are not part
2507 of the loadable file image. */
2510 assign_file_positions_for_relocs (abfd
)
2515 Elf_Internal_Shdr
**shdrpp
;
2517 off
= elf_tdata (abfd
)->next_file_pos
;
2519 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2520 i
< elf_elfheader (abfd
)->e_shnum
;
2523 Elf_Internal_Shdr
*shdrp
;
2526 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2527 && shdrp
->sh_offset
== -1)
2528 off
= assign_file_position_for_section (shdrp
, off
, true);
2531 elf_tdata (abfd
)->next_file_pos
= off
;
2535 NAME(bfd_elf
,write_object_contents
) (abfd
)
2538 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2539 Elf_Internal_Ehdr
*i_ehdrp
;
2540 Elf_Internal_Shdr
**i_shdrp
;
2543 if (! abfd
->output_has_begun
2544 && ! elf_compute_section_file_positions (abfd
,
2545 (struct bfd_link_info
*) NULL
))
2548 i_shdrp
= elf_elfsections (abfd
);
2549 i_ehdrp
= elf_elfheader (abfd
);
2551 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2552 assign_file_positions_for_relocs (abfd
);
2554 /* After writing the headers, we need to write the sections too... */
2555 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2557 if (bed
->elf_backend_section_processing
)
2558 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2559 if (i_shdrp
[count
]->contents
)
2561 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2562 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2564 != i_shdrp
[count
]->sh_size
))
2569 /* Write out the section header names. */
2570 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2571 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2574 if (bed
->elf_backend_final_write_processing
)
2575 (*bed
->elf_backend_final_write_processing
) (abfd
,
2576 elf_tdata (abfd
)->linker
);
2578 return write_shdrs_and_ehdr (abfd
);
2581 /* Given an ELF section number, retrieve the corresponding BFD
2585 section_from_elf_index (abfd
, index
)
2589 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2590 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2592 return elf_elfsections (abfd
)[index
]->bfd_section
;
2595 /* given a section, search the header to find them... */
2597 elf_section_from_bfd_section (abfd
, asect
)
2601 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2602 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2604 Elf_Internal_Shdr
*hdr
;
2605 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2607 if (bfd_is_abs_section (asect
))
2609 if (bfd_is_com_section (asect
))
2611 if (bfd_is_und_section (asect
))
2614 for (index
= 0; index
< maxindex
; index
++)
2616 hdr
= i_shdrp
[index
];
2617 if (hdr
->bfd_section
== asect
)
2621 if (bed
->elf_backend_section_from_bfd_section
)
2623 for (index
= 0; index
< maxindex
; index
++)
2627 hdr
= i_shdrp
[index
];
2629 if ((*bed
->elf_backend_section_from_bfd_section
)
2630 (abfd
, hdr
, asect
, &retval
))
2638 /* given a symbol, return the bfd index for that symbol. */
2640 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2642 struct symbol_cache_entry
**asym_ptr_ptr
;
2644 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2646 flagword flags
= asym_ptr
->flags
;
2648 /* When gas creates relocations against local labels, it creates its
2649 own symbol for the section, but does put the symbol into the
2650 symbol chain, so udata is 0. When the linker is generating
2651 relocatable output, this section symbol may be for one of the
2652 input sections rather than the output section. */
2653 if (asym_ptr
->udata
.i
== 0
2654 && (flags
& BSF_SECTION_SYM
)
2655 && asym_ptr
->section
)
2659 if (asym_ptr
->section
->output_section
!= NULL
)
2660 indx
= asym_ptr
->section
->output_section
->index
;
2662 indx
= asym_ptr
->section
->index
;
2663 if (elf_section_syms (abfd
)[indx
])
2664 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2667 idx
= asym_ptr
->udata
.i
;
2675 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2676 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2685 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2687 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2690 Elf_Internal_Shdr
*hdr
;
2691 long symcount
; /* Number of external ELF symbols */
2692 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2693 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2694 Elf_Internal_Sym i_sym
;
2695 Elf_External_Sym
*x_symp
= NULL
;
2697 /* Read each raw ELF symbol, converting from external ELF form to
2698 internal ELF form, and then using the information to create a
2699 canonical bfd symbol table entry.
2701 Note that we allocate the initial bfd canonical symbol buffer
2702 based on a one-to-one mapping of the ELF symbols to canonical
2703 symbols. We actually use all the ELF symbols, so there will be no
2704 space left over at the end. When we have all the symbols, we
2705 build the caller's pointer vector. */
2708 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2710 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2711 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2714 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2717 sym
= symbase
= NULL
;
2722 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2725 symbase
= ((elf_symbol_type
*)
2726 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2727 if (symbase
== (elf_symbol_type
*) NULL
)
2729 bfd_set_error (bfd_error_no_memory
);
2734 /* Temporarily allocate room for the raw ELF symbols. */
2735 x_symp
= ((Elf_External_Sym
*)
2736 malloc (symcount
* sizeof (Elf_External_Sym
)));
2737 if (x_symp
== NULL
&& symcount
!= 0)
2739 bfd_set_error (bfd_error_no_memory
);
2743 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2744 != symcount
* sizeof (Elf_External_Sym
))
2746 /* Skip first symbol, which is a null dummy. */
2747 for (i
= 1; i
< symcount
; i
++)
2749 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2750 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2751 #ifdef ELF_KEEP_EXTSYM
2752 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2754 sym
->symbol
.the_bfd
= abfd
;
2756 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2759 sym
->symbol
.value
= i_sym
.st_value
;
2761 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2763 sym
->symbol
.section
= section_from_elf_index (abfd
,
2765 if (sym
->symbol
.section
== NULL
)
2767 /* This symbol is in a section for which we did not
2768 create a BFD section. Just use bfd_abs_section,
2769 although it is wrong. FIXME. */
2770 sym
->symbol
.section
= bfd_abs_section_ptr
;
2773 else if (i_sym
.st_shndx
== SHN_ABS
)
2775 sym
->symbol
.section
= bfd_abs_section_ptr
;
2777 else if (i_sym
.st_shndx
== SHN_COMMON
)
2779 sym
->symbol
.section
= bfd_com_section_ptr
;
2780 /* Elf puts the alignment into the `value' field, and
2781 the size into the `size' field. BFD wants to see the
2782 size in the value field, and doesn't care (at the
2783 moment) about the alignment. */
2784 sym
->symbol
.value
= i_sym
.st_size
;
2786 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2788 sym
->symbol
.section
= bfd_und_section_ptr
;
2791 sym
->symbol
.section
= bfd_abs_section_ptr
;
2793 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2795 switch (ELF_ST_BIND (i_sym
.st_info
))
2798 sym
->symbol
.flags
|= BSF_LOCAL
;
2801 sym
->symbol
.flags
|= BSF_GLOBAL
;
2804 sym
->symbol
.flags
|= BSF_WEAK
;
2808 switch (ELF_ST_TYPE (i_sym
.st_info
))
2811 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2814 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2817 sym
->symbol
.flags
|= BSF_FUNCTION
;
2822 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2824 /* Do some backend-specific processing on this symbol. */
2826 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2827 if (ebd
->elf_backend_symbol_processing
)
2828 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2835 /* Do some backend-specific processing on this symbol table. */
2837 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2838 if (ebd
->elf_backend_symbol_table_processing
)
2839 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2842 /* We rely on the zalloc to clear out the final symbol entry. */
2844 symcount
= sym
- symbase
;
2846 /* Fill in the user's symbol pointer vector if needed. */
2854 *symptrs
++ = &sym
->symbol
;
2857 *symptrs
= 0; /* Final null pointer */
2869 /* Return the number of bytes required to hold the symtab vector.
2871 Note that we base it on the count plus 1, since we will null terminate
2872 the vector allocated based on this size. However, the ELF symbol table
2873 always has a dummy entry as symbol #0, so it ends up even. */
2876 elf_get_symtab_upper_bound (abfd
)
2881 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2883 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2884 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2890 elf_get_dynamic_symtab_upper_bound (abfd
)
2895 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2897 if (elf_dynsymtab (abfd
) == 0)
2899 bfd_set_error (bfd_error_invalid_operation
);
2903 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2904 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2910 elf_get_reloc_upper_bound (abfd
, asect
)
2914 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2917 /* Read in and swap the external relocs. */
2920 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2925 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2926 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2927 PTR allocated
= NULL
;
2928 bfd_byte
*native_relocs
;
2934 if (asect
->relocation
!= NULL
2935 || (asect
->flags
& SEC_RELOC
) == 0
2936 || asect
->reloc_count
== 0)
2939 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2940 && (asect
->reloc_count
2941 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2943 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2944 if (allocated
== NULL
)
2946 bfd_set_error (bfd_error_no_memory
);
2950 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2951 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2952 != d
->rel_hdr
.sh_size
))
2955 native_relocs
= (bfd_byte
*) allocated
;
2957 relents
= ((arelent
*)
2958 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2959 if (relents
== NULL
)
2961 bfd_set_error (bfd_error_no_memory
);
2965 entsize
= d
->rel_hdr
.sh_entsize
;
2966 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2967 || entsize
== sizeof (Elf_External_Rela
));
2969 for (i
= 0, relent
= relents
;
2970 i
< asect
->reloc_count
;
2971 i
++, relent
++, native_relocs
+= entsize
)
2973 Elf_Internal_Rela rela
;
2974 Elf_Internal_Rel rel
;
2976 if (entsize
== sizeof (Elf_External_Rela
))
2977 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2980 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2981 rela
.r_offset
= rel
.r_offset
;
2982 rela
.r_info
= rel
.r_info
;
2986 /* The address of an ELF reloc is section relative for an object
2987 file, and absolute for an executable file or shared library.
2988 The address of a BFD reloc is always section relative. */
2989 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2990 relent
->address
= rela
.r_offset
;
2992 relent
->address
= rela
.r_offset
- asect
->vma
;
2994 if (ELF_R_SYM (rela
.r_info
) == 0)
2995 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3000 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3003 /* Canonicalize ELF section symbols. FIXME: Why? */
3004 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3005 relent
->sym_ptr_ptr
= ps
;
3007 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3010 relent
->addend
= rela
.r_addend
;
3012 if (entsize
== sizeof (Elf_External_Rela
))
3013 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3015 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3018 asect
->relocation
= relents
;
3020 if (allocated
!= NULL
)
3026 if (allocated
!= NULL
)
3033 elf_debug_section (num
, hdr
)
3035 Elf_Internal_Shdr
*hdr
;
3037 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3038 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3041 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3042 (long) hdr
->sh_name
,
3043 (long) hdr
->sh_type
,
3044 (long) hdr
->sh_flags
);
3046 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3047 (long) hdr
->sh_addr
,
3048 (long) hdr
->sh_offset
,
3049 (long) hdr
->sh_size
);
3051 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3052 (long) hdr
->sh_link
,
3053 (long) hdr
->sh_info
,
3054 (long) hdr
->sh_addralign
);
3055 fprintf (stderr
, "sh_entsize = %ld\n",
3056 (long) hdr
->sh_entsize
);
3061 elf_debug_file (ehdrp
)
3062 Elf_Internal_Ehdr
*ehdrp
;
3064 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3065 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3066 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3067 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3068 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3069 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3070 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3074 /* Canonicalize the relocs. */
3077 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3086 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3089 tblptr
= section
->relocation
;
3090 for (i
= 0; i
< section
->reloc_count
; i
++)
3091 *relptr
++ = tblptr
++;
3095 return section
->reloc_count
;
3099 elf_get_symtab (abfd
, alocation
)
3101 asymbol
**alocation
;
3103 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3106 bfd_get_symcount (abfd
) = symcount
;
3111 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3113 asymbol
**alocation
;
3115 return elf_slurp_symbol_table (abfd
, alocation
, true);
3119 elf_make_empty_symbol (abfd
)
3122 elf_symbol_type
*newsym
;
3124 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3127 bfd_set_error (bfd_error_no_memory
);
3132 newsym
->symbol
.the_bfd
= abfd
;
3133 return &newsym
->symbol
;
3138 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3143 bfd_symbol_info (symbol
, ret
);
3147 elf_get_lineno (ignore_abfd
, symbol
)
3151 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3158 elf_set_arch_mach (abfd
, arch
, machine
)
3160 enum bfd_architecture arch
;
3161 unsigned long machine
;
3163 /* If this isn't the right architecture for this backend, and this
3164 isn't the generic backend, fail. */
3165 if (arch
!= get_elf_backend_data (abfd
)->arch
3166 && arch
!= bfd_arch_unknown
3167 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3170 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3174 elf_find_nearest_line (abfd
,
3185 CONST
char **filename_ptr
;
3186 CONST
char **functionname_ptr
;
3187 unsigned int *line_ptr
;
3193 elf_sizeof_headers (abfd
, reloc
)
3199 ret
= sizeof (Elf_External_Ehdr
);
3201 ret
+= get_program_header_size (abfd
);
3206 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3211 bfd_size_type count
;
3213 Elf_Internal_Shdr
*hdr
;
3215 if (! abfd
->output_has_begun
3216 && ! elf_compute_section_file_positions (abfd
,
3217 (struct bfd_link_info
*) NULL
))
3220 hdr
= &elf_section_data (section
)->this_hdr
;
3222 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3224 if (bfd_write (location
, 1, count
, abfd
) != count
)
3231 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3234 Elf_Internal_Rela
*dst
;
3236 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3242 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3245 Elf_Internal_Rel
*dst
;
3247 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3253 /* Core file support */
3255 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3256 #include <sys/procfs.h>
3258 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3259 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3260 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3266 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3273 prstatus_t
*status
= (prstatus_t
*) 0;
3275 if (descsz
== sizeof (prstatus_t
))
3277 newsect
= bfd_make_section (abfd
, ".reg");
3278 if (newsect
== NULL
)
3280 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3281 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3282 newsect
->flags
= SEC_HAS_CONTENTS
;
3283 newsect
->alignment_power
= 2;
3284 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3286 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3292 /* Stash a copy of the prpsinfo structure away for future use. */
3295 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3301 if (descsz
== sizeof (prpsinfo_t
))
3303 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3305 bfd_set_error (bfd_error_no_memory
);
3308 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3314 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3322 newsect
= bfd_make_section (abfd
, ".reg2");
3323 if (newsect
== NULL
)
3325 newsect
->_raw_size
= descsz
;
3326 newsect
->filepos
= filepos
;
3327 newsect
->flags
= SEC_HAS_CONTENTS
;
3328 newsect
->alignment_power
= 2;
3332 #endif /* HAVE_PROCFS */
3334 /* Return a pointer to the args (including the command name) that were
3335 seen by the program that generated the core dump. Note that for
3336 some reason, a spurious space is tacked onto the end of the args
3337 in some (at least one anyway) implementations, so strip it off if
3341 elf_core_file_failing_command (abfd
)
3345 if (core_prpsinfo (abfd
))
3347 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3348 char *scan
= p
->pr_psargs
;
3353 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3357 return p
->pr_psargs
;
3363 /* Return the number of the signal that caused the core dump. Presumably,
3364 since we have a core file, we got a signal of some kind, so don't bother
3365 checking the other process status fields, just return the signal number.
3369 elf_core_file_failing_signal (abfd
)
3373 if (core_prstatus (abfd
))
3375 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3381 /* Check to see if the core file could reasonably be expected to have
3382 come for the current executable file. Note that by default we return
3383 true unless we find something that indicates that there might be a
3388 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3397 /* First, xvecs must match since both are ELF files for the same target. */
3399 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3401 bfd_set_error (bfd_error_system_call
);
3407 /* If no prpsinfo, just return true. Otherwise, grab the last component
3408 of the exec'd pathname from the prpsinfo. */
3410 if (core_prpsinfo (core_bfd
))
3412 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3419 /* Find the last component of the executable pathname. */
3421 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3427 execname
= (char *) exec_bfd
->filename
;
3430 /* See if they match */
3432 return strcmp (execname
, corename
) ? false : true;
3438 #endif /* HAVE_PROCFS */
3441 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3442 the information that would normally be available from the /proc interface
3443 for the process, at the time the process dumped core. Currently this
3444 includes copies of the prstatus, prpsinfo, and fpregset structures.
3446 Since these structures are potentially machine dependent in size and
3447 ordering, bfd provides two levels of support for them. The first level,
3448 available on all machines since it does not require that the host
3449 have /proc support or the relevant include files, is to create a bfd
3450 section for each of the prstatus, prpsinfo, and fpregset structures,
3451 without any interpretation of their contents. With just this support,
3452 the bfd client will have to interpret the structures itself. Even with
3453 /proc support, it might want these full structures for it's own reasons.
3455 In the second level of support, where HAVE_PROCFS is defined, bfd will
3456 pick apart the structures to gather some additional information that
3457 clients may want, such as the general register set, the name of the
3458 exec'ed file and its arguments, the signal (if any) that caused the
3464 elf_corefile_note (abfd
, hdr
)
3466 Elf_Internal_Phdr
*hdr
;
3468 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3469 Elf_Internal_Note i_note
; /* Elf note, internal form */
3470 char *buf
= NULL
; /* Entire note segment contents */
3471 char *namedata
; /* Name portion of the note */
3472 char *descdata
; /* Descriptor portion of the note */
3473 char *sectname
; /* Name to use for new section */
3474 long filepos
; /* File offset to descriptor data */
3477 if (hdr
->p_filesz
> 0
3478 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3479 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3480 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3482 x_note_p
= (Elf_External_Note
*) buf
;
3483 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3485 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3486 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3487 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3488 namedata
= x_note_p
->name
;
3489 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3490 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3491 switch (i_note
.type
)
3494 /* process descdata as prstatus info */
3495 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3497 sectname
= ".prstatus";
3500 /* process descdata as fpregset info */
3501 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3503 sectname
= ".fpregset";
3506 /* process descdata as prpsinfo */
3507 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3509 sectname
= ".prpsinfo";
3512 /* Unknown descriptor, just ignore it. */
3516 if (sectname
!= NULL
)
3518 newsect
= bfd_make_section (abfd
, sectname
);
3519 if (newsect
== NULL
)
3521 newsect
->_raw_size
= i_note
.descsz
;
3522 newsect
->filepos
= filepos
;
3523 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3524 newsect
->alignment_power
= 2;
3526 x_note_p
= (Elf_External_Note
*)
3527 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3534 else if (hdr
->p_filesz
> 0)
3536 bfd_set_error (bfd_error_no_memory
);
3543 /* Core files are simply standard ELF formatted files that partition
3544 the file using the execution view of the file (program header table)
3545 rather than the linking view. In fact, there is no section header
3546 table in a core file.
3548 The process status information (including the contents of the general
3549 register set) and the floating point register set are stored in a
3550 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3551 that allow standard bfd access to the general registers (.reg) and the
3552 floating point registers (.reg2).
3557 elf_core_file_p (abfd
)
3560 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3561 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3562 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3563 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3564 unsigned int phindex
;
3565 struct elf_backend_data
*ebd
;
3567 /* Read in the ELF header in external format. */
3569 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3571 if (bfd_get_error () != bfd_error_system_call
)
3572 bfd_set_error (bfd_error_wrong_format
);
3576 /* Now check to see if we have a valid ELF file, and one that BFD can
3577 make use of. The magic number must match, the address size ('class')
3578 and byte-swapping must match our XVEC entry, and it must have a
3579 program header table (FIXME: See comments re segments at top of this
3582 if (elf_file_p (&x_ehdr
) == false)
3585 bfd_set_error (bfd_error_wrong_format
);
3589 /* FIXME, Check EI_VERSION here ! */
3593 int desired_address_size
= ELFCLASS32
;
3596 int desired_address_size
= ELFCLASS64
;
3599 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3603 /* Switch xvec to match the specified byte order. */
3604 switch (x_ehdr
.e_ident
[EI_DATA
])
3606 case ELFDATA2MSB
: /* Big-endian */
3607 if (abfd
->xvec
->byteorder_big_p
== false)
3610 case ELFDATA2LSB
: /* Little-endian */
3611 if (abfd
->xvec
->byteorder_big_p
== true)
3614 case ELFDATANONE
: /* No data encoding specified */
3615 default: /* Unknown data encoding specified */
3619 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3620 the tdata pointer in the bfd. */
3623 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3624 if (elf_tdata (abfd
) == NULL
)
3626 bfd_set_error (bfd_error_no_memory
);
3630 /* FIXME, `wrong' returns from this point onward, leak memory. */
3632 /* Now that we know the byte order, swap in the rest of the header */
3633 i_ehdrp
= elf_elfheader (abfd
);
3634 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3636 elf_debug_file (i_ehdrp
);
3639 ebd
= get_elf_backend_data (abfd
);
3641 /* Check that the ELF e_machine field matches what this particular
3642 BFD format expects. */
3643 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3645 const bfd_target
* const *target_ptr
;
3647 if (ebd
->elf_machine_code
!= EM_NONE
)
3650 /* This is the generic ELF target. Let it match any ELF target
3651 for which we do not have a specific backend. */
3652 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3654 struct elf_backend_data
*back
;
3656 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3658 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3659 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3661 /* target_ptr is an ELF backend which matches this
3662 object file, so reject the generic ELF target. */
3668 /* If there is no program header, or the type is not a core file, then
3670 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3673 /* Allocate space for a copy of the program header table in
3674 internal form, seek to the program header table in the file,
3675 read it in, and convert it to internal form. As a simple sanity
3676 check, verify that the what BFD thinks is the size of each program
3677 header table entry actually matches the size recorded in the file. */
3679 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3681 i_phdrp
= (Elf_Internal_Phdr
*)
3682 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3685 bfd_set_error (bfd_error_no_memory
);
3688 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3690 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3692 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3695 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3698 /* Once all of the program headers have been read and converted, we
3699 can start processing them. */
3701 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3703 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3704 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3706 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3711 /* Remember the entry point specified in the ELF file header. */
3713 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3718 /* ELF linker code. */
3720 static boolean elf_link_add_object_symbols
3721 PARAMS ((bfd
*, struct bfd_link_info
*));
3722 static boolean elf_link_add_archive_symbols
3723 PARAMS ((bfd
*, struct bfd_link_info
*));
3724 static Elf_Internal_Rela
*elf_link_read_relocs
3725 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3726 static boolean elf_export_symbol
3727 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3728 static boolean elf_adjust_dynamic_symbol
3729 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3731 /* Given an ELF BFD, add symbols to the global hash table as
3735 elf_bfd_link_add_symbols (abfd
, info
)
3737 struct bfd_link_info
*info
;
3741 switch (bfd_get_format (abfd
))
3744 return elf_link_add_object_symbols (abfd
, info
);
3746 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3749 if (! bfd_check_format (first
, bfd_object
))
3751 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
3753 /* On Linux, we may have an a.out archive which got
3754 recognized as an ELF archive. Therefore, we treat all
3755 archives as though they were actually of the flavour of
3756 their first element. */
3757 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
3759 return elf_link_add_archive_symbols (abfd
, info
);
3761 bfd_set_error (bfd_error_wrong_format
);
3766 /* Add symbols from an ELF archive file to the linker hash table. We
3767 don't use _bfd_generic_link_add_archive_symbols because of a
3768 problem which arises on UnixWare. The UnixWare libc.so is an
3769 archive which includes an entry libc.so.1 which defines a bunch of
3770 symbols. The libc.so archive also includes a number of other
3771 object files, which also define symbols, some of which are the same
3772 as those defined in libc.so.1. Correct linking requires that we
3773 consider each object file in turn, and include it if it defines any
3774 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3775 this; it looks through the list of undefined symbols, and includes
3776 any object file which defines them. When this algorithm is used on
3777 UnixWare, it winds up pulling in libc.so.1 early and defining a
3778 bunch of symbols. This means that some of the other objects in the
3779 archive are not included in the link, which is incorrect since they
3780 precede libc.so.1 in the archive.
3782 Fortunately, ELF archive handling is simpler than that done by
3783 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3784 oddities. In ELF, if we find a symbol in the archive map, and the
3785 symbol is currently undefined, we know that we must pull in that
3788 Unfortunately, we do have to make multiple passes over the symbol
3789 table until nothing further is resolved. */
3792 elf_link_add_archive_symbols (abfd
, info
)
3794 struct bfd_link_info
*info
;
3797 boolean
*defined
= NULL
;
3798 boolean
*included
= NULL
;
3802 if (! bfd_has_map (abfd
))
3804 /* An empty archive is a special case. */
3805 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3807 bfd_set_error (bfd_error_no_symbols
);
3811 /* Keep track of all symbols we know to be already defined, and all
3812 files we know to be already included. This is to speed up the
3813 second and subsequent passes. */
3814 c
= bfd_ardata (abfd
)->symdef_count
;
3817 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3818 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3819 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3821 bfd_set_error (bfd_error_no_memory
);
3824 memset (defined
, 0, c
* sizeof (boolean
));
3825 memset (included
, 0, c
* sizeof (boolean
));
3827 symdefs
= bfd_ardata (abfd
)->symdefs
;
3840 symdefend
= symdef
+ c
;
3841 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3843 struct elf_link_hash_entry
*h
;
3845 struct bfd_link_hash_entry
*undefs_tail
;
3848 if (defined
[i
] || included
[i
])
3850 if (symdef
->file_offset
== last
)
3856 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3857 false, false, false);
3858 if (h
== (struct elf_link_hash_entry
*) NULL
)
3860 if (h
->root
.type
!= bfd_link_hash_undefined
)
3866 /* We need to include this archive member. */
3868 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3869 if (element
== (bfd
*) NULL
)
3872 if (! bfd_check_format (element
, bfd_object
))
3875 /* Doublecheck that we have not included this object
3876 already--it should be impossible, but there may be
3877 something wrong with the archive. */
3878 if (element
->archive_pass
!= 0)
3880 bfd_set_error (bfd_error_bad_value
);
3883 element
->archive_pass
= 1;
3885 undefs_tail
= info
->hash
->undefs_tail
;
3887 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3890 if (! elf_link_add_object_symbols (element
, info
))
3893 /* If there are any new undefined symbols, we need to make
3894 another pass through the archive in order to see whether
3895 they can be defined. FIXME: This isn't perfect, because
3896 common symbols wind up on undefs_tail and because an
3897 undefined symbol which is defined later on in this pass
3898 does not require another pass. This isn't a bug, but it
3899 does make the code less efficient than it could be. */
3900 if (undefs_tail
!= info
->hash
->undefs_tail
)
3903 /* Look backward to mark all symbols from this object file
3904 which we have already seen in this pass. */
3908 included
[mark
] = true;
3913 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3915 /* We mark subsequent symbols from this object file as we go
3916 on through the loop. */
3917 last
= symdef
->file_offset
;
3928 if (defined
!= (boolean
*) NULL
)
3930 if (included
!= (boolean
*) NULL
)
3935 /* Record a new dynamic symbol. We record the dynamic symbols as we
3936 read the input files, since we need to have a list of all of them
3937 before we can determine the final sizes of the output sections.
3938 Note that we may actually call this function even though we are not
3939 going to output any dynamic symbols; in some cases we know that a
3940 symbol should be in the dynamic symbol table, but only if there is
3944 elf_link_record_dynamic_symbol (info
, h
)
3945 struct bfd_link_info
*info
;
3946 struct elf_link_hash_entry
*h
;
3948 if (h
->dynindx
== -1)
3950 struct bfd_strtab_hash
*dynstr
;
3952 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3953 ++elf_hash_table (info
)->dynsymcount
;
3955 dynstr
= elf_hash_table (info
)->dynstr
;
3958 /* Create a strtab to hold the dynamic symbol names. */
3959 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3964 h
->dynstr_index
= ((unsigned long)
3965 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3967 if (h
->dynstr_index
== (unsigned long) -1)
3974 /* Add symbols from an ELF object file to the linker hash table. */
3977 elf_link_add_object_symbols (abfd
, info
)
3979 struct bfd_link_info
*info
;
3981 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3982 const Elf_Internal_Sym
*,
3983 const char **, flagword
*,
3984 asection
**, bfd_vma
*));
3985 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3986 asection
*, const Elf_Internal_Rela
*));
3988 Elf_Internal_Shdr
*hdr
;
3992 Elf_External_Sym
*buf
= NULL
;
3993 struct elf_link_hash_entry
**sym_hash
;
3995 Elf_External_Dyn
*dynbuf
= NULL
;
3996 struct elf_link_hash_entry
*weaks
;
3997 Elf_External_Sym
*esym
;
3998 Elf_External_Sym
*esymend
;
4000 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4001 collect
= get_elf_backend_data (abfd
)->collect
;
4003 /* A stripped shared library might only have a dynamic symbol table,
4004 not a regular symbol table. In that case we can still go ahead
4005 and link using the dynamic symbol table. */
4006 if (elf_onesymtab (abfd
) == 0
4007 && elf_dynsymtab (abfd
) != 0)
4009 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4010 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4013 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4014 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4016 /* The sh_info field of the symtab header tells us where the
4017 external symbols start. We don't care about the local symbols at
4019 if (elf_bad_symtab (abfd
))
4021 extsymcount
= symcount
;
4026 extsymcount
= symcount
- hdr
->sh_info
;
4027 extsymoff
= hdr
->sh_info
;
4030 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4031 if (buf
== NULL
&& extsymcount
!= 0)
4033 bfd_set_error (bfd_error_no_memory
);
4037 /* We store a pointer to the hash table entry for each external
4039 sym_hash
= ((struct elf_link_hash_entry
**)
4041 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4042 if (sym_hash
== NULL
)
4044 bfd_set_error (bfd_error_no_memory
);
4047 elf_sym_hashes (abfd
) = sym_hash
;
4049 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4053 /* If we are creating a shared library, create all the dynamic
4054 sections immediately. We need to attach them to something,
4055 so we attach them to this BFD, provided it is the right
4056 format. FIXME: If there are no input BFD's of the same
4057 format as the output, we can't make a shared library. */
4059 && ! elf_hash_table (info
)->dynamic_sections_created
4060 && abfd
->xvec
== info
->hash
->creator
)
4062 if (! elf_link_create_dynamic_sections (abfd
, info
))
4070 bfd_size_type strindex
;
4074 /* You can't use -r against a dynamic object. Also, there's no
4075 hope of using a dynamic object which does not exactly match
4076 the format of the output file. */
4077 if (info
->relocateable
4078 || info
->hash
->creator
!= abfd
->xvec
)
4080 bfd_set_error (bfd_error_invalid_operation
);
4084 /* Find the name to use in a DT_NEEDED entry that refers to this
4085 object. If the object has a DT_SONAME entry, we use it.
4086 Otherwise, if the generic linker stuck something in
4087 elf_dt_needed_name, we use that. Otherwise, we just use the
4089 name
= bfd_get_filename (abfd
);
4090 if (elf_dt_needed_name (abfd
) != NULL
)
4091 name
= elf_dt_needed_name (abfd
);
4092 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4095 Elf_External_Dyn
*extdyn
;
4096 Elf_External_Dyn
*extdynend
;
4098 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4101 bfd_set_error (bfd_error_no_memory
);
4105 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4106 (file_ptr
) 0, s
->_raw_size
))
4110 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4111 for (; extdyn
< extdynend
; extdyn
++)
4113 Elf_Internal_Dyn dyn
;
4115 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4116 if (dyn
.d_tag
== DT_SONAME
)
4121 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4124 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4125 name
= elf_string_from_elf_section (abfd
, link
,
4138 /* We do not want to include any of the sections in a dynamic
4139 object in the output file. We hack by simply clobbering the
4140 list of sections in the BFD. This could be handled more
4141 cleanly by, say, a new section flag; the existing
4142 SEC_NEVER_LOAD flag is not the one we want, because that one
4143 still implies that the section takes up space in the output
4145 abfd
->sections
= NULL
;
4147 /* If this is the first dynamic object found in the link, create
4148 the special sections required for dynamic linking. */
4149 if (! elf_hash_table (info
)->dynamic_sections_created
)
4151 if (! elf_link_create_dynamic_sections (abfd
, info
))
4155 /* Add a DT_NEEDED entry for this dynamic object. */
4156 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4158 if (strindex
== (bfd_size_type
) -1)
4160 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4165 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4167 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4168 != extsymcount
* sizeof (Elf_External_Sym
)))
4173 esymend
= buf
+ extsymcount
;
4174 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4176 Elf_Internal_Sym sym
;
4182 struct elf_link_hash_entry
*h
= NULL
;
4185 elf_swap_symbol_in (abfd
, esym
, &sym
);
4187 flags
= BSF_NO_FLAGS
;
4189 value
= sym
.st_value
;
4192 bind
= ELF_ST_BIND (sym
.st_info
);
4193 if (bind
== STB_LOCAL
)
4195 /* This should be impossible, since ELF requires that all
4196 global symbols follow all local symbols, and that sh_info
4197 point to the first global symbol. Unfortunatealy, Irix 5
4201 else if (bind
== STB_GLOBAL
)
4203 else if (bind
== STB_WEAK
)
4207 /* Leave it up to the processor backend. */
4210 if (sym
.st_shndx
== SHN_UNDEF
)
4211 sec
= bfd_und_section_ptr
;
4212 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4214 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4218 sec
= bfd_abs_section_ptr
;
4220 else if (sym
.st_shndx
== SHN_ABS
)
4221 sec
= bfd_abs_section_ptr
;
4222 else if (sym
.st_shndx
== SHN_COMMON
)
4224 sec
= bfd_com_section_ptr
;
4225 /* What ELF calls the size we call the value. What ELF
4226 calls the value we call the alignment. */
4227 value
= sym
.st_size
;
4231 /* Leave it up to the processor backend. */
4234 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4235 if (name
== (const char *) NULL
)
4238 if (add_symbol_hook
)
4240 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4244 /* The hook function sets the name to NULL if this symbol
4245 should be skipped for some reason. */
4246 if (name
== (const char *) NULL
)
4250 /* Sanity check that all possibilities were handled. */
4251 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4253 bfd_set_error (bfd_error_bad_value
);
4257 if (bfd_is_und_section (sec
)
4258 || bfd_is_com_section (sec
))
4263 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4265 /* We need to look up the symbol now in order to get some of
4266 the dynamic object handling right. We pass the hash
4267 table entry in to _bfd_generic_link_add_one_symbol so
4268 that it does not have to look it up again. */
4269 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4270 true, false, false);
4275 /* If we are looking at a dynamic object, and this is a
4276 definition, we need to see if it has already been defined
4277 by some other object. If it has, we want to use the
4278 existing definition, and we do not want to report a
4279 multiple symbol definition error; we do this by
4280 clobbering sec to be bfd_und_section_ptr. */
4281 if (dynamic
&& definition
)
4283 if (h
->root
.type
== bfd_link_hash_defined
)
4284 sec
= bfd_und_section_ptr
;
4287 /* Similarly, if we are not looking at a dynamic object, and
4288 we have a definition, we want to override any definition
4289 we may have from a dynamic object. Symbols from regular
4290 files always take precedence over symbols from dynamic
4291 objects, even if they are defined after the dynamic
4292 object in the link. */
4295 && h
->root
.type
== bfd_link_hash_defined
4296 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4297 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4298 == bfd_target_elf_flavour
)
4299 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4302 /* Change the hash table entry to undefined, and let
4303 _bfd_generic_link_add_one_symbol do the right thing
4304 with the new definition. */
4305 h
->root
.type
= bfd_link_hash_undefined
;
4306 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4307 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4310 /* If this is a weak definition which we are going to use,
4311 and the symbol is currently undefined, record that the
4312 definition is weak. */
4314 && (flags
& BSF_WEAK
) != 0
4315 && ! bfd_is_und_section (sec
)
4316 && (h
->root
.type
== bfd_link_hash_new
4317 || h
->root
.type
== bfd_link_hash_undefined
4318 || h
->root
.type
== bfd_link_hash_weak
))
4319 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4322 if (! (_bfd_generic_link_add_one_symbol
4323 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4324 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4329 && (flags
& BSF_WEAK
) != 0
4330 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4331 && (*sym_hash
)->weakdef
== NULL
)
4333 /* Keep a list of all weak defined non function symbols from
4334 a dynamic object, using the weakdef field. Later in this
4335 function we will set the weakdef field to the correct
4336 value. We only put non-function symbols from dynamic
4337 objects on this list, because that happens to be the only
4338 time we need to know the normal symbol corresponding to a
4339 weak symbol, and the information is time consuming to
4340 figure out. If the weakdef field is not already NULL,
4341 then this symbol was already defined by some previous
4342 dynamic object, and we will be using that previous
4343 definition anyhow. */
4345 (*sym_hash
)->weakdef
= weaks
;
4349 /* Get the alignment of a common symbol. */
4350 if (sym
.st_shndx
== SHN_COMMON
4351 && h
->root
.type
== bfd_link_hash_common
)
4352 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4354 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4360 /* Remember the symbol size and type. */
4361 if (sym
.st_size
!= 0)
4363 /* FIXME: We should probably somehow give a warning if
4364 the symbol size changes. */
4365 h
->size
= sym
.st_size
;
4367 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4369 /* FIXME: We should probably somehow give a warning if
4370 the symbol type changes. */
4371 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4374 /* Set a flag in the hash table entry indicating the type of
4375 reference or definition we just found. Keep a count of
4376 the number of dynamic symbols we find. A dynamic symbol
4377 is one which is referenced or defined by both a regular
4378 object and a shared object, or one which is referenced or
4379 defined by more than one shared object. */
4380 old_flags
= h
->elf_link_hash_flags
;
4385 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4387 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4389 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4390 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4396 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4398 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4399 if ((old_flags
& new_flag
) != 0
4400 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4401 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4405 h
->elf_link_hash_flags
|= new_flag
;
4406 if (dynsym
&& h
->dynindx
== -1)
4408 if (! elf_link_record_dynamic_symbol (info
, h
))
4414 /* Now set the weakdefs field correctly for all the weak defined
4415 symbols we found. The only way to do this is to search all the
4416 symbols. Since we only need the information for non functions in
4417 dynamic objects, that's the only time we actually put anything on
4418 the list WEAKS. We need this information so that if a regular
4419 object refers to a symbol defined weakly in a dynamic object, the
4420 real symbol in the dynamic object is also put in the dynamic
4421 symbols; we also must arrange for both symbols to point to the
4422 same memory location. We could handle the general case of symbol
4423 aliasing, but a general symbol alias can only be generated in
4424 assembler code, handling it correctly would be very time
4425 consuming, and other ELF linkers don't handle general aliasing
4427 while (weaks
!= NULL
)
4429 struct elf_link_hash_entry
*hlook
;
4432 struct elf_link_hash_entry
**hpp
;
4433 struct elf_link_hash_entry
**hppend
;
4436 weaks
= hlook
->weakdef
;
4437 hlook
->weakdef
= NULL
;
4439 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4440 slook
= hlook
->root
.u
.def
.section
;
4441 vlook
= hlook
->root
.u
.def
.value
;
4443 hpp
= elf_sym_hashes (abfd
);
4444 hppend
= hpp
+ extsymcount
;
4445 for (; hpp
< hppend
; hpp
++)
4447 struct elf_link_hash_entry
*h
;
4451 && h
->root
.type
== bfd_link_hash_defined
4452 && h
->root
.u
.def
.section
== slook
4453 && h
->root
.u
.def
.value
== vlook
)
4457 /* If the weak definition is in the list of dynamic
4458 symbols, make sure the real definition is put there
4460 if (hlook
->dynindx
!= -1
4461 && h
->dynindx
== -1)
4463 if (! elf_link_record_dynamic_symbol (info
, h
))
4478 /* If this object is the same format as the output object, and it is
4479 not a shared library, then let the backend look through the
4482 This is required to build global offset table entries and to
4483 arrange for dynamic relocs. It is not required for the
4484 particular common case of linking non PIC code, even when linking
4485 against shared libraries, but unfortunately there is no way of
4486 knowing whether an object file has been compiled PIC or not.
4487 Looking through the relocs is not particularly time consuming.
4488 The problem is that we must either (1) keep the relocs in memory,
4489 which causes the linker to require additional runtime memory or
4490 (2) read the relocs twice from the input file, which wastes time.
4491 This would be a good case for using mmap.
4493 I have no idea how to handle linking PIC code into a file of a
4494 different format. It probably can't be done. */
4495 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4497 && abfd
->xvec
== info
->hash
->creator
4498 && check_relocs
!= NULL
)
4502 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4504 Elf_Internal_Rela
*internal_relocs
;
4507 if ((o
->flags
& SEC_RELOC
) == 0
4508 || o
->reloc_count
== 0)
4511 /* I believe we can ignore the relocs for any section which
4512 does not form part of the final process image, such as a
4513 debugging section. */
4514 if ((o
->flags
& SEC_ALLOC
) == 0)
4517 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4518 (Elf_Internal_Rela
*) NULL
,
4520 if (internal_relocs
== NULL
)
4523 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4525 if (! info
->keep_memory
)
4526 free (internal_relocs
);
4543 /* Create some sections which will be filled in with dynamic linking
4544 information. ABFD is an input file which requires dynamic sections
4545 to be created. The dynamic sections take up virtual memory space
4546 when the final executable is run, so we need to create them before
4547 addresses are assigned to the output sections. We work out the
4548 actual contents and size of these sections later. */
4551 elf_link_create_dynamic_sections (abfd
, info
)
4553 struct bfd_link_info
*info
;
4556 register asection
*s
;
4557 struct elf_link_hash_entry
*h
;
4558 struct elf_backend_data
*bed
;
4560 if (elf_hash_table (info
)->dynamic_sections_created
)
4563 /* Make sure that all dynamic sections use the same input BFD. */
4564 if (elf_hash_table (info
)->dynobj
== NULL
)
4565 elf_hash_table (info
)->dynobj
= abfd
;
4567 abfd
= elf_hash_table (info
)->dynobj
;
4569 /* Note that we set the SEC_IN_MEMORY flag for all of these
4571 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4573 /* A dynamically linked executable has a .interp section, but a
4574 shared library does not. */
4577 s
= bfd_make_section (abfd
, ".interp");
4579 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4583 s
= bfd_make_section (abfd
, ".dynsym");
4585 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4586 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4589 s
= bfd_make_section (abfd
, ".dynstr");
4591 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4594 /* Create a strtab to hold the dynamic symbol names. */
4595 if (elf_hash_table (info
)->dynstr
== NULL
)
4597 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4598 if (elf_hash_table (info
)->dynstr
== NULL
)
4602 s
= bfd_make_section (abfd
, ".dynamic");
4604 || ! bfd_set_section_flags (abfd
, s
, flags
)
4605 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4608 /* The special symbol _DYNAMIC is always set to the start of the
4609 .dynamic section. This call occurs before we have processed the
4610 symbols for any dynamic object, so we don't have to worry about
4611 overriding a dynamic definition. We could set _DYNAMIC in a
4612 linker script, but we only want to define it if we are, in fact,
4613 creating a .dynamic section. We don't want to define it if there
4614 is no .dynamic section, since on some ELF platforms the start up
4615 code examines it to decide how to initialize the process. */
4617 if (! (_bfd_generic_link_add_one_symbol
4618 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4619 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4620 (struct bfd_link_hash_entry
**) &h
)))
4622 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4623 h
->type
= STT_OBJECT
;
4626 && ! elf_link_record_dynamic_symbol (info
, h
))
4629 s
= bfd_make_section (abfd
, ".hash");
4631 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4632 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4635 /* Let the backend create the rest of the sections. This lets the
4636 backend set the right flags. The backend will normally create
4637 the .got and .plt sections. */
4638 bed
= get_elf_backend_data (abfd
);
4639 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4642 elf_hash_table (info
)->dynamic_sections_created
= true;
4647 /* Add an entry to the .dynamic table. */
4650 elf_add_dynamic_entry (info
, tag
, val
)
4651 struct bfd_link_info
*info
;
4655 Elf_Internal_Dyn dyn
;
4659 bfd_byte
*newcontents
;
4661 dynobj
= elf_hash_table (info
)->dynobj
;
4663 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4664 BFD_ASSERT (s
!= NULL
);
4666 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4667 if (s
->contents
== NULL
)
4668 newcontents
= (bfd_byte
*) malloc (newsize
);
4670 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4671 if (newcontents
== NULL
)
4673 bfd_set_error (bfd_error_no_memory
);
4678 dyn
.d_un
.d_val
= val
;
4679 elf_swap_dyn_out (dynobj
, &dyn
,
4680 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4682 s
->_raw_size
= newsize
;
4683 s
->contents
= newcontents
;
4688 /* Read and swap the relocs for a section. They may have been cached.
4689 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4690 they are used as buffers to read into. They are known to be large
4691 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4692 value is allocated using either malloc or bfd_alloc, according to
4693 the KEEP_MEMORY argument. */
4695 static Elf_Internal_Rela
*
4696 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4699 PTR external_relocs
;
4700 Elf_Internal_Rela
*internal_relocs
;
4701 boolean keep_memory
;
4703 Elf_Internal_Shdr
*rel_hdr
;
4705 Elf_Internal_Rela
*alloc2
= NULL
;
4707 if (elf_section_data (o
)->relocs
!= NULL
)
4708 return elf_section_data (o
)->relocs
;
4710 if (o
->reloc_count
== 0)
4713 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4715 if (internal_relocs
== NULL
)
4719 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4721 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4723 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4724 if (internal_relocs
== NULL
)
4726 bfd_set_error (bfd_error_no_memory
);
4731 if (external_relocs
== NULL
)
4733 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4736 bfd_set_error (bfd_error_no_memory
);
4739 external_relocs
= alloc1
;
4742 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4743 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4744 != rel_hdr
->sh_size
))
4747 /* Swap in the relocs. For convenience, we always produce an
4748 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4750 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4752 Elf_External_Rel
*erel
;
4753 Elf_External_Rel
*erelend
;
4754 Elf_Internal_Rela
*irela
;
4756 erel
= (Elf_External_Rel
*) external_relocs
;
4757 erelend
= erel
+ o
->reloc_count
;
4758 irela
= internal_relocs
;
4759 for (; erel
< erelend
; erel
++, irela
++)
4761 Elf_Internal_Rel irel
;
4763 elf_swap_reloc_in (abfd
, erel
, &irel
);
4764 irela
->r_offset
= irel
.r_offset
;
4765 irela
->r_info
= irel
.r_info
;
4766 irela
->r_addend
= 0;
4771 Elf_External_Rela
*erela
;
4772 Elf_External_Rela
*erelaend
;
4773 Elf_Internal_Rela
*irela
;
4775 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4777 erela
= (Elf_External_Rela
*) external_relocs
;
4778 erelaend
= erela
+ o
->reloc_count
;
4779 irela
= internal_relocs
;
4780 for (; erela
< erelaend
; erela
++, irela
++)
4781 elf_swap_reloca_in (abfd
, erela
, irela
);
4784 /* Cache the results for next time, if we can. */
4786 elf_section_data (o
)->relocs
= internal_relocs
;
4791 /* Don't free alloc2, since if it was allocated we are passing it
4792 back (under the name of internal_relocs). */
4794 return internal_relocs
;
4804 /* Record an assignment to a symbol made by a linker script. We need
4805 this in case some dynamic object refers to this symbol. */
4809 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4811 struct bfd_link_info
*info
;
4814 struct elf_link_hash_entry
*h
;
4816 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4820 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4821 h
->type
= STT_OBJECT
;
4823 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4824 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4826 && h
->dynindx
== -1)
4828 if (! elf_link_record_dynamic_symbol (info
, h
))
4831 /* If this is a weak defined symbol, and we know a corresponding
4832 real symbol from the same dynamic object, make sure the real
4833 symbol is also made into a dynamic symbol. */
4834 if (h
->weakdef
!= NULL
4835 && h
->weakdef
->dynindx
== -1)
4837 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4845 /* Array used to determine the number of hash table buckets to use
4846 based on the number of symbols there are. If there are fewer than
4847 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4848 fewer than 37 we use 17 buckets, and so forth. We never use more
4849 than 521 buckets. */
4851 static const size_t elf_buckets
[] =
4853 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4856 /* Set up the sizes and contents of the ELF dynamic sections. This is
4857 called by the ELF linker emulation before_allocation routine. We
4858 must set the sizes of the sections before the linker sets the
4859 addresses of the various sections. */
4862 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4863 export_dynamic
, info
, sinterpptr
)
4867 boolean export_dynamic
;
4868 struct bfd_link_info
*info
;
4869 asection
**sinterpptr
;
4873 Elf_Internal_Sym isym
;
4876 struct elf_backend_data
*bed
;
4880 dynobj
= elf_hash_table (info
)->dynobj
;
4882 /* If there were no dynamic objects in the link, there is nothing to
4887 /* If we are supposed to export all symbols into the dynamic symbol
4888 table (this is not the normal case), then do so. */
4890 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4893 if (elf_hash_table (info
)->dynamic_sections_created
)
4895 bfd_size_type strsize
;
4897 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4898 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4904 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4906 if (indx
== (bfd_size_type
) -1
4907 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4915 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4917 if (indx
== (bfd_size_type
) -1
4918 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4922 /* Find all symbols which were defined in a dynamic object and make
4923 the backend pick a reasonable value for them. */
4924 elf_link_hash_traverse (elf_hash_table (info
),
4925 elf_adjust_dynamic_symbol
,
4928 /* Add some entries to the .dynamic section. We fill in some of the
4929 values later, in elf_bfd_final_link, but we must add the entries
4930 now so that we know the final size of the .dynamic section. */
4931 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4932 false, false) != NULL
)
4934 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4937 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4938 false, false) != NULL
)
4940 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4943 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4944 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4945 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4946 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4947 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4948 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4949 sizeof (Elf_External_Sym
)))
4953 /* The backend must work out the sizes of all the other dynamic
4955 bed
= get_elf_backend_data (output_bfd
);
4956 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4959 if (elf_hash_table (info
)->dynamic_sections_created
)
4963 /* Set the size of the .dynsym and .hash sections. We counted
4964 the number of dynamic symbols in elf_link_add_object_symbols.
4965 We will build the contents of .dynsym and .hash when we build
4966 the final symbol table, because until then we do not know the
4967 correct value to give the symbols. We built the .dynstr
4968 section as we went along in elf_link_add_object_symbols. */
4969 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4970 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4971 BFD_ASSERT (s
!= NULL
);
4972 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4973 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4974 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4976 bfd_set_error (bfd_error_no_memory
);
4980 /* The first entry in .dynsym is a dummy symbol. */
4987 elf_swap_symbol_out (output_bfd
, &isym
,
4988 (Elf_External_Sym
*) s
->contents
);
4990 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4992 bucketcount
= elf_buckets
[i
];
4993 if (dynsymcount
< elf_buckets
[i
+ 1])
4997 s
= bfd_get_section_by_name (dynobj
, ".hash");
4998 BFD_ASSERT (s
!= NULL
);
4999 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
5000 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
5001 if (s
->contents
== NULL
)
5003 bfd_set_error (bfd_error_no_memory
);
5006 memset (s
->contents
, 0, s
->_raw_size
);
5008 put_word (output_bfd
, bucketcount
, s
->contents
);
5009 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
5011 elf_hash_table (info
)->bucketcount
= bucketcount
;
5013 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
5014 BFD_ASSERT (s
!= NULL
);
5015 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5017 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
5024 /* This routine is used to export all defined symbols into the dynamic
5025 symbol table. It is called via elf_link_hash_traverse. */
5028 elf_export_symbol (h
, data
)
5029 struct elf_link_hash_entry
*h
;
5032 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5034 if (h
->dynindx
== -1
5035 && (h
->elf_link_hash_flags
5036 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
5038 if (! elf_link_record_dynamic_symbol (info
, h
))
5040 /* FIXME: No way to report error. */
5048 /* Make the backend pick a good value for a dynamic symbol. This is
5049 called via elf_link_hash_traverse, and also calls itself
5053 elf_adjust_dynamic_symbol (h
, data
)
5054 struct elf_link_hash_entry
*h
;
5057 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5059 struct elf_backend_data
*bed
;
5061 /* If this symbol does not require a PLT entry, and it is not
5062 defined by a dynamic object, or is not referenced by a regular
5063 object, ignore it. FIXME: Do we need to worry about symbols
5064 which are defined by one dynamic object and referenced by another
5066 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5067 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5068 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5069 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5072 /* If we've already adjusted this symbol, don't do it again. This
5073 can happen via a recursive call. */
5074 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5077 /* Don't look at this symbol again. Note that we must set this
5078 after checking the above conditions, because we may look at a
5079 symbol once, decide not to do anything, and then get called
5080 recursively later after REF_REGULAR is set below. */
5081 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5083 /* If this is a weak definition, and we know a real definition, and
5084 the real symbol is not itself defined by a regular object file,
5085 then get a good value for the real definition. We handle the
5086 real symbol first, for the convenience of the backend routine.
5088 Note that there is a confusing case here. If the real definition
5089 is defined by a regular object file, we don't get the real symbol
5090 from the dynamic object, but we do get the weak symbol. If the
5091 processor backend uses a COPY reloc, then if some routine in the
5092 dynamic object changes the real symbol, we will not see that
5093 change in the corresponding weak symbol. This is the way other
5094 ELF linkers work as well, and seems to be a result of the shared
5097 I will clarify this issue. Most SVR4 shared libraries define the
5098 variable _timezone and define timezone as a weak synonym. The
5099 tzset call changes _timezone. If you write
5100 extern int timezone;
5102 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5103 you might expect that, since timezone is a synonym for _timezone,
5104 the same number will print both times. However, if the processor
5105 backend uses a COPY reloc, then actually timezone will be copied
5106 into your process image, and, since you define _timezone
5107 yourself, _timezone will not. Thus timezone and _timezone will
5108 wind up at different memory locations. The tzset call will set
5109 _timezone, leaving timezone unchanged. */
5111 if (h
->weakdef
!= NULL
)
5113 struct elf_link_hash_entry
*weakdef
;
5115 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5116 weakdef
= h
->weakdef
;
5117 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5118 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5119 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5121 /* This symbol is defined by a regular object file, so we
5122 will not do anything special. Clear weakdef for the
5123 convenience of the processor backend. */
5128 /* There is an implicit reference by a regular object file
5129 via the weak symbol. */
5130 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5131 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5136 dynobj
= elf_hash_table (info
)->dynobj
;
5137 bed
= get_elf_backend_data (dynobj
);
5138 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5140 /* FIXME: No way to return error. */
5147 /* Final phase of ELF linker. */
5149 /* A structure we use to avoid passing large numbers of arguments. */
5151 struct elf_final_link_info
5153 /* General link information. */
5154 struct bfd_link_info
*info
;
5157 /* Symbol string table. */
5158 struct bfd_strtab_hash
*symstrtab
;
5159 /* .dynsym section. */
5160 asection
*dynsym_sec
;
5161 /* .hash section. */
5163 /* Buffer large enough to hold contents of any section. */
5165 /* Buffer large enough to hold external relocs of any section. */
5166 PTR external_relocs
;
5167 /* Buffer large enough to hold internal relocs of any section. */
5168 Elf_Internal_Rela
*internal_relocs
;
5169 /* Buffer large enough to hold external local symbols of any input
5171 Elf_External_Sym
*external_syms
;
5172 /* Buffer large enough to hold internal local symbols of any input
5174 Elf_Internal_Sym
*internal_syms
;
5175 /* Array large enough to hold a symbol index for each local symbol
5176 of any input BFD. */
5178 /* Array large enough to hold a section pointer for each local
5179 symbol of any input BFD. */
5180 asection
**sections
;
5181 /* Buffer to hold swapped out symbols. */
5182 Elf_External_Sym
*symbuf
;
5183 /* Number of swapped out symbols in buffer. */
5184 size_t symbuf_count
;
5185 /* Number of symbols which fit in symbuf. */
5189 static boolean elf_link_output_sym
5190 PARAMS ((struct elf_final_link_info
*, const char *,
5191 Elf_Internal_Sym
*, asection
*));
5192 static boolean elf_link_flush_output_syms
5193 PARAMS ((struct elf_final_link_info
*));
5194 static boolean elf_link_output_extsym
5195 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5196 static boolean elf_link_input_bfd
5197 PARAMS ((struct elf_final_link_info
*, bfd
*));
5198 static boolean elf_reloc_link_order
5199 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5200 struct bfd_link_order
*));
5202 /* Do the final step of an ELF link. */
5205 elf_bfd_final_link (abfd
, info
)
5207 struct bfd_link_info
*info
;
5211 struct elf_final_link_info finfo
;
5212 register asection
*o
;
5213 register struct bfd_link_order
*p
;
5215 size_t max_contents_size
;
5216 size_t max_external_reloc_size
;
5217 size_t max_internal_reloc_count
;
5218 size_t max_sym_count
;
5220 Elf_Internal_Sym elfsym
;
5222 Elf_Internal_Shdr
*symtab_hdr
;
5223 Elf_Internal_Shdr
*symstrtab_hdr
;
5224 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5227 abfd
->flags
|= DYNAMIC
;
5229 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5230 dynobj
= elf_hash_table (info
)->dynobj
;
5233 finfo
.output_bfd
= abfd
;
5234 finfo
.symstrtab
= elf_stringtab_init ();
5235 if (finfo
.symstrtab
== NULL
)
5239 finfo
.dynsym_sec
= NULL
;
5240 finfo
.hash_sec
= NULL
;
5244 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5245 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5246 if (finfo
.dynsym_sec
== NULL
5247 || finfo
.hash_sec
== NULL
)
5250 finfo
.contents
= NULL
;
5251 finfo
.external_relocs
= NULL
;
5252 finfo
.internal_relocs
= NULL
;
5253 finfo
.external_syms
= NULL
;
5254 finfo
.internal_syms
= NULL
;
5255 finfo
.indices
= NULL
;
5256 finfo
.sections
= NULL
;
5257 finfo
.symbuf
= NULL
;
5258 finfo
.symbuf_count
= 0;
5260 /* Count up the number of relocations we will output for each output
5261 section, so that we know the sizes of the reloc sections. We
5262 also figure out some maximum sizes. */
5263 max_contents_size
= 0;
5264 max_external_reloc_size
= 0;
5265 max_internal_reloc_count
= 0;
5267 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5271 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5273 if (p
->type
== bfd_section_reloc_link_order
5274 || p
->type
== bfd_symbol_reloc_link_order
)
5276 else if (p
->type
== bfd_indirect_link_order
)
5280 sec
= p
->u
.indirect
.section
;
5282 if (info
->relocateable
)
5283 o
->reloc_count
+= sec
->reloc_count
;
5285 if (sec
->_raw_size
> max_contents_size
)
5286 max_contents_size
= sec
->_raw_size
;
5287 if (sec
->_cooked_size
> max_contents_size
)
5288 max_contents_size
= sec
->_cooked_size
;
5290 /* We are interested in just local symbols, not all
5292 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5296 if (elf_bad_symtab (sec
->owner
))
5297 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5298 / sizeof (Elf_External_Sym
));
5300 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5302 if (sym_count
> max_sym_count
)
5303 max_sym_count
= sym_count
;
5305 if ((sec
->flags
& SEC_RELOC
) != 0)
5309 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5310 if (ext_size
> max_external_reloc_size
)
5311 max_external_reloc_size
= ext_size
;
5312 if (sec
->reloc_count
> max_internal_reloc_count
)
5313 max_internal_reloc_count
= sec
->reloc_count
;
5319 if (o
->reloc_count
> 0)
5320 o
->flags
|= SEC_RELOC
;
5323 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5324 set it (this is probably a bug) and if it is set
5325 assign_section_numbers will create a reloc section. */
5326 o
->flags
&=~ SEC_RELOC
;
5329 /* If the SEC_ALLOC flag is not set, force the section VMA to
5330 zero. This is done in elf_fake_sections as well, but forcing
5331 the VMA to 0 here will ensure that relocs against these
5332 sections are handled correctly. */
5333 if ((o
->flags
& SEC_ALLOC
) == 0)
5337 /* Figure out the file positions for everything but the symbol table
5338 and the relocs. We set symcount to force assign_section_numbers
5339 to create a symbol table. */
5340 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5341 BFD_ASSERT (! abfd
->output_has_begun
);
5342 if (! elf_compute_section_file_positions (abfd
, info
))
5345 /* That created the reloc sections. Set their sizes, and assign
5346 them file positions, and allocate some buffers. */
5347 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5349 if ((o
->flags
& SEC_RELOC
) != 0)
5351 Elf_Internal_Shdr
*rel_hdr
;
5352 register struct elf_link_hash_entry
**p
, **pend
;
5354 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5356 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5358 /* The contents field must last into write_object_contents,
5359 so we allocate it with bfd_alloc rather than malloc. */
5360 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5361 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5363 bfd_set_error (bfd_error_no_memory
);
5367 p
= ((struct elf_link_hash_entry
**)
5368 malloc (o
->reloc_count
5369 * sizeof (struct elf_link_hash_entry
*)));
5370 if (p
== NULL
&& o
->reloc_count
!= 0)
5372 bfd_set_error (bfd_error_no_memory
);
5375 elf_section_data (o
)->rel_hashes
= p
;
5376 pend
= p
+ o
->reloc_count
;
5377 for (; p
< pend
; p
++)
5380 /* Use the reloc_count field as an index when outputting the
5386 assign_file_positions_for_relocs (abfd
);
5388 /* We have now assigned file positions for all the sections except
5389 .symtab and .strtab. We start the .symtab section at the current
5390 file position, and write directly to it. We build the .strtab
5391 section in memory. When we add .dynsym support, we will build
5392 that in memory as well (.dynsym is smaller than .symtab). */
5394 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5395 /* sh_name is set in prep_headers. */
5396 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5397 symtab_hdr
->sh_flags
= 0;
5398 symtab_hdr
->sh_addr
= 0;
5399 symtab_hdr
->sh_size
= 0;
5400 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5401 /* sh_link is set in assign_section_numbers. */
5402 /* sh_info is set below. */
5403 /* sh_offset is set just below. */
5404 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5406 off
= elf_tdata (abfd
)->next_file_pos
;
5407 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5409 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5410 incorrect. We do not yet know the size of the .symtab section.
5411 We correct next_file_pos below, after we do know the size. */
5413 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5414 continuously seeking to the right position in the file. */
5415 if (! info
->keep_memory
|| max_sym_count
< 20)
5416 finfo
.symbuf_size
= 20;
5418 finfo
.symbuf_size
= max_sym_count
;
5419 finfo
.symbuf
= ((Elf_External_Sym
*)
5420 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5421 if (finfo
.symbuf
== NULL
)
5423 bfd_set_error (bfd_error_no_memory
);
5427 /* Start writing out the symbol table. The first symbol is always a
5429 elfsym
.st_value
= 0;
5432 elfsym
.st_other
= 0;
5433 elfsym
.st_shndx
= SHN_UNDEF
;
5434 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5435 &elfsym
, bfd_und_section_ptr
))
5439 /* Some standard ELF linkers do this, but we don't because it causes
5440 bootstrap comparison failures. */
5441 /* Output a file symbol for the output file as the second symbol.
5442 We output this even if we are discarding local symbols, although
5443 I'm not sure if this is correct. */
5444 elfsym
.st_value
= 0;
5446 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5447 elfsym
.st_other
= 0;
5448 elfsym
.st_shndx
= SHN_ABS
;
5449 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5450 &elfsym
, bfd_abs_section_ptr
))
5454 /* Output a symbol for each section. We output these even if we are
5455 discarding local symbols, since they are used for relocs. These
5456 symbols have no names. We store the index of each one in the
5457 index field of the section, so that we can find it again when
5458 outputting relocs. */
5459 elfsym
.st_value
= 0;
5461 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5462 elfsym
.st_other
= 0;
5463 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5465 o
= section_from_elf_index (abfd
, i
);
5467 o
->target_index
= abfd
->symcount
;
5468 elfsym
.st_shndx
= i
;
5469 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5474 /* Allocate some memory to hold information read in from the input
5476 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5477 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5478 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5479 malloc (max_internal_reloc_count
5480 * sizeof (Elf_Internal_Rela
)));
5481 finfo
.external_syms
= ((Elf_External_Sym
*)
5482 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5483 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5484 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5485 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5486 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5487 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5488 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5489 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5490 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5491 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5492 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5493 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5495 bfd_set_error (bfd_error_no_memory
);
5499 /* Since ELF permits relocations to be against local symbols, we
5500 must have the local symbols available when we do the relocations.
5501 Since we would rather only read the local symbols once, and we
5502 would rather not keep them in memory, we handle all the
5503 relocations for a single input file at the same time.
5505 Unfortunately, there is no way to know the total number of local
5506 symbols until we have seen all of them, and the local symbol
5507 indices precede the global symbol indices. This means that when
5508 we are generating relocateable output, and we see a reloc against
5509 a global symbol, we can not know the symbol index until we have
5510 finished examining all the local symbols to see which ones we are
5511 going to output. To deal with this, we keep the relocations in
5512 memory, and don't output them until the end of the link. This is
5513 an unfortunate waste of memory, but I don't see a good way around
5514 it. Fortunately, it only happens when performing a relocateable
5515 link, which is not the common case. FIXME: If keep_memory is set
5516 we could write the relocs out and then read them again; I don't
5517 know how bad the memory loss will be. */
5519 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5520 sub
->output_has_begun
= false;
5521 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5523 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5525 if (p
->type
== bfd_indirect_link_order
5526 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5527 == bfd_target_elf_flavour
))
5529 sub
= p
->u
.indirect
.section
->owner
;
5530 if (! sub
->output_has_begun
)
5532 if (! elf_link_input_bfd (&finfo
, sub
))
5534 sub
->output_has_begun
= true;
5537 else if (p
->type
== bfd_section_reloc_link_order
5538 || p
->type
== bfd_symbol_reloc_link_order
)
5540 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5545 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5551 /* That wrote out all the local symbols. Finish up the symbol table
5552 with the global symbols. */
5554 /* The sh_info field records the index of the first non local
5556 symtab_hdr
->sh_info
= abfd
->symcount
;
5558 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5560 /* We get the global symbols from the hash table. */
5561 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5564 /* Flush all symbols to the file. */
5565 if (! elf_link_flush_output_syms (&finfo
))
5568 /* Now we know the size of the symtab section. */
5569 off
+= symtab_hdr
->sh_size
;
5571 /* Finish up and write out the symbol string table (.strtab)
5573 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5574 /* sh_name was set in prep_headers. */
5575 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5576 symstrtab_hdr
->sh_flags
= 0;
5577 symstrtab_hdr
->sh_addr
= 0;
5578 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5579 symstrtab_hdr
->sh_entsize
= 0;
5580 symstrtab_hdr
->sh_link
= 0;
5581 symstrtab_hdr
->sh_info
= 0;
5582 /* sh_offset is set just below. */
5583 symstrtab_hdr
->sh_addralign
= 1;
5585 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5586 elf_tdata (abfd
)->next_file_pos
= off
;
5588 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5589 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5592 /* Adjust the relocs to have the correct symbol indices. */
5593 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5595 struct elf_link_hash_entry
**rel_hash
;
5596 Elf_Internal_Shdr
*rel_hdr
;
5598 if ((o
->flags
& SEC_RELOC
) == 0)
5601 rel_hash
= elf_section_data (o
)->rel_hashes
;
5602 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5603 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5605 if (*rel_hash
== NULL
)
5608 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5610 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5612 Elf_External_Rel
*erel
;
5613 Elf_Internal_Rel irel
;
5615 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5616 elf_swap_reloc_in (abfd
, erel
, &irel
);
5617 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5618 ELF_R_TYPE (irel
.r_info
));
5619 elf_swap_reloc_out (abfd
, &irel
, erel
);
5623 Elf_External_Rela
*erela
;
5624 Elf_Internal_Rela irela
;
5626 BFD_ASSERT (rel_hdr
->sh_entsize
5627 == sizeof (Elf_External_Rela
));
5629 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5630 elf_swap_reloca_in (abfd
, erela
, &irela
);
5631 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5632 ELF_R_TYPE (irela
.r_info
));
5633 elf_swap_reloca_out (abfd
, &irela
, erela
);
5637 /* Set the reloc_count field to 0 to prevent write_relocs from
5638 trying to swap the relocs out itself. */
5642 /* If we are linking against a dynamic object, or generating a
5643 shared library, finish up the dynamic linking information. */
5646 Elf_External_Dyn
*dyncon
, *dynconend
;
5648 /* Fix up .dynamic entries. */
5649 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5650 BFD_ASSERT (o
!= NULL
);
5652 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5653 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5654 for (; dyncon
< dynconend
; dyncon
++)
5656 Elf_Internal_Dyn dyn
;
5660 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5667 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5668 magic _init and _fini symbols. This is pretty ugly,
5669 but we are compatible. */
5677 struct elf_link_hash_entry
*h
;
5679 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5680 false, false, true);
5681 BFD_ASSERT (h
!= NULL
);
5682 if (h
->root
.type
== bfd_link_hash_defined
)
5684 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5685 o
= h
->root
.u
.def
.section
;
5686 if (o
->output_section
!= NULL
)
5687 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5688 + o
->output_offset
);
5690 dyn
.d_un
.d_val
+= o
->vma
;
5692 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5705 o
= bfd_get_section_by_name (abfd
, name
);
5706 BFD_ASSERT (o
!= NULL
);
5707 dyn
.d_un
.d_ptr
= o
->vma
;
5708 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5715 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5720 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5722 Elf_Internal_Shdr
*hdr
;
5724 hdr
= elf_elfsections (abfd
)[i
];
5725 if (hdr
->sh_type
== type
5726 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5728 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5729 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5732 if (dyn
.d_un
.d_val
== 0
5733 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5734 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5738 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5744 /* If we have created any dynamic sections, then output them. */
5747 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5750 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5752 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5753 || o
->_raw_size
== 0)
5755 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5757 /* At this point, we are only interested in sections
5758 created by elf_link_create_dynamic_sections. FIXME:
5759 This test is fragile. */
5762 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5764 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5766 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5767 o
->contents
, o
->output_offset
,
5775 /* The contents of the .dynstr section are actually in a
5777 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5778 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5779 || ! _bfd_stringtab_emit (abfd
,
5780 elf_hash_table (info
)->dynstr
))
5786 if (finfo
.symstrtab
!= NULL
)
5787 _bfd_stringtab_free (finfo
.symstrtab
);
5788 if (finfo
.contents
!= NULL
)
5789 free (finfo
.contents
);
5790 if (finfo
.external_relocs
!= NULL
)
5791 free (finfo
.external_relocs
);
5792 if (finfo
.internal_relocs
!= NULL
)
5793 free (finfo
.internal_relocs
);
5794 if (finfo
.external_syms
!= NULL
)
5795 free (finfo
.external_syms
);
5796 if (finfo
.internal_syms
!= NULL
)
5797 free (finfo
.internal_syms
);
5798 if (finfo
.indices
!= NULL
)
5799 free (finfo
.indices
);
5800 if (finfo
.sections
!= NULL
)
5801 free (finfo
.sections
);
5802 if (finfo
.symbuf
!= NULL
)
5803 free (finfo
.symbuf
);
5804 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5806 if ((o
->flags
& SEC_RELOC
) != 0
5807 && elf_section_data (o
)->rel_hashes
!= NULL
)
5808 free (elf_section_data (o
)->rel_hashes
);
5811 elf_tdata (abfd
)->linker
= true;
5816 if (finfo
.symstrtab
!= NULL
)
5817 _bfd_stringtab_free (finfo
.symstrtab
);
5818 if (finfo
.contents
!= NULL
)
5819 free (finfo
.contents
);
5820 if (finfo
.external_relocs
!= NULL
)
5821 free (finfo
.external_relocs
);
5822 if (finfo
.internal_relocs
!= NULL
)
5823 free (finfo
.internal_relocs
);
5824 if (finfo
.external_syms
!= NULL
)
5825 free (finfo
.external_syms
);
5826 if (finfo
.internal_syms
!= NULL
)
5827 free (finfo
.internal_syms
);
5828 if (finfo
.indices
!= NULL
)
5829 free (finfo
.indices
);
5830 if (finfo
.sections
!= NULL
)
5831 free (finfo
.sections
);
5832 if (finfo
.symbuf
!= NULL
)
5833 free (finfo
.symbuf
);
5834 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5836 if ((o
->flags
& SEC_RELOC
) != 0
5837 && elf_section_data (o
)->rel_hashes
!= NULL
)
5838 free (elf_section_data (o
)->rel_hashes
);
5844 /* Add a symbol to the output symbol table. */
5847 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5848 struct elf_final_link_info
*finfo
;
5850 Elf_Internal_Sym
*elfsym
;
5851 asection
*input_sec
;
5853 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5854 struct bfd_link_info
*info
,
5859 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5860 elf_backend_link_output_symbol_hook
;
5861 if (output_symbol_hook
!= NULL
)
5863 if (! ((*output_symbol_hook
)
5864 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5868 if (name
== (const char *) NULL
|| *name
== '\0')
5869 elfsym
->st_name
= 0;
5872 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5875 if (elfsym
->st_name
== (unsigned long) -1)
5879 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5881 if (! elf_link_flush_output_syms (finfo
))
5885 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5886 finfo
->symbuf
+ finfo
->symbuf_count
);
5887 ++finfo
->symbuf_count
;
5889 ++finfo
->output_bfd
->symcount
;
5894 /* Flush the output symbols to the file. */
5897 elf_link_flush_output_syms (finfo
)
5898 struct elf_final_link_info
*finfo
;
5900 Elf_Internal_Shdr
*symtab
;
5902 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5904 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5906 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5907 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5908 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5911 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5913 finfo
->symbuf_count
= 0;
5918 /* Add an external symbol to the symbol table. This is called from
5919 the hash table traversal routine. */
5922 elf_link_output_extsym (h
, data
)
5923 struct elf_link_hash_entry
*h
;
5926 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5928 Elf_Internal_Sym sym
;
5929 asection
*input_sec
;
5931 /* We don't want to output symbols that have never been mentioned by
5932 a regular file, or that we have been told to strip. However, if
5933 h->indx is set to -2, the symbol is used by a reloc and we must
5937 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5938 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5939 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5940 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5942 else if (finfo
->info
->strip
== strip_all
5943 || (finfo
->info
->strip
== strip_some
5944 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5945 h
->root
.root
.string
,
5946 false, false) == NULL
))
5951 /* If we're stripping it, and it's not a dynamic symbol, there's
5952 nothing else to do. */
5953 if (strip
&& h
->dynindx
== -1)
5957 sym
.st_size
= h
->size
;
5959 if (h
->root
.type
== bfd_link_hash_weak
5960 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5961 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5963 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5965 switch (h
->root
.type
)
5968 case bfd_link_hash_new
:
5972 case bfd_link_hash_undefined
:
5973 input_sec
= bfd_und_section_ptr
;
5974 sym
.st_shndx
= SHN_UNDEF
;
5977 case bfd_link_hash_weak
:
5978 input_sec
= bfd_und_section_ptr
;
5979 sym
.st_shndx
= SHN_UNDEF
;
5982 case bfd_link_hash_defined
:
5984 input_sec
= h
->root
.u
.def
.section
;
5985 if (input_sec
->output_section
!= NULL
)
5988 elf_section_from_bfd_section (finfo
->output_bfd
,
5989 input_sec
->output_section
);
5990 if (sym
.st_shndx
== (unsigned short) -1)
5992 /* FIXME: No way to handle errors. */
5996 /* ELF symbols in relocateable files are section relative,
5997 but in nonrelocateable files they are virtual
5999 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
6000 if (! finfo
->info
->relocateable
)
6001 sym
.st_value
+= input_sec
->output_section
->vma
;
6005 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
6006 == bfd_target_elf_flavour
)
6007 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
6008 sym
.st_shndx
= SHN_UNDEF
;
6009 input_sec
= bfd_und_section_ptr
;
6014 case bfd_link_hash_common
:
6015 input_sec
= bfd_com_section_ptr
;
6016 sym
.st_shndx
= SHN_COMMON
;
6017 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
6020 case bfd_link_hash_indirect
:
6021 case bfd_link_hash_warning
:
6022 /* I have no idea how these should be handled. */
6026 /* If this symbol should be put in the .dynsym section, then put it
6027 there now. We have already know the symbol index. We also fill
6028 in the entry in the .hash section. */
6029 if (h
->dynindx
!= -1
6030 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6032 struct elf_backend_data
*bed
;
6035 bfd_byte
*bucketpos
;
6038 sym
.st_name
= h
->dynstr_index
;
6040 /* Give the processor backend a chance to tweak the symbol
6041 value, and also to finish up anything that needs to be done
6043 bed
= get_elf_backend_data (finfo
->output_bfd
);
6044 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6045 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6047 /* FIXME: No way to return error. */
6051 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6052 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6055 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6056 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6058 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6059 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6060 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6061 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6062 put_word (finfo
->output_bfd
, chain
,
6063 ((bfd_byte
*) finfo
->hash_sec
->contents
6064 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6067 /* If we're stripping it, then it was just a dynamic symbol, and
6068 there's nothing else to do. */
6072 h
->indx
= finfo
->output_bfd
->symcount
;
6074 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6076 /* FIXME: No way to return error. */
6083 /* Link an input file into the linker output file. This function
6084 handles all the sections and relocations of the input file at once.
6085 This is so that we only have to read the local symbols once, and
6086 don't have to keep them in memory. */
6089 elf_link_input_bfd (finfo
, input_bfd
)
6090 struct elf_final_link_info
*finfo
;
6093 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6094 bfd
*, asection
*, bfd_byte
*,
6095 Elf_Internal_Rela
*,
6096 Elf_Internal_Sym
*, asection
**));
6098 Elf_Internal_Shdr
*symtab_hdr
;
6101 Elf_External_Sym
*esym
;
6102 Elf_External_Sym
*esymend
;
6103 Elf_Internal_Sym
*isym
;
6105 asection
**ppsection
;
6108 output_bfd
= finfo
->output_bfd
;
6110 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6112 /* If this is a dynamic object, we don't want to do anything here:
6113 we don't want the local symbols, and we don't want the section
6115 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6118 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6119 if (elf_bad_symtab (input_bfd
))
6121 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6126 locsymcount
= symtab_hdr
->sh_info
;
6127 extsymoff
= symtab_hdr
->sh_info
;
6130 /* Read the local symbols. */
6132 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6133 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6134 locsymcount
, input_bfd
)
6135 != locsymcount
* sizeof (Elf_External_Sym
))))
6138 /* Swap in the local symbols and write out the ones which we know
6139 are going into the output file. */
6140 esym
= finfo
->external_syms
;
6141 esymend
= esym
+ locsymcount
;
6142 isym
= finfo
->internal_syms
;
6143 pindex
= finfo
->indices
;
6144 ppsection
= finfo
->sections
;
6145 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6149 Elf_Internal_Sym osym
;
6151 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6154 if (elf_bad_symtab (input_bfd
))
6156 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6163 if (isym
->st_shndx
== SHN_UNDEF
)
6164 isec
= bfd_und_section_ptr
;
6165 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6166 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6167 else if (isym
->st_shndx
== SHN_ABS
)
6168 isec
= bfd_abs_section_ptr
;
6169 else if (isym
->st_shndx
== SHN_COMMON
)
6170 isec
= bfd_com_section_ptr
;
6179 /* Don't output the first, undefined, symbol. */
6180 if (esym
== finfo
->external_syms
)
6183 /* If we are stripping all symbols, we don't want to output this
6185 if (finfo
->info
->strip
== strip_all
)
6188 /* We never output section symbols. Instead, we use the section
6189 symbol of the corresponding section in the output file. */
6190 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6193 /* If we are discarding all local symbols, we don't want to
6194 output this one. If we are generating a relocateable output
6195 file, then some of the local symbols may be required by
6196 relocs; we output them below as we discover that they are
6198 if (finfo
->info
->discard
== discard_all
)
6201 /* Get the name of the symbol. */
6202 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6207 /* See if we are discarding symbols with this name. */
6208 if ((finfo
->info
->strip
== strip_some
6209 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6211 || (finfo
->info
->discard
== discard_l
6212 && strncmp (name
, finfo
->info
->lprefix
,
6213 finfo
->info
->lprefix_len
) == 0))
6216 /* If we get here, we are going to output this symbol. */
6220 /* Adjust the section index for the output file. */
6221 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6222 isec
->output_section
);
6223 if (osym
.st_shndx
== (unsigned short) -1)
6226 *pindex
= output_bfd
->symcount
;
6228 /* ELF symbols in relocateable files are section relative, but
6229 in executable files they are virtual addresses. Note that
6230 this code assumes that all ELF sections have an associated
6231 BFD section with a reasonable value for output_offset; below
6232 we assume that they also have a reasonable value for
6233 output_section. Any special sections must be set up to meet
6234 these requirements. */
6235 osym
.st_value
+= isec
->output_offset
;
6236 if (! finfo
->info
->relocateable
)
6237 osym
.st_value
+= isec
->output_section
->vma
;
6239 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6243 /* Relocate the contents of each section. */
6244 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6246 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6249 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6250 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6252 /* Section was created by elf_link_create_dynamic_sections.
6253 FIXME: This test is fragile. */
6257 /* Read the contents of the section. */
6258 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6259 (file_ptr
) 0, o
->_raw_size
))
6262 if ((o
->flags
& SEC_RELOC
) != 0)
6264 Elf_Internal_Rela
*internal_relocs
;
6266 /* Get the swapped relocs. */
6267 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6268 finfo
->external_relocs
,
6269 finfo
->internal_relocs
,
6271 if (internal_relocs
== NULL
6272 && o
->reloc_count
> 0)
6275 /* Relocate the section by invoking a back end routine.
6277 The back end routine is responsible for adjusting the
6278 section contents as necessary, and (if using Rela relocs
6279 and generating a relocateable output file) adjusting the
6280 reloc addend as necessary.
6282 The back end routine does not have to worry about setting
6283 the reloc address or the reloc symbol index.
6285 The back end routine is given a pointer to the swapped in
6286 internal symbols, and can access the hash table entries
6287 for the external symbols via elf_sym_hashes (input_bfd).
6289 When generating relocateable output, the back end routine
6290 must handle STB_LOCAL/STT_SECTION symbols specially. The
6291 output symbol is going to be a section symbol
6292 corresponding to the output section, which will require
6293 the addend to be adjusted. */
6295 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6299 finfo
->internal_syms
,
6303 if (finfo
->info
->relocateable
)
6305 Elf_Internal_Rela
*irela
;
6306 Elf_Internal_Rela
*irelaend
;
6307 struct elf_link_hash_entry
**rel_hash
;
6308 Elf_Internal_Shdr
*input_rel_hdr
;
6309 Elf_Internal_Shdr
*output_rel_hdr
;
6311 /* Adjust the reloc addresses and symbol indices. */
6313 irela
= internal_relocs
;
6314 irelaend
= irela
+ o
->reloc_count
;
6315 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6316 + o
->output_section
->reloc_count
);
6317 for (; irela
< irelaend
; irela
++, rel_hash
++)
6320 Elf_Internal_Sym
*isym
;
6323 irela
->r_offset
+= o
->output_offset
;
6325 r_symndx
= ELF_R_SYM (irela
->r_info
);
6330 if (r_symndx
>= locsymcount
6331 || (elf_bad_symtab (input_bfd
)
6332 && finfo
->sections
[r_symndx
] == NULL
))
6336 /* This is a reloc against a global symbol. We
6337 have not yet output all the local symbols, so
6338 we do not know the symbol index of any global
6339 symbol. We set the rel_hash entry for this
6340 reloc to point to the global hash table entry
6341 for this symbol. The symbol index is then
6342 set at the end of elf_bfd_final_link. */
6343 indx
= r_symndx
- extsymoff
;
6344 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6346 /* Setting the index to -2 tells
6347 elf_link_output_extsym that this symbol is
6349 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6350 (*rel_hash
)->indx
= -2;
6355 /* This is a reloc against a local symbol. */
6358 isym
= finfo
->internal_syms
+ r_symndx
;
6359 sec
= finfo
->sections
[r_symndx
];
6360 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6362 /* I suppose the backend ought to fill in the
6363 section of any STT_SECTION symbol against a
6364 processor specific section. */
6365 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6367 else if (sec
== NULL
|| sec
->owner
== NULL
)
6369 bfd_set_error (bfd_error_bad_value
);
6374 r_symndx
= sec
->output_section
->target_index
;
6381 if (finfo
->indices
[r_symndx
] == -1)
6387 if (finfo
->info
->strip
== strip_all
)
6389 /* You can't do ld -r -s. */
6390 bfd_set_error (bfd_error_invalid_operation
);
6394 /* This symbol was skipped earlier, but
6395 since it is needed by a reloc, we
6396 must output it now. */
6397 link
= symtab_hdr
->sh_link
;
6398 name
= elf_string_from_elf_section (input_bfd
,
6404 osec
= sec
->output_section
;
6406 elf_section_from_bfd_section (output_bfd
,
6408 if (isym
->st_shndx
== (unsigned short) -1)
6411 isym
->st_value
+= sec
->output_offset
;
6412 if (! finfo
->info
->relocateable
)
6413 isym
->st_value
+= osec
->vma
;
6415 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6417 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6421 r_symndx
= finfo
->indices
[r_symndx
];
6424 irela
->r_info
= ELF_R_INFO (r_symndx
,
6425 ELF_R_TYPE (irela
->r_info
));
6428 /* Swap out the relocs. */
6429 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6430 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6431 BFD_ASSERT (output_rel_hdr
->sh_entsize
6432 == input_rel_hdr
->sh_entsize
);
6433 irela
= internal_relocs
;
6434 irelaend
= irela
+ o
->reloc_count
;
6435 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6437 Elf_External_Rel
*erel
;
6439 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6440 + o
->output_section
->reloc_count
);
6441 for (; irela
< irelaend
; irela
++, erel
++)
6443 Elf_Internal_Rel irel
;
6445 irel
.r_offset
= irela
->r_offset
;
6446 irel
.r_info
= irela
->r_info
;
6447 BFD_ASSERT (irela
->r_addend
== 0);
6448 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6453 Elf_External_Rela
*erela
;
6455 BFD_ASSERT (input_rel_hdr
->sh_entsize
6456 == sizeof (Elf_External_Rela
));
6457 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6458 + o
->output_section
->reloc_count
);
6459 for (; irela
< irelaend
; irela
++, erela
++)
6460 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6463 o
->output_section
->reloc_count
+= o
->reloc_count
;
6467 /* Write out the modified section contents. */
6468 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6469 finfo
->contents
, o
->output_offset
,
6470 (o
->_cooked_size
!= 0
6479 /* Generate a reloc when linking an ELF file. This is a reloc
6480 requested by the linker, and does come from any input file. This
6481 is used to build constructor and destructor tables when linking
6485 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6487 struct bfd_link_info
*info
;
6488 asection
*output_section
;
6489 struct bfd_link_order
*link_order
;
6491 const reloc_howto_type
*howto
;
6494 struct elf_link_hash_entry
**rel_hash_ptr
;
6495 Elf_Internal_Shdr
*rel_hdr
;
6497 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6500 bfd_set_error (bfd_error_bad_value
);
6504 /* If this is an inplace reloc, we must write the addend into the
6506 if (howto
->partial_inplace
6507 && link_order
->u
.reloc
.p
->addend
!= 0)
6510 bfd_reloc_status_type rstat
;
6514 size
= bfd_get_reloc_size (howto
);
6515 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6516 if (buf
== (bfd_byte
*) NULL
)
6518 bfd_set_error (bfd_error_no_memory
);
6521 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6522 link_order
->u
.reloc
.p
->addend
, buf
);
6528 case bfd_reloc_outofrange
:
6530 case bfd_reloc_overflow
:
6531 if (! ((*info
->callbacks
->reloc_overflow
)
6533 (link_order
->type
== bfd_section_reloc_link_order
6534 ? bfd_section_name (output_bfd
,
6535 link_order
->u
.reloc
.p
->u
.section
)
6536 : link_order
->u
.reloc
.p
->u
.name
),
6537 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6538 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6545 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6546 (file_ptr
) link_order
->offset
, size
);
6552 /* Figure out the symbol index. */
6553 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6554 + output_section
->reloc_count
);
6555 if (link_order
->type
== bfd_section_reloc_link_order
)
6557 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6560 *rel_hash_ptr
= NULL
;
6564 struct elf_link_hash_entry
*h
;
6566 h
= elf_link_hash_lookup (elf_hash_table (info
),
6567 link_order
->u
.reloc
.p
->u
.name
,
6568 false, false, true);
6571 /* Setting the index to -2 tells elf_link_output_extsym that
6572 this symbol is used by a reloc. */
6579 if (! ((*info
->callbacks
->unattached_reloc
)
6580 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6581 (asection
*) NULL
, (bfd_vma
) 0)))
6587 /* The address of a reloc is relative to the section in a
6588 relocateable file, and is a virtual address in an executable
6590 offset
= link_order
->offset
;
6591 if (! info
->relocateable
)
6592 offset
+= output_section
->vma
;
6594 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6596 if (rel_hdr
->sh_type
== SHT_REL
)
6598 Elf_Internal_Rel irel
;
6599 Elf_External_Rel
*erel
;
6601 irel
.r_offset
= offset
;
6602 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6603 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6604 + output_section
->reloc_count
);
6605 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6609 Elf_Internal_Rela irela
;
6610 Elf_External_Rela
*erela
;
6612 irela
.r_offset
= offset
;
6613 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6614 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6615 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6616 + output_section
->reloc_count
);
6617 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6620 ++output_section
->reloc_count
;