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
;
1046 if (!(abfd
->flags
& EXEC_P
))
1047 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1049 dst_rela
.r_offset
= ptr
->address
;
1051 sym
= *ptr
->sym_ptr_ptr
;
1052 if (sym
== last_sym
)
1057 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1059 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1061 dst_rela
.r_addend
= ptr
->addend
;
1062 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1066 /* REL relocations */
1068 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1070 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1072 Elf_Internal_Rel dst_rel
;
1073 Elf_External_Rel
*src_rel
;
1078 ptr
= sec
->orelocation
[idx
];
1079 sym
= *ptr
->sym_ptr_ptr
;
1080 src_rel
= outbound_relocs
+ idx
;
1081 if (!(abfd
->flags
& EXEC_P
))
1082 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1084 dst_rel
.r_offset
= ptr
->address
;
1086 if (sym
== last_sym
)
1091 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1093 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1095 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1100 /* Set up an ELF internal section header for a section. */
1104 elf_fake_sections (abfd
, asect
, failedptrarg
)
1109 boolean
*failedptr
= (boolean
*) failedptrarg
;
1110 Elf_Internal_Shdr
*this_hdr
;
1114 /* We already failed; just get out of the bfd_map_over_sections
1119 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1121 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1124 if (this_hdr
->sh_name
== (unsigned long) -1)
1130 this_hdr
->sh_flags
= 0;
1131 if ((asect
->flags
& SEC_ALLOC
) != 0)
1132 this_hdr
->sh_addr
= asect
->vma
;
1134 this_hdr
->sh_addr
= 0;
1135 this_hdr
->sh_offset
= 0;
1136 this_hdr
->sh_size
= asect
->_raw_size
;
1137 this_hdr
->sh_link
= 0;
1138 this_hdr
->sh_info
= 0;
1139 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1140 this_hdr
->sh_entsize
= 0;
1142 this_hdr
->bfd_section
= asect
;
1143 this_hdr
->contents
= NULL
;
1145 /* FIXME: This should not be based on section names. */
1146 if (strcmp (asect
->name
, ".dynstr") == 0)
1147 this_hdr
->sh_type
= SHT_STRTAB
;
1148 else if (strcmp (asect
->name
, ".hash") == 0)
1150 this_hdr
->sh_type
= SHT_HASH
;
1151 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1153 else if (strcmp (asect
->name
, ".dynsym") == 0)
1155 this_hdr
->sh_type
= SHT_DYNSYM
;
1156 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1158 else if (strcmp (asect
->name
, ".dynamic") == 0)
1160 this_hdr
->sh_type
= SHT_DYNAMIC
;
1161 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1163 else if (strncmp (asect
->name
, ".rela", 5) == 0
1164 && get_elf_backend_data (abfd
)->use_rela_p
)
1166 this_hdr
->sh_type
= SHT_RELA
;
1167 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1169 else if (strncmp (asect
->name
, ".rel", 4) == 0
1170 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1172 this_hdr
->sh_type
= SHT_REL
;
1173 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1175 else if (strcmp (asect
->name
, ".note") == 0)
1176 this_hdr
->sh_type
= SHT_NOTE
;
1177 else if (strncmp (asect
->name
, ".stab", 5) == 0
1178 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1179 this_hdr
->sh_type
= SHT_STRTAB
;
1180 else if ((asect
->flags
& SEC_ALLOC
) != 0
1181 && (asect
->flags
& SEC_LOAD
) != 0)
1182 this_hdr
->sh_type
= SHT_PROGBITS
;
1183 else if ((asect
->flags
& SEC_ALLOC
) != 0
1184 && ((asect
->flags
& SEC_LOAD
) == 0))
1186 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1187 || strcmp (asect
->name
, ".sbss") == 0);
1188 this_hdr
->sh_type
= SHT_NOBITS
;
1193 this_hdr
->sh_type
= SHT_PROGBITS
;
1196 if ((asect
->flags
& SEC_ALLOC
) != 0)
1197 this_hdr
->sh_flags
|= SHF_ALLOC
;
1198 if ((asect
->flags
& SEC_READONLY
) == 0)
1199 this_hdr
->sh_flags
|= SHF_WRITE
;
1200 if ((asect
->flags
& SEC_CODE
) != 0)
1201 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1203 /* Check for processor-specific section types. */
1205 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1207 if (bed
->elf_backend_fake_sections
)
1208 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1211 /* If the section has relocs, set up a section header for the
1212 SHT_REL[A] section. */
1213 if ((asect
->flags
& SEC_RELOC
) != 0)
1215 Elf_Internal_Shdr
*rela_hdr
;
1216 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1219 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1220 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1223 bfd_set_error (bfd_error_no_memory
);
1227 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1229 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1231 if (rela_hdr
->sh_name
== (unsigned int) -1)
1236 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1237 rela_hdr
->sh_entsize
= (use_rela_p
1238 ? sizeof (Elf_External_Rela
)
1239 : sizeof (Elf_External_Rel
));
1240 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1241 rela_hdr
->sh_flags
= 0;
1242 rela_hdr
->sh_addr
= 0;
1243 rela_hdr
->sh_size
= 0;
1244 rela_hdr
->sh_offset
= 0;
1248 /* Assign all ELF section numbers. The dummy first section is handled here
1249 too. The link/info pointers for the standard section types are filled
1250 in here too, while we're at it. */
1253 assign_section_numbers (abfd
)
1256 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1258 unsigned int section_number
;
1259 Elf_Internal_Shdr
**i_shdrp
;
1263 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1265 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1267 d
->this_idx
= section_number
++;
1268 if ((sec
->flags
& SEC_RELOC
) == 0)
1271 d
->rel_idx
= section_number
++;
1274 t
->shstrtab_section
= section_number
++;
1275 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1276 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1278 if (abfd
->symcount
> 0)
1280 t
->symtab_section
= section_number
++;
1281 t
->strtab_section
= section_number
++;
1284 elf_elfheader (abfd
)->e_shnum
= section_number
;
1286 /* Set up the list of section header pointers, in agreement with the
1288 i_shdrp
= ((Elf_Internal_Shdr
**)
1289 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1290 if (i_shdrp
== NULL
)
1292 bfd_set_error (bfd_error_no_memory
);
1296 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1297 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1298 if (i_shdrp
[0] == NULL
)
1300 bfd_release (abfd
, i_shdrp
);
1301 bfd_set_error (bfd_error_no_memory
);
1304 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1306 elf_elfsections (abfd
) = i_shdrp
;
1308 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1309 if (abfd
->symcount
> 0)
1311 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1312 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1313 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1315 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1317 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1321 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1322 if (d
->rel_idx
!= 0)
1323 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1325 /* Fill in the sh_link and sh_info fields while we're at it. */
1327 /* sh_link of a reloc section is the section index of the symbol
1328 table. sh_info is the section index of the section to which
1329 the relocation entries apply. */
1330 if (d
->rel_idx
!= 0)
1332 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1333 d
->rel_hdr
.sh_info
= d
->this_idx
;
1336 switch (d
->this_hdr
.sh_type
)
1340 /* A reloc section which we are treating as a normal BFD
1341 section. sh_link is the section index of the symbol
1342 table. sh_info is the section index of the section to
1343 which the relocation entries apply. We assume that an
1344 allocated reloc section uses the dynamic symbol table.
1345 FIXME: How can we be sure? */
1346 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1348 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1350 /* We look up the section the relocs apply to by name. */
1352 if (d
->this_hdr
.sh_type
== SHT_REL
)
1356 s
= bfd_get_section_by_name (abfd
, name
);
1358 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1362 /* We assume that a section named .stab*str is a stabs
1363 string section. We look for a section with the same name
1364 but without the trailing ``str'', and set its sh_link
1365 field to point to this section. */
1366 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1367 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1372 len
= strlen (sec
->name
);
1373 alc
= (char *) malloc (len
- 2);
1376 bfd_set_error (bfd_error_no_memory
);
1379 strncpy (alc
, sec
->name
, len
- 3);
1380 alc
[len
- 3] = '\0';
1381 s
= bfd_get_section_by_name (abfd
, alc
);
1385 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1387 /* This is a .stab section. */
1388 elf_section_data (s
)->this_hdr
.sh_entsize
=
1389 4 + 2 * (ARCH_SIZE
/ 8);
1396 /* sh_link is the section header index of the string table
1397 used for the dynamic entries or symbol table. */
1398 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1400 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1404 /* sh_link is the section header index of the symbol table
1405 this hash table is for. */
1406 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1408 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1416 /* Map symbol from it's internal number to the external number, moving
1417 all local symbols to be at the head of the list. */
1420 sym_is_global (abfd
, sym
)
1424 /* If the backend has a special mapping, use it. */
1425 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1426 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1429 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1431 if (sym
->flags
& BSF_LOCAL
)
1435 if (sym
->section
== 0)
1437 /* Is this valid? */
1442 if (bfd_is_und_section (sym
->section
))
1444 if (bfd_is_com_section (sym
->section
))
1446 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1452 elf_map_symbols (abfd
)
1455 int symcount
= bfd_get_symcount (abfd
);
1456 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1457 asymbol
**sect_syms
;
1459 int num_globals
= 0;
1460 int num_locals2
= 0;
1461 int num_globals2
= 0;
1463 int num_sections
= 0;
1469 fprintf (stderr
, "elf_map_symbols\n");
1473 /* Add a section symbol for each BFD section. FIXME: Is this really
1475 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1477 if (max_index
< asect
->index
)
1478 max_index
= asect
->index
;
1482 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1483 if (sect_syms
== NULL
)
1485 bfd_set_error (bfd_error_no_memory
);
1488 elf_section_syms (abfd
) = sect_syms
;
1490 for (idx
= 0; idx
< symcount
; idx
++)
1492 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0)
1496 sec
= syms
[idx
]->section
;
1497 if (sec
->owner
!= NULL
)
1499 if (sec
->owner
!= abfd
)
1501 sec
= sec
->output_section
;
1502 BFD_ASSERT (sec
->owner
== abfd
);
1504 sect_syms
[sec
->index
] = syms
[idx
];
1509 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1513 if (sect_syms
[asect
->index
] != NULL
)
1516 sym
= bfd_make_empty_symbol (abfd
);
1519 sym
->the_bfd
= abfd
;
1520 sym
->name
= asect
->name
;
1521 sym
->value
= asect
->vma
;
1522 /* Set the flags to 0 to indicate that this one was newly added. */
1524 sym
->section
= asect
;
1525 sect_syms
[asect
->index
] = sym
;
1529 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1530 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1534 /* Classify all of the symbols. */
1535 for (idx
= 0; idx
< symcount
; idx
++)
1537 if (!sym_is_global (abfd
, syms
[idx
]))
1542 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1544 if (sect_syms
[asect
->index
] != NULL
1545 && sect_syms
[asect
->index
]->flags
== 0)
1547 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1548 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1552 sect_syms
[asect
->index
]->flags
= 0;
1556 /* Now sort the symbols so the local symbols are first. */
1557 new_syms
= ((asymbol
**)
1559 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1560 if (new_syms
== NULL
)
1562 bfd_set_error (bfd_error_no_memory
);
1566 for (idx
= 0; idx
< symcount
; idx
++)
1568 asymbol
*sym
= syms
[idx
];
1571 if (!sym_is_global (abfd
, sym
))
1574 i
= num_locals
+ num_globals2
++;
1576 sym
->udata
.i
= i
+ 1;
1578 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1580 if (sect_syms
[asect
->index
] != NULL
1581 && sect_syms
[asect
->index
]->flags
== 0)
1583 asymbol
*sym
= sect_syms
[asect
->index
];
1586 sym
->flags
= BSF_SECTION_SYM
;
1587 if (!sym_is_global (abfd
, sym
))
1590 i
= num_locals
+ num_globals2
++;
1592 sym
->udata
.i
= i
+ 1;
1596 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1598 elf_num_locals (abfd
) = num_locals
;
1599 elf_num_globals (abfd
) = num_globals
;
1603 /* Compute the file positions we are going to put the sections at, and
1604 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1605 is not NULL, this is being called by the ELF backend linker. */
1608 elf_compute_section_file_positions (abfd
, link_info
)
1610 struct bfd_link_info
*link_info
;
1612 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1614 struct bfd_strtab_hash
*strtab
;
1615 Elf_Internal_Shdr
*shstrtab_hdr
;
1617 if (abfd
->output_has_begun
)
1620 /* Do any elf backend specific processing first. */
1621 if (bed
->elf_backend_begin_write_processing
)
1622 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1624 if (! prep_headers (abfd
))
1628 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1632 if (!assign_section_numbers (abfd
))
1635 /* The backend linker builds symbol table information itself. */
1636 if (link_info
== NULL
)
1638 if (! swap_out_syms (abfd
, &strtab
))
1642 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1643 /* sh_name was set in prep_headers. */
1644 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1645 shstrtab_hdr
->sh_flags
= 0;
1646 shstrtab_hdr
->sh_addr
= 0;
1647 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1648 shstrtab_hdr
->sh_entsize
= 0;
1649 shstrtab_hdr
->sh_link
= 0;
1650 shstrtab_hdr
->sh_info
= 0;
1651 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1652 shstrtab_hdr
->sh_addralign
= 1;
1654 if (!assign_file_positions_except_relocs (abfd
,
1655 link_info
== NULL
? true : false))
1658 if (link_info
== NULL
)
1660 /* Now that we know where the .strtab section goes, write it
1662 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1664 || ! _bfd_stringtab_emit (abfd
, strtab
))
1666 _bfd_stringtab_free (strtab
);
1669 abfd
->output_has_begun
= true;
1675 /* Align to the maximum file alignment that could be required for any
1676 ELF data structure. */
1678 static INLINE file_ptr
1679 align_file_position (off
)
1682 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1685 /* Assign a file position to a section, optionally aligning to the
1686 required section alignment. */
1688 static INLINE file_ptr
1689 assign_file_position_for_section (i_shdrp
, offset
, align
)
1690 Elf_Internal_Shdr
*i_shdrp
;
1698 al
= i_shdrp
->sh_addralign
;
1700 offset
= BFD_ALIGN (offset
, al
);
1702 i_shdrp
->sh_offset
= offset
;
1703 if (i_shdrp
->bfd_section
!= NULL
)
1704 i_shdrp
->bfd_section
->filepos
= offset
;
1705 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1706 offset
+= i_shdrp
->sh_size
;
1710 /* Get the size of the program header. This is called by the linker
1711 before any of the section VMA's are set, so it can't calculate the
1712 correct value for a strange memory layout. */
1714 static bfd_size_type
1715 get_program_header_size (abfd
)
1721 /* Assume we will need exactly two PT_LOAD segments: one for text
1722 and one for data. */
1725 s
= bfd_get_section_by_name (abfd
, ".interp");
1726 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1728 /* If we have a loadable interpreter section, we need a
1729 PT_INTERP segment. In this case, assume we also need a
1730 PT_PHDR segment, although that may not be true for all
1735 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1737 /* We need a PT_DYNAMIC segment. */
1741 return segs
* sizeof (Elf_External_Phdr
);
1744 /* Create the program header. OFF is the file offset where the
1745 program header should be written. FIRST is the first loadable ELF
1746 section. PHDR_SIZE is the size of the program header as returned
1747 by get_program_header_size. */
1750 map_program_segments (abfd
, off
, first
, phdr_size
)
1753 Elf_Internal_Shdr
*first
;
1754 bfd_size_type phdr_size
;
1756 Elf_Internal_Phdr phdrs
[10];
1757 unsigned int phdr_count
;
1758 Elf_Internal_Phdr
*phdr
;
1759 int phdr_size_adjust
;
1761 Elf_Internal_Shdr
**hdrpp
;
1762 asection
*sinterp
, *sdyn
;
1763 unsigned int last_type
;
1764 Elf_Internal_Ehdr
*i_ehdrp
;
1766 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1767 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1768 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1773 phdr_size_adjust
= 0;
1775 /* If we have a loadable .interp section, we must create a PT_INTERP
1776 segment which must precede all PT_LOAD segments. We assume that
1777 we must also create a PT_PHDR segment, although that may not be
1778 true for all targets. */
1779 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1780 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1782 BFD_ASSERT (first
!= NULL
);
1784 phdr
->p_type
= PT_PHDR
;
1786 phdr
->p_offset
= off
;
1788 /* Account for any adjustment made because of the alignment of
1789 the first loadable section. */
1790 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1791 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1793 /* The program header precedes all loadable sections. This lets
1794 us compute its loadable address. This depends on the linker
1796 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1799 phdr
->p_filesz
= phdr_size
;
1800 phdr
->p_memsz
= phdr_size
;
1802 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1803 phdr
->p_flags
= PF_R
| PF_X
;
1805 phdr
->p_align
= FILE_ALIGN
;
1806 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1808 /* Include the ELF header in the first loadable segment. */
1809 phdr_size_adjust
+= off
;
1814 phdr
->p_type
= PT_INTERP
;
1815 phdr
->p_offset
= sinterp
->filepos
;
1816 phdr
->p_vaddr
= sinterp
->vma
;
1818 phdr
->p_filesz
= sinterp
->_raw_size
;
1819 phdr
->p_memsz
= sinterp
->_raw_size
;
1820 phdr
->p_flags
= PF_R
;
1821 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1827 /* Look through the sections to see how they will be divided into
1828 program segments. The sections must be arranged in order by
1829 sh_addr for this to work correctly. */
1830 phdr
->p_type
= PT_NULL
;
1831 last_type
= SHT_PROGBITS
;
1832 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1833 i
< elf_elfheader (abfd
)->e_shnum
;
1836 Elf_Internal_Shdr
*hdr
;
1840 /* Ignore any section which will not be part of the process
1842 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1845 /* If this section fits in the segment we are constructing, add
1847 if (phdr
->p_type
!= PT_NULL
1848 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1849 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1850 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1852 bfd_size_type adjust
;
1854 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1855 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1856 if (hdr
->sh_type
!= SHT_NOBITS
)
1857 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1858 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1859 phdr
->p_flags
|= PF_W
;
1860 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1861 phdr
->p_flags
|= PF_X
;
1862 last_type
= hdr
->sh_type
;
1866 /* If we have a segment, move to the next one. */
1867 if (phdr
->p_type
!= PT_NULL
)
1873 /* Start a new segment. */
1874 phdr
->p_type
= PT_LOAD
;
1875 phdr
->p_offset
= hdr
->sh_offset
;
1876 phdr
->p_vaddr
= hdr
->sh_addr
;
1878 if (hdr
->sh_type
== SHT_NOBITS
)
1881 phdr
->p_filesz
= hdr
->sh_size
;
1882 phdr
->p_memsz
= hdr
->sh_size
;
1883 phdr
->p_flags
= PF_R
;
1884 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1885 phdr
->p_flags
|= PF_W
;
1886 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1887 phdr
->p_flags
|= PF_X
;
1888 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1892 && (sinterp
->flags
& SEC_LOAD
) != 0)
1894 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1895 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1896 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1897 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1900 last_type
= hdr
->sh_type
;
1903 if (phdr
->p_type
!= PT_NULL
)
1909 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1910 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1911 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1913 phdr
->p_type
= PT_DYNAMIC
;
1914 phdr
->p_offset
= sdyn
->filepos
;
1915 phdr
->p_vaddr
= sdyn
->vma
;
1917 phdr
->p_filesz
= sdyn
->_raw_size
;
1918 phdr
->p_memsz
= sdyn
->_raw_size
;
1919 phdr
->p_flags
= PF_R
;
1920 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1921 phdr
->p_flags
|= PF_W
;
1922 if ((sdyn
->flags
& SEC_CODE
) != 0)
1923 phdr
->p_flags
|= PF_X
;
1924 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1930 /* Make sure the return value from get_program_header_size matches
1931 what we computed here. Actually, it's OK if we allocated too
1932 much space in the program header. */
1933 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1936 /* Set up program header information. */
1937 i_ehdrp
= elf_elfheader (abfd
);
1938 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1939 i_ehdrp
->e_phoff
= off
;
1940 i_ehdrp
->e_phnum
= phdr_count
;
1942 /* Save the program headers away. I don't think anybody uses this
1943 information right now. */
1944 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1947 * sizeof (Elf_Internal_Phdr
))));
1948 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1950 bfd_set_error (bfd_error_no_memory
);
1951 return (file_ptr
) -1;
1953 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1954 phdr_count
* sizeof (Elf_Internal_Phdr
));
1956 /* Write out the program headers. */
1957 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1958 return (file_ptr
) -1;
1960 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1962 Elf_External_Phdr extphdr
;
1964 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1965 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1966 != sizeof (Elf_External_Phdr
))
1967 return (file_ptr
) -1;
1970 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1973 /* Work out the file positions of all the sections. This is called by
1974 elf_compute_section_file_positions. All the section sizes and VMAs
1975 must be known before this is called.
1977 We do not consider reloc sections at this point, unless they form
1978 part of the loadable image. Reloc sections are assigned file
1979 positions in assign_file_positions_for_relocs, which is called by
1980 write_object_contents and final_link.
1982 If DOSYMS is false, we do not assign file positions for the symbol
1983 table or the string table. */
1986 assign_file_positions_except_relocs (abfd
, dosyms
)
1990 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1991 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1992 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1995 /* Start after the ELF header. */
1996 off
= i_ehdrp
->e_ehsize
;
1998 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2000 Elf_Internal_Shdr
**hdrpp
;
2003 /* We are not creating an executable, which means that we are
2004 not creating a program header, and that the actual order of
2005 the sections in the file is unimportant. */
2006 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2008 Elf_Internal_Shdr
*hdr
;
2011 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2013 hdr
->sh_offset
= -1;
2017 && (i
== tdata
->symtab_section
2018 || i
== tdata
->strtab_section
))
2020 hdr
->sh_offset
= -1;
2024 off
= assign_file_position_for_section (hdr
, off
, true);
2030 bfd_size_type phdr_size
;
2031 bfd_vma maxpagesize
;
2033 Elf_Internal_Shdr
**sorted_hdrs
;
2034 Elf_Internal_Shdr
**hdrpp
;
2036 Elf_Internal_Shdr
*first
;
2039 /* We are creating an executable. We must create a program
2040 header. We can't actually create the program header until we
2041 have set the file positions for the sections, but we can
2042 figure out how big it is going to be. */
2043 off
= align_file_position (off
);
2044 phdr_size
= get_program_header_size (abfd
);
2045 if (phdr_size
== (file_ptr
) -1)
2050 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2051 if (maxpagesize
== 0)
2054 /* We must sort the sections. The GNU linker will always create
2055 the sections in an appropriate order, but the Irix 5 linker
2056 will not. We don't include the dummy first section in the
2057 sort. We sort sections which are not SHF_ALLOC to the end. */
2058 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
2059 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
2060 if (sorted_hdrs
== NULL
)
2062 bfd_set_error (bfd_error_no_memory
);
2066 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
2067 qsort (sorted_hdrs
, i_ehdrp
->e_shnum
- 1, sizeof (Elf_Internal_Shdr
*),
2071 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2073 Elf_Internal_Shdr
*hdr
;
2076 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2078 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2080 hdr
->sh_offset
= -1;
2084 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
2085 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
2087 hdr
->sh_offset
= -1;
2096 /* The section VMA must equal the file position modulo
2097 the page size. This is required by the program
2099 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2102 off
= assign_file_position_for_section (hdr
, off
, false);
2105 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2106 if (phdr_map
== (file_ptr
) -1)
2108 BFD_ASSERT (phdr_map
<= phdr_off
+ phdr_size
);
2111 /* Place the section headers. */
2112 off
= align_file_position (off
);
2113 i_ehdrp
->e_shoff
= off
;
2114 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2116 elf_tdata (abfd
)->next_file_pos
= off
;
2121 /* Sort the ELF headers by VMA. We sort headers which are not
2122 SHF_ALLOC to the end. */
2125 elf_sort_hdrs (arg1
, arg2
)
2129 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2130 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2132 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2134 if ((hdr2
->sh_flags
& SHF_ALLOC
) == 0)
2136 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2138 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2145 if ((hdr1
->sh_flags
& SHF_ALLOC
) != 0)
2155 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2156 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2157 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2159 struct bfd_strtab_hash
*shstrtab
;
2161 i_ehdrp
= elf_elfheader (abfd
);
2162 i_shdrp
= elf_elfsections (abfd
);
2164 shstrtab
= elf_stringtab_init ();
2165 if (shstrtab
== NULL
)
2168 elf_shstrtab (abfd
) = shstrtab
;
2170 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2171 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2172 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2173 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2175 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2176 i_ehdrp
->e_ident
[EI_DATA
] =
2177 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2178 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2180 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2181 i_ehdrp
->e_ident
[count
] = 0;
2183 if ((abfd
->flags
& DYNAMIC
) != 0)
2184 i_ehdrp
->e_type
= ET_DYN
;
2185 else if ((abfd
->flags
& EXEC_P
) != 0)
2186 i_ehdrp
->e_type
= ET_EXEC
;
2188 i_ehdrp
->e_type
= ET_REL
;
2190 switch (bfd_get_arch (abfd
))
2192 case bfd_arch_unknown
:
2193 i_ehdrp
->e_machine
= EM_NONE
;
2195 case bfd_arch_sparc
:
2197 i_ehdrp
->e_machine
= EM_SPARC64
;
2199 i_ehdrp
->e_machine
= EM_SPARC
;
2203 i_ehdrp
->e_machine
= EM_386
;
2206 i_ehdrp
->e_machine
= EM_68K
;
2209 i_ehdrp
->e_machine
= EM_88K
;
2212 i_ehdrp
->e_machine
= EM_860
;
2214 case bfd_arch_mips
: /* MIPS Rxxxx */
2215 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2218 i_ehdrp
->e_machine
= EM_PARISC
;
2220 case bfd_arch_powerpc
:
2221 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2223 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2225 i_ehdrp
->e_machine
= EM_NONE
;
2227 i_ehdrp
->e_version
= EV_CURRENT
;
2228 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2230 /* no program header, for now. */
2231 i_ehdrp
->e_phoff
= 0;
2232 i_ehdrp
->e_phentsize
= 0;
2233 i_ehdrp
->e_phnum
= 0;
2235 /* each bfd section is section header entry */
2236 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2237 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2239 /* if we're building an executable, we'll need a program header table */
2240 if (abfd
->flags
& EXEC_P
)
2242 /* it all happens later */
2244 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2246 /* elf_build_phdrs() returns a (NULL-terminated) array of
2247 Elf_Internal_Phdrs */
2248 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2249 i_ehdrp
->e_phoff
= outbase
;
2250 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2255 i_ehdrp
->e_phentsize
= 0;
2257 i_ehdrp
->e_phoff
= 0;
2260 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2261 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2262 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2263 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2264 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2265 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2266 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2267 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2268 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2275 swap_out_syms (abfd
, sttp
)
2277 struct bfd_strtab_hash
**sttp
;
2279 if (!elf_map_symbols (abfd
))
2282 /* Dump out the symtabs. */
2284 int symcount
= bfd_get_symcount (abfd
);
2285 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2286 struct bfd_strtab_hash
*stt
;
2287 Elf_Internal_Shdr
*symtab_hdr
;
2288 Elf_Internal_Shdr
*symstrtab_hdr
;
2289 Elf_External_Sym
*outbound_syms
;
2292 stt
= elf_stringtab_init ();
2296 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2297 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2298 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2299 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2300 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2301 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2303 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2304 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2306 outbound_syms
= ((Elf_External_Sym
*)
2308 (1 + symcount
) * sizeof (Elf_External_Sym
)));
2309 if (outbound_syms
== NULL
)
2311 bfd_set_error (bfd_error_no_memory
);
2314 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2316 /* now generate the data (for "contents") */
2318 /* Fill in zeroth symbol and swap it out. */
2319 Elf_Internal_Sym sym
;
2325 sym
.st_shndx
= SHN_UNDEF
;
2326 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2329 for (idx
= 0; idx
< symcount
; idx
++)
2331 Elf_Internal_Sym sym
;
2332 bfd_vma value
= syms
[idx
]->value
;
2333 elf_symbol_type
*type_ptr
;
2335 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2336 /* Section symbols have no names. */
2340 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2343 if (sym
.st_name
== (unsigned long) -1)
2347 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2349 if (bfd_is_com_section (syms
[idx
]->section
))
2351 /* ELF common symbols put the alignment into the `value' field,
2352 and the size into the `size' field. This is backwards from
2353 how BFD handles it, so reverse it here. */
2354 sym
.st_size
= value
;
2355 if (type_ptr
== NULL
2356 || type_ptr
->internal_elf_sym
.st_value
== 0)
2357 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2359 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2360 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2361 syms
[idx
]->section
);
2365 asection
*sec
= syms
[idx
]->section
;
2368 if (sec
->output_section
)
2370 value
+= sec
->output_offset
;
2371 sec
= sec
->output_section
;
2374 sym
.st_value
= value
;
2375 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2376 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2380 /* Writing this would be a hell of a lot easier if we had
2381 some decent documentation on bfd, and knew what to expect
2382 of the library, and what to demand of applications. For
2383 example, it appears that `objcopy' might not set the
2384 section of a symbol to be a section that is actually in
2386 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2387 BFD_ASSERT (sec2
!= 0);
2388 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2389 BFD_ASSERT (shndx
!= -1);
2393 if (bfd_is_com_section (syms
[idx
]->section
))
2394 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2395 else if (bfd_is_und_section (syms
[idx
]->section
))
2396 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2397 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2400 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2401 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2402 else if (syms
[idx
]->flags
& BSF_FILE
)
2403 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2406 int bind
= STB_LOCAL
;
2407 int type
= STT_OBJECT
;
2408 unsigned int flags
= syms
[idx
]->flags
;
2410 if (flags
& BSF_LOCAL
)
2412 else if (flags
& BSF_WEAK
)
2414 else if (flags
& BSF_GLOBAL
)
2417 if (flags
& BSF_FUNCTION
)
2420 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2424 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2429 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2430 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2432 symstrtab_hdr
->sh_flags
= 0;
2433 symstrtab_hdr
->sh_addr
= 0;
2434 symstrtab_hdr
->sh_entsize
= 0;
2435 symstrtab_hdr
->sh_link
= 0;
2436 symstrtab_hdr
->sh_info
= 0;
2437 symstrtab_hdr
->sh_addralign
= 1;
2444 write_shdrs_and_ehdr (abfd
)
2447 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2448 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2449 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2450 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2453 i_ehdrp
= elf_elfheader (abfd
);
2454 i_shdrp
= elf_elfsections (abfd
);
2456 /* swap the header before spitting it out... */
2459 elf_debug_file (i_ehdrp
);
2461 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2462 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2463 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2464 != sizeof (x_ehdr
)))
2467 /* at this point we've concocted all the ELF sections... */
2468 x_shdrp
= (Elf_External_Shdr
*)
2469 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2472 bfd_set_error (bfd_error_no_memory
);
2476 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2479 elf_debug_section (count
, i_shdrp
[count
]);
2481 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2483 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2484 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2485 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2488 /* need to dump the string table too... */
2493 /* Assign file positions for all the reloc sections which are not part
2494 of the loadable file image. */
2497 assign_file_positions_for_relocs (abfd
)
2502 Elf_Internal_Shdr
**shdrpp
;
2504 off
= elf_tdata (abfd
)->next_file_pos
;
2506 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2507 i
< elf_elfheader (abfd
)->e_shnum
;
2510 Elf_Internal_Shdr
*shdrp
;
2513 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2514 && shdrp
->sh_offset
== -1)
2515 off
= assign_file_position_for_section (shdrp
, off
, true);
2518 elf_tdata (abfd
)->next_file_pos
= off
;
2522 NAME(bfd_elf
,write_object_contents
) (abfd
)
2525 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2526 Elf_Internal_Ehdr
*i_ehdrp
;
2527 Elf_Internal_Shdr
**i_shdrp
;
2530 if (! abfd
->output_has_begun
2531 && ! elf_compute_section_file_positions (abfd
,
2532 (struct bfd_link_info
*) NULL
))
2535 i_shdrp
= elf_elfsections (abfd
);
2536 i_ehdrp
= elf_elfheader (abfd
);
2538 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2539 assign_file_positions_for_relocs (abfd
);
2541 /* After writing the headers, we need to write the sections too... */
2542 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2544 if (bed
->elf_backend_section_processing
)
2545 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2546 if (i_shdrp
[count
]->contents
)
2548 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2549 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2551 != i_shdrp
[count
]->sh_size
))
2556 /* Write out the section header names. */
2557 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2558 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2561 if (bed
->elf_backend_final_write_processing
)
2562 (*bed
->elf_backend_final_write_processing
) (abfd
,
2563 elf_tdata (abfd
)->linker
);
2565 return write_shdrs_and_ehdr (abfd
);
2568 /* Given an ELF section number, retrieve the corresponding BFD
2572 section_from_elf_index (abfd
, index
)
2576 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2577 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2579 return elf_elfsections (abfd
)[index
]->bfd_section
;
2582 /* given a section, search the header to find them... */
2584 elf_section_from_bfd_section (abfd
, asect
)
2588 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2589 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2591 Elf_Internal_Shdr
*hdr
;
2592 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2594 if (bfd_is_abs_section (asect
))
2596 if (bfd_is_com_section (asect
))
2598 if (bfd_is_und_section (asect
))
2601 for (index
= 0; index
< maxindex
; index
++)
2603 hdr
= i_shdrp
[index
];
2604 if (hdr
->bfd_section
== asect
)
2608 if (bed
->elf_backend_section_from_bfd_section
)
2610 for (index
= 0; index
< maxindex
; index
++)
2614 hdr
= i_shdrp
[index
];
2616 if ((*bed
->elf_backend_section_from_bfd_section
)
2617 (abfd
, hdr
, asect
, &retval
))
2625 /* given a symbol, return the bfd index for that symbol. */
2627 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2629 struct symbol_cache_entry
**asym_ptr_ptr
;
2631 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2633 flagword flags
= asym_ptr
->flags
;
2635 /* When gas creates relocations against local labels, it creates its
2636 own symbol for the section, but does put the symbol into the
2637 symbol chain, so udata is 0. When the linker is generating
2638 relocatable output, this section symbol may be for one of the
2639 input sections rather than the output section. */
2640 if (asym_ptr
->udata
.i
== 0
2641 && (flags
& BSF_SECTION_SYM
)
2642 && asym_ptr
->section
)
2646 if (asym_ptr
->section
->output_section
!= NULL
)
2647 indx
= asym_ptr
->section
->output_section
->index
;
2649 indx
= asym_ptr
->section
->index
;
2650 if (elf_section_syms (abfd
)[indx
])
2651 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2654 idx
= asym_ptr
->udata
.i
;
2662 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2663 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2672 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2674 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2677 Elf_Internal_Shdr
*hdr
;
2678 long symcount
; /* Number of external ELF symbols */
2679 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2680 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2681 Elf_Internal_Sym i_sym
;
2682 Elf_External_Sym
*x_symp
= NULL
;
2684 /* Read each raw ELF symbol, converting from external ELF form to
2685 internal ELF form, and then using the information to create a
2686 canonical bfd symbol table entry.
2688 Note that we allocate the initial bfd canonical symbol buffer
2689 based on a one-to-one mapping of the ELF symbols to canonical
2690 symbols. We actually use all the ELF symbols, so there will be no
2691 space left over at the end. When we have all the symbols, we
2692 build the caller's pointer vector. */
2695 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2697 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2698 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2701 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2704 sym
= symbase
= NULL
;
2709 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2712 symbase
= ((elf_symbol_type
*)
2713 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2714 if (symbase
== (elf_symbol_type
*) NULL
)
2716 bfd_set_error (bfd_error_no_memory
);
2721 /* Temporarily allocate room for the raw ELF symbols. */
2722 x_symp
= ((Elf_External_Sym
*)
2723 malloc (symcount
* sizeof (Elf_External_Sym
)));
2724 if (x_symp
== NULL
&& symcount
!= 0)
2726 bfd_set_error (bfd_error_no_memory
);
2730 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2731 != symcount
* sizeof (Elf_External_Sym
))
2733 /* Skip first symbol, which is a null dummy. */
2734 for (i
= 1; i
< symcount
; i
++)
2736 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2737 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2738 #ifdef ELF_KEEP_EXTSYM
2739 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2741 sym
->symbol
.the_bfd
= abfd
;
2743 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2746 sym
->symbol
.value
= i_sym
.st_value
;
2748 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2750 sym
->symbol
.section
= section_from_elf_index (abfd
,
2752 if (sym
->symbol
.section
== NULL
)
2754 /* This symbol is in a section for which we did not
2755 create a BFD section. Just use bfd_abs_section,
2756 although it is wrong. FIXME. */
2757 sym
->symbol
.section
= bfd_abs_section_ptr
;
2760 else if (i_sym
.st_shndx
== SHN_ABS
)
2762 sym
->symbol
.section
= bfd_abs_section_ptr
;
2764 else if (i_sym
.st_shndx
== SHN_COMMON
)
2766 sym
->symbol
.section
= bfd_com_section_ptr
;
2767 /* Elf puts the alignment into the `value' field, and
2768 the size into the `size' field. BFD wants to see the
2769 size in the value field, and doesn't care (at the
2770 moment) about the alignment. */
2771 sym
->symbol
.value
= i_sym
.st_size
;
2773 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2775 sym
->symbol
.section
= bfd_und_section_ptr
;
2778 sym
->symbol
.section
= bfd_abs_section_ptr
;
2780 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2782 switch (ELF_ST_BIND (i_sym
.st_info
))
2785 sym
->symbol
.flags
|= BSF_LOCAL
;
2788 sym
->symbol
.flags
|= BSF_GLOBAL
;
2791 sym
->symbol
.flags
|= BSF_WEAK
;
2795 switch (ELF_ST_TYPE (i_sym
.st_info
))
2798 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2801 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2804 sym
->symbol
.flags
|= BSF_FUNCTION
;
2809 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2811 /* Do some backend-specific processing on this symbol. */
2813 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2814 if (ebd
->elf_backend_symbol_processing
)
2815 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2822 /* Do some backend-specific processing on this symbol table. */
2824 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2825 if (ebd
->elf_backend_symbol_table_processing
)
2826 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2829 /* We rely on the zalloc to clear out the final symbol entry. */
2831 symcount
= sym
- symbase
;
2833 /* Fill in the user's symbol pointer vector if needed. */
2841 *symptrs
++ = &sym
->symbol
;
2844 *symptrs
= 0; /* Final null pointer */
2856 /* Return the number of bytes required to hold the symtab vector.
2858 Note that we base it on the count plus 1, since we will null terminate
2859 the vector allocated based on this size. However, the ELF symbol table
2860 always has a dummy entry as symbol #0, so it ends up even. */
2863 elf_get_symtab_upper_bound (abfd
)
2868 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2870 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2871 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2877 elf_get_dynamic_symtab_upper_bound (abfd
)
2882 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2884 if (elf_dynsymtab (abfd
) == 0)
2886 bfd_set_error (bfd_error_invalid_operation
);
2890 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2891 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2897 elf_get_reloc_upper_bound (abfd
, asect
)
2901 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2904 /* Read in and swap the external relocs. */
2907 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2912 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2913 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2914 PTR allocated
= NULL
;
2915 bfd_byte
*native_relocs
;
2921 if (asect
->relocation
!= NULL
2922 || (asect
->flags
& SEC_RELOC
) == 0
2923 || asect
->reloc_count
== 0)
2926 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2927 && (asect
->reloc_count
2928 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2930 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2931 if (allocated
== NULL
)
2933 bfd_set_error (bfd_error_no_memory
);
2937 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2938 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2939 != d
->rel_hdr
.sh_size
))
2942 native_relocs
= (bfd_byte
*) allocated
;
2944 relents
= ((arelent
*)
2945 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2946 if (relents
== NULL
)
2948 bfd_set_error (bfd_error_no_memory
);
2952 entsize
= d
->rel_hdr
.sh_entsize
;
2953 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2954 || entsize
== sizeof (Elf_External_Rela
));
2956 for (i
= 0, relent
= relents
;
2957 i
< asect
->reloc_count
;
2958 i
++, relent
++, native_relocs
+= entsize
)
2960 Elf_Internal_Rela rela
;
2961 Elf_Internal_Rel rel
;
2963 if (entsize
== sizeof (Elf_External_Rela
))
2964 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2967 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2968 rela
.r_offset
= rel
.r_offset
;
2969 rela
.r_info
= rel
.r_info
;
2973 /* The address of an ELF reloc is section relative for an object
2974 file, and absolute for an executable file or shared library.
2975 The address of a BFD reloc is always section relative. */
2976 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2977 relent
->address
= rela
.r_offset
;
2979 relent
->address
= rela
.r_offset
- asect
->vma
;
2981 if (ELF_R_SYM (rela
.r_info
) == 0)
2982 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2987 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
2990 /* Canonicalize ELF section symbols. FIXME: Why? */
2991 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
2992 relent
->sym_ptr_ptr
= ps
;
2994 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2997 relent
->addend
= rela
.r_addend
;
2999 if (entsize
== sizeof (Elf_External_Rela
))
3000 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3002 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3005 asect
->relocation
= relents
;
3007 if (allocated
!= NULL
)
3013 if (allocated
!= NULL
)
3020 elf_debug_section (num
, hdr
)
3022 Elf_Internal_Shdr
*hdr
;
3024 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
3025 hdr
->bfd_section
!= NULL
? hfd
->bfd_section
->name
: "",
3028 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3029 (long) hdr
->sh_name
,
3030 (long) hdr
->sh_type
,
3031 (long) hdr
->sh_flags
);
3033 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3034 (long) hdr
->sh_addr
,
3035 (long) hdr
->sh_offset
,
3036 (long) hdr
->sh_size
);
3038 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3039 (long) hdr
->sh_link
,
3040 (long) hdr
->sh_info
,
3041 (long) hdr
->sh_addralign
);
3042 fprintf (stderr
, "sh_entsize = %ld\n",
3043 (long) hdr
->sh_entsize
);
3048 elf_debug_file (ehdrp
)
3049 Elf_Internal_Ehdr
*ehdrp
;
3051 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3052 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3053 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3054 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3055 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3056 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3057 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3061 /* Canonicalize the relocs. */
3064 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3073 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3076 tblptr
= section
->relocation
;
3077 for (i
= 0; i
< section
->reloc_count
; i
++)
3078 *relptr
++ = tblptr
++;
3082 return section
->reloc_count
;
3086 elf_get_symtab (abfd
, alocation
)
3088 asymbol
**alocation
;
3090 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3093 bfd_get_symcount (abfd
) = symcount
;
3098 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3100 asymbol
**alocation
;
3102 return elf_slurp_symbol_table (abfd
, alocation
, true);
3106 elf_make_empty_symbol (abfd
)
3109 elf_symbol_type
*newsym
;
3111 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3114 bfd_set_error (bfd_error_no_memory
);
3119 newsym
->symbol
.the_bfd
= abfd
;
3120 return &newsym
->symbol
;
3125 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3130 bfd_symbol_info (symbol
, ret
);
3134 elf_get_lineno (ignore_abfd
, symbol
)
3138 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3145 elf_set_arch_mach (abfd
, arch
, machine
)
3147 enum bfd_architecture arch
;
3148 unsigned long machine
;
3150 /* If this isn't the right architecture for this backend, and this
3151 isn't the generic backend, fail. */
3152 if (arch
!= get_elf_backend_data (abfd
)->arch
3153 && arch
!= bfd_arch_unknown
3154 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3157 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3161 elf_find_nearest_line (abfd
,
3172 CONST
char **filename_ptr
;
3173 CONST
char **functionname_ptr
;
3174 unsigned int *line_ptr
;
3180 elf_sizeof_headers (abfd
, reloc
)
3186 ret
= sizeof (Elf_External_Ehdr
);
3188 ret
+= get_program_header_size (abfd
);
3193 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3198 bfd_size_type count
;
3200 Elf_Internal_Shdr
*hdr
;
3202 if (! abfd
->output_has_begun
3203 && ! elf_compute_section_file_positions (abfd
,
3204 (struct bfd_link_info
*) NULL
))
3207 hdr
= &elf_section_data (section
)->this_hdr
;
3209 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3211 if (bfd_write (location
, 1, count
, abfd
) != count
)
3218 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3221 Elf_Internal_Rela
*dst
;
3223 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3229 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3232 Elf_Internal_Rel
*dst
;
3234 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3240 /* Core file support */
3242 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3243 #include <sys/procfs.h>
3245 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3246 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3247 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3253 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3260 prstatus_t
*status
= (prstatus_t
*) 0;
3262 if (descsz
== sizeof (prstatus_t
))
3264 newsect
= bfd_make_section (abfd
, ".reg");
3265 if (newsect
== NULL
)
3267 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3268 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3269 newsect
->flags
= SEC_HAS_CONTENTS
;
3270 newsect
->alignment_power
= 2;
3271 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3273 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3279 /* Stash a copy of the prpsinfo structure away for future use. */
3282 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3288 if (descsz
== sizeof (prpsinfo_t
))
3290 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3292 bfd_set_error (bfd_error_no_memory
);
3295 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3301 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3309 newsect
= bfd_make_section (abfd
, ".reg2");
3310 if (newsect
== NULL
)
3312 newsect
->_raw_size
= descsz
;
3313 newsect
->filepos
= filepos
;
3314 newsect
->flags
= SEC_HAS_CONTENTS
;
3315 newsect
->alignment_power
= 2;
3319 #endif /* HAVE_PROCFS */
3321 /* Return a pointer to the args (including the command name) that were
3322 seen by the program that generated the core dump. Note that for
3323 some reason, a spurious space is tacked onto the end of the args
3324 in some (at least one anyway) implementations, so strip it off if
3328 elf_core_file_failing_command (abfd
)
3332 if (core_prpsinfo (abfd
))
3334 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3335 char *scan
= p
->pr_psargs
;
3340 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3344 return p
->pr_psargs
;
3350 /* Return the number of the signal that caused the core dump. Presumably,
3351 since we have a core file, we got a signal of some kind, so don't bother
3352 checking the other process status fields, just return the signal number.
3356 elf_core_file_failing_signal (abfd
)
3360 if (core_prstatus (abfd
))
3362 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3368 /* Check to see if the core file could reasonably be expected to have
3369 come for the current executable file. Note that by default we return
3370 true unless we find something that indicates that there might be a
3375 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3384 /* First, xvecs must match since both are ELF files for the same target. */
3386 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3388 bfd_set_error (bfd_error_system_call
);
3394 /* If no prpsinfo, just return true. Otherwise, grab the last component
3395 of the exec'd pathname from the prpsinfo. */
3397 if (core_prpsinfo (core_bfd
))
3399 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3406 /* Find the last component of the executable pathname. */
3408 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3414 execname
= (char *) exec_bfd
->filename
;
3417 /* See if they match */
3419 return strcmp (execname
, corename
) ? false : true;
3425 #endif /* HAVE_PROCFS */
3428 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3429 the information that would normally be available from the /proc interface
3430 for the process, at the time the process dumped core. Currently this
3431 includes copies of the prstatus, prpsinfo, and fpregset structures.
3433 Since these structures are potentially machine dependent in size and
3434 ordering, bfd provides two levels of support for them. The first level,
3435 available on all machines since it does not require that the host
3436 have /proc support or the relevant include files, is to create a bfd
3437 section for each of the prstatus, prpsinfo, and fpregset structures,
3438 without any interpretation of their contents. With just this support,
3439 the bfd client will have to interpret the structures itself. Even with
3440 /proc support, it might want these full structures for it's own reasons.
3442 In the second level of support, where HAVE_PROCFS is defined, bfd will
3443 pick apart the structures to gather some additional information that
3444 clients may want, such as the general register set, the name of the
3445 exec'ed file and its arguments, the signal (if any) that caused the
3451 elf_corefile_note (abfd
, hdr
)
3453 Elf_Internal_Phdr
*hdr
;
3455 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3456 Elf_Internal_Note i_note
; /* Elf note, internal form */
3457 char *buf
= NULL
; /* Entire note segment contents */
3458 char *namedata
; /* Name portion of the note */
3459 char *descdata
; /* Descriptor portion of the note */
3460 char *sectname
; /* Name to use for new section */
3461 long filepos
; /* File offset to descriptor data */
3464 if (hdr
->p_filesz
> 0
3465 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3466 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3467 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3469 x_note_p
= (Elf_External_Note
*) buf
;
3470 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3472 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3473 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3474 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3475 namedata
= x_note_p
->name
;
3476 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3477 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3478 switch (i_note
.type
)
3481 /* process descdata as prstatus info */
3482 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3484 sectname
= ".prstatus";
3487 /* process descdata as fpregset info */
3488 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3490 sectname
= ".fpregset";
3493 /* process descdata as prpsinfo */
3494 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3496 sectname
= ".prpsinfo";
3499 /* Unknown descriptor, just ignore it. */
3503 if (sectname
!= NULL
)
3505 newsect
= bfd_make_section (abfd
, sectname
);
3506 if (newsect
== NULL
)
3508 newsect
->_raw_size
= i_note
.descsz
;
3509 newsect
->filepos
= filepos
;
3510 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3511 newsect
->alignment_power
= 2;
3513 x_note_p
= (Elf_External_Note
*)
3514 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3521 else if (hdr
->p_filesz
> 0)
3523 bfd_set_error (bfd_error_no_memory
);
3530 /* Core files are simply standard ELF formatted files that partition
3531 the file using the execution view of the file (program header table)
3532 rather than the linking view. In fact, there is no section header
3533 table in a core file.
3535 The process status information (including the contents of the general
3536 register set) and the floating point register set are stored in a
3537 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3538 that allow standard bfd access to the general registers (.reg) and the
3539 floating point registers (.reg2).
3544 elf_core_file_p (abfd
)
3547 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3548 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3549 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3550 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3551 unsigned int phindex
;
3552 struct elf_backend_data
*ebd
;
3554 /* Read in the ELF header in external format. */
3556 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3558 if (bfd_get_error () != bfd_error_system_call
)
3559 bfd_set_error (bfd_error_wrong_format
);
3563 /* Now check to see if we have a valid ELF file, and one that BFD can
3564 make use of. The magic number must match, the address size ('class')
3565 and byte-swapping must match our XVEC entry, and it must have a
3566 program header table (FIXME: See comments re segments at top of this
3569 if (elf_file_p (&x_ehdr
) == false)
3572 bfd_set_error (bfd_error_wrong_format
);
3576 /* FIXME, Check EI_VERSION here ! */
3580 int desired_address_size
= ELFCLASS32
;
3583 int desired_address_size
= ELFCLASS64
;
3586 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3590 /* Switch xvec to match the specified byte order. */
3591 switch (x_ehdr
.e_ident
[EI_DATA
])
3593 case ELFDATA2MSB
: /* Big-endian */
3594 if (abfd
->xvec
->byteorder_big_p
== false)
3597 case ELFDATA2LSB
: /* Little-endian */
3598 if (abfd
->xvec
->byteorder_big_p
== true)
3601 case ELFDATANONE
: /* No data encoding specified */
3602 default: /* Unknown data encoding specified */
3606 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3607 the tdata pointer in the bfd. */
3610 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3611 if (elf_tdata (abfd
) == NULL
)
3613 bfd_set_error (bfd_error_no_memory
);
3617 /* FIXME, `wrong' returns from this point onward, leak memory. */
3619 /* Now that we know the byte order, swap in the rest of the header */
3620 i_ehdrp
= elf_elfheader (abfd
);
3621 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3623 elf_debug_file (i_ehdrp
);
3626 ebd
= get_elf_backend_data (abfd
);
3628 /* Check that the ELF e_machine field matches what this particular
3629 BFD format expects. */
3630 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3632 const bfd_target
* const *target_ptr
;
3634 if (ebd
->elf_machine_code
!= EM_NONE
)
3637 /* This is the generic ELF target. Let it match any ELF target
3638 for which we do not have a specific backend. */
3639 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3641 struct elf_backend_data
*back
;
3643 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3645 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3646 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3648 /* target_ptr is an ELF backend which matches this
3649 object file, so reject the generic ELF target. */
3655 /* If there is no program header, or the type is not a core file, then
3657 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3660 /* Allocate space for a copy of the program header table in
3661 internal form, seek to the program header table in the file,
3662 read it in, and convert it to internal form. As a simple sanity
3663 check, verify that the what BFD thinks is the size of each program
3664 header table entry actually matches the size recorded in the file. */
3666 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3668 i_phdrp
= (Elf_Internal_Phdr
*)
3669 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3672 bfd_set_error (bfd_error_no_memory
);
3675 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3677 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3679 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3682 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3685 /* Once all of the program headers have been read and converted, we
3686 can start processing them. */
3688 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3690 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3691 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3693 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3698 /* Remember the entry point specified in the ELF file header. */
3700 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3705 /* ELF linker code. */
3707 static boolean elf_link_add_object_symbols
3708 PARAMS ((bfd
*, struct bfd_link_info
*));
3709 static boolean elf_link_add_archive_symbols
3710 PARAMS ((bfd
*, struct bfd_link_info
*));
3711 static Elf_Internal_Rela
*elf_link_read_relocs
3712 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3713 static boolean elf_export_symbol
3714 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3715 static boolean elf_adjust_dynamic_symbol
3716 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3718 /* Given an ELF BFD, add symbols to the global hash table as
3722 elf_bfd_link_add_symbols (abfd
, info
)
3724 struct bfd_link_info
*info
;
3726 switch (bfd_get_format (abfd
))
3729 return elf_link_add_object_symbols (abfd
, info
);
3731 return elf_link_add_archive_symbols (abfd
, info
);
3733 bfd_set_error (bfd_error_wrong_format
);
3738 /* Add symbols from an ELF archive file to the linker hash table. We
3739 don't use _bfd_generic_link_add_archive_symbols because of a
3740 problem which arises on UnixWare. The UnixWare libc.so is an
3741 archive which includes an entry libc.so.1 which defines a bunch of
3742 symbols. The libc.so archive also includes a number of other
3743 object files, which also define symbols, some of which are the same
3744 as those defined in libc.so.1. Correct linking requires that we
3745 consider each object file in turn, and include it if it defines any
3746 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3747 this; it looks through the list of undefined symbols, and includes
3748 any object file which defines them. When this algorithm is used on
3749 UnixWare, it winds up pulling in libc.so.1 early and defining a
3750 bunch of symbols. This means that some of the other objects in the
3751 archive are not included in the link, which is incorrect since they
3752 precede libc.so.1 in the archive.
3754 Fortunately, ELF archive handling is simpler than that done by
3755 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3756 oddities. In ELF, if we find a symbol in the archive map, and the
3757 symbol is currently undefined, we know that we must pull in that
3760 Unfortunately, we do have to make multiple passes over the symbol
3761 table until nothing further is resolved. */
3764 elf_link_add_archive_symbols (abfd
, info
)
3766 struct bfd_link_info
*info
;
3769 boolean
*defined
= NULL
;
3770 boolean
*included
= NULL
;
3774 if (! bfd_has_map (abfd
))
3776 /* An empty archive is a special case. */
3777 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3779 bfd_set_error (bfd_error_no_symbols
);
3783 /* Keep track of all symbols we know to be already defined, and all
3784 files we know to be already included. This is to speed up the
3785 second and subsequent passes. */
3786 c
= bfd_ardata (abfd
)->symdef_count
;
3789 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3790 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3791 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3793 bfd_set_error (bfd_error_no_memory
);
3796 memset (defined
, 0, c
* sizeof (boolean
));
3797 memset (included
, 0, c
* sizeof (boolean
));
3799 symdefs
= bfd_ardata (abfd
)->symdefs
;
3812 symdefend
= symdef
+ c
;
3813 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3815 struct elf_link_hash_entry
*h
;
3817 struct bfd_link_hash_entry
*undefs_tail
;
3820 if (defined
[i
] || included
[i
])
3822 if (symdef
->file_offset
== last
)
3828 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3829 false, false, false);
3830 if (h
== (struct elf_link_hash_entry
*) NULL
)
3832 if (h
->root
.type
!= bfd_link_hash_undefined
)
3838 /* We need to include this archive member. */
3840 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3841 if (element
== (bfd
*) NULL
)
3844 if (! bfd_check_format (element
, bfd_object
))
3847 /* Doublecheck that we have not included this object
3848 already--it should be impossible, but there may be
3849 something wrong with the archive. */
3850 if (element
->archive_pass
!= 0)
3852 bfd_set_error (bfd_error_bad_value
);
3855 element
->archive_pass
= 1;
3857 undefs_tail
= info
->hash
->undefs_tail
;
3859 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3862 if (! elf_link_add_object_symbols (element
, info
))
3865 /* If there are any new undefined symbols, we need to make
3866 another pass through the archive in order to see whether
3867 they can be defined. FIXME: This isn't perfect, because
3868 common symbols wind up on undefs_tail and because an
3869 undefined symbol which is defined later on in this pass
3870 does not require another pass. This isn't a bug, but it
3871 does make the code less efficient than it could be. */
3872 if (undefs_tail
!= info
->hash
->undefs_tail
)
3875 /* Look backward to mark all symbols from this object file
3876 which we have already seen in this pass. */
3880 included
[mark
] = true;
3885 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3887 /* We mark subsequent symbols from this object file as we go
3888 on through the loop. */
3889 last
= symdef
->file_offset
;
3900 if (defined
!= (boolean
*) NULL
)
3902 if (included
!= (boolean
*) NULL
)
3907 /* Record a new dynamic symbol. We record the dynamic symbols as we
3908 read the input files, since we need to have a list of all of them
3909 before we can determine the final sizes of the output sections.
3910 Note that we may actually call this function even though we are not
3911 going to output any dynamic symbols; in some cases we know that a
3912 symbol should be in the dynamic symbol table, but only if there is
3916 elf_link_record_dynamic_symbol (info
, h
)
3917 struct bfd_link_info
*info
;
3918 struct elf_link_hash_entry
*h
;
3920 if (h
->dynindx
== -1)
3922 struct bfd_strtab_hash
*dynstr
;
3924 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3925 ++elf_hash_table (info
)->dynsymcount
;
3927 dynstr
= elf_hash_table (info
)->dynstr
;
3930 /* Create a strtab to hold the dynamic symbol names. */
3931 elf_hash_table (info
)->dynstr
= dynstr
= elf_stringtab_init ();
3936 h
->dynstr_index
= ((unsigned long)
3937 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
3939 if (h
->dynstr_index
== (unsigned long) -1)
3946 /* Add symbols from an ELF object file to the linker hash table. */
3949 elf_link_add_object_symbols (abfd
, info
)
3951 struct bfd_link_info
*info
;
3953 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3954 const Elf_Internal_Sym
*,
3955 const char **, flagword
*,
3956 asection
**, bfd_vma
*));
3957 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3958 asection
*, const Elf_Internal_Rela
*));
3960 Elf_Internal_Shdr
*hdr
;
3964 Elf_External_Sym
*buf
= NULL
;
3965 struct elf_link_hash_entry
**sym_hash
;
3967 Elf_External_Dyn
*dynbuf
= NULL
;
3968 struct elf_link_hash_entry
*weaks
;
3969 Elf_External_Sym
*esym
;
3970 Elf_External_Sym
*esymend
;
3972 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
3973 collect
= get_elf_backend_data (abfd
)->collect
;
3975 /* A stripped shared library might only have a dynamic symbol table,
3976 not a regular symbol table. In that case we can still go ahead
3977 and link using the dynamic symbol table. */
3978 if (elf_onesymtab (abfd
) == 0
3979 && elf_dynsymtab (abfd
) != 0)
3981 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
3982 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
3985 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3986 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3988 /* The sh_info field of the symtab header tells us where the
3989 external symbols start. We don't care about the local symbols at
3991 if (elf_bad_symtab (abfd
))
3993 extsymcount
= symcount
;
3998 extsymcount
= symcount
- hdr
->sh_info
;
3999 extsymoff
= hdr
->sh_info
;
4002 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4003 if (buf
== NULL
&& extsymcount
!= 0)
4005 bfd_set_error (bfd_error_no_memory
);
4009 /* We store a pointer to the hash table entry for each external
4011 sym_hash
= ((struct elf_link_hash_entry
**)
4013 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4014 if (sym_hash
== NULL
)
4016 bfd_set_error (bfd_error_no_memory
);
4019 elf_sym_hashes (abfd
) = sym_hash
;
4021 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4025 /* If we are creating a shared library, create all the dynamic
4026 sections immediately. We need to attach them to something,
4027 so we attach them to this BFD, provided it is the right
4028 format. FIXME: If there are no input BFD's of the same
4029 format as the output, we can't make a shared library. */
4031 && ! elf_hash_table (info
)->dynamic_sections_created
4032 && abfd
->xvec
== info
->hash
->creator
)
4034 if (! elf_link_create_dynamic_sections (abfd
, info
))
4042 bfd_size_type strindex
;
4046 /* You can't use -r against a dynamic object. Also, there's no
4047 hope of using a dynamic object which does not exactly match
4048 the format of the output file. */
4049 if (info
->relocateable
4050 || info
->hash
->creator
!= abfd
->xvec
)
4052 bfd_set_error (bfd_error_invalid_operation
);
4056 /* Find the name to use in a DT_NEEDED entry that refers to this
4057 object. If the object has a DT_SONAME entry, we use it.
4058 Otherwise, if the generic linker stuck something in
4059 elf_dt_needed_name, we use that. Otherwise, we just use the
4061 name
= bfd_get_filename (abfd
);
4062 if (elf_dt_needed_name (abfd
) != NULL
)
4063 name
= elf_dt_needed_name (abfd
);
4064 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4067 Elf_External_Dyn
*extdyn
;
4068 Elf_External_Dyn
*extdynend
;
4070 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4073 bfd_set_error (bfd_error_no_memory
);
4077 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4078 (file_ptr
) 0, s
->_raw_size
))
4082 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4083 for (; extdyn
< extdynend
; extdyn
++)
4085 Elf_Internal_Dyn dyn
;
4087 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4088 if (dyn
.d_tag
== DT_SONAME
)
4093 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4096 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4097 name
= elf_string_from_elf_section (abfd
, link
,
4110 /* We do not want to include any of the sections in a dynamic
4111 object in the output file. We hack by simply clobbering the
4112 list of sections in the BFD. This could be handled more
4113 cleanly by, say, a new section flag; the existing
4114 SEC_NEVER_LOAD flag is not the one we want, because that one
4115 still implies that the section takes up space in the output
4117 abfd
->sections
= NULL
;
4119 /* If this is the first dynamic object found in the link, create
4120 the special sections required for dynamic linking. */
4121 if (! elf_hash_table (info
)->dynamic_sections_created
)
4123 if (! elf_link_create_dynamic_sections (abfd
, info
))
4127 /* Add a DT_NEEDED entry for this dynamic object. */
4128 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
4130 if (strindex
== (bfd_size_type
) -1)
4132 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4137 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4139 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4140 != extsymcount
* sizeof (Elf_External_Sym
)))
4145 esymend
= buf
+ extsymcount
;
4146 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4148 Elf_Internal_Sym sym
;
4154 struct elf_link_hash_entry
*h
= NULL
;
4157 elf_swap_symbol_in (abfd
, esym
, &sym
);
4159 flags
= BSF_NO_FLAGS
;
4161 value
= sym
.st_value
;
4164 bind
= ELF_ST_BIND (sym
.st_info
);
4165 if (bind
== STB_LOCAL
)
4167 /* This should be impossible, since ELF requires that all
4168 global symbols follow all local symbols, and that sh_info
4169 point to the first global symbol. Unfortunatealy, Irix 5
4173 else if (bind
== STB_GLOBAL
)
4175 else if (bind
== STB_WEAK
)
4179 /* Leave it up to the processor backend. */
4182 if (sym
.st_shndx
== SHN_UNDEF
)
4183 sec
= bfd_und_section_ptr
;
4184 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4186 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4190 sec
= bfd_abs_section_ptr
;
4192 else if (sym
.st_shndx
== SHN_ABS
)
4193 sec
= bfd_abs_section_ptr
;
4194 else if (sym
.st_shndx
== SHN_COMMON
)
4196 sec
= bfd_com_section_ptr
;
4197 /* What ELF calls the size we call the value. What ELF
4198 calls the value we call the alignment. */
4199 value
= sym
.st_size
;
4203 /* Leave it up to the processor backend. */
4206 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4207 if (name
== (const char *) NULL
)
4210 if (add_symbol_hook
)
4212 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4216 /* The hook function sets the name to NULL if this symbol
4217 should be skipped for some reason. */
4218 if (name
== (const char *) NULL
)
4222 /* Sanity check that all possibilities were handled. */
4223 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4225 bfd_set_error (bfd_error_bad_value
);
4229 if (bfd_is_und_section (sec
)
4230 || bfd_is_com_section (sec
))
4235 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4237 /* We need to look up the symbol now in order to get some of
4238 the dynamic object handling right. We pass the hash
4239 table entry in to _bfd_generic_link_add_one_symbol so
4240 that it does not have to look it up again. */
4241 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4242 true, false, false);
4247 /* If we are looking at a dynamic object, and this is a
4248 definition, we need to see if it has already been defined
4249 by some other object. If it has, we want to use the
4250 existing definition, and we do not want to report a
4251 multiple symbol definition error; we do this by
4252 clobbering sec to be bfd_und_section_ptr. */
4253 if (dynamic
&& definition
)
4255 if (h
->root
.type
== bfd_link_hash_defined
)
4256 sec
= bfd_und_section_ptr
;
4259 /* Similarly, if we are not looking at a dynamic object, and
4260 we have a definition, we want to override any definition
4261 we may have from a dynamic object. Symbols from regular
4262 files always take precedence over symbols from dynamic
4263 objects, even if they are defined after the dynamic
4264 object in the link. */
4267 && h
->root
.type
== bfd_link_hash_defined
4268 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4269 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4270 == bfd_target_elf_flavour
)
4271 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4274 /* Change the hash table entry to undefined, and let
4275 _bfd_generic_link_add_one_symbol do the right thing
4276 with the new definition. */
4277 h
->root
.type
= bfd_link_hash_undefined
;
4278 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4279 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4282 /* If this is a weak definition which we are going to use,
4283 and the symbol is currently undefined, record that the
4284 definition is weak. */
4286 && (flags
& BSF_WEAK
) != 0
4287 && ! bfd_is_und_section (sec
)
4288 && (h
->root
.type
== bfd_link_hash_new
4289 || h
->root
.type
== bfd_link_hash_undefined
4290 || h
->root
.type
== bfd_link_hash_weak
))
4291 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4294 if (! (_bfd_generic_link_add_one_symbol
4295 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4296 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4301 && (flags
& BSF_WEAK
) != 0
4302 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4303 && (*sym_hash
)->weakdef
== NULL
)
4305 /* Keep a list of all weak defined non function symbols from
4306 a dynamic object, using the weakdef field. Later in this
4307 function we will set the weakdef field to the correct
4308 value. We only put non-function symbols from dynamic
4309 objects on this list, because that happens to be the only
4310 time we need to know the normal symbol corresponding to a
4311 weak symbol, and the information is time consuming to
4312 figure out. If the weakdef field is not already NULL,
4313 then this symbol was already defined by some previous
4314 dynamic object, and we will be using that previous
4315 definition anyhow. */
4317 (*sym_hash
)->weakdef
= weaks
;
4321 /* Get the alignment of a common symbol. */
4322 if (sym
.st_shndx
== SHN_COMMON
4323 && h
->root
.type
== bfd_link_hash_common
)
4324 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4326 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4332 /* Remember the symbol size and type. */
4333 if (sym
.st_size
!= 0)
4335 /* FIXME: We should probably somehow give a warning if
4336 the symbol size changes. */
4337 h
->size
= sym
.st_size
;
4339 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4341 /* FIXME: We should probably somehow give a warning if
4342 the symbol type changes. */
4343 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4346 /* Set a flag in the hash table entry indicating the type of
4347 reference or definition we just found. Keep a count of
4348 the number of dynamic symbols we find. A dynamic symbol
4349 is one which is referenced or defined by both a regular
4350 object and a shared object, or one which is referenced or
4351 defined by more than one shared object. */
4352 old_flags
= h
->elf_link_hash_flags
;
4357 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4359 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4361 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4362 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4368 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4370 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4371 if ((old_flags
& new_flag
) != 0
4372 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4373 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4377 h
->elf_link_hash_flags
|= new_flag
;
4378 if (dynsym
&& h
->dynindx
== -1)
4380 if (! elf_link_record_dynamic_symbol (info
, h
))
4386 /* Now set the weakdefs field correctly for all the weak defined
4387 symbols we found. The only way to do this is to search all the
4388 symbols. Since we only need the information for non functions in
4389 dynamic objects, that's the only time we actually put anything on
4390 the list WEAKS. We need this information so that if a regular
4391 object refers to a symbol defined weakly in a dynamic object, the
4392 real symbol in the dynamic object is also put in the dynamic
4393 symbols; we also must arrange for both symbols to point to the
4394 same memory location. We could handle the general case of symbol
4395 aliasing, but a general symbol alias can only be generated in
4396 assembler code, handling it correctly would be very time
4397 consuming, and other ELF linkers don't handle general aliasing
4399 while (weaks
!= NULL
)
4401 struct elf_link_hash_entry
*hlook
;
4404 struct elf_link_hash_entry
**hpp
;
4405 struct elf_link_hash_entry
**hppend
;
4408 weaks
= hlook
->weakdef
;
4409 hlook
->weakdef
= NULL
;
4411 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4412 slook
= hlook
->root
.u
.def
.section
;
4413 vlook
= hlook
->root
.u
.def
.value
;
4415 hpp
= elf_sym_hashes (abfd
);
4416 hppend
= hpp
+ extsymcount
;
4417 for (; hpp
< hppend
; hpp
++)
4419 struct elf_link_hash_entry
*h
;
4423 && h
->root
.type
== bfd_link_hash_defined
4424 && h
->root
.u
.def
.section
== slook
4425 && h
->root
.u
.def
.value
== vlook
)
4429 /* If the weak definition is in the list of dynamic
4430 symbols, make sure the real definition is put there
4432 if (hlook
->dynindx
!= -1
4433 && h
->dynindx
== -1)
4435 if (! elf_link_record_dynamic_symbol (info
, h
))
4450 /* If this object is the same format as the output object, and it is
4451 not a shared library, then let the backend look through the
4454 This is required to build global offset table entries and to
4455 arrange for dynamic relocs. It is not required for the
4456 particular common case of linking non PIC code, even when linking
4457 against shared libraries, but unfortunately there is no way of
4458 knowing whether an object file has been compiled PIC or not.
4459 Looking through the relocs is not particularly time consuming.
4460 The problem is that we must either (1) keep the relocs in memory,
4461 which causes the linker to require additional runtime memory or
4462 (2) read the relocs twice from the input file, which wastes time.
4463 This would be a good case for using mmap.
4465 I have no idea how to handle linking PIC code into a file of a
4466 different format. It probably can't be done. */
4467 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4469 && abfd
->xvec
== info
->hash
->creator
4470 && check_relocs
!= NULL
)
4474 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4476 Elf_Internal_Rela
*internal_relocs
;
4479 if ((o
->flags
& SEC_RELOC
) == 0
4480 || o
->reloc_count
== 0)
4483 /* I believe we can ignore the relocs for any section which
4484 does not form part of the final process image, such as a
4485 debugging section. */
4486 if ((o
->flags
& SEC_ALLOC
) == 0)
4489 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4490 (Elf_Internal_Rela
*) NULL
,
4492 if (internal_relocs
== NULL
)
4495 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4497 if (! info
->keep_memory
)
4498 free (internal_relocs
);
4515 /* Create some sections which will be filled in with dynamic linking
4516 information. ABFD is an input file which requires dynamic sections
4517 to be created. The dynamic sections take up virtual memory space
4518 when the final executable is run, so we need to create them before
4519 addresses are assigned to the output sections. We work out the
4520 actual contents and size of these sections later. */
4523 elf_link_create_dynamic_sections (abfd
, info
)
4525 struct bfd_link_info
*info
;
4528 register asection
*s
;
4529 struct elf_link_hash_entry
*h
;
4530 struct elf_backend_data
*bed
;
4532 if (elf_hash_table (info
)->dynamic_sections_created
)
4535 /* Make sure that all dynamic sections use the same input BFD. */
4536 if (elf_hash_table (info
)->dynobj
== NULL
)
4537 elf_hash_table (info
)->dynobj
= abfd
;
4539 abfd
= elf_hash_table (info
)->dynobj
;
4541 /* Note that we set the SEC_IN_MEMORY flag for all of these
4543 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4545 /* A dynamically linked executable has a .interp section, but a
4546 shared library does not. */
4549 s
= bfd_make_section (abfd
, ".interp");
4551 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4555 s
= bfd_make_section (abfd
, ".dynsym");
4557 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4558 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4561 s
= bfd_make_section (abfd
, ".dynstr");
4563 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4566 /* Create a strtab to hold the dynamic symbol names. */
4567 if (elf_hash_table (info
)->dynstr
== NULL
)
4569 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
4570 if (elf_hash_table (info
)->dynstr
== NULL
)
4574 s
= bfd_make_section (abfd
, ".dynamic");
4576 || ! bfd_set_section_flags (abfd
, s
, flags
)
4577 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4580 /* The special symbol _DYNAMIC is always set to the start of the
4581 .dynamic section. This call occurs before we have processed the
4582 symbols for any dynamic object, so we don't have to worry about
4583 overriding a dynamic definition. We could set _DYNAMIC in a
4584 linker script, but we only want to define it if we are, in fact,
4585 creating a .dynamic section. We don't want to define it if there
4586 is no .dynamic section, since on some ELF platforms the start up
4587 code examines it to decide how to initialize the process. */
4589 if (! (_bfd_generic_link_add_one_symbol
4590 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4591 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4592 (struct bfd_link_hash_entry
**) &h
)))
4594 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4595 h
->type
= STT_OBJECT
;
4598 && ! elf_link_record_dynamic_symbol (info
, h
))
4601 s
= bfd_make_section (abfd
, ".hash");
4603 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4604 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4607 /* Let the backend create the rest of the sections. This lets the
4608 backend set the right flags. The backend will normally create
4609 the .got and .plt sections. */
4610 bed
= get_elf_backend_data (abfd
);
4611 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
4614 elf_hash_table (info
)->dynamic_sections_created
= true;
4619 /* Add an entry to the .dynamic table. */
4622 elf_add_dynamic_entry (info
, tag
, val
)
4623 struct bfd_link_info
*info
;
4627 Elf_Internal_Dyn dyn
;
4631 bfd_byte
*newcontents
;
4633 dynobj
= elf_hash_table (info
)->dynobj
;
4635 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4636 BFD_ASSERT (s
!= NULL
);
4638 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4639 if (s
->contents
== NULL
)
4640 newcontents
= (bfd_byte
*) malloc (newsize
);
4642 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4643 if (newcontents
== NULL
)
4645 bfd_set_error (bfd_error_no_memory
);
4650 dyn
.d_un
.d_val
= val
;
4651 elf_swap_dyn_out (dynobj
, &dyn
,
4652 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4654 s
->_raw_size
= newsize
;
4655 s
->contents
= newcontents
;
4660 /* Read and swap the relocs for a section. They may have been cached.
4661 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4662 they are used as buffers to read into. They are known to be large
4663 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4664 value is allocated using either malloc or bfd_alloc, according to
4665 the KEEP_MEMORY argument. */
4667 static Elf_Internal_Rela
*
4668 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4671 PTR external_relocs
;
4672 Elf_Internal_Rela
*internal_relocs
;
4673 boolean keep_memory
;
4675 Elf_Internal_Shdr
*rel_hdr
;
4677 Elf_Internal_Rela
*alloc2
= NULL
;
4679 if (elf_section_data (o
)->relocs
!= NULL
)
4680 return elf_section_data (o
)->relocs
;
4682 if (o
->reloc_count
== 0)
4685 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4687 if (internal_relocs
== NULL
)
4691 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4693 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4695 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4696 if (internal_relocs
== NULL
)
4698 bfd_set_error (bfd_error_no_memory
);
4703 if (external_relocs
== NULL
)
4705 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4708 bfd_set_error (bfd_error_no_memory
);
4711 external_relocs
= alloc1
;
4714 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4715 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4716 != rel_hdr
->sh_size
))
4719 /* Swap in the relocs. For convenience, we always produce an
4720 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4722 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4724 Elf_External_Rel
*erel
;
4725 Elf_External_Rel
*erelend
;
4726 Elf_Internal_Rela
*irela
;
4728 erel
= (Elf_External_Rel
*) external_relocs
;
4729 erelend
= erel
+ o
->reloc_count
;
4730 irela
= internal_relocs
;
4731 for (; erel
< erelend
; erel
++, irela
++)
4733 Elf_Internal_Rel irel
;
4735 elf_swap_reloc_in (abfd
, erel
, &irel
);
4736 irela
->r_offset
= irel
.r_offset
;
4737 irela
->r_info
= irel
.r_info
;
4738 irela
->r_addend
= 0;
4743 Elf_External_Rela
*erela
;
4744 Elf_External_Rela
*erelaend
;
4745 Elf_Internal_Rela
*irela
;
4747 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4749 erela
= (Elf_External_Rela
*) external_relocs
;
4750 erelaend
= erela
+ o
->reloc_count
;
4751 irela
= internal_relocs
;
4752 for (; erela
< erelaend
; erela
++, irela
++)
4753 elf_swap_reloca_in (abfd
, erela
, irela
);
4756 /* Cache the results for next time, if we can. */
4758 elf_section_data (o
)->relocs
= internal_relocs
;
4763 /* Don't free alloc2, since if it was allocated we are passing it
4764 back (under the name of internal_relocs). */
4766 return internal_relocs
;
4776 /* Record an assignment to a symbol made by a linker script. We need
4777 this in case some dynamic object refers to this symbol. */
4781 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4783 struct bfd_link_info
*info
;
4786 struct elf_link_hash_entry
*h
;
4788 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4792 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4793 h
->type
= STT_OBJECT
;
4795 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4796 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4798 && h
->dynindx
== -1)
4800 if (! elf_link_record_dynamic_symbol (info
, h
))
4803 /* If this is a weak defined symbol, and we know a corresponding
4804 real symbol from the same dynamic object, make sure the real
4805 symbol is also made into a dynamic symbol. */
4806 if (h
->weakdef
!= NULL
4807 && h
->weakdef
->dynindx
== -1)
4809 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4817 /* Array used to determine the number of hash table buckets to use
4818 based on the number of symbols there are. If there are fewer than
4819 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4820 fewer than 37 we use 17 buckets, and so forth. We never use more
4821 than 521 buckets. */
4823 static const size_t elf_buckets
[] =
4825 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4828 /* Set up the sizes and contents of the ELF dynamic sections. This is
4829 called by the ELF linker emulation before_allocation routine. We
4830 must set the sizes of the sections before the linker sets the
4831 addresses of the various sections. */
4834 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
4835 export_dynamic
, info
, sinterpptr
)
4839 boolean export_dynamic
;
4840 struct bfd_link_info
*info
;
4841 asection
**sinterpptr
;
4845 Elf_Internal_Sym isym
;
4848 struct elf_backend_data
*bed
;
4852 dynobj
= elf_hash_table (info
)->dynobj
;
4854 /* If there were no dynamic objects in the link, there is nothing to
4859 /* If we are supposed to export all symbols into the dynamic symbol
4860 table (this is not the normal case), then do so. */
4862 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
4865 if (elf_hash_table (info
)->dynamic_sections_created
)
4867 bfd_size_type strsize
;
4869 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4870 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4876 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
4878 if (indx
== (bfd_size_type
) -1
4879 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4887 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
4889 if (indx
== (bfd_size_type
) -1
4890 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4894 /* Find all symbols which were defined in a dynamic object and make
4895 the backend pick a reasonable value for them. */
4896 elf_link_hash_traverse (elf_hash_table (info
),
4897 elf_adjust_dynamic_symbol
,
4900 /* Add some entries to the .dynamic section. We fill in some of the
4901 values later, in elf_bfd_final_link, but we must add the entries
4902 now so that we know the final size of the .dynamic section. */
4903 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
4904 false, false) != NULL
)
4906 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4909 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
4910 false, false) != NULL
)
4912 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4915 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4916 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4917 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4918 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4919 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
4920 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4921 sizeof (Elf_External_Sym
)))
4925 /* The backend must work out the sizes of all the other dynamic
4927 bed
= get_elf_backend_data (output_bfd
);
4928 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4931 if (elf_hash_table (info
)->dynamic_sections_created
)
4935 /* Set the size of the .dynsym and .hash sections. We counted
4936 the number of dynamic symbols in elf_link_add_object_symbols.
4937 We will build the contents of .dynsym and .hash when we build
4938 the final symbol table, because until then we do not know the
4939 correct value to give the symbols. We built the .dynstr
4940 section as we went along in elf_link_add_object_symbols. */
4941 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4942 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4943 BFD_ASSERT (s
!= NULL
);
4944 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4945 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4946 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4948 bfd_set_error (bfd_error_no_memory
);
4952 /* The first entry in .dynsym is a dummy symbol. */
4959 elf_swap_symbol_out (output_bfd
, &isym
,
4960 (Elf_External_Sym
*) s
->contents
);
4962 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4964 bucketcount
= elf_buckets
[i
];
4965 if (dynsymcount
< elf_buckets
[i
+ 1])
4969 s
= bfd_get_section_by_name (dynobj
, ".hash");
4970 BFD_ASSERT (s
!= NULL
);
4971 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4972 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4973 if (s
->contents
== NULL
)
4975 bfd_set_error (bfd_error_no_memory
);
4978 memset (s
->contents
, 0, s
->_raw_size
);
4980 put_word (output_bfd
, bucketcount
, s
->contents
);
4981 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4983 elf_hash_table (info
)->bucketcount
= bucketcount
;
4985 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4986 BFD_ASSERT (s
!= NULL
);
4987 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
4989 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
4996 /* This routine is used to export all defined symbols into the dynamic
4997 symbol table. It is called via elf_link_hash_traverse. */
5000 elf_export_symbol (h
, data
)
5001 struct elf_link_hash_entry
*h
;
5004 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5006 if (h
->dynindx
== -1
5007 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5009 if (! elf_link_record_dynamic_symbol (info
, h
))
5011 /* FIXME: No way to report error. */
5019 /* Make the backend pick a good value for a dynamic symbol. This is
5020 called via elf_link_hash_traverse, and also calls itself
5024 elf_adjust_dynamic_symbol (h
, data
)
5025 struct elf_link_hash_entry
*h
;
5028 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5030 struct elf_backend_data
*bed
;
5032 /* If this symbol does not require a PLT entry, and it is not
5033 defined by a dynamic object, or is not referenced by a regular
5034 object, ignore it. FIXME: Do we need to worry about symbols
5035 which are defined by one dynamic object and referenced by another
5037 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
5038 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5039 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5040 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
5043 /* If we've already adjusted this symbol, don't do it again. This
5044 can happen via a recursive call. */
5045 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5048 /* Don't look at this symbol again. Note that we must set this
5049 after checking the above conditions, because we may look at a
5050 symbol once, decide not to do anything, and then get called
5051 recursively later after REF_REGULAR is set below. */
5052 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5054 /* If this is a weak definition, and we know a real definition, and
5055 the real symbol is not itself defined by a regular object file,
5056 then get a good value for the real definition. We handle the
5057 real symbol first, for the convenience of the backend routine.
5059 Note that there is a confusing case here. If the real definition
5060 is defined by a regular object file, we don't get the real symbol
5061 from the dynamic object, but we do get the weak symbol. If the
5062 processor backend uses a COPY reloc, then if some routine in the
5063 dynamic object changes the real symbol, we will not see that
5064 change in the corresponding weak symbol. This is the way other
5065 ELF linkers work as well, and seems to be a result of the shared
5068 I will clarify this issue. Most SVR4 shared libraries define the
5069 variable _timezone and define timezone as a weak synonym. The
5070 tzset call changes _timezone. If you write
5071 extern int timezone;
5073 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5074 you might expect that, since timezone is a synonym for _timezone,
5075 the same number will print both times. However, if the processor
5076 backend uses a COPY reloc, then actually timezone will be copied
5077 into your process image, and, since you define _timezone
5078 yourself, _timezone will not. Thus timezone and _timezone will
5079 wind up at different memory locations. The tzset call will set
5080 _timezone, leaving timezone unchanged. */
5082 if (h
->weakdef
!= NULL
)
5084 struct elf_link_hash_entry
*weakdef
;
5086 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5087 weakdef
= h
->weakdef
;
5088 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5089 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5090 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5092 /* This symbol is defined by a regular object file, so we
5093 will not do anything special. Clear weakdef for the
5094 convenience of the processor backend. */
5099 /* There is an implicit reference by a regular object file
5100 via the weak symbol. */
5101 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5102 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5107 dynobj
= elf_hash_table (info
)->dynobj
;
5108 bed
= get_elf_backend_data (dynobj
);
5109 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5111 /* FIXME: No way to return error. */
5118 /* Final phase of ELF linker. */
5120 /* A structure we use to avoid passing large numbers of arguments. */
5122 struct elf_final_link_info
5124 /* General link information. */
5125 struct bfd_link_info
*info
;
5128 /* Symbol string table. */
5129 struct bfd_strtab_hash
*symstrtab
;
5130 /* .dynsym section. */
5131 asection
*dynsym_sec
;
5132 /* .hash section. */
5134 /* Buffer large enough to hold contents of any section. */
5136 /* Buffer large enough to hold external relocs of any section. */
5137 PTR external_relocs
;
5138 /* Buffer large enough to hold internal relocs of any section. */
5139 Elf_Internal_Rela
*internal_relocs
;
5140 /* Buffer large enough to hold external local symbols of any input
5142 Elf_External_Sym
*external_syms
;
5143 /* Buffer large enough to hold internal local symbols of any input
5145 Elf_Internal_Sym
*internal_syms
;
5146 /* Array large enough to hold a symbol index for each local symbol
5147 of any input BFD. */
5149 /* Array large enough to hold a section pointer for each local
5150 symbol of any input BFD. */
5151 asection
**sections
;
5152 /* Buffer to hold swapped out symbols. */
5153 Elf_External_Sym
*symbuf
;
5154 /* Number of swapped out symbols in buffer. */
5155 size_t symbuf_count
;
5156 /* Number of symbols which fit in symbuf. */
5160 static boolean elf_link_output_sym
5161 PARAMS ((struct elf_final_link_info
*, const char *,
5162 Elf_Internal_Sym
*, asection
*));
5163 static boolean elf_link_flush_output_syms
5164 PARAMS ((struct elf_final_link_info
*));
5165 static boolean elf_link_output_extsym
5166 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5167 static boolean elf_link_input_bfd
5168 PARAMS ((struct elf_final_link_info
*, bfd
*));
5169 static boolean elf_reloc_link_order
5170 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5171 struct bfd_link_order
*));
5173 /* Do the final step of an ELF link. */
5176 elf_bfd_final_link (abfd
, info
)
5178 struct bfd_link_info
*info
;
5182 struct elf_final_link_info finfo
;
5183 register asection
*o
;
5184 register struct bfd_link_order
*p
;
5186 size_t max_contents_size
;
5187 size_t max_external_reloc_size
;
5188 size_t max_internal_reloc_count
;
5189 size_t max_sym_count
;
5191 Elf_Internal_Sym elfsym
;
5193 Elf_Internal_Shdr
*symtab_hdr
;
5194 Elf_Internal_Shdr
*symstrtab_hdr
;
5195 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5198 abfd
->flags
|= DYNAMIC
;
5200 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
5201 dynobj
= elf_hash_table (info
)->dynobj
;
5204 finfo
.output_bfd
= abfd
;
5205 finfo
.symstrtab
= elf_stringtab_init ();
5206 if (finfo
.symstrtab
== NULL
)
5210 finfo
.dynsym_sec
= NULL
;
5211 finfo
.hash_sec
= NULL
;
5215 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5216 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5217 if (finfo
.dynsym_sec
== NULL
5218 || finfo
.hash_sec
== NULL
)
5221 finfo
.contents
= NULL
;
5222 finfo
.external_relocs
= NULL
;
5223 finfo
.internal_relocs
= NULL
;
5224 finfo
.external_syms
= NULL
;
5225 finfo
.internal_syms
= NULL
;
5226 finfo
.indices
= NULL
;
5227 finfo
.sections
= NULL
;
5228 finfo
.symbuf
= NULL
;
5229 finfo
.symbuf_count
= 0;
5231 /* Count up the number of relocations we will output for each output
5232 section, so that we know the sizes of the reloc sections. We
5233 also figure out some maximum sizes. */
5234 max_contents_size
= 0;
5235 max_external_reloc_size
= 0;
5236 max_internal_reloc_count
= 0;
5238 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5242 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5244 if (p
->type
== bfd_section_reloc_link_order
5245 || p
->type
== bfd_symbol_reloc_link_order
)
5247 else if (p
->type
== bfd_indirect_link_order
)
5251 sec
= p
->u
.indirect
.section
;
5253 if (info
->relocateable
)
5254 o
->reloc_count
+= sec
->reloc_count
;
5256 if (sec
->_raw_size
> max_contents_size
)
5257 max_contents_size
= sec
->_raw_size
;
5258 if (sec
->_cooked_size
> max_contents_size
)
5259 max_contents_size
= sec
->_cooked_size
;
5261 /* We are interested in just local symbols, not all
5263 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5267 if (elf_bad_symtab (sec
->owner
))
5268 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5269 / sizeof (Elf_External_Sym
));
5271 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5273 if (sym_count
> max_sym_count
)
5274 max_sym_count
= sym_count
;
5276 if ((sec
->flags
& SEC_RELOC
) != 0)
5280 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5281 if (ext_size
> max_external_reloc_size
)
5282 max_external_reloc_size
= ext_size
;
5283 if (sec
->reloc_count
> max_internal_reloc_count
)
5284 max_internal_reloc_count
= sec
->reloc_count
;
5290 if (o
->reloc_count
> 0)
5291 o
->flags
|= SEC_RELOC
;
5294 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5295 set it (this is probably a bug) and if it is set
5296 assign_section_numbers will create a reloc section. */
5297 o
->flags
&=~ SEC_RELOC
;
5300 /* If the SEC_ALLOC flag is not set, force the section VMA to
5301 zero. This is done in elf_fake_sections as well, but forcing
5302 the VMA to 0 here will ensure that relocs against these
5303 sections are handled correctly. */
5304 if ((o
->flags
& SEC_ALLOC
) == 0)
5308 /* Figure out the file positions for everything but the symbol table
5309 and the relocs. We set symcount to force assign_section_numbers
5310 to create a symbol table. */
5311 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5312 BFD_ASSERT (! abfd
->output_has_begun
);
5313 if (! elf_compute_section_file_positions (abfd
, info
))
5316 /* That created the reloc sections. Set their sizes, and assign
5317 them file positions, and allocate some buffers. */
5318 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5320 if ((o
->flags
& SEC_RELOC
) != 0)
5322 Elf_Internal_Shdr
*rel_hdr
;
5323 register struct elf_link_hash_entry
**p
, **pend
;
5325 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5327 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5329 /* The contents field must last into write_object_contents,
5330 so we allocate it with bfd_alloc rather than malloc. */
5331 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5332 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5334 bfd_set_error (bfd_error_no_memory
);
5338 p
= ((struct elf_link_hash_entry
**)
5339 malloc (o
->reloc_count
5340 * sizeof (struct elf_link_hash_entry
*)));
5341 if (p
== NULL
&& o
->reloc_count
!= 0)
5343 bfd_set_error (bfd_error_no_memory
);
5346 elf_section_data (o
)->rel_hashes
= p
;
5347 pend
= p
+ o
->reloc_count
;
5348 for (; p
< pend
; p
++)
5351 /* Use the reloc_count field as an index when outputting the
5357 assign_file_positions_for_relocs (abfd
);
5359 /* We have now assigned file positions for all the sections except
5360 .symtab and .strtab. We start the .symtab section at the current
5361 file position, and write directly to it. We build the .strtab
5362 section in memory. When we add .dynsym support, we will build
5363 that in memory as well (.dynsym is smaller than .symtab). */
5365 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5366 /* sh_name is set in prep_headers. */
5367 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5368 symtab_hdr
->sh_flags
= 0;
5369 symtab_hdr
->sh_addr
= 0;
5370 symtab_hdr
->sh_size
= 0;
5371 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5372 /* sh_link is set in assign_section_numbers. */
5373 /* sh_info is set below. */
5374 /* sh_offset is set just below. */
5375 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5377 off
= elf_tdata (abfd
)->next_file_pos
;
5378 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5380 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5381 incorrect. We do not yet know the size of the .symtab section.
5382 We correct next_file_pos below, after we do know the size. */
5384 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5385 continuously seeking to the right position in the file. */
5386 if (! info
->keep_memory
|| max_sym_count
< 20)
5387 finfo
.symbuf_size
= 20;
5389 finfo
.symbuf_size
= max_sym_count
;
5390 finfo
.symbuf
= ((Elf_External_Sym
*)
5391 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5392 if (finfo
.symbuf
== NULL
)
5394 bfd_set_error (bfd_error_no_memory
);
5398 /* Start writing out the symbol table. The first symbol is always a
5400 elfsym
.st_value
= 0;
5403 elfsym
.st_other
= 0;
5404 elfsym
.st_shndx
= SHN_UNDEF
;
5405 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5406 &elfsym
, bfd_und_section_ptr
))
5410 /* Some standard ELF linkers do this, but we don't because it causes
5411 bootstrap comparison failures. */
5412 /* Output a file symbol for the output file as the second symbol.
5413 We output this even if we are discarding local symbols, although
5414 I'm not sure if this is correct. */
5415 elfsym
.st_value
= 0;
5417 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5418 elfsym
.st_other
= 0;
5419 elfsym
.st_shndx
= SHN_ABS
;
5420 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5421 &elfsym
, bfd_abs_section_ptr
))
5425 /* Output a symbol for each section. We output these even if we are
5426 discarding local symbols, since they are used for relocs. These
5427 symbols have no names. We store the index of each one in the
5428 index field of the section, so that we can find it again when
5429 outputting relocs. */
5430 elfsym
.st_value
= 0;
5432 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5433 elfsym
.st_other
= 0;
5434 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5436 o
= section_from_elf_index (abfd
, i
);
5438 o
->target_index
= abfd
->symcount
;
5439 elfsym
.st_shndx
= i
;
5440 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5445 /* Allocate some memory to hold information read in from the input
5447 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5448 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5449 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5450 malloc (max_internal_reloc_count
5451 * sizeof (Elf_Internal_Rela
)));
5452 finfo
.external_syms
= ((Elf_External_Sym
*)
5453 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5454 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5455 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5456 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5457 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5458 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5459 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5460 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5461 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5462 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5463 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5464 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5466 bfd_set_error (bfd_error_no_memory
);
5470 /* Since ELF permits relocations to be against local symbols, we
5471 must have the local symbols available when we do the relocations.
5472 Since we would rather only read the local symbols once, and we
5473 would rather not keep them in memory, we handle all the
5474 relocations for a single input file at the same time.
5476 Unfortunately, there is no way to know the total number of local
5477 symbols until we have seen all of them, and the local symbol
5478 indices precede the global symbol indices. This means that when
5479 we are generating relocateable output, and we see a reloc against
5480 a global symbol, we can not know the symbol index until we have
5481 finished examining all the local symbols to see which ones we are
5482 going to output. To deal with this, we keep the relocations in
5483 memory, and don't output them until the end of the link. This is
5484 an unfortunate waste of memory, but I don't see a good way around
5485 it. Fortunately, it only happens when performing a relocateable
5486 link, which is not the common case. FIXME: If keep_memory is set
5487 we could write the relocs out and then read them again; I don't
5488 know how bad the memory loss will be. */
5490 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5491 sub
->output_has_begun
= false;
5492 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5494 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5496 if (p
->type
== bfd_indirect_link_order
5497 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5498 == bfd_target_elf_flavour
))
5500 sub
= p
->u
.indirect
.section
->owner
;
5501 if (! sub
->output_has_begun
)
5503 if (! elf_link_input_bfd (&finfo
, sub
))
5505 sub
->output_has_begun
= true;
5508 else if (p
->type
== bfd_section_reloc_link_order
5509 || p
->type
== bfd_symbol_reloc_link_order
)
5511 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5516 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5522 /* That wrote out all the local symbols. Finish up the symbol table
5523 with the global symbols. */
5525 /* The sh_info field records the index of the first non local
5527 symtab_hdr
->sh_info
= abfd
->symcount
;
5529 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5531 /* We get the global symbols from the hash table. */
5532 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5535 /* Flush all symbols to the file. */
5536 if (! elf_link_flush_output_syms (&finfo
))
5539 /* Now we know the size of the symtab section. */
5540 off
+= symtab_hdr
->sh_size
;
5542 /* Finish up and write out the symbol string table (.strtab)
5544 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5545 /* sh_name was set in prep_headers. */
5546 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5547 symstrtab_hdr
->sh_flags
= 0;
5548 symstrtab_hdr
->sh_addr
= 0;
5549 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
5550 symstrtab_hdr
->sh_entsize
= 0;
5551 symstrtab_hdr
->sh_link
= 0;
5552 symstrtab_hdr
->sh_info
= 0;
5553 /* sh_offset is set just below. */
5554 symstrtab_hdr
->sh_addralign
= 1;
5556 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5557 elf_tdata (abfd
)->next_file_pos
= off
;
5559 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
5560 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
5563 /* Adjust the relocs to have the correct symbol indices. */
5564 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5566 struct elf_link_hash_entry
**rel_hash
;
5567 Elf_Internal_Shdr
*rel_hdr
;
5569 if ((o
->flags
& SEC_RELOC
) == 0)
5572 rel_hash
= elf_section_data (o
)->rel_hashes
;
5573 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5574 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5576 if (*rel_hash
== NULL
)
5579 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5581 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5583 Elf_External_Rel
*erel
;
5584 Elf_Internal_Rel irel
;
5586 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5587 elf_swap_reloc_in (abfd
, erel
, &irel
);
5588 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5589 ELF_R_TYPE (irel
.r_info
));
5590 elf_swap_reloc_out (abfd
, &irel
, erel
);
5594 Elf_External_Rela
*erela
;
5595 Elf_Internal_Rela irela
;
5597 BFD_ASSERT (rel_hdr
->sh_entsize
5598 == sizeof (Elf_External_Rela
));
5600 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5601 elf_swap_reloca_in (abfd
, erela
, &irela
);
5602 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5603 ELF_R_TYPE (irela
.r_info
));
5604 elf_swap_reloca_out (abfd
, &irela
, erela
);
5608 /* Set the reloc_count field to 0 to prevent write_relocs from
5609 trying to swap the relocs out itself. */
5613 /* If we are linking against a dynamic object, or generating a
5614 shared library, finish up the dynamic linking information. */
5617 Elf_External_Dyn
*dyncon
, *dynconend
;
5619 /* Fix up .dynamic entries. */
5620 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5621 BFD_ASSERT (o
!= NULL
);
5623 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5624 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5625 for (; dyncon
< dynconend
; dyncon
++)
5627 Elf_Internal_Dyn dyn
;
5631 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5638 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5639 magic _init and _fini symbols. This is pretty ugly,
5640 but we are compatible. */
5648 struct elf_link_hash_entry
*h
;
5650 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
5651 false, false, true);
5652 BFD_ASSERT (h
!= NULL
);
5653 if (h
->root
.type
== bfd_link_hash_defined
)
5655 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
5656 o
= h
->root
.u
.def
.section
;
5657 if (o
->output_section
!= NULL
)
5658 dyn
.d_un
.d_val
+= (o
->output_section
->vma
5659 + o
->output_offset
);
5661 dyn
.d_un
.d_val
+= o
->vma
;
5663 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5676 o
= bfd_get_section_by_name (abfd
, name
);
5677 BFD_ASSERT (o
!= NULL
);
5678 dyn
.d_un
.d_ptr
= o
->vma
;
5679 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5686 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5691 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5693 Elf_Internal_Shdr
*hdr
;
5695 hdr
= elf_elfsections (abfd
)[i
];
5696 if (hdr
->sh_type
== type
5697 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5699 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5700 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5703 if (dyn
.d_un
.d_val
== 0
5704 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5705 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5709 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5715 /* If we have created any dynamic sections, then output them. */
5718 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5721 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5723 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5724 || o
->_raw_size
== 0)
5726 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5728 /* At this point, we are only interested in sections
5729 created by elf_link_create_dynamic_sections. FIXME:
5730 This test is fragile. */
5733 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
5735 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
5737 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5738 o
->contents
, o
->output_offset
,
5746 /* The contents of the .dynstr section are actually in a
5748 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
5749 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
5750 || ! _bfd_stringtab_emit (abfd
,
5751 elf_hash_table (info
)->dynstr
))
5757 if (finfo
.symstrtab
!= NULL
)
5758 _bfd_stringtab_free (finfo
.symstrtab
);
5759 if (finfo
.contents
!= NULL
)
5760 free (finfo
.contents
);
5761 if (finfo
.external_relocs
!= NULL
)
5762 free (finfo
.external_relocs
);
5763 if (finfo
.internal_relocs
!= NULL
)
5764 free (finfo
.internal_relocs
);
5765 if (finfo
.external_syms
!= NULL
)
5766 free (finfo
.external_syms
);
5767 if (finfo
.internal_syms
!= NULL
)
5768 free (finfo
.internal_syms
);
5769 if (finfo
.indices
!= NULL
)
5770 free (finfo
.indices
);
5771 if (finfo
.sections
!= NULL
)
5772 free (finfo
.sections
);
5773 if (finfo
.symbuf
!= NULL
)
5774 free (finfo
.symbuf
);
5775 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5777 if ((o
->flags
& SEC_RELOC
) != 0
5778 && elf_section_data (o
)->rel_hashes
!= NULL
)
5779 free (elf_section_data (o
)->rel_hashes
);
5782 elf_tdata (abfd
)->linker
= true;
5787 if (finfo
.symstrtab
!= NULL
)
5788 _bfd_stringtab_free (finfo
.symstrtab
);
5789 if (finfo
.contents
!= NULL
)
5790 free (finfo
.contents
);
5791 if (finfo
.external_relocs
!= NULL
)
5792 free (finfo
.external_relocs
);
5793 if (finfo
.internal_relocs
!= NULL
)
5794 free (finfo
.internal_relocs
);
5795 if (finfo
.external_syms
!= NULL
)
5796 free (finfo
.external_syms
);
5797 if (finfo
.internal_syms
!= NULL
)
5798 free (finfo
.internal_syms
);
5799 if (finfo
.indices
!= NULL
)
5800 free (finfo
.indices
);
5801 if (finfo
.sections
!= NULL
)
5802 free (finfo
.sections
);
5803 if (finfo
.symbuf
!= NULL
)
5804 free (finfo
.symbuf
);
5805 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5807 if ((o
->flags
& SEC_RELOC
) != 0
5808 && elf_section_data (o
)->rel_hashes
!= NULL
)
5809 free (elf_section_data (o
)->rel_hashes
);
5815 /* Add a symbol to the output symbol table. */
5818 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5819 struct elf_final_link_info
*finfo
;
5821 Elf_Internal_Sym
*elfsym
;
5822 asection
*input_sec
;
5824 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5825 struct bfd_link_info
*info
,
5830 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5831 elf_backend_link_output_symbol_hook
;
5832 if (output_symbol_hook
!= NULL
)
5834 if (! ((*output_symbol_hook
)
5835 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5839 if (name
== (const char *) NULL
|| *name
== '\0')
5840 elfsym
->st_name
= 0;
5843 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
5846 if (elfsym
->st_name
== (unsigned long) -1)
5850 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5852 if (! elf_link_flush_output_syms (finfo
))
5856 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5857 finfo
->symbuf
+ finfo
->symbuf_count
);
5858 ++finfo
->symbuf_count
;
5860 ++finfo
->output_bfd
->symcount
;
5865 /* Flush the output symbols to the file. */
5868 elf_link_flush_output_syms (finfo
)
5869 struct elf_final_link_info
*finfo
;
5871 Elf_Internal_Shdr
*symtab
;
5873 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5875 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5877 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5878 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5879 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5882 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5884 finfo
->symbuf_count
= 0;
5889 /* Add an external symbol to the symbol table. This is called from
5890 the hash table traversal routine. */
5893 elf_link_output_extsym (h
, data
)
5894 struct elf_link_hash_entry
*h
;
5897 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5899 Elf_Internal_Sym sym
;
5900 asection
*input_sec
;
5902 /* We don't want to output symbols that have never been mentioned by
5903 a regular file, or that we have been told to strip. However, if
5904 h->indx is set to -2, the symbol is used by a reloc and we must
5908 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5909 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5910 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5911 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5913 else if (finfo
->info
->strip
== strip_all
5914 || (finfo
->info
->strip
== strip_some
5915 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5916 h
->root
.root
.string
,
5917 false, false) == NULL
))
5922 /* If we're stripping it, and it's not a dynamic symbol, there's
5923 nothing else to do. */
5924 if (strip
&& h
->dynindx
== -1)
5928 sym
.st_size
= h
->size
;
5930 if (h
->root
.type
== bfd_link_hash_weak
5931 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5932 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5934 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5936 switch (h
->root
.type
)
5939 case bfd_link_hash_new
:
5943 case bfd_link_hash_undefined
:
5944 input_sec
= bfd_und_section_ptr
;
5945 sym
.st_shndx
= SHN_UNDEF
;
5948 case bfd_link_hash_weak
:
5949 input_sec
= bfd_und_section_ptr
;
5950 sym
.st_shndx
= SHN_UNDEF
;
5953 case bfd_link_hash_defined
:
5955 input_sec
= h
->root
.u
.def
.section
;
5956 if (input_sec
->output_section
!= NULL
)
5959 elf_section_from_bfd_section (finfo
->output_bfd
,
5960 input_sec
->output_section
);
5961 if (sym
.st_shndx
== (unsigned short) -1)
5963 /* FIXME: No way to handle errors. */
5967 /* ELF symbols in relocateable files are section relative,
5968 but in nonrelocateable files they are virtual
5970 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5971 if (! finfo
->info
->relocateable
)
5972 sym
.st_value
+= input_sec
->output_section
->vma
;
5976 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
5977 == bfd_target_elf_flavour
)
5978 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5979 sym
.st_shndx
= SHN_UNDEF
;
5980 input_sec
= bfd_und_section_ptr
;
5985 case bfd_link_hash_common
:
5986 input_sec
= bfd_com_section_ptr
;
5987 sym
.st_shndx
= SHN_COMMON
;
5988 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
5991 case bfd_link_hash_indirect
:
5992 case bfd_link_hash_warning
:
5993 /* I have no idea how these should be handled. */
5997 /* If this symbol should be put in the .dynsym section, then put it
5998 there now. We have already know the symbol index. We also fill
5999 in the entry in the .hash section. */
6000 if (h
->dynindx
!= -1
6001 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6003 struct elf_backend_data
*bed
;
6006 bfd_byte
*bucketpos
;
6009 sym
.st_name
= h
->dynstr_index
;
6011 /* Give the processor backend a chance to tweak the symbol
6012 value, and also to finish up anything that needs to be done
6014 bed
= get_elf_backend_data (finfo
->output_bfd
);
6015 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
6016 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
6018 /* FIXME: No way to return error. */
6022 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
6023 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
6026 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6027 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
6029 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6030 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
6031 chain
= get_word (finfo
->output_bfd
, bucketpos
);
6032 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
6033 put_word (finfo
->output_bfd
, chain
,
6034 ((bfd_byte
*) finfo
->hash_sec
->contents
6035 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
6038 /* If we're stripping it, then it was just a dynamic symbol, and
6039 there's nothing else to do. */
6043 h
->indx
= finfo
->output_bfd
->symcount
;
6045 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6047 /* FIXME: No way to return error. */
6054 /* Link an input file into the linker output file. This function
6055 handles all the sections and relocations of the input file at once.
6056 This is so that we only have to read the local symbols once, and
6057 don't have to keep them in memory. */
6060 elf_link_input_bfd (finfo
, input_bfd
)
6061 struct elf_final_link_info
*finfo
;
6064 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6065 bfd
*, asection
*, bfd_byte
*,
6066 Elf_Internal_Rela
*,
6067 Elf_Internal_Sym
*, asection
**));
6069 Elf_Internal_Shdr
*symtab_hdr
;
6072 Elf_External_Sym
*esym
;
6073 Elf_External_Sym
*esymend
;
6074 Elf_Internal_Sym
*isym
;
6076 asection
**ppsection
;
6079 output_bfd
= finfo
->output_bfd
;
6081 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6083 /* If this is a dynamic object, we don't want to do anything here:
6084 we don't want the local symbols, and we don't want the section
6086 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6089 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6090 if (elf_bad_symtab (input_bfd
))
6092 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6097 locsymcount
= symtab_hdr
->sh_info
;
6098 extsymoff
= symtab_hdr
->sh_info
;
6101 /* Read the local symbols. */
6103 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6104 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6105 locsymcount
, input_bfd
)
6106 != locsymcount
* sizeof (Elf_External_Sym
))))
6109 /* Swap in the local symbols and write out the ones which we know
6110 are going into the output file. */
6111 esym
= finfo
->external_syms
;
6112 esymend
= esym
+ locsymcount
;
6113 isym
= finfo
->internal_syms
;
6114 pindex
= finfo
->indices
;
6115 ppsection
= finfo
->sections
;
6116 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6120 Elf_Internal_Sym osym
;
6122 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6125 if (elf_bad_symtab (input_bfd
))
6127 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6134 if (isym
->st_shndx
== SHN_UNDEF
)
6135 isec
= bfd_und_section_ptr
;
6136 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6137 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6138 else if (isym
->st_shndx
== SHN_ABS
)
6139 isec
= bfd_abs_section_ptr
;
6140 else if (isym
->st_shndx
== SHN_COMMON
)
6141 isec
= bfd_com_section_ptr
;
6150 /* Don't output the first, undefined, symbol. */
6151 if (esym
== finfo
->external_syms
)
6154 /* If we are stripping all symbols, we don't want to output this
6156 if (finfo
->info
->strip
== strip_all
)
6159 /* We never output section symbols. Instead, we use the section
6160 symbol of the corresponding section in the output file. */
6161 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6164 /* If we are discarding all local symbols, we don't want to
6165 output this one. If we are generating a relocateable output
6166 file, then some of the local symbols may be required by
6167 relocs; we output them below as we discover that they are
6169 if (finfo
->info
->discard
== discard_all
)
6172 /* Get the name of the symbol. */
6173 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6178 /* See if we are discarding symbols with this name. */
6179 if ((finfo
->info
->strip
== strip_some
6180 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6182 || (finfo
->info
->discard
== discard_l
6183 && strncmp (name
, finfo
->info
->lprefix
,
6184 finfo
->info
->lprefix_len
) == 0))
6187 /* If we get here, we are going to output this symbol. */
6191 /* Adjust the section index for the output file. */
6192 osym
.st_shndx
= elf_section_from_bfd_section (output_bfd
,
6193 isec
->output_section
);
6194 if (osym
.st_shndx
== (unsigned short) -1)
6197 *pindex
= output_bfd
->symcount
;
6199 /* ELF symbols in relocateable files are section relative, but
6200 in executable files they are virtual addresses. Note that
6201 this code assumes that all ELF sections have an associated
6202 BFD section with a reasonable value for output_offset; below
6203 we assume that they also have a reasonable value for
6204 output_section. Any special sections must be set up to meet
6205 these requirements. */
6206 osym
.st_value
+= isec
->output_offset
;
6207 if (! finfo
->info
->relocateable
)
6208 osym
.st_value
+= isec
->output_section
->vma
;
6210 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6214 /* Relocate the contents of each section. */
6215 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6217 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6220 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6221 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6223 /* Section was created by elf_link_create_dynamic_sections.
6224 FIXME: This test is fragile. */
6228 /* Read the contents of the section. */
6229 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6230 (file_ptr
) 0, o
->_raw_size
))
6233 if ((o
->flags
& SEC_RELOC
) != 0)
6235 Elf_Internal_Rela
*internal_relocs
;
6237 /* Get the swapped relocs. */
6238 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6239 finfo
->external_relocs
,
6240 finfo
->internal_relocs
,
6242 if (internal_relocs
== NULL
6243 && o
->reloc_count
> 0)
6246 /* Relocate the section by invoking a back end routine.
6248 The back end routine is responsible for adjusting the
6249 section contents as necessary, and (if using Rela relocs
6250 and generating a relocateable output file) adjusting the
6251 reloc addend as necessary.
6253 The back end routine does not have to worry about setting
6254 the reloc address or the reloc symbol index.
6256 The back end routine is given a pointer to the swapped in
6257 internal symbols, and can access the hash table entries
6258 for the external symbols via elf_sym_hashes (input_bfd).
6260 When generating relocateable output, the back end routine
6261 must handle STB_LOCAL/STT_SECTION symbols specially. The
6262 output symbol is going to be a section symbol
6263 corresponding to the output section, which will require
6264 the addend to be adjusted. */
6266 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6270 finfo
->internal_syms
,
6274 if (finfo
->info
->relocateable
)
6276 Elf_Internal_Rela
*irela
;
6277 Elf_Internal_Rela
*irelaend
;
6278 struct elf_link_hash_entry
**rel_hash
;
6279 Elf_Internal_Shdr
*input_rel_hdr
;
6280 Elf_Internal_Shdr
*output_rel_hdr
;
6282 /* Adjust the reloc addresses and symbol indices. */
6284 irela
= internal_relocs
;
6285 irelaend
= irela
+ o
->reloc_count
;
6286 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6287 + o
->output_section
->reloc_count
);
6288 for (; irela
< irelaend
; irela
++, rel_hash
++)
6291 Elf_Internal_Sym
*isym
;
6294 irela
->r_offset
+= o
->output_offset
;
6296 r_symndx
= ELF_R_SYM (irela
->r_info
);
6301 if (r_symndx
>= locsymcount
6302 || (elf_bad_symtab (input_bfd
)
6303 && finfo
->sections
[r_symndx
] == NULL
))
6307 /* This is a reloc against a global symbol. We
6308 have not yet output all the local symbols, so
6309 we do not know the symbol index of any global
6310 symbol. We set the rel_hash entry for this
6311 reloc to point to the global hash table entry
6312 for this symbol. The symbol index is then
6313 set at the end of elf_bfd_final_link. */
6314 indx
= r_symndx
- extsymoff
;
6315 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6317 /* Setting the index to -2 tells
6318 elf_link_output_extsym that this symbol is
6320 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6321 (*rel_hash
)->indx
= -2;
6326 /* This is a reloc against a local symbol. */
6329 isym
= finfo
->internal_syms
+ r_symndx
;
6330 sec
= finfo
->sections
[r_symndx
];
6331 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6333 /* I suppose the backend ought to fill in the
6334 section of any STT_SECTION symbol against a
6335 processor specific section. */
6336 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6338 else if (sec
== NULL
|| sec
->owner
== NULL
)
6340 bfd_set_error (bfd_error_bad_value
);
6345 r_symndx
= sec
->output_section
->target_index
;
6352 if (finfo
->indices
[r_symndx
] == -1)
6358 if (finfo
->info
->strip
== strip_all
)
6360 /* You can't do ld -r -s. */
6361 bfd_set_error (bfd_error_invalid_operation
);
6365 /* This symbol was skipped earlier, but
6366 since it is needed by a reloc, we
6367 must output it now. */
6368 link
= symtab_hdr
->sh_link
;
6369 name
= elf_string_from_elf_section (input_bfd
,
6375 osec
= sec
->output_section
;
6377 elf_section_from_bfd_section (output_bfd
,
6379 if (isym
->st_shndx
== (unsigned short) -1)
6382 isym
->st_value
+= sec
->output_offset
;
6383 if (! finfo
->info
->relocateable
)
6384 isym
->st_value
+= osec
->vma
;
6386 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6388 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6392 r_symndx
= finfo
->indices
[r_symndx
];
6395 irela
->r_info
= ELF_R_INFO (r_symndx
,
6396 ELF_R_TYPE (irela
->r_info
));
6399 /* Swap out the relocs. */
6400 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6401 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6402 BFD_ASSERT (output_rel_hdr
->sh_entsize
6403 == input_rel_hdr
->sh_entsize
);
6404 irela
= internal_relocs
;
6405 irelaend
= irela
+ o
->reloc_count
;
6406 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6408 Elf_External_Rel
*erel
;
6410 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6411 + o
->output_section
->reloc_count
);
6412 for (; irela
< irelaend
; irela
++, erel
++)
6414 Elf_Internal_Rel irel
;
6416 irel
.r_offset
= irela
->r_offset
;
6417 irel
.r_info
= irela
->r_info
;
6418 BFD_ASSERT (irela
->r_addend
== 0);
6419 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6424 Elf_External_Rela
*erela
;
6426 BFD_ASSERT (input_rel_hdr
->sh_entsize
6427 == sizeof (Elf_External_Rela
));
6428 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6429 + o
->output_section
->reloc_count
);
6430 for (; irela
< irelaend
; irela
++, erela
++)
6431 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6434 o
->output_section
->reloc_count
+= o
->reloc_count
;
6438 /* Write out the modified section contents. */
6439 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6440 finfo
->contents
, o
->output_offset
,
6441 (o
->_cooked_size
!= 0
6450 /* Generate a reloc when linking an ELF file. This is a reloc
6451 requested by the linker, and does come from any input file. This
6452 is used to build constructor and destructor tables when linking
6456 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6458 struct bfd_link_info
*info
;
6459 asection
*output_section
;
6460 struct bfd_link_order
*link_order
;
6462 const reloc_howto_type
*howto
;
6465 struct elf_link_hash_entry
**rel_hash_ptr
;
6466 Elf_Internal_Shdr
*rel_hdr
;
6468 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6471 bfd_set_error (bfd_error_bad_value
);
6475 /* If this is an inplace reloc, we must write the addend into the
6477 if (howto
->partial_inplace
6478 && link_order
->u
.reloc
.p
->addend
!= 0)
6481 bfd_reloc_status_type rstat
;
6485 size
= bfd_get_reloc_size (howto
);
6486 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6487 if (buf
== (bfd_byte
*) NULL
)
6489 bfd_set_error (bfd_error_no_memory
);
6492 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6493 link_order
->u
.reloc
.p
->addend
, buf
);
6499 case bfd_reloc_outofrange
:
6501 case bfd_reloc_overflow
:
6502 if (! ((*info
->callbacks
->reloc_overflow
)
6504 (link_order
->type
== bfd_section_reloc_link_order
6505 ? bfd_section_name (output_bfd
,
6506 link_order
->u
.reloc
.p
->u
.section
)
6507 : link_order
->u
.reloc
.p
->u
.name
),
6508 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6509 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6516 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6517 (file_ptr
) link_order
->offset
, size
);
6523 /* Figure out the symbol index. */
6524 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6525 + output_section
->reloc_count
);
6526 if (link_order
->type
== bfd_section_reloc_link_order
)
6528 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6531 *rel_hash_ptr
= NULL
;
6535 struct elf_link_hash_entry
*h
;
6537 h
= elf_link_hash_lookup (elf_hash_table (info
),
6538 link_order
->u
.reloc
.p
->u
.name
,
6539 false, false, true);
6542 /* Setting the index to -2 tells elf_link_output_extsym that
6543 this symbol is used by a reloc. */
6550 if (! ((*info
->callbacks
->unattached_reloc
)
6551 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6552 (asection
*) NULL
, (bfd_vma
) 0)))
6558 /* The address of a reloc is relative to the section in a
6559 relocateable file, and is a virtual address in an executable
6561 offset
= link_order
->offset
;
6562 if (! info
->relocateable
)
6563 offset
+= output_section
->vma
;
6565 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6567 if (rel_hdr
->sh_type
== SHT_REL
)
6569 Elf_Internal_Rel irel
;
6570 Elf_External_Rel
*erel
;
6572 irel
.r_offset
= offset
;
6573 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6574 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6575 + output_section
->reloc_count
);
6576 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6580 Elf_Internal_Rela irela
;
6581 Elf_External_Rela
*erela
;
6583 irela
.r_offset
= offset
;
6584 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6585 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6586 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6587 + output_section
->reloc_count
);
6588 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6591 ++output_section
->reloc_count
;