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
62 #include <string.h> /* For strrchr and friends */
69 /* Renaming structures, typedefs, macros and functions to be size-specific. */
70 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
71 #define Elf_External_Sym NAME(Elf,External_Sym)
72 #define Elf_External_Shdr NAME(Elf,External_Shdr)
73 #define Elf_External_Phdr NAME(Elf,External_Phdr)
74 #define Elf_External_Rel NAME(Elf,External_Rel)
75 #define Elf_External_Rela NAME(Elf,External_Rela)
76 #define Elf_External_Dyn NAME(Elf,External_Dyn)
78 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
79 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
80 #define elf_core_file_matches_executable_p \
81 NAME(bfd_elf,core_file_matches_executable_p)
82 #define elf_object_p NAME(bfd_elf,object_p)
83 #define elf_core_file_p NAME(bfd_elf,core_file_p)
84 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
85 #define elf_get_dynamic_symtab_upper_bound \
86 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
87 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
88 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
89 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
90 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
91 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
92 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
93 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
94 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
95 #define elf_get_symtab NAME(bfd_elf,get_symtab)
96 #define elf_canonicalize_dynamic_symtab \
97 NAME(bfd_elf,canonicalize_dynamic_symtab)
98 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
99 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
100 #define elf_print_symbol NAME(bfd_elf,print_symbol)
101 #define elf_get_lineno NAME(bfd_elf,get_lineno)
102 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
103 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
104 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
105 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
106 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
107 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
108 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
109 #define write_relocs NAME(bfd_elf,_write_relocs)
110 #define elf_find_section NAME(bfd_elf,find_section)
111 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
112 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
113 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
116 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
117 #define ELF_R_SYM(X) ELF64_R_SYM(X)
118 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
119 #define ELFCLASS ELFCLASS64
121 #define LOG_FILE_ALIGN 3
124 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
125 #define ELF_R_SYM(X) ELF32_R_SYM(X)
126 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
127 #define ELFCLASS ELFCLASS32
129 #define LOG_FILE_ALIGN 2
132 /* Forward declarations of static functions */
134 static unsigned long bfd_add_to_strtab
135 PARAMS ((bfd
*, struct strtab
*, const char *));
136 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
138 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
140 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
142 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
143 struct symbol_cache_entry
**));
145 static boolean elf_compute_section_file_positions
146 PARAMS ((bfd
*, struct bfd_link_info
*));
147 static boolean prep_headers
PARAMS ((bfd
*));
148 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
149 static boolean assign_section_numbers
PARAMS ((bfd
*));
150 static file_ptr align_file_position
PARAMS ((file_ptr
));
151 static file_ptr assign_file_position_for_section
152 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
153 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
154 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
155 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
156 static file_ptr map_program_segments
157 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
159 static boolean elf_map_symbols
PARAMS ((bfd
*));
160 static boolean swap_out_syms
PARAMS ((bfd
*));
162 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
165 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
166 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
169 #define elf_string_from_elf_strtab(abfd,strindex) \
170 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
173 /* Structure swapping routines */
175 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
176 can be handled by explicitly specifying 32 bits or "the long type". */
178 #define put_word bfd_h_put_64
179 #define get_word bfd_h_get_64
182 #define put_word bfd_h_put_32
183 #define get_word bfd_h_get_32
186 /* Translate an ELF symbol in external format into an ELF symbol in internal
190 elf_swap_symbol_in (abfd
, src
, dst
)
192 Elf_External_Sym
*src
;
193 Elf_Internal_Sym
*dst
;
195 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
196 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
197 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
198 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
199 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
200 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
203 /* Translate an ELF symbol in internal format into an ELF symbol in external
207 elf_swap_symbol_out (abfd
, src
, dst
)
209 Elf_Internal_Sym
*src
;
210 Elf_External_Sym
*dst
;
212 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
213 put_word (abfd
, src
->st_value
, dst
->st_value
);
214 put_word (abfd
, src
->st_size
, dst
->st_size
);
215 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
216 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
217 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
221 /* Translate an ELF file header in external format into an ELF file header in
225 elf_swap_ehdr_in (abfd
, src
, dst
)
227 Elf_External_Ehdr
*src
;
228 Elf_Internal_Ehdr
*dst
;
230 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
231 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
232 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
233 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
234 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
235 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
236 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
237 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
238 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
239 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
240 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
241 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
242 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
243 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
246 /* Translate an ELF file header in internal format into an ELF file header in
250 elf_swap_ehdr_out (abfd
, src
, dst
)
252 Elf_Internal_Ehdr
*src
;
253 Elf_External_Ehdr
*dst
;
255 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
256 /* note that all elements of dst are *arrays of unsigned char* already... */
257 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
258 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
259 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
260 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
261 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
262 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
263 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
264 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
265 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
266 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
267 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
268 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
269 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
273 /* Translate an ELF section header table entry in external format into an
274 ELF section header table entry in internal format. */
277 elf_swap_shdr_in (abfd
, src
, dst
)
279 Elf_External_Shdr
*src
;
280 Elf_Internal_Shdr
*dst
;
282 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
283 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
284 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
285 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
286 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
287 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
288 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
289 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
290 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
291 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
292 /* we haven't done any processing on it yet, so... */
293 dst
->rawdata
= (void *) 0;
296 /* Translate an ELF section header table entry in internal format into an
297 ELF section header table entry in external format. */
300 elf_swap_shdr_out (abfd
, src
, dst
)
302 Elf_Internal_Shdr
*src
;
303 Elf_External_Shdr
*dst
;
305 /* note that all elements of dst are *arrays of unsigned char* already... */
306 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
307 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
308 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
309 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
310 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
311 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
312 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
313 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
314 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
315 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
319 /* Translate an ELF program header table entry in external format into an
320 ELF program header table entry in internal format. */
323 elf_swap_phdr_in (abfd
, src
, dst
)
325 Elf_External_Phdr
*src
;
326 Elf_Internal_Phdr
*dst
;
328 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
329 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
330 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
331 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
332 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
333 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
334 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
335 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
339 elf_swap_phdr_out (abfd
, src
, dst
)
341 Elf_Internal_Phdr
*src
;
342 Elf_External_Phdr
*dst
;
344 /* note that all elements of dst are *arrays of unsigned char* already... */
345 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
346 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
347 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
348 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
349 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
350 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
351 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
352 put_word (abfd
, src
->p_align
, dst
->p_align
);
355 /* Translate an ELF reloc from external format to internal format. */
357 elf_swap_reloc_in (abfd
, src
, dst
)
359 Elf_External_Rel
*src
;
360 Elf_Internal_Rel
*dst
;
362 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
363 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
367 elf_swap_reloca_in (abfd
, src
, dst
)
369 Elf_External_Rela
*src
;
370 Elf_Internal_Rela
*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
);
374 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
377 /* Translate an ELF reloc from internal format to external format. */
379 elf_swap_reloc_out (abfd
, src
, dst
)
381 Elf_Internal_Rel
*src
;
382 Elf_External_Rel
*dst
;
384 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
385 put_word (abfd
, src
->r_info
, dst
->r_info
);
389 elf_swap_reloca_out (abfd
, src
, dst
)
391 Elf_Internal_Rela
*src
;
392 Elf_External_Rela
*dst
;
394 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
395 put_word (abfd
, src
->r_info
, dst
->r_info
);
396 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
400 elf_swap_dyn_in (abfd
, src
, dst
)
402 const Elf_External_Dyn
*src
;
403 Elf_Internal_Dyn
*dst
;
405 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
406 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
410 elf_swap_dyn_out (abfd
, src
, dst
)
412 const Elf_Internal_Dyn
*src
;
413 Elf_External_Dyn
*dst
;
415 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
416 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
419 /* String table creation/manipulation routines */
421 static struct strtab
*
422 bfd_new_strtab (abfd
)
427 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
430 bfd_set_error (bfd_error_no_memory
);
433 ss
->tab
= malloc (1);
436 bfd_set_error (bfd_error_no_memory
);
447 bfd_add_to_strtab (abfd
, ss
, str
)
452 /* should search first, but for now: */
453 /* include the trailing NUL */
454 int ln
= strlen (str
) + 1;
456 /* FIXME: This is slow. Also, we could combine this with the a.out
457 string table building and use a hash table, although it might not
458 be worth it since ELF symbols don't include debugging information
459 and thus have much less overlap. */
460 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
463 bfd_set_error (bfd_error_no_memory
);
464 return (unsigned long) -1;
467 strcpy (ss
->tab
+ ss
->length
, str
);
471 return ss
->length
- ln
;
475 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
481 /* should search first, but for now: */
482 /* include the trailing NUL */
483 int ln
= strlen (str
) + strlen (str2
) + 1;
485 /* should this be using obstacks? */
487 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
489 ss
->tab
= malloc (ln
);
491 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
492 strcpy (ss
->tab
+ ss
->length
, str
);
493 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
497 return ss
->length
- ln
;
500 /* ELF .o/exec file reading */
502 /* Create a new bfd section from an ELF section header. */
505 bfd_section_from_shdr (abfd
, shindex
)
507 unsigned int shindex
;
509 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
510 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
513 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
515 switch (hdr
->sh_type
)
518 /* Inactive section. Throw it away. */
521 case SHT_PROGBITS
: /* Normal section with contents. */
522 case SHT_DYNAMIC
: /* Dynamic linking information. */
523 case SHT_NOBITS
: /* .bss section. */
524 case SHT_HASH
: /* .hash section. */
525 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
527 case SHT_SYMTAB
: /* A symbol table */
528 if (elf_onesymtab (abfd
) == shindex
)
531 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
532 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
533 elf_onesymtab (abfd
) = shindex
;
534 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
535 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
536 abfd
->flags
|= HAS_SYMS
;
539 case SHT_DYNSYM
: /* A dynamic symbol table */
540 if (elf_dynsymtab (abfd
) == shindex
)
543 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
544 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
545 elf_dynsymtab (abfd
) = shindex
;
546 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
547 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
548 abfd
->flags
|= HAS_SYMS
;
550 /* Besides being a symbol table, we also treat this as a regular
551 section, so that objcopy can handle it. */
552 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
554 case SHT_STRTAB
: /* A string table */
555 if (hdr
->rawdata
!= NULL
)
557 if (ehdr
->e_shstrndx
== shindex
)
559 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
560 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
561 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
567 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
569 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
570 if (hdr2
->sh_link
== shindex
)
572 if (! bfd_section_from_shdr (abfd
, i
))
574 if (elf_onesymtab (abfd
) == i
)
576 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
577 elf_elfsections (abfd
)[shindex
] =
578 &elf_tdata (abfd
)->strtab_hdr
;
581 if (elf_dynsymtab (abfd
) == i
)
583 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
584 elf_elfsections (abfd
)[shindex
] =
585 &elf_tdata (abfd
)->dynstrtab_hdr
;
586 /* We also treat this as a regular section, so
587 that objcopy can handle it. */
590 #if 0 /* Not handling other string tables specially right now. */
591 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
592 /* We have a strtab for some random other section. */
593 newsect
= (asection
*) hdr2
->rawdata
;
596 hdr
->rawdata
= (PTR
) newsect
;
597 hdr2
= &elf_section_data (newsect
)->str_hdr
;
599 elf_elfsections (abfd
)[shindex
] = hdr2
;
605 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
609 /* *These* do a lot of work -- but build no sections! */
611 asection
*target_sect
;
612 Elf_Internal_Shdr
*hdr2
;
613 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
615 /* Get the symbol table. */
616 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
619 /* If this reloc section does not use the main symbol table we
620 don't treat it as a reloc section. BFD can't adequately
621 represent such a section, so at least for now, we don't
622 try. We just present it as a normal section. */
623 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
624 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
626 /* Don't allow REL relocations on a machine that uses RELA and
628 /* @@ Actually, the generic ABI does suggest that both might be
629 used in one file. But the four ABI Processor Supplements I
630 have access to right now all specify that only one is used on
631 each of those architectures. It's conceivable that, e.g., a
632 bunch of absolute 32-bit relocs might be more compact in REL
633 form even on a RELA machine... */
634 BFD_ASSERT (use_rela_p
635 ? (hdr
->sh_type
== SHT_RELA
636 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
637 : (hdr
->sh_type
== SHT_REL
638 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
640 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
642 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
643 if (target_sect
== NULL
644 || elf_section_data (target_sect
) == NULL
)
647 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
649 elf_elfsections (abfd
)[shindex
] = hdr2
;
650 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
651 target_sect
->flags
|= SEC_RELOC
;
652 target_sect
->relocation
= NULL
;
653 target_sect
->rel_filepos
= hdr
->sh_offset
;
654 abfd
->flags
|= HAS_RELOC
;
661 fprintf (stderr
, "Note Sections not yet supported.\n");
668 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
673 /* Check for any processor-specific section types. */
675 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
677 if (bed
->elf_backend_section_from_shdr
)
678 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
687 elf_new_section_hook (abfd
, sec
)
692 struct bfd_elf_section_data
*sdata
;
694 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
697 bfd_set_error (bfd_error_no_memory
);
700 sec
->used_by_bfd
= (PTR
) sdata
;
701 memset (sdata
, 0, sizeof (*sdata
));
705 /* Create a new bfd section from an ELF program header.
707 Since program segments have no names, we generate a synthetic name
708 of the form segment<NUM>, where NUM is generally the index in the
709 program header table. For segments that are split (see below) we
710 generate the names segment<NUM>a and segment<NUM>b.
712 Note that some program segments may have a file size that is different than
713 (less than) the memory size. All this means is that at execution the
714 system must allocate the amount of memory specified by the memory size,
715 but only initialize it with the first "file size" bytes read from the
716 file. This would occur for example, with program segments consisting
717 of combined data+bss.
719 To handle the above situation, this routine generates TWO bfd sections
720 for the single program segment. The first has the length specified by
721 the file size of the segment, and the second has the length specified
722 by the difference between the two sizes. In effect, the segment is split
723 into it's initialized and uninitialized parts.
728 bfd_section_from_phdr (abfd
, hdr
, index
)
730 Elf_Internal_Phdr
*hdr
;
738 split
= ((hdr
->p_memsz
> 0) &&
739 (hdr
->p_filesz
> 0) &&
740 (hdr
->p_memsz
> hdr
->p_filesz
));
741 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
742 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
745 bfd_set_error (bfd_error_no_memory
);
748 strcpy (name
, namebuf
);
749 newsect
= bfd_make_section (abfd
, name
);
752 newsect
->vma
= hdr
->p_vaddr
;
753 newsect
->_raw_size
= hdr
->p_filesz
;
754 newsect
->filepos
= hdr
->p_offset
;
755 newsect
->flags
|= SEC_HAS_CONTENTS
;
756 if (hdr
->p_type
== PT_LOAD
)
758 newsect
->flags
|= SEC_ALLOC
;
759 newsect
->flags
|= SEC_LOAD
;
760 if (hdr
->p_flags
& PF_X
)
762 /* FIXME: all we known is that it has execute PERMISSION,
764 newsect
->flags
|= SEC_CODE
;
767 if (!(hdr
->p_flags
& PF_W
))
769 newsect
->flags
|= SEC_READONLY
;
774 sprintf (namebuf
, "segment%db", index
);
775 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
778 bfd_set_error (bfd_error_no_memory
);
781 strcpy (name
, namebuf
);
782 newsect
= bfd_make_section (abfd
, name
);
785 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
786 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
787 if (hdr
->p_type
== PT_LOAD
)
789 newsect
->flags
|= SEC_ALLOC
;
790 if (hdr
->p_flags
& PF_X
)
791 newsect
->flags
|= SEC_CODE
;
793 if (!(hdr
->p_flags
& PF_W
))
794 newsect
->flags
|= SEC_READONLY
;
800 /* Begin processing a given object.
802 First we validate the file by reading in the ELF header and checking
805 static INLINE boolean
807 Elf_External_Ehdr
*x_ehdrp
;
809 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
810 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
811 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
812 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
815 /* Check to see if the file associated with ABFD matches the target vector
818 Note that we may be called several times with the same ABFD, but different
819 target vectors, most of which will not match. We have to avoid leaving
820 any side effects in ABFD, or any data it points to (like tdata), if the
821 file does not match the target vector. */
827 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
828 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
829 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
830 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
831 unsigned int shindex
;
832 char *shstrtab
; /* Internal copy of section header stringtab */
833 struct elf_backend_data
*ebd
;
834 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
835 struct elf_obj_tdata
*new_tdata
= NULL
;
837 /* Read in the ELF header in external format. */
839 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
841 if (bfd_get_error () != bfd_error_system_call
)
842 goto got_wrong_format_error
;
847 /* Now check to see if we have a valid ELF file, and one that BFD can
848 make use of. The magic number must match, the address size ('class')
849 and byte-swapping must match our XVEC entry, and it must have a
850 section header table (FIXME: See comments re sections at top of this
853 if ((elf_file_p (&x_ehdr
) == false) ||
854 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
855 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
856 goto got_wrong_format_error
;
858 /* Check that file's byte order matches xvec's */
859 switch (x_ehdr
.e_ident
[EI_DATA
])
861 case ELFDATA2MSB
: /* Big-endian */
862 if (!abfd
->xvec
->header_byteorder_big_p
)
863 goto got_wrong_format_error
;
865 case ELFDATA2LSB
: /* Little-endian */
866 if (abfd
->xvec
->header_byteorder_big_p
)
867 goto got_wrong_format_error
;
869 case ELFDATANONE
: /* No data encoding specified */
870 default: /* Unknown data encoding specified */
871 goto got_wrong_format_error
;
874 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
875 the tdata pointer in the bfd. */
877 new_tdata
= ((struct elf_obj_tdata
*)
878 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
879 if (new_tdata
== NULL
)
880 goto got_no_memory_error
;
881 elf_tdata (abfd
) = new_tdata
;
883 /* Now that we know the byte order, swap in the rest of the header */
884 i_ehdrp
= elf_elfheader (abfd
);
885 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
887 elf_debug_file (i_ehdrp
);
890 /* If there is no section header table, we're hosed. */
891 if (i_ehdrp
->e_shoff
== 0)
892 goto got_wrong_format_error
;
894 /* As a simple sanity check, verify that the what BFD thinks is the
895 size of each section header table entry actually matches the size
896 recorded in the file. */
897 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
898 goto got_wrong_format_error
;
900 ebd
= get_elf_backend_data (abfd
);
902 /* Check that the ELF e_machine field matches what this particular
903 BFD format expects. */
904 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
906 bfd_target
**target_ptr
;
908 if (ebd
->elf_machine_code
!= EM_NONE
)
909 goto got_wrong_format_error
;
911 /* This is the generic ELF target. Let it match any ELF target
912 for which we do not have a specific backend. */
913 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
915 struct elf_backend_data
*back
;
917 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
919 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
920 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
922 /* target_ptr is an ELF backend which matches this
923 object file, so reject the generic ELF target. */
924 goto got_wrong_format_error
;
929 if (i_ehdrp
->e_type
== ET_EXEC
)
930 abfd
->flags
|= EXEC_P
;
931 else if (i_ehdrp
->e_type
== ET_DYN
)
932 abfd
->flags
|= DYNAMIC
;
934 if (i_ehdrp
->e_phnum
> 0)
935 abfd
->flags
|= D_PAGED
;
937 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
940 /* Remember the entry point specified in the ELF file header. */
941 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
943 /* Allocate space for a copy of the section header table in
944 internal form, seek to the section header table in the file,
945 read it in, and convert it to internal form. */
946 i_shdrp
= ((Elf_Internal_Shdr
*)
947 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
948 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
950 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
951 if (!i_shdrp
|| !elf_elfsections (abfd
))
952 goto got_no_memory_error
;
953 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
955 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
957 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
959 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
960 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
962 /* If this is a .dynamic section, mark the object file as being
963 dynamically linked. */
964 if (i_shdrp
[shindex
].sh_type
== SHT_DYNAMIC
)
965 abfd
->flags
|= DYNAMIC
;
967 if (i_ehdrp
->e_shstrndx
)
969 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
973 /* Read in the string table containing the names of the sections. We
974 will need the base pointer to this table later. */
975 /* We read this inline now, so that we don't have to go through
976 bfd_section_from_shdr with it (since this particular strtab is
977 used to find all of the ELF section names.) */
979 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
983 /* Once all of the section headers have been read and converted, we
984 can start processing them. Note that the first section header is
985 a dummy placeholder entry, so we ignore it. */
987 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
989 if (! bfd_section_from_shdr (abfd
, shindex
))
993 /* Let the backend double check the format and override global
995 if (ebd
->elf_backend_object_p
)
997 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
998 goto got_wrong_format_error
;
1001 return (abfd
->xvec
);
1003 got_wrong_format_error
:
1004 bfd_set_error (bfd_error_wrong_format
);
1006 got_no_memory_error
:
1007 bfd_set_error (bfd_error_no_memory
);
1010 if (new_tdata
!= NULL
1011 && new_tdata
->elf_sect_ptr
!= NULL
)
1012 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1013 if (i_shdrp
!= NULL
)
1014 bfd_release (abfd
, i_shdrp
);
1015 if (new_tdata
!= NULL
)
1016 bfd_release (abfd
, new_tdata
);
1017 elf_tdata (abfd
) = preserved_tdata
;
1022 /* ELF .o/exec file writing */
1024 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1025 of the symbol if there is one. */
1026 static INLINE elf_symbol_type
*
1027 elf_symbol_from (ignore_abfd
, symbol
)
1031 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1034 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1037 return (elf_symbol_type
*) symbol
;
1041 write_relocs (abfd
, sec
, xxx
)
1046 Elf_Internal_Shdr
*rela_hdr
;
1047 Elf_External_Rela
*outbound_relocas
;
1048 Elf_External_Rel
*outbound_relocs
;
1050 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1051 asymbol
*last_sym
= 0;
1052 int last_sym_idx
= 9999999; /* should always be written before use */
1054 if ((sec
->flags
& SEC_RELOC
) == 0)
1057 /* The linker backend writes the relocs out itself, and sets the
1058 reloc_count field to zero to inhibit writing them here. Also,
1059 sometimes the SEC_RELOC flag gets set even when there aren't any
1061 if (sec
->reloc_count
== 0)
1064 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1066 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1067 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1068 if (!rela_hdr
->contents
)
1070 bfd_set_error (bfd_error_no_memory
);
1071 abort (); /* FIXME */
1074 /* orelocation has the data, reloc_count has the count... */
1077 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1079 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1081 Elf_Internal_Rela dst_rela
;
1082 Elf_External_Rela
*src_rela
;
1087 ptr
= sec
->orelocation
[idx
];
1088 src_rela
= outbound_relocas
+ idx
;
1089 if (!(abfd
->flags
& EXEC_P
))
1090 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1092 dst_rela
.r_offset
= ptr
->address
;
1094 sym
= *ptr
->sym_ptr_ptr
;
1095 if (sym
== last_sym
)
1100 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1102 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1104 dst_rela
.r_addend
= ptr
->addend
;
1105 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1109 /* REL relocations */
1111 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1113 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1115 Elf_Internal_Rel dst_rel
;
1116 Elf_External_Rel
*src_rel
;
1121 ptr
= sec
->orelocation
[idx
];
1122 sym
= *ptr
->sym_ptr_ptr
;
1123 src_rel
= outbound_relocs
+ idx
;
1124 if (!(abfd
->flags
& EXEC_P
))
1125 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1127 dst_rel
.r_offset
= ptr
->address
;
1129 if (sym
== last_sym
)
1134 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1136 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1138 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1143 /* Set up an ELF internal section header for a section. */
1147 elf_fake_sections (abfd
, asect
, ignore
)
1152 Elf_Internal_Shdr
*this_hdr
;
1154 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1156 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1158 if (this_hdr
->sh_name
== (unsigned long) -1)
1159 abort (); /* FIXME */
1161 this_hdr
->sh_flags
= 0;
1162 if ((asect
->flags
& SEC_ALLOC
) != 0)
1163 this_hdr
->sh_addr
= asect
->vma
;
1165 this_hdr
->sh_addr
= 0;
1166 this_hdr
->sh_offset
= 0;
1167 this_hdr
->sh_size
= asect
->_raw_size
;
1168 this_hdr
->sh_link
= 0;
1169 this_hdr
->sh_info
= 0;
1170 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1171 this_hdr
->sh_entsize
= 0;
1173 this_hdr
->rawdata
= (PTR
) asect
;
1174 this_hdr
->contents
= NULL
;
1177 /* FIXME: This should not be based on section names. */
1178 if (strcmp (asect
->name
, ".dynstr") == 0)
1179 this_hdr
->sh_type
= SHT_STRTAB
;
1180 else if (strcmp (asect
->name
, ".hash") == 0)
1182 this_hdr
->sh_type
= SHT_HASH
;
1183 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1185 else if (strcmp (asect
->name
, ".dynsym") == 0)
1187 this_hdr
->sh_type
= SHT_DYNSYM
;
1188 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1190 else if (strcmp (asect
->name
, ".dynamic") == 0)
1192 this_hdr
->sh_type
= SHT_DYNAMIC
;
1193 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1195 else if (strncmp (asect
->name
, ".rel.", 5) == 0)
1197 this_hdr
->sh_type
= SHT_REL
;
1198 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1200 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1202 this_hdr
->sh_type
= SHT_RELA
;
1203 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1205 else if (strcmp (asect
->name
, ".note") == 0)
1206 this_hdr
->sh_type
= SHT_NOTE
;
1207 else if (strncmp (asect
->name
, ".stab", 5) == 0
1208 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1209 this_hdr
->sh_type
= SHT_STRTAB
;
1210 else if ((asect
->flags
& SEC_ALLOC
) != 0
1211 && (asect
->flags
& SEC_LOAD
) != 0)
1212 this_hdr
->sh_type
= SHT_PROGBITS
;
1213 else if ((asect
->flags
& SEC_ALLOC
) != 0
1214 && ((asect
->flags
& SEC_LOAD
) == 0))
1216 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1217 || strcmp (asect
->name
, ".sbss") == 0);
1218 this_hdr
->sh_type
= SHT_NOBITS
;
1223 this_hdr
->sh_type
= SHT_PROGBITS
;
1226 if ((asect
->flags
& SEC_ALLOC
) != 0)
1227 this_hdr
->sh_flags
|= SHF_ALLOC
;
1228 if ((asect
->flags
& SEC_READONLY
) == 0)
1229 this_hdr
->sh_flags
|= SHF_WRITE
;
1230 if ((asect
->flags
& SEC_CODE
) != 0)
1231 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1233 /* Check for processor-specific section types. */
1235 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1237 if (bed
->elf_backend_fake_sections
)
1238 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1241 /* If the section has relocs, set up a section header for the
1242 SHT_REL[A] section. */
1243 if ((asect
->flags
& SEC_RELOC
) != 0)
1245 Elf_Internal_Shdr
*rela_hdr
;
1246 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1248 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1250 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1251 use_rela_p
? ".rela" : ".rel",
1253 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1254 rela_hdr
->sh_entsize
= (use_rela_p
1255 ? sizeof (Elf_External_Rela
)
1256 : sizeof (Elf_External_Rel
));
1257 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1258 rela_hdr
->sh_flags
= 0;
1259 rela_hdr
->sh_addr
= 0;
1260 rela_hdr
->sh_size
= 0;
1261 rela_hdr
->sh_offset
= 0;
1266 /* Assign all ELF section numbers. The dummy first section is handled here
1267 too. The link/info pointers for the standard section types are filled
1268 in here too, while we're at it. */
1271 assign_section_numbers (abfd
)
1274 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1276 unsigned int section_number
;
1277 Elf_Internal_Shdr
**i_shdrp
;
1281 t
->shstrtab_section
= section_number
++;
1282 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1283 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1284 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1286 if (abfd
->symcount
> 0)
1288 t
->symtab_section
= section_number
++;
1289 t
->strtab_section
= section_number
++;
1292 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1294 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1296 d
->this_idx
= section_number
++;
1297 if ((sec
->flags
& SEC_RELOC
) == 0)
1300 d
->rel_idx
= section_number
++;
1303 elf_elfheader (abfd
)->e_shnum
= section_number
;
1305 /* Set up the list of section header pointers, in agreement with the
1307 i_shdrp
= ((Elf_Internal_Shdr
**)
1308 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1309 if (i_shdrp
== NULL
)
1311 bfd_set_error (bfd_error_no_memory
);
1315 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1316 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1317 if (i_shdrp
[0] == NULL
)
1319 bfd_release (abfd
, i_shdrp
);
1320 bfd_set_error (bfd_error_no_memory
);
1323 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1325 elf_elfsections (abfd
) = i_shdrp
;
1327 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1328 if (abfd
->symcount
> 0)
1330 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1331 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1332 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1334 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1336 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1340 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1341 if (d
->rel_idx
!= 0)
1342 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1344 /* Fill in the sh_link and sh_info fields while we're at it. */
1346 /* sh_link of a reloc section is the section index of the symbol
1347 table. sh_info is the section index of the section to which
1348 the relocation entries apply. */
1349 if (d
->rel_idx
!= 0)
1351 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1352 d
->rel_hdr
.sh_info
= d
->this_idx
;
1355 switch (d
->this_hdr
.sh_type
)
1359 /* A reloc section which we are treating as a normal BFD
1360 section. sh_link is the section index of the symbol
1361 table. sh_info is the section index of the section to
1362 which the relocation entries apply. We assume that an
1363 allocated reloc section uses the dynamic symbol table.
1364 FIXME: How can we be sure? */
1365 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1367 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1369 /* We look up the section the relocs apply to by name. */
1371 if (d
->this_hdr
.sh_type
== SHT_REL
)
1375 s
= bfd_get_section_by_name (abfd
, name
);
1377 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1381 /* We assume that a section named .stab*str is a stabs
1382 string section. We look for a section with the same name
1383 but without the trailing ``str'', and set its sh_link
1384 field to point to this section. */
1385 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1386 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1391 len
= strlen (sec
->name
);
1392 alc
= (char *) malloc (len
- 2);
1395 bfd_set_error (bfd_error_no_memory
);
1398 strncpy (alc
, sec
->name
, len
- 3);
1399 alc
[len
- 3] = '\0';
1400 s
= bfd_get_section_by_name (abfd
, alc
);
1404 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1406 /* This is a .stab section. */
1407 elf_section_data (s
)->this_hdr
.sh_entsize
=
1408 4 + 2 * (ARCH_SIZE
/ 8);
1415 /* sh_link is the section header index of the string table
1416 used for the dynamic entries or symbol table. */
1417 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1419 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1423 /* sh_link is the section header index of the symbol table
1424 this hash table is for. */
1425 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1427 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1435 /* Map symbol from it's internal number to the external number, moving
1436 all local symbols to be at the head of the list. */
1439 sym_is_global (abfd
, sym
)
1443 /* If the backend has a special mapping, use it. */
1444 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1445 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1448 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1450 if (sym
->flags
& BSF_LOCAL
)
1454 if (sym
->section
== 0)
1456 /* Is this valid? */
1461 if (sym
->section
== &bfd_und_section
)
1463 if (bfd_is_com_section (sym
->section
))
1465 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1471 elf_map_symbols (abfd
)
1474 int symcount
= bfd_get_symcount (abfd
);
1475 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1476 asymbol
**sect_syms
;
1478 int num_globals
= 0;
1479 int num_locals2
= 0;
1480 int num_globals2
= 0;
1482 int num_sections
= 0;
1483 Elf_Sym_Extra
*sym_extra
;
1488 fprintf (stderr
, "elf_map_symbols\n");
1492 /* Add local symbols for each section for which there are relocs.
1493 FIXME: How can we tell which sections have relocs at this point?
1494 Will reloc_count always be accurate? Actually, I think most ELF
1495 targets create section symbols for all sections anyhow. */
1496 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1498 if (max_index
< asect
->index
)
1499 max_index
= asect
->index
;
1503 elf_num_section_syms (abfd
) = max_index
;
1504 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1505 elf_section_syms (abfd
) = sect_syms
;
1509 bfd_set_error (bfd_error_no_memory
);
1513 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1515 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1518 bfd_set_error (bfd_error_no_memory
);
1521 sym
->the_bfd
= abfd
;
1522 sym
->name
= asect
->name
;
1523 sym
->value
= asect
->vma
;
1524 sym
->flags
= BSF_SECTION_SYM
;
1525 sym
->section
= asect
;
1526 sect_syms
[asect
->index
] = sym
;
1530 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1531 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1538 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1539 ((symcount
+ num_sections
+ 1)
1540 * sizeof (asymbol
*)));
1542 syms
= (asymbol
**) bfd_alloc (abfd
,
1543 (num_sections
+ 1) * sizeof (asymbol
*));
1546 bfd_set_error (bfd_error_no_memory
);
1550 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1552 if (sect_syms
[asect
->index
])
1553 syms
[symcount
++] = sect_syms
[asect
->index
];
1556 syms
[symcount
] = (asymbol
*) 0;
1557 bfd_set_symtab (abfd
, syms
, symcount
);
1560 elf_sym_extra (abfd
) = sym_extra
1561 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1564 bfd_set_error (bfd_error_no_memory
);
1568 /* Identify and classify all of the symbols. */
1569 for (idx
= 0; idx
< symcount
; idx
++)
1571 if (!sym_is_global (abfd
, syms
[idx
]))
1577 /* Now provide mapping information. Add +1 for skipping over the
1579 for (idx
= 0; idx
< symcount
; idx
++)
1581 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1582 if (!sym_is_global (abfd
, syms
[idx
]))
1583 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1585 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1588 elf_num_locals (abfd
) = num_locals
;
1589 elf_num_globals (abfd
) = num_globals
;
1593 /* Compute the file positions we are going to put the sections at, and
1594 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1595 is not NULL, this is being called by the ELF backend linker. */
1598 elf_compute_section_file_positions (abfd
, link_info
)
1600 struct bfd_link_info
*link_info
;
1602 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1603 Elf_Internal_Shdr
*shstrtab_hdr
;
1605 if (abfd
->output_has_begun
)
1608 /* Do any elf backend specific processing first. */
1609 if (bed
->elf_backend_begin_write_processing
)
1610 (*bed
->elf_backend_begin_write_processing
) (abfd
);
1612 if (! prep_headers (abfd
))
1615 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1617 if (!assign_section_numbers (abfd
))
1620 /* The backend linker builds symbol table information itself. */
1621 if (link_info
== NULL
)
1623 if (! swap_out_syms (abfd
))
1627 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1628 /* sh_name was set in prep_headers. */
1629 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1630 shstrtab_hdr
->sh_flags
= 0;
1631 shstrtab_hdr
->sh_addr
= 0;
1632 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1633 shstrtab_hdr
->sh_entsize
= 0;
1634 shstrtab_hdr
->sh_link
= 0;
1635 shstrtab_hdr
->sh_info
= 0;
1636 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1637 shstrtab_hdr
->sh_addralign
= 1;
1638 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1640 if (!assign_file_positions_except_relocs (abfd
,
1641 link_info
== NULL
? true : false))
1644 abfd
->output_has_begun
= true;
1650 /* Align to the maximum file alignment that could be required for any
1651 ELF data structure. */
1653 static INLINE file_ptr
1654 align_file_position (off
)
1657 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1660 /* Assign a file position to a section, optionally aligning to the
1661 required section alignment. */
1663 static INLINE file_ptr
1664 assign_file_position_for_section (i_shdrp
, offset
, align
)
1665 Elf_Internal_Shdr
*i_shdrp
;
1673 al
= i_shdrp
->sh_addralign
;
1675 offset
= BFD_ALIGN (offset
, al
);
1677 i_shdrp
->sh_offset
= offset
;
1678 if (i_shdrp
->rawdata
!= NULL
)
1679 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1680 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1681 offset
+= i_shdrp
->sh_size
;
1685 /* Get the size of the program header. This is called by the linker
1686 before any of the section VMA's are set, so it can't calculate the
1687 correct value for a strange memory layout. */
1689 static bfd_size_type
1690 get_program_header_size (abfd
)
1696 /* Assume we will need exactly two PT_LOAD segments: one for text
1697 and one for data. */
1700 s
= bfd_get_section_by_name (abfd
, ".interp");
1701 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1703 /* If we have a loadable interpreter section, we need a
1704 PT_INTERP segment. In this case, assume we also need a
1705 PT_PHDR segment, although that may not be true for all
1710 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1712 /* We need a PT_DYNAMIC segment. */
1716 return segs
* sizeof (Elf_External_Phdr
);
1719 /* Create the program header. OFF is the file offset where the
1720 program header should be written. FIRST is the first loadable ELF
1721 section. PHDR_SIZE is the size of the program header as returned
1722 by get_program_header_size. */
1725 map_program_segments (abfd
, off
, first
, phdr_size
)
1728 Elf_Internal_Shdr
*first
;
1729 bfd_size_type phdr_size
;
1731 Elf_Internal_Phdr phdrs
[10];
1732 unsigned int phdr_count
;
1733 Elf_Internal_Phdr
*phdr
;
1734 int phdr_size_adjust
;
1736 Elf_Internal_Shdr
**hdrpp
;
1737 asection
*sinterp
, *sdyn
;
1738 unsigned int last_type
;
1739 Elf_Internal_Ehdr
*i_ehdrp
;
1741 BFD_ASSERT ((abfd
->flags
& EXEC_P
) != 0);
1742 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1743 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1748 phdr_size_adjust
= 0;
1750 /* If we have a loadable .interp section, we must create a PT_INTERP
1751 segment which must precede all PT_LOAD segments. We assume that
1752 we must also create a PT_PHDR segment, although that may not be
1753 true for all targets. */
1754 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1755 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1757 BFD_ASSERT (first
!= NULL
);
1759 phdr
->p_type
= PT_PHDR
;
1761 phdr
->p_offset
= off
;
1763 /* Account for any adjustment made because of the alignment of
1764 the first loadable section. */
1765 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1766 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1768 /* The program header precedes all loadable sections. This lets
1769 us compute its loadable address. This depends on the linker
1771 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1774 phdr
->p_filesz
= phdr_size
;
1775 phdr
->p_memsz
= phdr_size
;
1777 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1778 phdr
->p_flags
= PF_R
| PF_X
;
1780 phdr
->p_align
= FILE_ALIGN
;
1781 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1783 /* Include the ELF header in the first loadable segment. */
1784 phdr_size_adjust
+= off
;
1789 phdr
->p_type
= PT_INTERP
;
1790 phdr
->p_offset
= sinterp
->filepos
;
1791 phdr
->p_vaddr
= sinterp
->vma
;
1793 phdr
->p_filesz
= sinterp
->_raw_size
;
1794 phdr
->p_memsz
= sinterp
->_raw_size
;
1795 phdr
->p_flags
= PF_R
;
1796 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1802 /* Look through the sections to see how they will be divided into
1803 program segments. The sections must be arranged in order by
1804 sh_addr for this to work correctly. */
1805 phdr
->p_type
= PT_NULL
;
1806 last_type
= SHT_PROGBITS
;
1807 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1808 i
< elf_elfheader (abfd
)->e_shnum
;
1811 Elf_Internal_Shdr
*hdr
;
1815 /* Ignore any section which will not be part of the process
1817 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1820 /* If this section fits in the segment we are constructing, add
1822 if (phdr
->p_type
!= PT_NULL
1823 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1824 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1825 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1827 bfd_size_type adjust
;
1829 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1830 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1831 if (hdr
->sh_type
!= SHT_NOBITS
)
1832 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1833 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1834 phdr
->p_flags
|= PF_W
;
1835 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1836 phdr
->p_flags
|= PF_X
;
1837 last_type
= hdr
->sh_type
;
1841 /* If we have a segment, move to the next one. */
1842 if (phdr
->p_type
!= PT_NULL
)
1848 /* Start a new segment. */
1849 phdr
->p_type
= PT_LOAD
;
1850 phdr
->p_offset
= hdr
->sh_offset
;
1851 phdr
->p_vaddr
= hdr
->sh_addr
;
1853 if (hdr
->sh_type
== SHT_NOBITS
)
1856 phdr
->p_filesz
= hdr
->sh_size
;
1857 phdr
->p_memsz
= hdr
->sh_size
;
1858 phdr
->p_flags
= PF_R
;
1859 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1860 phdr
->p_flags
|= PF_W
;
1861 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1862 phdr
->p_flags
|= PF_X
;
1863 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1867 && (sinterp
->flags
& SEC_LOAD
) != 0)
1869 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1870 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1871 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1872 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1875 last_type
= hdr
->sh_type
;
1878 if (phdr
->p_type
!= PT_NULL
)
1884 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1885 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1886 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1888 phdr
->p_type
= PT_DYNAMIC
;
1889 phdr
->p_offset
= sdyn
->filepos
;
1890 phdr
->p_vaddr
= sdyn
->vma
;
1892 phdr
->p_filesz
= sdyn
->_raw_size
;
1893 phdr
->p_memsz
= sdyn
->_raw_size
;
1894 phdr
->p_flags
= PF_R
;
1895 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1896 phdr
->p_flags
|= PF_W
;
1897 if ((sdyn
->flags
& SEC_CODE
) != 0)
1898 phdr
->p_flags
|= PF_X
;
1899 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1905 /* Make sure the return value from get_program_header_size matches
1906 what we computed here. */
1907 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1910 /* Set up program header information. */
1911 i_ehdrp
= elf_elfheader (abfd
);
1912 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1913 i_ehdrp
->e_phoff
= off
;
1914 i_ehdrp
->e_phnum
= phdr_count
;
1916 /* Save the program headers away. I don't think anybody uses this
1917 information right now. */
1918 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1921 * sizeof (Elf_Internal_Phdr
))));
1922 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1924 bfd_set_error (bfd_error_no_memory
);
1925 return (file_ptr
) -1;
1927 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1928 phdr_count
* sizeof (Elf_Internal_Phdr
));
1930 /* Write out the program headers. */
1931 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1932 return (file_ptr
) -1;
1934 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1936 Elf_External_Phdr extphdr
;
1938 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1939 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1940 != sizeof (Elf_External_Phdr
))
1941 return (file_ptr
) -1;
1944 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1947 /* Work out the file positions of all the sections. This is called by
1948 elf_compute_section_file_positions. All the section sizes and VMAs
1949 must be known before this is called.
1951 We do not consider reloc sections at this point, unless they form
1952 part of the loadable image. Reloc sections are assigned file
1953 positions in assign_file_positions_for_relocs, which is called by
1954 write_object_contents and final_link.
1956 If DOSYMS is false, we do not assign file positions for the symbol
1957 table or the string table. */
1960 assign_file_positions_except_relocs (abfd
, dosyms
)
1964 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1965 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1966 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1969 /* Start after the ELF header. */
1970 off
= i_ehdrp
->e_ehsize
;
1972 if ((abfd
->flags
& EXEC_P
) == 0)
1974 Elf_Internal_Shdr
**hdrpp
;
1977 /* We are not creating an executable, which means that we are
1978 not creating a program header, and that the actual order of
1979 the sections in the file is unimportant. */
1980 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1982 Elf_Internal_Shdr
*hdr
;
1985 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1987 hdr
->sh_offset
= -1;
1991 && (i
== tdata
->symtab_section
1992 || i
== tdata
->strtab_section
))
1994 hdr
->sh_offset
= -1;
1998 off
= assign_file_position_for_section (hdr
, off
, true);
2004 bfd_size_type phdr_size
;
2005 bfd_vma maxpagesize
;
2006 Elf_Internal_Shdr
**hdrpp
;
2008 Elf_Internal_Shdr
*first
;
2011 /* We are creating an executable. We must create a program
2012 header. We can't actually create the program header until we
2013 have set the file positions for the sections, but we can
2014 figure out how big it is going to be. */
2015 off
= align_file_position (off
);
2016 phdr_size
= get_program_header_size (abfd
);
2017 if (phdr_size
== (file_ptr
) -1)
2022 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2023 if (maxpagesize
== 0)
2026 /* FIXME: We might want to sort the sections on the sh_addr
2027 field here. For now, we just assume that the linker will
2028 create the sections in an appropriate order. */
2030 /* Assign file positions in two passes. In the first pass, we
2031 assign a file position to every section which forms part of
2032 the executable image. */
2034 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2036 Elf_Internal_Shdr
*hdr
;
2039 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2045 if ((abfd
->flags
& D_PAGED
) != 0)
2047 /* The section VMA must equal the file position modulo
2048 the page size. This is required by the program
2050 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2053 off
= assign_file_position_for_section (hdr
, off
, false);
2056 /* Assign file positions to all the sections which do not form
2057 part of the loadable image, except for the relocs. */
2058 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2060 Elf_Internal_Shdr
*hdr
;
2063 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2065 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2067 hdr
->sh_offset
= -1;
2071 && (i
== tdata
->symtab_section
2072 || i
== tdata
->strtab_section
))
2074 hdr
->sh_offset
= -1;
2078 off
= assign_file_position_for_section (hdr
, off
, true);
2081 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2082 if (phdr_map
== (file_ptr
) -1)
2084 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2087 /* Place the section headers. */
2088 off
= align_file_position (off
);
2089 i_ehdrp
->e_shoff
= off
;
2090 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2092 elf_tdata (abfd
)->next_file_pos
= off
;
2101 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2102 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2103 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2105 struct strtab
*shstrtab
;
2107 i_ehdrp
= elf_elfheader (abfd
);
2108 i_shdrp
= elf_elfsections (abfd
);
2110 shstrtab
= bfd_new_strtab (abfd
);
2114 elf_shstrtab (abfd
) = shstrtab
;
2116 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2117 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2118 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2119 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2121 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2122 i_ehdrp
->e_ident
[EI_DATA
] =
2123 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2124 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2126 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2127 i_ehdrp
->e_ident
[count
] = 0;
2129 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
2130 switch (bfd_get_arch (abfd
))
2132 case bfd_arch_unknown
:
2133 i_ehdrp
->e_machine
= EM_NONE
;
2135 case bfd_arch_sparc
:
2136 i_ehdrp
->e_machine
= EM_SPARC
;
2137 /* start-sanitize-v9 */
2139 i_ehdrp
->e_machine
= EM_SPARC64
;
2141 /* end-sanitize-v9 */
2144 i_ehdrp
->e_machine
= EM_386
;
2147 i_ehdrp
->e_machine
= EM_68K
;
2150 i_ehdrp
->e_machine
= EM_88K
;
2153 i_ehdrp
->e_machine
= EM_860
;
2155 case bfd_arch_mips
: /* MIPS Rxxxx */
2156 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2159 i_ehdrp
->e_machine
= EM_PARISC
;
2161 case bfd_arch_powerpc
:
2162 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2164 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2166 i_ehdrp
->e_machine
= EM_NONE
;
2168 i_ehdrp
->e_version
= EV_CURRENT
;
2169 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2171 /* no program header, for now. */
2172 i_ehdrp
->e_phoff
= 0;
2173 i_ehdrp
->e_phentsize
= 0;
2174 i_ehdrp
->e_phnum
= 0;
2176 /* each bfd section is section header entry */
2177 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2178 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2180 /* if we're building an executable, we'll need a program header table */
2181 if (abfd
->flags
& EXEC_P
)
2183 /* it all happens later */
2185 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2187 /* elf_build_phdrs() returns a (NULL-terminated) array of
2188 Elf_Internal_Phdrs */
2189 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2190 i_ehdrp
->e_phoff
= outbase
;
2191 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2196 i_ehdrp
->e_phentsize
= 0;
2198 i_ehdrp
->e_phoff
= 0;
2201 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2203 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2205 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2207 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2208 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2209 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2216 swap_out_syms (abfd
)
2219 if (!elf_map_symbols (abfd
))
2222 /* Dump out the symtabs. */
2224 int symcount
= bfd_get_symcount (abfd
);
2225 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2226 struct strtab
*stt
= bfd_new_strtab (abfd
);
2227 Elf_Internal_Shdr
*symtab_hdr
;
2228 Elf_Internal_Shdr
*symstrtab_hdr
;
2229 Elf_External_Sym
*outbound_syms
;
2234 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2235 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2236 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2237 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2238 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2239 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2241 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2242 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2244 outbound_syms
= (Elf_External_Sym
*)
2245 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2248 bfd_set_error (bfd_error_no_memory
);
2251 /* now generate the data (for "contents") */
2253 /* Fill in zeroth symbol and swap it out. */
2254 Elf_Internal_Sym sym
;
2260 sym
.st_shndx
= SHN_UNDEF
;
2261 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2263 for (idx
= 0; idx
< symcount
; idx
++)
2265 Elf_Internal_Sym sym
;
2266 bfd_vma value
= syms
[idx
]->value
;
2268 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2269 /* Section symbols have no names. */
2273 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2274 if (sym
.st_name
== (unsigned long) -1)
2278 if (bfd_is_com_section (syms
[idx
]->section
))
2280 /* ELF common symbols put the alignment into the `value' field,
2281 and the size into the `size' field. This is backwards from
2282 how BFD handles it, so reverse it here. */
2283 sym
.st_size
= value
;
2284 /* Should retrieve this from somewhere... */
2286 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2287 syms
[idx
]->section
);
2291 asection
*sec
= syms
[idx
]->section
;
2292 elf_symbol_type
*type_ptr
;
2295 if (sec
->output_section
)
2297 value
+= sec
->output_offset
;
2298 sec
= sec
->output_section
;
2301 sym
.st_value
= value
;
2302 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2303 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2304 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2308 /* Writing this would be a hell of a lot easier if we had
2309 some decent documentation on bfd, and knew what to expect
2310 of the library, and what to demand of applications. For
2311 example, it appears that `objcopy' might not set the
2312 section of a symbol to be a section that is actually in
2314 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2315 BFD_ASSERT (sec2
!= 0);
2316 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2317 BFD_ASSERT (shndx
!= -1);
2321 if (bfd_is_com_section (syms
[idx
]->section
))
2322 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2323 else if (syms
[idx
]->section
== &bfd_und_section
)
2324 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2325 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2326 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2327 else if (syms
[idx
]->flags
& BSF_FILE
)
2328 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2331 int bind
= STB_LOCAL
;
2332 int type
= STT_OBJECT
;
2333 unsigned int flags
= syms
[idx
]->flags
;
2335 if (flags
& BSF_LOCAL
)
2337 else if (flags
& BSF_WEAK
)
2339 else if (flags
& BSF_GLOBAL
)
2342 if (flags
& BSF_FUNCTION
)
2345 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2349 elf_swap_symbol_out (abfd
, &sym
,
2351 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2354 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2355 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2356 symstrtab_hdr
->sh_size
= stt
->length
;
2357 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2359 symstrtab_hdr
->sh_flags
= 0;
2360 symstrtab_hdr
->sh_addr
= 0;
2361 symstrtab_hdr
->sh_entsize
= 0;
2362 symstrtab_hdr
->sh_link
= 0;
2363 symstrtab_hdr
->sh_info
= 0;
2364 symstrtab_hdr
->sh_addralign
= 1;
2365 symstrtab_hdr
->size
= 0;
2372 write_shdrs_and_ehdr (abfd
)
2375 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2376 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2377 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2378 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2380 struct strtab
*shstrtab
;
2382 i_ehdrp
= elf_elfheader (abfd
);
2383 i_shdrp
= elf_elfsections (abfd
);
2384 shstrtab
= elf_shstrtab (abfd
);
2386 /* swap the header before spitting it out... */
2389 elf_debug_file (i_ehdrp
);
2391 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2392 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2393 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2394 != sizeof (x_ehdr
)))
2397 /* at this point we've concocted all the ELF sections... */
2398 x_shdrp
= (Elf_External_Shdr
*)
2399 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2402 bfd_set_error (bfd_error_no_memory
);
2406 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2409 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2412 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2414 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2415 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2416 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2419 /* need to dump the string table too... */
2424 /* Assign file positions for all the reloc sections which are not part
2425 of the loadable file image. */
2428 assign_file_positions_for_relocs (abfd
)
2433 Elf_Internal_Shdr
**shdrpp
;
2435 off
= elf_tdata (abfd
)->next_file_pos
;
2437 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2438 i
< elf_elfheader (abfd
)->e_shnum
;
2441 Elf_Internal_Shdr
*shdrp
;
2444 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2445 && shdrp
->sh_offset
== -1)
2446 off
= assign_file_position_for_section (shdrp
, off
, true);
2449 elf_tdata (abfd
)->next_file_pos
= off
;
2453 NAME(bfd_elf
,write_object_contents
) (abfd
)
2456 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2457 Elf_Internal_Ehdr
*i_ehdrp
;
2458 Elf_Internal_Shdr
**i_shdrp
;
2461 if (! abfd
->output_has_begun
2462 && ! elf_compute_section_file_positions (abfd
,
2463 (struct bfd_link_info
*) NULL
))
2466 i_shdrp
= elf_elfsections (abfd
);
2467 i_ehdrp
= elf_elfheader (abfd
);
2469 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2470 assign_file_positions_for_relocs (abfd
);
2472 /* After writing the headers, we need to write the sections too... */
2473 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2475 if (bed
->elf_backend_section_processing
)
2476 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2477 if (i_shdrp
[count
]->contents
)
2479 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2480 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2482 != i_shdrp
[count
]->sh_size
))
2487 if (bed
->elf_backend_final_write_processing
)
2488 (*bed
->elf_backend_final_write_processing
) (abfd
);
2490 return write_shdrs_and_ehdr (abfd
);
2493 /* Given an index of a section, retrieve a pointer to it. Note
2494 that for our purposes, sections are indexed by {1, 2, ...} with
2495 0 being an illegal index. */
2497 /* In the original, each ELF section went into exactly one BFD
2498 section. This doesn't really make sense, so we need a real mapping.
2499 The mapping has to hide in the Elf_Internal_Shdr since asection
2500 doesn't have anything like a tdata field... */
2503 section_from_elf_index (abfd
, index
)
2507 /* @@ Is bfd_com_section really correct in all the places it could
2508 be returned from this routine? */
2510 if (index
== SHN_ABS
)
2511 return &bfd_com_section
; /* not abs? */
2512 if (index
== SHN_COMMON
)
2513 return &bfd_com_section
;
2515 if (index
> elf_elfheader (abfd
)->e_shnum
)
2519 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2521 switch (hdr
->sh_type
)
2523 /* ELF sections that map to BFD sections */
2528 if (hdr
->rawdata
== NULL
)
2530 if (! bfd_section_from_shdr (abfd
, index
))
2533 return (struct sec
*) hdr
->rawdata
;
2536 return (struct sec
*) &bfd_abs_section
;
2541 /* given a section, search the header to find them... */
2543 elf_section_from_bfd_section (abfd
, asect
)
2547 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2549 Elf_Internal_Shdr
*hdr
;
2550 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2552 if (asect
== &bfd_abs_section
)
2554 if (asect
== &bfd_com_section
)
2556 if (asect
== &bfd_und_section
)
2559 for (index
= 0; index
< maxindex
; index
++)
2561 hdr
= i_shdrp
[index
];
2562 switch (hdr
->sh_type
)
2564 /* ELF sections that map to BFD sections */
2573 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2580 /* We sometimes map a reloc section to a BFD section. */
2581 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2582 && (asection
*) hdr
->rawdata
== asect
)
2587 /* We map most string tables to BFD sections. */
2588 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2589 && index
!= elf_onesymtab (abfd
)
2590 && (asection
*) hdr
->rawdata
== asect
)
2596 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2598 if (bed
->elf_backend_section_from_bfd_section
)
2603 if ((*bed
->elf_backend_section_from_bfd_section
)
2604 (abfd
, hdr
, asect
, &retval
))
2614 /* given a symbol, return the bfd index for that symbol. */
2616 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2618 struct symbol_cache_entry
**asym_ptr_ptr
;
2620 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2622 flagword flags
= asym_ptr
->flags
;
2624 /* When gas creates relocations against local labels, it creates its
2625 own symbol for the section, but does put the symbol into the
2626 symbol chain, so udata is 0. When the linker is generating
2627 relocatable output, this section symbol may be for one of the
2628 input sections rather than the output section. */
2629 if (asym_ptr
->udata
== (PTR
) 0
2630 && (flags
& BSF_SECTION_SYM
)
2631 && asym_ptr
->section
)
2635 if (asym_ptr
->section
->output_section
!= NULL
)
2636 indx
= asym_ptr
->section
->output_section
->index
;
2638 indx
= asym_ptr
->section
->index
;
2639 if (elf_section_syms (abfd
)[indx
])
2640 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2643 if (asym_ptr
->udata
)
2644 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2654 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2655 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2664 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2666 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2669 Elf_Internal_Shdr
*hdr
;
2670 long symcount
; /* Number of external ELF symbols */
2671 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2672 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2673 Elf_Internal_Sym i_sym
;
2674 Elf_External_Sym
*x_symp
= NULL
;
2676 /* Read each raw ELF symbol, converting from external ELF form to
2677 internal ELF form, and then using the information to create a
2678 canonical bfd symbol table entry.
2680 Note that we allocate the initial bfd canonical symbol buffer
2681 based on a one-to-one mapping of the ELF symbols to canonical
2682 symbols. We actually use all the ELF symbols, so there will be no
2683 space left over at the end. When we have all the symbols, we
2684 build the caller's pointer vector. */
2687 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2689 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2690 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2693 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2696 sym
= symbase
= NULL
;
2701 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2704 symbase
= ((elf_symbol_type
*)
2705 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2706 if (symbase
== (elf_symbol_type
*) NULL
)
2708 bfd_set_error (bfd_error_no_memory
);
2713 /* Temporarily allocate room for the raw ELF symbols. */
2714 x_symp
= ((Elf_External_Sym
*)
2715 malloc (symcount
* sizeof (Elf_External_Sym
)));
2716 if (x_symp
== NULL
&& symcount
!= 0)
2718 bfd_set_error (bfd_error_no_memory
);
2722 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2723 != symcount
* sizeof (Elf_External_Sym
))
2725 /* Skip first symbol, which is a null dummy. */
2726 for (i
= 1; i
< symcount
; i
++)
2728 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2729 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2730 #ifdef ELF_KEEP_EXTSYM
2731 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2733 sym
->symbol
.the_bfd
= abfd
;
2735 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2738 sym
->symbol
.value
= i_sym
.st_value
;
2740 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2742 sym
->symbol
.section
= section_from_elf_index (abfd
,
2744 if (sym
->symbol
.section
== NULL
)
2746 /* This symbol is in a section for which we did not
2747 create a BFD section. Just use bfd_abs_section,
2748 although it is wrong. FIXME. */
2749 sym
->symbol
.section
= &bfd_abs_section
;
2752 else if (i_sym
.st_shndx
== SHN_ABS
)
2754 sym
->symbol
.section
= &bfd_abs_section
;
2756 else if (i_sym
.st_shndx
== SHN_COMMON
)
2758 sym
->symbol
.section
= &bfd_com_section
;
2759 /* Elf puts the alignment into the `value' field, and
2760 the size into the `size' field. BFD wants to see the
2761 size in the value field, and doesn't care (at the
2762 moment) about the alignment. */
2763 sym
->symbol
.value
= i_sym
.st_size
;
2765 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2767 sym
->symbol
.section
= &bfd_und_section
;
2770 sym
->symbol
.section
= &bfd_abs_section
;
2772 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2774 switch (ELF_ST_BIND (i_sym
.st_info
))
2777 sym
->symbol
.flags
|= BSF_LOCAL
;
2780 sym
->symbol
.flags
|= BSF_GLOBAL
;
2783 sym
->symbol
.flags
|= BSF_WEAK
;
2787 switch (ELF_ST_TYPE (i_sym
.st_info
))
2790 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2793 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2796 sym
->symbol
.flags
|= BSF_FUNCTION
;
2801 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2803 /* Do some backend-specific processing on this symbol. */
2805 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2806 if (ebd
->elf_backend_symbol_processing
)
2807 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2814 /* Do some backend-specific processing on this symbol table. */
2816 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2817 if (ebd
->elf_backend_symbol_table_processing
)
2818 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2821 /* We rely on the zalloc to clear out the final symbol entry. */
2823 symcount
= sym
- symbase
;
2825 /* Fill in the user's symbol pointer vector if needed. */
2833 *symptrs
++ = &sym
->symbol
;
2836 *symptrs
= 0; /* Final null pointer */
2848 /* Return the number of bytes required to hold the symtab vector.
2850 Note that we base it on the count plus 1, since we will null terminate
2851 the vector allocated based on this size. However, the ELF symbol table
2852 always has a dummy entry as symbol #0, so it ends up even. */
2855 elf_get_symtab_upper_bound (abfd
)
2860 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2862 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2863 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2869 elf_get_dynamic_symtab_upper_bound (abfd
)
2874 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2876 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2877 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2883 This function return the number of bytes required to store the
2884 relocation information associated with section <<sect>>
2885 attached to bfd <<abfd>>
2889 elf_get_reloc_upper_bound (abfd
, asect
)
2893 if (asect
->flags
& SEC_RELOC
)
2895 /* either rel or rela */
2896 return elf_section_data (asect
)->rel_hdr
.sh_size
;
2903 elf_slurp_reloca_table (abfd
, asect
, symbols
)
2908 Elf_External_Rela
*native_relocs
;
2909 arelent
*reloc_cache
;
2914 if (asect
->relocation
)
2916 if (asect
->reloc_count
== 0)
2918 if (asect
->flags
& SEC_CONSTRUCTOR
)
2921 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2923 native_relocs
= (Elf_External_Rela
*)
2924 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2927 bfd_set_error (bfd_error_no_memory
);
2930 if (bfd_read ((PTR
) native_relocs
,
2931 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
)
2932 != sizeof (Elf_External_Rela
) * asect
->reloc_count
)
2935 reloc_cache
= (arelent
*)
2936 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2940 bfd_set_error (bfd_error_no_memory
);
2944 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2946 Elf_Internal_Rela dst
;
2947 Elf_External_Rela
*src
;
2949 cache_ptr
= reloc_cache
+ idx
;
2950 src
= native_relocs
+ idx
;
2951 elf_swap_reloca_in (abfd
, src
, &dst
);
2953 #ifdef RELOC_PROCESSING
2954 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2956 if (asect
->flags
& SEC_RELOC
)
2958 /* relocatable, so the offset is off of the section */
2959 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2963 /* non-relocatable, so the offset a virtual address */
2964 cache_ptr
->address
= dst
.r_offset
;
2967 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2968 of zero points to the dummy symbol, which was not read into
2969 the symbol table SYMBOLS. */
2970 if (ELF_R_SYM (dst
.r_info
) == 0)
2971 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2976 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2978 /* Translate any ELF section symbol into a BFD section
2980 s
= *(cache_ptr
->sym_ptr_ptr
);
2981 if (s
->flags
& BSF_SECTION_SYM
)
2983 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2984 s
= *cache_ptr
->sym_ptr_ptr
;
2985 if (s
->name
== 0 || s
->name
[0] == 0)
2989 cache_ptr
->addend
= dst
.r_addend
;
2991 /* Fill in the cache_ptr->howto field from dst.r_type */
2993 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2994 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2999 asect
->relocation
= reloc_cache
;
3005 elf_debug_section (str
, num
, hdr
)
3008 Elf_Internal_Shdr
*hdr
;
3010 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3012 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3013 (long) hdr
->sh_name
,
3014 (long) hdr
->sh_type
,
3015 (long) hdr
->sh_flags
);
3017 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3018 (long) hdr
->sh_addr
,
3019 (long) hdr
->sh_offset
,
3020 (long) hdr
->sh_size
);
3022 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3023 (long) hdr
->sh_link
,
3024 (long) hdr
->sh_info
,
3025 (long) hdr
->sh_addralign
);
3026 fprintf (stderr
, "sh_entsize = %ld\n",
3027 (long) hdr
->sh_entsize
);
3028 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3029 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3030 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3035 elf_debug_file (ehdrp
)
3036 Elf_Internal_Ehdr
*ehdrp
;
3038 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3039 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3040 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3041 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3042 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3043 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3044 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3049 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3054 Elf_External_Rel
*native_relocs
;
3055 arelent
*reloc_cache
;
3057 Elf_Internal_Shdr
*data_hdr
;
3059 unsigned long data_max
;
3060 char buf
[4]; /* FIXME -- might be elf64 */
3064 if (asect
->relocation
)
3066 if (asect
->reloc_count
== 0)
3068 if (asect
->flags
& SEC_CONSTRUCTOR
)
3071 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
3073 native_relocs
= (Elf_External_Rel
*)
3074 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
3077 bfd_set_error (bfd_error_no_memory
);
3080 if (bfd_read ((PTR
) native_relocs
,
3081 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
)
3082 != sizeof (Elf_External_Rel
) * asect
->reloc_count
)
3085 reloc_cache
= (arelent
*)
3086 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3090 bfd_set_error (bfd_error_no_memory
);
3094 /* Get the offset of the start of the segment we are relocating to read in
3095 the implicit addend. */
3096 data_hdr
= &elf_section_data (asect
)->this_hdr
;
3097 data_off
= data_hdr
->sh_offset
;
3098 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
3101 elf_debug_section ("data section", -1, data_hdr
);
3104 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3106 #ifdef RELOC_PROCESSING
3107 Elf_Internal_Rel dst
;
3108 Elf_External_Rel
*src
;
3110 cache_ptr
= reloc_cache
+ idx
;
3111 src
= native_relocs
+ idx
;
3112 elf_swap_reloc_in (abfd
, src
, &dst
);
3114 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3116 Elf_Internal_Rel dst
;
3117 Elf_External_Rel
*src
;
3119 cache_ptr
= reloc_cache
+ idx
;
3120 src
= native_relocs
+ idx
;
3122 elf_swap_reloc_in (abfd
, src
, &dst
);
3124 if (asect
->flags
& SEC_RELOC
)
3126 /* relocatable, so the offset is off of the section */
3127 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3131 /* non-relocatable, so the offset a virtual address */
3132 cache_ptr
->address
= dst
.r_offset
;
3135 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3136 of zero points to the dummy symbol, which was not read into
3137 the symbol table SYMBOLS. */
3138 if (ELF_R_SYM (dst
.r_info
) == 0)
3139 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3144 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3146 /* Translate any ELF section symbol into a BFD section
3148 s
= *(cache_ptr
->sym_ptr_ptr
);
3149 if (s
->flags
& BSF_SECTION_SYM
)
3151 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3152 s
= *cache_ptr
->sym_ptr_ptr
;
3153 if (s
->name
== 0 || s
->name
[0] == 0)
3157 BFD_ASSERT (dst
.r_offset
<= data_max
);
3158 cache_ptr
->addend
= 0;
3160 /* Fill in the cache_ptr->howto field from dst.r_type */
3162 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3163 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3168 asect
->relocation
= reloc_cache
;
3173 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3179 arelent
*tblptr
= section
->relocation
;
3180 unsigned int count
= 0;
3181 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3183 /* snarfed from coffcode.h */
3186 if (! elf_slurp_reloca_table (abfd
, section
, symbols
))
3191 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3195 tblptr
= section
->relocation
;
3197 for (; count
++ < section
->reloc_count
;)
3198 *relptr
++ = tblptr
++;
3201 return section
->reloc_count
;
3205 elf_get_symtab (abfd
, alocation
)
3207 asymbol
**alocation
;
3209 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3212 bfd_get_symcount (abfd
) = symcount
;
3217 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3219 asymbol
**alocation
;
3221 return elf_slurp_symbol_table (abfd
, alocation
, true);
3225 elf_make_empty_symbol (abfd
)
3228 elf_symbol_type
*newsym
;
3230 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3233 bfd_set_error (bfd_error_no_memory
);
3238 newsym
->symbol
.the_bfd
= abfd
;
3239 return &newsym
->symbol
;
3244 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3249 bfd_symbol_info (symbol
, ret
);
3253 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3257 bfd_print_symbol_type how
;
3259 FILE *file
= (FILE *) filep
;
3262 case bfd_print_symbol_name
:
3263 fprintf (file
, "%s", symbol
->name
);
3265 case bfd_print_symbol_more
:
3266 fprintf (file
, "elf ");
3267 fprintf_vma (file
, symbol
->value
);
3268 fprintf (file
, " %lx", (long) symbol
->flags
);
3270 case bfd_print_symbol_all
:
3272 CONST
char *section_name
;
3273 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3274 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3275 fprintf (file
, " %s\t%s",
3285 elf_get_lineno (ignore_abfd
, symbol
)
3289 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3296 elf_set_arch_mach (abfd
, arch
, machine
)
3298 enum bfd_architecture arch
;
3299 unsigned long machine
;
3301 /* If this isn't the right architecture for this backend, and this
3302 isn't the generic backend, fail. */
3303 if (arch
!= get_elf_backend_data (abfd
)->arch
3304 && arch
!= bfd_arch_unknown
3305 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3308 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3312 elf_find_nearest_line (abfd
,
3323 CONST
char **filename_ptr
;
3324 CONST
char **functionname_ptr
;
3325 unsigned int *line_ptr
;
3331 elf_sizeof_headers (abfd
, reloc
)
3337 ret
= sizeof (Elf_External_Ehdr
);
3339 ret
+= get_program_header_size (abfd
);
3344 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3349 bfd_size_type count
;
3351 Elf_Internal_Shdr
*hdr
;
3353 if (! abfd
->output_has_begun
3354 && ! elf_compute_section_file_positions (abfd
,
3355 (struct bfd_link_info
*) NULL
))
3358 hdr
= &elf_section_data (section
)->this_hdr
;
3360 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3362 if (bfd_write (location
, 1, count
, abfd
) != count
)
3369 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3372 Elf_Internal_Rela
*dst
;
3374 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3380 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3383 Elf_Internal_Rel
*dst
;
3385 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3391 /* Core file support */
3393 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3394 #include <sys/procfs.h>
3396 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3397 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3398 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3404 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3411 prstatus_t
*status
= (prstatus_t
*) 0;
3413 if (descsz
== sizeof (prstatus_t
))
3415 newsect
= bfd_make_section (abfd
, ".reg");
3416 if (newsect
== NULL
)
3418 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3419 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3420 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3421 newsect
->alignment_power
= 2;
3422 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3424 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3430 /* Stash a copy of the prpsinfo structure away for future use. */
3433 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3439 if (descsz
== sizeof (prpsinfo_t
))
3441 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3443 bfd_set_error (bfd_error_no_memory
);
3446 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3452 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3460 newsect
= bfd_make_section (abfd
, ".reg2");
3461 if (newsect
== NULL
)
3463 newsect
->_raw_size
= descsz
;
3464 newsect
->filepos
= filepos
;
3465 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3466 newsect
->alignment_power
= 2;
3470 #endif /* HAVE_PROCFS */
3472 /* Return a pointer to the args (including the command name) that were
3473 seen by the program that generated the core dump. Note that for
3474 some reason, a spurious space is tacked onto the end of the args
3475 in some (at least one anyway) implementations, so strip it off if
3479 elf_core_file_failing_command (abfd
)
3483 if (core_prpsinfo (abfd
))
3485 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3486 char *scan
= p
->pr_psargs
;
3491 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3495 return p
->pr_psargs
;
3501 /* Return the number of the signal that caused the core dump. Presumably,
3502 since we have a core file, we got a signal of some kind, so don't bother
3503 checking the other process status fields, just return the signal number.
3507 elf_core_file_failing_signal (abfd
)
3511 if (core_prstatus (abfd
))
3513 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3519 /* Check to see if the core file could reasonably be expected to have
3520 come for the current executable file. Note that by default we return
3521 true unless we find something that indicates that there might be a
3526 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3535 /* First, xvecs must match since both are ELF files for the same target. */
3537 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3539 bfd_set_error (bfd_error_system_call
);
3545 /* If no prpsinfo, just return true. Otherwise, grab the last component
3546 of the exec'd pathname from the prpsinfo. */
3548 if (core_prpsinfo (core_bfd
))
3550 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3557 /* Find the last component of the executable pathname. */
3559 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3565 execname
= (char *) exec_bfd
->filename
;
3568 /* See if they match */
3570 return strcmp (execname
, corename
) ? false : true;
3576 #endif /* HAVE_PROCFS */
3579 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3580 the information that would normally be available from the /proc interface
3581 for the process, at the time the process dumped core. Currently this
3582 includes copies of the prstatus, prpsinfo, and fpregset structures.
3584 Since these structures are potentially machine dependent in size and
3585 ordering, bfd provides two levels of support for them. The first level,
3586 available on all machines since it does not require that the host
3587 have /proc support or the relevant include files, is to create a bfd
3588 section for each of the prstatus, prpsinfo, and fpregset structures,
3589 without any interpretation of their contents. With just this support,
3590 the bfd client will have to interpret the structures itself. Even with
3591 /proc support, it might want these full structures for it's own reasons.
3593 In the second level of support, where HAVE_PROCFS is defined, bfd will
3594 pick apart the structures to gather some additional information that
3595 clients may want, such as the general register set, the name of the
3596 exec'ed file and its arguments, the signal (if any) that caused the
3602 elf_corefile_note (abfd
, hdr
)
3604 Elf_Internal_Phdr
*hdr
;
3606 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3607 Elf_Internal_Note i_note
; /* Elf note, internal form */
3608 char *buf
= NULL
; /* Entire note segment contents */
3609 char *namedata
; /* Name portion of the note */
3610 char *descdata
; /* Descriptor portion of the note */
3611 char *sectname
; /* Name to use for new section */
3612 long filepos
; /* File offset to descriptor data */
3615 if (hdr
->p_filesz
> 0
3616 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3617 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3618 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3620 x_note_p
= (Elf_External_Note
*) buf
;
3621 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3623 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3624 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3625 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3626 namedata
= x_note_p
->name
;
3627 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3628 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3629 switch (i_note
.type
)
3632 /* process descdata as prstatus info */
3633 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3635 sectname
= ".prstatus";
3638 /* process descdata as fpregset info */
3639 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3641 sectname
= ".fpregset";
3644 /* process descdata as prpsinfo */
3645 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3647 sectname
= ".prpsinfo";
3650 /* Unknown descriptor, just ignore it. */
3654 if (sectname
!= NULL
)
3656 newsect
= bfd_make_section (abfd
, sectname
);
3657 if (newsect
== NULL
)
3659 newsect
->_raw_size
= i_note
.descsz
;
3660 newsect
->filepos
= filepos
;
3661 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3662 newsect
->alignment_power
= 2;
3664 x_note_p
= (Elf_External_Note
*)
3665 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3672 else if (hdr
->p_filesz
> 0)
3674 bfd_set_error (bfd_error_no_memory
);
3681 /* Core files are simply standard ELF formatted files that partition
3682 the file using the execution view of the file (program header table)
3683 rather than the linking view. In fact, there is no section header
3684 table in a core file.
3686 The process status information (including the contents of the general
3687 register set) and the floating point register set are stored in a
3688 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3689 that allow standard bfd access to the general registers (.reg) and the
3690 floating point registers (.reg2).
3695 elf_core_file_p (abfd
)
3698 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3699 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3700 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3701 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3702 unsigned int phindex
;
3703 struct elf_backend_data
*ebd
;
3705 /* Read in the ELF header in external format. */
3707 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3709 if (bfd_get_error () != bfd_error_system_call
)
3710 bfd_set_error (bfd_error_wrong_format
);
3714 /* Now check to see if we have a valid ELF file, and one that BFD can
3715 make use of. The magic number must match, the address size ('class')
3716 and byte-swapping must match our XVEC entry, and it must have a
3717 program header table (FIXME: See comments re segments at top of this
3720 if (elf_file_p (&x_ehdr
) == false)
3723 bfd_set_error (bfd_error_wrong_format
);
3727 /* FIXME, Check EI_VERSION here ! */
3731 int desired_address_size
= ELFCLASS32
;
3734 int desired_address_size
= ELFCLASS64
;
3737 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3741 /* Switch xvec to match the specified byte order. */
3742 switch (x_ehdr
.e_ident
[EI_DATA
])
3744 case ELFDATA2MSB
: /* Big-endian */
3745 if (abfd
->xvec
->byteorder_big_p
== false)
3748 case ELFDATA2LSB
: /* Little-endian */
3749 if (abfd
->xvec
->byteorder_big_p
== true)
3752 case ELFDATANONE
: /* No data encoding specified */
3753 default: /* Unknown data encoding specified */
3757 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3758 the tdata pointer in the bfd. */
3761 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3762 if (elf_tdata (abfd
) == NULL
)
3764 bfd_set_error (bfd_error_no_memory
);
3768 /* FIXME, `wrong' returns from this point onward, leak memory. */
3770 /* Now that we know the byte order, swap in the rest of the header */
3771 i_ehdrp
= elf_elfheader (abfd
);
3772 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3774 elf_debug_file (i_ehdrp
);
3777 ebd
= get_elf_backend_data (abfd
);
3779 /* Check that the ELF e_machine field matches what this particular
3780 BFD format expects. */
3781 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3783 bfd_target
**target_ptr
;
3785 if (ebd
->elf_machine_code
!= EM_NONE
)
3788 /* This is the generic ELF target. Let it match any ELF target
3789 for which we do not have a specific backend. */
3790 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3792 struct elf_backend_data
*back
;
3794 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3796 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3797 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3799 /* target_ptr is an ELF backend which matches this
3800 object file, so reject the generic ELF target. */
3806 /* If there is no program header, or the type is not a core file, then
3808 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3811 /* Allocate space for a copy of the program header table in
3812 internal form, seek to the program header table in the file,
3813 read it in, and convert it to internal form. As a simple sanity
3814 check, verify that the what BFD thinks is the size of each program
3815 header table entry actually matches the size recorded in the file. */
3817 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3819 i_phdrp
= (Elf_Internal_Phdr
*)
3820 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3823 bfd_set_error (bfd_error_no_memory
);
3826 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3828 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3830 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3833 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3836 /* Once all of the program headers have been read and converted, we
3837 can start processing them. */
3839 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3841 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3842 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3844 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3849 /* Remember the entry point specified in the ELF file header. */
3851 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3856 /* ELF linker code. */
3858 static boolean elf_link_add_object_symbols
3859 PARAMS ((bfd
*, struct bfd_link_info
*));
3860 static boolean elf_link_add_archive_symbols
3861 PARAMS ((bfd
*, struct bfd_link_info
*));
3862 static INLINE boolean elf_link_record_dynamic_symbol
3863 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
3864 static boolean elf_link_create_dynamic_sections
3865 PARAMS ((bfd
*, struct bfd_link_info
*));
3866 static boolean elf_adjust_dynamic_symbol
3867 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3869 /* Given an ELF BFD, add symbols to the global hash table as
3873 elf_bfd_link_add_symbols (abfd
, info
)
3875 struct bfd_link_info
*info
;
3877 switch (bfd_get_format (abfd
))
3880 return elf_link_add_object_symbols (abfd
, info
);
3882 return elf_link_add_archive_symbols (abfd
, info
);
3884 bfd_set_error (bfd_error_wrong_format
);
3889 /* Add symbols from an ELF archive file to the linker hash table. We
3890 don't use _bfd_generic_link_add_archive_symbols because of a
3891 problem which arises on UnixWare. The UnixWare libc.so is an
3892 archive which includes an entry libc.so.1 which defines a bunch of
3893 symbols. The libc.so archive also includes a number of other
3894 object files, which also define symbols, some of which are the same
3895 as those defined in libc.so.1. Correct linking requires that we
3896 consider each object file in turn, and include it if it defines any
3897 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3898 this; it looks through the list of undefined symbols, and includes
3899 any object file which defines them. When this algorithm is used on
3900 UnixWare, it winds up pulling in libc.so.1 early and defining a
3901 bunch of symbols. This means that some of the other objects in the
3902 archive are not included in the link, which is incorrect since they
3903 precede libc.so.1 in the archive.
3905 Fortunately, ELF archive handling is simpler than that done by
3906 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3907 oddities. In ELF, if we find a symbol in the archive map, and the
3908 symbol is currently undefined, we know that we must pull in that
3911 Unfortunately, we do have to make multiple passes over the symbol
3912 table until nothing further is resolved. */
3915 elf_link_add_archive_symbols (abfd
, info
)
3917 struct bfd_link_info
*info
;
3920 boolean
*defined
= NULL
;
3921 boolean
*included
= NULL
;
3925 if (! bfd_has_map (abfd
))
3927 bfd_set_error (bfd_error_no_symbols
);
3931 /* Keep track of all symbols we know to be already defined, and all
3932 files we know to be already included. This is to speed up the
3933 second and subsequent passes. */
3934 c
= bfd_ardata (abfd
)->symdef_count
;
3937 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3938 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3939 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3941 bfd_set_error (bfd_error_no_memory
);
3944 memset (defined
, 0, c
* sizeof (boolean
));
3945 memset (included
, 0, c
* sizeof (boolean
));
3947 symdefs
= bfd_ardata (abfd
)->symdefs
;
3960 symdefend
= symdef
+ c
;
3961 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3963 struct elf_link_hash_entry
*h
;
3965 struct bfd_link_hash_entry
*undefs_tail
;
3968 if (defined
[i
] || included
[i
])
3970 if (symdef
->file_offset
== last
)
3976 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3977 false, false, false);
3978 if (h
== (struct elf_link_hash_entry
*) NULL
)
3980 if (h
->root
.type
!= bfd_link_hash_undefined
)
3986 /* We need to include this archive member. */
3988 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3989 if (element
== (bfd
*) NULL
)
3992 if (! bfd_check_format (element
, bfd_object
))
3995 /* Doublecheck that we have not included this object
3996 already--it should be impossible, but there may be
3997 something wrong with the archive. */
3998 if (element
->archive_pass
!= 0)
4000 bfd_set_error (bfd_error_bad_value
);
4003 element
->archive_pass
= 1;
4005 undefs_tail
= info
->hash
->undefs_tail
;
4007 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4010 if (! elf_link_add_object_symbols (element
, info
))
4013 /* If there are any new undefined symbols, we need to make
4014 another pass through the archive in order to see whether
4015 they can be defined. FIXME: This isn't perfect, because
4016 common symbols wind up on undefs_tail and because an
4017 undefined symbol which is defined later on in this pass
4018 does not require another pass. This isn't a bug, but it
4019 does make the code less efficient than it could be. */
4020 if (undefs_tail
!= info
->hash
->undefs_tail
)
4023 /* Look backward to mark all symbols from this object file
4024 which we have already seen in this pass. */
4028 included
[mark
] = true;
4033 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4035 /* We mark subsequent symbols from this object file as we go
4036 on through the loop. */
4037 last
= symdef
->file_offset
;
4048 if (defined
!= (boolean
*) NULL
)
4050 if (included
!= (boolean
*) NULL
)
4055 /* Record a new dynamic symbol. We record the dynamic symbols as we
4056 read the input files, since we need to have a list of all of them
4057 before we can determine the final sizes of the output sections. */
4059 static INLINE boolean
4060 elf_link_record_dynamic_symbol (info
, h
)
4061 struct bfd_link_info
*info
;
4062 struct elf_link_hash_entry
*h
;
4064 if (h
->dynindx
== -1)
4066 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4067 ++elf_hash_table (info
)->dynsymcount
;
4068 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
4069 elf_hash_table (info
)->dynstr
,
4070 h
->root
.root
.string
);
4071 if (h
->dynstr_index
== (unsigned long) -1)
4078 /* Add symbols from an ELF object file to the linker hash table. */
4081 elf_link_add_object_symbols (abfd
, info
)
4083 struct bfd_link_info
*info
;
4085 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4086 const Elf_Internal_Sym
*,
4087 const char **, flagword
*,
4088 asection
**, bfd_vma
*));
4090 Elf_Internal_Shdr
*hdr
;
4094 Elf_External_Sym
*buf
= NULL
;
4095 struct elf_link_hash_entry
**sym_hash
;
4097 Elf_External_Dyn
*dynbuf
= NULL
;
4098 struct elf_link_hash_entry
*weaks
;
4099 Elf_External_Sym
*esym
;
4100 Elf_External_Sym
*esymend
;
4102 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4103 collect
= get_elf_backend_data (abfd
)->collect
;
4105 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4106 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4108 /* The sh_info field of the symtab header tells us where the
4109 external symbols start. We don't care about the local symbols at
4111 if (elf_bad_symtab (abfd
))
4113 extsymcount
= symcount
;
4118 extsymcount
= symcount
- hdr
->sh_info
;
4119 extsymoff
= hdr
->sh_info
;
4122 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4123 if (buf
== NULL
&& extsymcount
!= 0)
4125 bfd_set_error (bfd_error_no_memory
);
4129 /* We store a pointer to the hash table entry for each external
4131 sym_hash
= ((struct elf_link_hash_entry
**)
4133 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4134 if (sym_hash
== NULL
)
4136 bfd_set_error (bfd_error_no_memory
);
4139 elf_sym_hashes (abfd
) = sym_hash
;
4141 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4147 unsigned long strindex
;
4151 /* You can't use -r against a dynamic object. There's no hope
4152 of using a dynamic object which does not exactly match the
4153 format of the output file. */
4154 if (info
->relocateable
4155 || info
->hash
->creator
!= abfd
->xvec
)
4157 bfd_set_error (bfd_error_invalid_operation
);
4161 /* Find the name to use in a DT_NEEDED entry that refers to this
4162 object. If the object has a DT_SONAME entry, we use it.
4163 Otherwise, we use the file name. */
4164 name
= bfd_get_filename (abfd
);
4165 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4168 Elf_External_Dyn
*extdyn
;
4169 Elf_External_Dyn
*extdynend
;
4171 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4174 bfd_set_error (bfd_error_no_memory
);
4178 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4179 (file_ptr
) 0, s
->_raw_size
))
4183 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4184 for (; extdyn
< extdynend
; extdyn
++)
4186 Elf_Internal_Dyn dyn
;
4188 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4189 if (dyn
.d_tag
== DT_SONAME
)
4194 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4197 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4198 name
= elf_string_from_elf_section (abfd
, link
,
4211 /* We do not want to include any of the sections in a dynamic
4212 object in the output file. We hack by simply clobbering the
4213 list of sections in the BFD. This could be handled more
4214 cleanly by, say, a new section flag; the existing
4215 SEC_NEVER_LOAD flag is not the one we want, because that one
4216 still implies that the section takes up space in the output
4218 abfd
->sections
= NULL
;
4220 /* If this is the first dynamic object found in the link, create
4221 the special sections required for dynamic linking. We need
4222 to put them somewhere, and attaching them to the first
4223 dynamic object is as good place as any. */
4224 if (elf_hash_table (info
)->dynobj
== NULL
)
4226 if (! elf_link_create_dynamic_sections (abfd
, info
))
4228 elf_hash_table (info
)->dynobj
= abfd
;
4231 /* Add a DT_NEEDED entry for this dynamic object. */
4232 strindex
= bfd_add_to_strtab (abfd
,
4233 elf_hash_table (info
)->dynstr
,
4236 if (strindex
== (unsigned long) -1)
4238 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4243 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4245 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4246 != extsymcount
* sizeof (Elf_External_Sym
)))
4251 esymend
= buf
+ extsymcount
;
4252 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4254 Elf_Internal_Sym sym
;
4260 struct elf_link_hash_entry
*h
= NULL
;
4263 elf_swap_symbol_in (abfd
, esym
, &sym
);
4265 flags
= BSF_NO_FLAGS
;
4267 value
= sym
.st_value
;
4270 bind
= ELF_ST_BIND (sym
.st_info
);
4271 if (bind
== STB_LOCAL
)
4273 /* This should be impossible, since ELF requires that all
4274 global symbols follow all local symbols, and that sh_info
4275 point to the first global symbol. Unfortunatealy, Irix 5
4279 else if (bind
== STB_GLOBAL
)
4281 else if (bind
== STB_WEAK
)
4285 /* Leave it up to the processor backend. */
4288 if (sym
.st_shndx
== SHN_UNDEF
)
4289 sec
= &bfd_und_section
;
4290 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4292 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4297 else if (sym
.st_shndx
== SHN_ABS
)
4298 sec
= &bfd_abs_section
;
4299 else if (sym
.st_shndx
== SHN_COMMON
)
4301 sec
= &bfd_com_section
;
4302 /* What ELF calls the size we call the value. What ELF
4303 calls the value we call the alignment. */
4304 value
= sym
.st_size
;
4308 /* Leave it up to the processor backend. */
4311 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4312 if (name
== (const char *) NULL
)
4315 if (add_symbol_hook
)
4317 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4321 /* The hook function sets the name to NULL if this symbol
4322 should be skipped for some reason. */
4323 if (name
== (const char *) NULL
)
4327 /* Sanity check that all possibilities were handled. */
4328 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4330 bfd_set_error (bfd_error_bad_value
);
4334 if (sec
== &bfd_und_section
4335 || bfd_is_com_section (sec
))
4340 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4342 /* We need to look up the symbol now in order to get some of
4343 the dynamic object handling right. We pass the hash
4344 table entry in to _bfd_generic_link_add_one_symbol so
4345 that it does not have to look it up again. */
4346 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4347 true, false, false);
4352 /* If we are looking at a dynamic object, and this is a
4353 definition, we need to see if it has already been defined
4354 by some other object. If it has, we want to use the
4355 existing definition, and we do not want to report a
4356 multiple symbol definition error; we do this by
4357 clobbering sec to be bfd_und_section. */
4358 if (dynamic
&& definition
)
4360 if (h
->root
.type
== bfd_link_hash_defined
)
4361 sec
= &bfd_und_section
;
4364 /* Similarly, if we are not looking at a dynamic object, and
4365 we have a definition, we want to override any definition
4366 we may have from a dynamic object. Symbols from regular
4367 files always take precedence over symbols from dynamic
4368 objects, even if they are defined after the dynamic
4369 object in the link. */
4372 && h
->root
.type
== bfd_link_hash_defined
4373 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4374 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4375 == bfd_target_elf_flavour
)
4376 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4379 /* Change the hash table entry to undefined, and let
4380 _bfd_generic_link_add_one_symbol do the right thing
4381 with the new definition. */
4382 h
->root
.type
= bfd_link_hash_undefined
;
4383 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4387 if (! (_bfd_generic_link_add_one_symbol
4388 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4389 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4394 && (flags
& BSF_WEAK
) != 0
4395 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4396 && (*sym_hash
)->weakdef
== NULL
)
4398 /* Keep a list of all weak defined non function symbols from
4399 a dynamic object, using the weakdef field. Later in this
4400 function we will set the weakdef field to the correct
4401 value. We only put non-function symbols from dynamic
4402 objects on this list, because that happens to be the only
4403 time we need to know the normal symbol corresponding to a
4404 weak symbol, and the information is time consuming to
4405 figure out. If the weakdef field is not already NULL,
4406 then this symbol was already defined by some previous
4407 dynamic object, and we will be using that previous
4408 definition anyhow. */
4410 (*sym_hash
)->weakdef
= weaks
;
4414 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4420 /* Remember the symbol size, type and alignment. */
4421 if (sym
.st_size
!= 0)
4423 /* FIXME: We should probably somehow give a warning if
4424 the symbol size changes. */
4425 h
->size
= sym
.st_size
;
4427 if (sym
.st_shndx
== SHN_COMMON
4428 && sym
.st_value
> h
->align
)
4429 h
->align
= sym
.st_value
;
4430 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4432 /* FIXME: We should probably somehow give a warning if
4433 the symbol type changes. */
4434 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4437 /* Set a flag in the hash table entry indicating the type of
4438 reference or definition we just found. Keep a count of
4439 the number of dynamic symbols we find. A dynamic symbol
4440 is one which is referenced or defined by both a regular
4441 object and a shared object, or one which is referenced or
4442 defined by more than one shared object. */
4443 old_flags
= h
->elf_link_hash_flags
;
4448 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4450 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4451 if ((old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4452 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4458 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4460 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4461 if ((old_flags
& new_flag
) != 0)
4464 new_flag
= ELF_LINK_HASH_REF_DYNAMIC_MULTIPLE
;
4466 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC_MULTIPLE
;
4471 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4472 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4477 h
->elf_link_hash_flags
|= new_flag
;
4478 if (dynsym
&& h
->dynindx
== -1)
4480 if (! elf_link_record_dynamic_symbol (info
, h
))
4486 /* Now set the weakdefs field correctly for all the weak defined
4487 symbols we found. The only way to do this is to search all the
4488 symbols. Since we only need the information for non functions in
4489 dynamic objects, that's the only time we actually put anything on
4490 the list WEAKS. We need this information so that if a regular
4491 object refers to a symbol defined weakly in a dynamic object, the
4492 real symbol in the dynamic object is also put in the dynamic
4493 symbols; we also must arrange for both symbols to point to the
4494 same memory location. We could handle the general case of symbol
4495 aliasing, but a general symbol alias can only be generated in
4496 assembler code, handling it correctly would be very time
4497 consuming, and other ELF linkers don't handle general aliasing
4499 while (weaks
!= NULL
)
4501 struct elf_link_hash_entry
*hlook
;
4504 struct elf_link_hash_entry
**hpp
;
4505 struct elf_link_hash_entry
**hppend
;
4508 weaks
= hlook
->weakdef
;
4509 hlook
->weakdef
= NULL
;
4511 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4512 slook
= hlook
->root
.u
.def
.section
;
4513 vlook
= hlook
->root
.u
.def
.value
;
4515 hpp
= elf_sym_hashes (abfd
);
4516 hppend
= hpp
+ extsymcount
;
4517 for (; hpp
< hppend
; hpp
++)
4519 struct elf_link_hash_entry
*h
;
4523 && h
->root
.type
== bfd_link_hash_defined
4524 && h
->root
.u
.def
.section
== slook
4525 && h
->root
.u
.def
.value
== vlook
)
4529 /* If the weak definition is in the list of dynamic
4530 symbols, make sure the real definition is put there
4532 if (hlook
->dynindx
!= -1
4533 && h
->dynindx
== -1)
4535 if (! elf_link_record_dynamic_symbol (info
, h
))
4557 /* Create some sections which will be filled in with dynamic linking
4558 information. The ABFD argument is an input file which is a dynamic
4559 object. The dynamic sections take up virtual memory space when the
4560 final executable is run, so we need to create them before addresses
4561 are assigned to the output sections. We work out the actual
4562 contents and size of these sections later. */
4565 elf_link_create_dynamic_sections (abfd
, info
)
4567 struct bfd_link_info
*info
;
4570 register asection
*s
;
4571 struct elf_link_hash_entry
*h
;
4572 struct elf_backend_data
*bed
;
4574 /* Note that we set the SEC_IN_MEMORY flag for all of these
4576 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4578 s
= bfd_make_section (abfd
, ".interp");
4580 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4583 s
= bfd_make_section (abfd
, ".dynamic");
4585 || ! bfd_set_section_flags (abfd
, s
, flags
)
4586 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4589 /* The special symbol _DYNAMIC is always set to the start of the
4590 .dynamic section. This call occurs before we have processed the
4591 symbols for any dynamic object, so we don't have to worry about
4592 overriding a dynamic definition. We could set _DYNAMIC in a
4593 linker script, but we only want to define it if we are, in fact,
4594 creating a .dynamic section. We don't want to define it if there
4595 is no .dynamic section, since on some ELF platforms the start up
4596 code examines it to decide how to initialize the process. */
4598 if (! (_bfd_generic_link_add_one_symbol
4599 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4600 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4601 (struct bfd_link_hash_entry
**) &h
)))
4603 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4605 s
= bfd_make_section (abfd
, ".dynsym");
4607 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4608 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4611 /* The first .dynsym symbol is a dummy. */
4612 elf_hash_table (info
)->dynsymcount
= 1;
4614 s
= bfd_make_section (abfd
, ".dynstr");
4616 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4619 /* Create a strtab to hold the dynamic symbol names. */
4620 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4621 if (elf_hash_table (info
)->dynstr
== NULL
)
4624 s
= bfd_make_section (abfd
, ".hash");
4626 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4627 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4630 /* Let the backend create the rest of the sections. This lets the
4631 backend set the right flags. The backend will normally create
4632 the .got and .plt sections. */
4633 bed
= get_elf_backend_data (abfd
);
4634 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4637 /* Add an entry to the .dynamic table. */
4640 elf_add_dynamic_entry (info
, tag
, val
)
4641 struct bfd_link_info
*info
;
4645 Elf_Internal_Dyn dyn
;
4649 bfd_byte
*newcontents
;
4651 dynobj
= elf_hash_table (info
)->dynobj
;
4653 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4654 BFD_ASSERT (s
!= NULL
);
4656 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4657 if (s
->contents
== NULL
)
4658 newcontents
= (bfd_byte
*) malloc (newsize
);
4660 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4661 if (newcontents
== NULL
)
4663 bfd_set_error (bfd_error_no_memory
);
4668 dyn
.d_un
.d_val
= val
;
4669 elf_swap_dyn_out (dynobj
, &dyn
,
4670 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4672 s
->_raw_size
= newsize
;
4673 s
->contents
= newcontents
;
4678 /* Record an assignment to a symbol made by a linker script. We need
4679 this in case some dynamic object refers to this symbol. */
4683 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4685 struct bfd_link_info
*info
;
4688 struct elf_link_hash_entry
*h
;
4690 /* This is called after we have examined all the input objects. If
4691 the symbol does not exist, it merely means that no object refers
4692 to it, and we can just ignore it at this point. */
4693 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4694 false, false, false);
4698 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4700 if ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4701 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4702 && h
->dynindx
== -1)
4704 if (! elf_link_record_dynamic_symbol (info
, h
))
4707 /* If this is a weak defined symbol, and we know a corresponding
4708 real symbol from the same dynamic object, make sure the real
4709 symbol is also made into a dynamic symbol. */
4710 if (h
->weakdef
!= NULL
4711 && h
->weakdef
->dynindx
== -1)
4713 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4721 /* Array used to determine the number of hash table buckets to use
4722 based on the number of symbols there are. If there are fewer than
4723 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4724 fewer than 37 we use 17 buckets, and so forth. We never use more
4725 than 521 buckets. */
4727 static const size_t elf_buckets
[] =
4729 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4732 /* Set up the sizes and contents of the ELF dynamic sections. This is
4733 called by the ELF linker emulation before_allocation routine. We
4734 must set the sizes of the sections before the linker sets the
4735 addresses of the various sections. */
4738 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, info
)
4740 struct bfd_link_info
*info
;
4745 Elf_Internal_Sym isym
;
4748 struct elf_backend_data
*bed
;
4750 dynobj
= elf_hash_table (info
)->dynobj
;
4751 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4753 /* If there were no dynamic objects in the link, there is nothing to
4758 /* Set the size of the .dynsym and .hash sections. We counted the
4759 number of dynamic symbols in elf_link_add_object_symbols. We
4760 will build the contents of .dynsym and .hash when we build the
4761 final symbol table, because until then we do not know the correct
4762 value to give the symbols. We built the .dynstr section as we
4763 went along in elf_link_add_object_symbols. */
4764 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4765 BFD_ASSERT (s
!= NULL
);
4766 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4767 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4768 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4770 bfd_set_error (bfd_error_no_memory
);
4774 /* The first entry in .dynsym is a dummy symbol. */
4781 elf_swap_symbol_out (output_bfd
, &isym
,
4782 (Elf_External_Sym
*) s
->contents
);
4784 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4786 bucketcount
= elf_buckets
[i
];
4787 if (dynsymcount
< elf_buckets
[i
+ 1])
4791 s
= bfd_get_section_by_name (dynobj
, ".hash");
4792 BFD_ASSERT (s
!= NULL
);
4793 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4794 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4795 if (s
->contents
== NULL
)
4797 bfd_set_error (bfd_error_no_memory
);
4800 memset (s
->contents
, 0, s
->_raw_size
);
4802 put_word (output_bfd
, bucketcount
, s
->contents
);
4803 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4805 elf_hash_table (info
)->bucketcount
= bucketcount
;
4807 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4808 BFD_ASSERT (s
!= NULL
);
4809 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4810 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4812 /* Find all symbols which were defined in a dynamic object and make
4813 the backend pick a reasonable value for them. */
4814 elf_link_hash_traverse (elf_hash_table (info
),
4815 elf_adjust_dynamic_symbol
,
4818 /* Add some entries to the .dynamic section. We fill in some of the
4819 values later, in elf_bfd_final_link, but we must add the entries
4820 now so that we know the final size of the .dynamic section. */
4821 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4823 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4826 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4828 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4831 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4832 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4833 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4834 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4835 elf_hash_table (info
)->dynstr
->length
)
4836 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4837 sizeof (Elf_External_Sym
)))
4840 /* The backend must work out the sizes of all the other dynamic
4842 bed
= get_elf_backend_data (output_bfd
);
4843 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4846 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4849 /* Make the backend pick a good value for a dynamic symbol. This is
4850 called via elf_link_hash_traverse, and also calls itself
4854 elf_adjust_dynamic_symbol (h
, data
)
4855 struct elf_link_hash_entry
*h
;
4858 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4860 struct elf_backend_data
*bed
;
4862 /* If this symbol is not defined by a dynamic object, or is not
4863 referenced by a regular object, ignore it. FIXME: Do we need to
4864 worry about symbols which are defined by one dynamic object and
4865 referenced by another one? */
4866 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4867 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4868 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4871 /* If we've already adjusted this symbol, don't do it again. This
4872 can happen via a recursive call. */
4873 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4876 /* Don't look at this symbol again. Note that we must set this
4877 after checking the above conditions, because we may look at a
4878 symbol once, decide not to do anything, and then get called
4879 recursively later after REF_REGULAR is set below. */
4880 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4882 /* If this is a weak definition, and we know a real definition, and
4883 the real symbol is not itself defined by a regular object file,
4884 then get a good value for the real definition. We handle the
4885 real symbol first, for the convenience of the backend routine.
4887 Note that there is a confusing case here. If the real definition
4888 is defined by a regular object file, we don't get the real symbol
4889 from the dynamic object, but we do get the weak symbol. If the
4890 processor backend uses a COPY reloc, then if some routine in the
4891 dynamic object changes the real symbol, we will not see that
4892 change in the corresponding weak symbol. This is the way other
4893 ELF linkers work as well, and seems to be a result of the shared
4896 I will clarify this issue. Most SVR4 shared libraries define the
4897 variable _timezone and define timezone as a weak synonym. The
4898 tzset call changes _timezone. If you write
4899 extern int timezone;
4901 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4902 you might expect that, since timezone is a synonym for _timezone,
4903 the same number will print both times. However, if the processor
4904 backend uses a COPY reloc, then actually timezone will be copied
4905 into your process image, and, since you define _timezone
4906 yourself, _timezone will not. Thus timezone and _timezone will
4907 wind up at different memory locations. The tzset call will set
4908 _timezone, leaving timezone unchanged. */
4910 if (h
->weakdef
!= NULL
)
4912 struct elf_link_hash_entry
*weakdef
;
4914 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4915 weakdef
= h
->weakdef
;
4916 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4917 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4918 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4919 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4921 /* This symbol is defined or referenced by a regular object
4922 file, so we will not do anything special. Clear weakdef
4923 for the convenience of the processor backend. */
4928 /* There is an implicit reference by a regular object file
4929 via the weak symbol. */
4930 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
4931 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
4936 dynobj
= elf_hash_table (info
)->dynobj
;
4937 bed
= get_elf_backend_data (dynobj
);
4938 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
4940 /* FIXME: No way to return error. */
4947 /* Final phase of ELF linker. */
4949 /* A structure we use to avoid passing large numbers of arguments. */
4951 struct elf_final_link_info
4953 /* General link information. */
4954 struct bfd_link_info
*info
;
4957 /* Symbol string table. */
4958 struct strtab
*symstrtab
;
4959 /* .dynsym section. */
4960 asection
*dynsym_sec
;
4961 /* .hash section. */
4963 /* Buffer large enough to hold contents of any section. */
4965 /* Buffer large enough to hold external relocs of any section. */
4966 PTR external_relocs
;
4967 /* Buffer large enough to hold internal relocs of any section. */
4968 Elf_Internal_Rela
*internal_relocs
;
4969 /* Buffer large enough to hold external local symbols of any input
4971 Elf_External_Sym
*external_syms
;
4972 /* Buffer large enough to hold internal local symbols of any input
4974 Elf_Internal_Sym
*internal_syms
;
4975 /* Array large enough to hold a symbol index for each local symbol
4976 of any input BFD. */
4978 /* Array large enough to hold a section pointer for each local
4979 symbol of any input BFD. */
4980 asection
**sections
;
4981 /* Buffer to hold swapped out symbols. */
4982 Elf_External_Sym
*symbuf
;
4983 /* Number of swapped out symbols in buffer. */
4984 size_t symbuf_count
;
4985 /* Number of symbols which fit in symbuf. */
4989 static boolean elf_link_output_sym
4990 PARAMS ((struct elf_final_link_info
*, const char *, Elf_Internal_Sym
*));
4991 static boolean elf_link_flush_output_syms
4992 PARAMS ((struct elf_final_link_info
*));
4993 static boolean elf_link_output_extsym
4994 PARAMS ((struct elf_link_hash_entry
*, PTR
));
4995 static boolean elf_link_input_bfd
4996 PARAMS ((struct elf_final_link_info
*, bfd
*));
4997 static boolean elf_reloc_link_order
4998 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4999 struct bfd_link_order
*));
5001 /* Do the final step of an ELF link. */
5004 elf_bfd_final_link (abfd
, info
)
5006 struct bfd_link_info
*info
;
5009 struct elf_final_link_info finfo
;
5010 register asection
*o
;
5011 register struct bfd_link_order
*p
;
5013 size_t max_contents_size
;
5014 size_t max_external_reloc_size
;
5015 size_t max_internal_reloc_count
;
5016 size_t max_sym_count
;
5018 Elf_Internal_Sym elfsym
;
5020 Elf_Internal_Shdr
*symtab_hdr
;
5021 Elf_Internal_Shdr
*symstrtab_hdr
;
5023 dynobj
= elf_hash_table (info
)->dynobj
;
5026 finfo
.output_bfd
= abfd
;
5027 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5028 if (finfo
.symstrtab
== NULL
)
5032 finfo
.dynsym_sec
= NULL
;
5033 finfo
.hash_sec
= NULL
;
5037 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5038 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5039 if (finfo
.dynsym_sec
== NULL
5040 || finfo
.hash_sec
== NULL
)
5043 finfo
.contents
= NULL
;
5044 finfo
.external_relocs
= NULL
;
5045 finfo
.internal_relocs
= NULL
;
5046 finfo
.external_syms
= NULL
;
5047 finfo
.internal_syms
= NULL
;
5048 finfo
.indices
= NULL
;
5049 finfo
.sections
= NULL
;
5050 finfo
.symbuf
= NULL
;
5051 finfo
.symbuf_count
= 0;
5053 /* Count up the number of relocations we will output for each output
5054 section, so that we know the sizes of the reloc sections. We
5055 also figure out some maximum sizes. */
5056 max_contents_size
= 0;
5057 max_external_reloc_size
= 0;
5058 max_internal_reloc_count
= 0;
5060 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5064 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5066 if (p
->type
== bfd_section_reloc_link_order
5067 || p
->type
== bfd_symbol_reloc_link_order
)
5069 else if (p
->type
== bfd_indirect_link_order
)
5073 sec
= p
->u
.indirect
.section
;
5075 if (info
->relocateable
)
5076 o
->reloc_count
+= sec
->reloc_count
;
5078 if (sec
->_raw_size
> max_contents_size
)
5079 max_contents_size
= sec
->_raw_size
;
5080 if (sec
->_cooked_size
> max_contents_size
)
5081 max_contents_size
= sec
->_cooked_size
;
5083 /* We are interested in just local symbols, not all
5085 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5089 if (elf_bad_symtab (sec
->owner
))
5090 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5091 / sizeof (Elf_External_Sym
));
5093 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5095 if (sym_count
> max_sym_count
)
5096 max_sym_count
= sym_count
;
5099 if ((sec
->flags
& SEC_RELOC
) != 0)
5103 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5104 if (ext_size
> max_external_reloc_size
)
5105 max_external_reloc_size
= ext_size
;
5106 if (sec
->reloc_count
> max_internal_reloc_count
)
5107 max_internal_reloc_count
= sec
->reloc_count
;
5112 if (o
->reloc_count
> 0)
5113 o
->flags
|= SEC_RELOC
;
5116 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5117 set it (this is probably a bug) and if it is set
5118 assign_section_numbers will create a reloc section. */
5119 o
->flags
&=~ SEC_RELOC
;
5123 /* Figure out the file positions for everything but the symbol table
5124 and the relocs. We set symcount to force assign_section_numbers
5125 to create a symbol table. */
5126 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5127 BFD_ASSERT (! abfd
->output_has_begun
);
5128 if (! elf_compute_section_file_positions (abfd
, info
))
5131 /* That created the reloc sections. Set their sizes, and assign
5132 them file positions, and allocate some buffers. */
5133 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5135 if ((o
->flags
& SEC_RELOC
) != 0)
5137 Elf_Internal_Shdr
*rel_hdr
;
5138 register struct elf_link_hash_entry
**p
, **pend
;
5140 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5142 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5144 /* The contents field must last into write_object_contents,
5145 so we allocate it with bfd_alloc rather than malloc. */
5146 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5147 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5149 bfd_set_error (bfd_error_no_memory
);
5153 p
= ((struct elf_link_hash_entry
**)
5154 malloc (o
->reloc_count
5155 * sizeof (struct elf_link_hash_entry
*)));
5156 if (p
== NULL
&& o
->reloc_count
!= 0)
5158 bfd_set_error (bfd_error_no_memory
);
5161 elf_section_data (o
)->rel_hashes
= p
;
5162 pend
= p
+ o
->reloc_count
;
5163 for (; p
< pend
; p
++)
5166 /* Use the reloc_count field as an index when outputting the
5172 assign_file_positions_for_relocs (abfd
);
5174 /* We have now assigned file positions for all the sections except
5175 .symtab and .strtab. We start the .symtab section at the current
5176 file position, and write directly to it. We build the .strtab
5177 section in memory. When we add .dynsym support, we will build
5178 that in memory as well (.dynsym is smaller than .symtab). */
5180 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5181 /* sh_name is set in prep_headers. */
5182 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5183 symtab_hdr
->sh_flags
= 0;
5184 symtab_hdr
->sh_addr
= 0;
5185 symtab_hdr
->sh_size
= 0;
5186 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5187 /* sh_link is set in assign_section_numbers. */
5188 /* sh_info is set below. */
5189 /* sh_offset is set just below. */
5190 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5192 off
= elf_tdata (abfd
)->next_file_pos
;
5193 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5195 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5196 incorrect. We do not yet know the size of the .symtab section.
5197 We correct next_file_pos below, after we do know the size. */
5199 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5200 continuously seeking to the right position in the file. */
5201 if (! info
->keep_memory
|| max_sym_count
< 20)
5202 finfo
.symbuf_size
= 20;
5204 finfo
.symbuf_size
= max_sym_count
;
5205 finfo
.symbuf
= ((Elf_External_Sym
*)
5206 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5207 if (finfo
.symbuf
== NULL
)
5209 bfd_set_error (bfd_error_no_memory
);
5213 /* Start writing out the symbol table. The first symbol is always a
5215 elfsym
.st_value
= 0;
5218 elfsym
.st_other
= 0;
5219 elfsym
.st_shndx
= SHN_UNDEF
;
5220 if (! elf_link_output_sym (&finfo
, (const char *) NULL
, &elfsym
))
5224 /* Some standard ELF linkers do this, but we don't because it causes
5225 bootstrap comparison failures. */
5226 /* Output a file symbol for the output file as the second symbol.
5227 We output this even if we are discarding local symbols, although
5228 I'm not sure if this is correct. */
5229 elfsym
.st_value
= 0;
5231 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5232 elfsym
.st_other
= 0;
5233 elfsym
.st_shndx
= SHN_ABS
;
5234 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
), &elfsym
))
5238 /* Output a symbol for each section. We output these even if we are
5239 discarding local symbols, since they are used for relocs. These
5240 symbols have no names. We store the index of each one in the
5241 index field of the section, so that we can find it again when
5242 outputting relocs. */
5243 elfsym
.st_value
= 0;
5245 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5246 elfsym
.st_other
= 0;
5247 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5249 o
= section_from_elf_index (abfd
, i
);
5250 if (o
!= &bfd_abs_section
)
5251 o
->target_index
= abfd
->symcount
;
5252 elfsym
.st_shndx
= i
;
5253 if (! elf_link_output_sym (&finfo
, (const char *) NULL
, &elfsym
))
5257 /* Allocate some memory to hold information read in from the input
5259 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5260 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5261 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5262 malloc (max_internal_reloc_count
5263 * sizeof (Elf_Internal_Rela
)));
5264 finfo
.external_syms
= ((Elf_External_Sym
*)
5265 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5266 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5267 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5268 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5269 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5270 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5271 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5272 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5273 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5274 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5275 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5276 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5278 bfd_set_error (bfd_error_no_memory
);
5282 /* Since ELF permits relocations to be against local symbols, we
5283 must have the local symbols available when we do the relocations.
5284 Since we would rather only read the local symbols once, and we
5285 would rather not keep them in memory, we handle all the
5286 relocations for a single input file at the same time.
5288 Unfortunately, there is no way to know the total number of local
5289 symbols until we have seen all of them, and the local symbol
5290 indices precede the global symbol indices. This means that when
5291 we are generating relocateable output, and we see a reloc against
5292 a global symbol, we can not know the symbol index until we have
5293 finished examining all the local symbols to see which ones we are
5294 going to output. To deal with this, we keep the relocations in
5295 memory, and don't output them until the end of the link. This is
5296 an unfortunate waste of memory, but I don't see a good way around
5297 it. Fortunately, it only happens when performing a relocateable
5298 link, which is not the common case. FIXME: If keep_memory is set
5299 we could write the relocs out and then read them again; I don't
5300 know how bad the memory loss will be. */
5302 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5303 sub
->output_has_begun
= false;
5304 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5306 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5308 if (p
->type
== bfd_indirect_link_order
5309 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5310 == bfd_target_elf_flavour
))
5312 sub
= p
->u
.indirect
.section
->owner
;
5313 if (! sub
->output_has_begun
)
5315 if (! elf_link_input_bfd (&finfo
, sub
))
5317 sub
->output_has_begun
= true;
5320 else if (p
->type
== bfd_section_reloc_link_order
5321 || p
->type
== bfd_symbol_reloc_link_order
)
5323 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5328 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5334 /* That wrote out all the local symbols. Finish up the symbol table
5335 with the global symbols. */
5337 /* The sh_info field records the index of the first non local
5339 symtab_hdr
->sh_info
= abfd
->symcount
;
5341 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5343 /* We get the global symbols from the hash table. */
5344 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5347 /* Flush all symbols to the file. */
5348 if (! elf_link_flush_output_syms (&finfo
))
5351 /* Now we know the size of the symtab section. */
5352 off
+= symtab_hdr
->sh_size
;
5354 /* Finish up the symbol string table (.strtab) section. */
5355 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5356 /* sh_name was set in prep_headers. */
5357 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5358 symstrtab_hdr
->sh_flags
= 0;
5359 symstrtab_hdr
->sh_addr
= 0;
5360 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5361 symstrtab_hdr
->sh_entsize
= 0;
5362 symstrtab_hdr
->sh_link
= 0;
5363 symstrtab_hdr
->sh_info
= 0;
5364 /* sh_offset is set just below. */
5365 symstrtab_hdr
->sh_addralign
= 1;
5366 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5368 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5369 elf_tdata (abfd
)->next_file_pos
= off
;
5371 /* Adjust the relocs to have the correct symbol indices. */
5372 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5374 struct elf_link_hash_entry
**rel_hash
;
5375 Elf_Internal_Shdr
*rel_hdr
;
5377 if ((o
->flags
& SEC_RELOC
) == 0)
5380 rel_hash
= elf_section_data (o
)->rel_hashes
;
5381 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5382 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5384 if (*rel_hash
== NULL
)
5387 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5389 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5391 Elf_External_Rel
*erel
;
5392 Elf_Internal_Rel irel
;
5394 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5395 elf_swap_reloc_in (abfd
, erel
, &irel
);
5396 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5397 ELF_R_TYPE (irel
.r_info
));
5398 elf_swap_reloc_out (abfd
, &irel
, erel
);
5402 Elf_External_Rela
*erela
;
5403 Elf_Internal_Rela irela
;
5405 BFD_ASSERT (rel_hdr
->sh_entsize
5406 == sizeof (Elf_External_Rela
));
5408 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5409 elf_swap_reloca_in (abfd
, erela
, &irela
);
5410 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5411 ELF_R_TYPE (irela
.r_info
));
5412 elf_swap_reloca_out (abfd
, &irela
, erela
);
5416 /* Set the reloc_count field to 0 to prevent write_relocs from
5417 trying to swap the relocs out itself. */
5421 /* If we are linking against a dynamic object, finish up the dynamic
5422 linking information. */
5425 Elf_External_Dyn
*dyncon
, *dynconend
;
5426 struct elf_backend_data
*bed
;
5428 /* Fix up .dynamic entries. */
5429 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5430 BFD_ASSERT (o
!= NULL
);
5432 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5433 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5434 for (; dyncon
< dynconend
; dyncon
++)
5436 Elf_Internal_Dyn dyn
;
5440 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5462 o
= bfd_get_section_by_name (abfd
, name
);
5463 BFD_ASSERT (o
!= NULL
);
5464 dyn
.d_un
.d_ptr
= o
->vma
;
5465 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5472 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5477 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5479 Elf_Internal_Shdr
*hdr
;
5481 hdr
= elf_elfsections (abfd
)[i
];
5482 if (hdr
->sh_type
== type
5483 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5485 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5486 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5489 if (dyn
.d_un
.d_val
== 0
5490 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5491 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5495 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5500 bed
= get_elf_backend_data (abfd
);
5501 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5504 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5506 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5508 BFD_ASSERT ((o
->flags
& SEC_IN_MEMORY
) != 0);
5509 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5510 o
->contents
, o
->output_offset
,
5516 if (finfo
.contents
!= NULL
)
5517 free (finfo
.contents
);
5518 if (finfo
.external_relocs
!= NULL
)
5519 free (finfo
.external_relocs
);
5520 if (finfo
.internal_relocs
!= NULL
)
5521 free (finfo
.internal_relocs
);
5522 if (finfo
.external_syms
!= NULL
)
5523 free (finfo
.external_syms
);
5524 if (finfo
.internal_syms
!= NULL
)
5525 free (finfo
.internal_syms
);
5526 if (finfo
.indices
!= NULL
)
5527 free (finfo
.indices
);
5528 if (finfo
.sections
!= NULL
)
5529 free (finfo
.sections
);
5530 if (finfo
.symbuf
!= NULL
)
5531 free (finfo
.symbuf
);
5532 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5534 if ((o
->flags
& SEC_RELOC
) != 0
5535 && elf_section_data (o
)->rel_hashes
!= NULL
)
5536 free (elf_section_data (o
)->rel_hashes
);
5542 if (finfo
.contents
!= NULL
)
5543 free (finfo
.contents
);
5544 if (finfo
.external_relocs
!= NULL
)
5545 free (finfo
.external_relocs
);
5546 if (finfo
.internal_relocs
!= NULL
)
5547 free (finfo
.internal_relocs
);
5548 if (finfo
.external_syms
!= NULL
)
5549 free (finfo
.external_syms
);
5550 if (finfo
.internal_syms
!= NULL
)
5551 free (finfo
.internal_syms
);
5552 if (finfo
.indices
!= NULL
)
5553 free (finfo
.indices
);
5554 if (finfo
.sections
!= NULL
)
5555 free (finfo
.sections
);
5556 if (finfo
.symbuf
!= NULL
)
5557 free (finfo
.symbuf
);
5558 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5560 if ((o
->flags
& SEC_RELOC
) != 0
5561 && elf_section_data (o
)->rel_hashes
!= NULL
)
5562 free (elf_section_data (o
)->rel_hashes
);
5568 /* Add a symbol to the output symbol table. */
5571 elf_link_output_sym (finfo
, name
, elfsym
)
5572 struct elf_final_link_info
*finfo
;
5574 Elf_Internal_Sym
*elfsym
;
5576 if (name
== (const char *) NULL
|| *name
== '\0')
5577 elfsym
->st_name
= 0;
5580 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5581 finfo
->symstrtab
, name
);
5582 if (elfsym
->st_name
== (unsigned long) -1)
5586 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5588 if (! elf_link_flush_output_syms (finfo
))
5592 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5593 finfo
->symbuf
+ finfo
->symbuf_count
);
5594 ++finfo
->symbuf_count
;
5596 ++finfo
->output_bfd
->symcount
;
5601 /* Flush the output symbols to the file. */
5604 elf_link_flush_output_syms (finfo
)
5605 struct elf_final_link_info
*finfo
;
5607 Elf_Internal_Shdr
*symtab
;
5609 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5611 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5613 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5614 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5615 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5618 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5620 finfo
->symbuf_count
= 0;
5625 /* Add an external symbol to the symbol table. This is called from
5626 the hash table traversal routine. */
5629 elf_link_output_extsym (h
, data
)
5630 struct elf_link_hash_entry
*h
;
5633 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5635 Elf_Internal_Sym sym
;
5637 /* We don't want to output symbols that have never been mentioned by
5638 a regular file, or that we have been told to strip. However, if
5639 h->indx is set to -2, the symbol is used by a reloc and we must
5643 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5644 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5645 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5646 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5648 else if (finfo
->info
->strip
== strip_all
5649 || (finfo
->info
->strip
== strip_some
5650 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5651 h
->root
.root
.string
,
5652 false, false) == NULL
))
5657 /* If we're stripping it, and it's not a dynamic symbol, there's
5658 nothing else to do. */
5659 if (strip
&& h
->dynindx
== -1)
5663 sym
.st_size
= h
->size
;
5664 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5667 switch (h
->root
.type
)
5670 case bfd_link_hash_new
:
5674 case bfd_link_hash_undefined
:
5675 sym
.st_shndx
= SHN_UNDEF
;
5678 case bfd_link_hash_weak
:
5679 sym
.st_shndx
= SHN_UNDEF
;
5680 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5683 case bfd_link_hash_defined
:
5687 sec
= h
->root
.u
.def
.section
;
5688 if (sec
->output_section
!= NULL
)
5690 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5691 sec
->output_section
);
5692 if (sym
.st_shndx
== (unsigned short) -1)
5694 /* FIXME: No way to handle errors. */
5698 /* ELF symbols in relocateable files are section relative,
5699 but in nonrelocateable files they are virtual
5701 sym
.st_value
= h
->root
.u
.def
.value
+ sec
->output_offset
;
5702 if (! finfo
->info
->relocateable
)
5703 sym
.st_value
+= sec
->output_section
->vma
;
5707 BFD_ASSERT (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
5708 && elf_elfheader (sec
->owner
)->e_type
== ET_DYN
);
5709 sym
.st_shndx
= SHN_UNDEF
;
5714 case bfd_link_hash_common
:
5715 sym
.st_shndx
= SHN_COMMON
;
5719 sym
.st_value
= h
->align
;
5722 case bfd_link_hash_indirect
:
5723 case bfd_link_hash_warning
:
5724 /* I have no idea how these should be handled. */
5728 /* If this symbol should be put in the .dynsym section, then put it
5729 there now. We have already know the symbol index. We also fill
5730 in the entry in the .hash section. */
5731 if (h
->dynindx
!= -1)
5733 struct elf_backend_data
*bed
;
5736 bfd_byte
*bucketpos
;
5739 sym
.st_name
= h
->dynstr_index
;
5741 /* Give the processor backend a chance to tweak the symbol
5742 value, and also to finish up anything that needs to be done
5744 bed
= get_elf_backend_data (finfo
->output_bfd
);
5745 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5746 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5748 /* FIXME: No way to return error. */
5752 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5753 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5756 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5757 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5758 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5759 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5760 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5761 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5762 put_word (finfo
->output_bfd
, chain
,
5763 ((bfd_byte
*) finfo
->hash_sec
->contents
5764 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5767 /* If we're stripping it, then it was just a dynamic symbol, and
5768 there's nothing else to do. */
5772 h
->indx
= finfo
->output_bfd
->symcount
;
5774 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
))
5776 /* FIXME: No way to return error. */
5783 /* Link an input file into the linker output file. This function
5784 handles all the sections and relocations of the input file at once.
5785 This is so that we only have to read the local symbols once, and
5786 don't have to keep them in memory. */
5789 elf_link_input_bfd (finfo
, input_bfd
)
5790 struct elf_final_link_info
*finfo
;
5793 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5794 bfd
*, asection
*, bfd_byte
*,
5795 Elf_Internal_Rela
*,
5799 Elf_Internal_Shdr
*symtab_hdr
;
5802 Elf_External_Sym
*esym
;
5803 Elf_External_Sym
*esymend
;
5804 Elf_Internal_Sym
*isym
;
5806 asection
**ppsection
;
5809 output_bfd
= finfo
->output_bfd
;
5811 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5813 /* If this is a dynamic object, we don't want to do anything here:
5814 we don't want the local symbols, and we don't want the section
5816 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5819 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5820 if (elf_bad_symtab (input_bfd
))
5822 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5827 locsymcount
= symtab_hdr
->sh_info
;
5828 extsymoff
= symtab_hdr
->sh_info
;
5831 /* Read the local symbols. */
5832 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5833 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5834 locsymcount
, input_bfd
)
5835 != locsymcount
* sizeof (Elf_External_Sym
)))
5838 /* Swap in the local symbols and write out the ones which we know
5839 are going into the output file. */
5840 esym
= finfo
->external_syms
;
5841 esymend
= esym
+ locsymcount
;
5842 isym
= finfo
->internal_syms
;
5843 pindex
= finfo
->indices
;
5844 ppsection
= finfo
->sections
;
5845 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5851 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5854 if (elf_bad_symtab (input_bfd
))
5856 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5863 if (isym
->st_shndx
== SHN_UNDEF
)
5864 isec
= &bfd_und_section
;
5865 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5867 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5871 else if (isym
->st_shndx
== SHN_ABS
)
5872 isec
= &bfd_abs_section
;
5873 else if (isym
->st_shndx
== SHN_COMMON
)
5874 isec
= &bfd_com_section
;
5883 /* Don't output the first, undefined, symbol. */
5884 if (esym
== finfo
->external_syms
)
5887 /* If we are stripping all symbols, we don't want to output this
5889 if (finfo
->info
->strip
== strip_all
)
5892 /* We never output section symbols. Instead, we use the section
5893 symbol of the corresponding section in the output file. */
5894 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5897 /* If we are discarding all local symbols, we don't want to
5898 output this one. If we are generating a relocateable output
5899 file, then some of the local symbols may be required by
5900 relocs; we output them below as we discover that they are
5902 if (finfo
->info
->discard
== discard_all
)
5905 /* Get the name of the symbol. */
5906 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5911 /* See if we are discarding symbols with this name. */
5912 if ((finfo
->info
->strip
== strip_some
5913 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5915 || (finfo
->info
->discard
== discard_l
5916 && strncmp (name
, finfo
->info
->lprefix
,
5917 finfo
->info
->lprefix_len
) == 0))
5920 /* If we get here, we are going to output this symbol. */
5922 /* Adjust the section index for the output file. */
5923 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
5924 isec
->output_section
);
5925 if (isym
->st_shndx
== (unsigned short) -1)
5928 *pindex
= output_bfd
->symcount
;
5930 /* ELF symbols in relocateable files are section relative, but
5931 in executable files they are virtual addresses. Note that
5932 this code assumes that all ELF sections have an associated
5933 BFD section with a reasonable value for output_offset; below
5934 we assume that they also have a reasonable value for
5935 output_section. Any special sections must be set up to meet
5936 these requirements. */
5937 oldval
= isym
->st_value
;
5938 isym
->st_value
+= isec
->output_offset
;
5939 if (! finfo
->info
->relocateable
)
5940 isym
->st_value
+= isec
->output_section
->vma
;
5942 if (! elf_link_output_sym (finfo
, name
, isym
))
5945 /* Restore the old value for reloc handling. */
5946 isym
->st_value
= oldval
;
5949 /* Relocate the contents of each section. */
5950 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5952 Elf_Internal_Shdr
*input_rel_hdr
;
5954 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5957 /* Read the contents of the section. */
5958 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5959 (file_ptr
) 0, o
->_raw_size
))
5962 if ((o
->flags
& SEC_RELOC
) != 0)
5964 /* Read in the relocs. */
5965 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5966 if (bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
) != 0
5967 || bfd_read (finfo
->external_relocs
, 1, input_rel_hdr
->sh_size
,
5968 input_bfd
) != input_rel_hdr
->sh_size
)
5971 /* Swap in the relocs. For convenience, we always produce
5972 an Elf_Internal_Rela array; if the relocs are Rel, we set
5974 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5976 Elf_External_Rel
*erel
;
5977 Elf_External_Rel
*erelend
;
5978 Elf_Internal_Rela
*irela
;
5980 erel
= (Elf_External_Rel
*) finfo
->external_relocs
;
5981 erelend
= erel
+ o
->reloc_count
;
5982 irela
= finfo
->internal_relocs
;
5983 for (; erel
< erelend
; erel
++, irela
++)
5985 Elf_Internal_Rel irel
;
5987 elf_swap_reloc_in (input_bfd
, erel
, &irel
);
5988 irela
->r_offset
= irel
.r_offset
;
5989 irela
->r_info
= irel
.r_info
;
5990 irela
->r_addend
= 0;
5995 Elf_External_Rela
*erela
;
5996 Elf_External_Rela
*erelaend
;
5997 Elf_Internal_Rela
*irela
;
5999 BFD_ASSERT (input_rel_hdr
->sh_entsize
6000 == sizeof (Elf_External_Rela
));
6002 erela
= (Elf_External_Rela
*) finfo
->external_relocs
;
6003 erelaend
= erela
+ o
->reloc_count
;
6004 irela
= finfo
->internal_relocs
;
6005 for (; erela
< erelaend
; erela
++, irela
++)
6006 elf_swap_reloca_in (input_bfd
, erela
, irela
);
6009 /* Relocate the section by invoking a back end routine.
6011 The back end routine is responsible for adjusting the
6012 section contents as necessary, and (if using Rela relocs
6013 and generating a relocateable output file) adjusting the
6014 reloc addend as necessary.
6016 The back end routine does not have to worry about setting
6017 the reloc address or the reloc symbol index.
6019 The back end routine is given a pointer to the swapped in
6020 internal symbols, and can access the hash table entries
6021 for the external symbols via elf_sym_hashes (input_bfd).
6023 When generating relocateable output, the back end routine
6024 must handle STB_LOCAL/STT_SECTION symbols specially. The
6025 output symbol is going to be a section symbol
6026 corresponding to the output section, which will require
6027 the addend to be adjusted. */
6029 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6032 finfo
->internal_relocs
,
6033 finfo
->internal_syms
,
6037 if (finfo
->info
->relocateable
)
6039 Elf_Internal_Rela
*irela
;
6040 Elf_Internal_Rela
*irelaend
;
6041 struct elf_link_hash_entry
**rel_hash
;
6042 Elf_Internal_Shdr
*output_rel_hdr
;
6044 /* Adjust the reloc addresses and symbol indices. */
6046 irela
= finfo
->internal_relocs
;
6047 irelaend
= irela
+ o
->reloc_count
;
6048 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6049 + o
->output_section
->reloc_count
);
6050 for (; irela
< irelaend
; irela
++, rel_hash
++)
6053 Elf_Internal_Sym
*isym
;
6056 irela
->r_offset
+= o
->output_offset
;
6058 r_symndx
= ELF_R_SYM (irela
->r_info
);
6063 if (r_symndx
>= locsymcount
6064 || (elf_bad_symtab (input_bfd
)
6065 && finfo
->sections
[r_symndx
] == NULL
))
6069 /* This is a reloc against a global symbol. We
6070 have not yet output all the local symbols, so
6071 we do not know the symbol index of any global
6072 symbol. We set the rel_hash entry for this
6073 reloc to point to the global hash table entry
6074 for this symbol. The symbol index is then
6075 set at the end of elf_bfd_final_link. */
6076 indx
= r_symndx
- extsymoff
;
6077 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6079 /* Setting the index to -2 tells
6080 elf_link_output_extsym that this symbol is
6082 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6083 (*rel_hash
)->indx
= -2;
6088 /* This is a reloc against a local symbol. */
6091 isym
= finfo
->internal_syms
+ r_symndx
;
6092 sec
= finfo
->sections
[r_symndx
];
6093 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6095 /* I suppose the backend ought to fill in the
6096 section of any STT_SECTION symbol against a
6097 processor specific section. */
6099 || sec
== &bfd_und_section
6100 || sec
== &bfd_com_section
)
6102 bfd_set_error (bfd_error_bad_value
);
6105 else if (sec
== &bfd_abs_section
)
6109 r_symndx
= sec
->output_section
->target_index
;
6116 if (finfo
->indices
[r_symndx
] == -1)
6122 if (finfo
->info
->strip
== strip_all
)
6124 /* You can't do ld -r -s. */
6125 bfd_set_error (bfd_error_invalid_operation
);
6129 /* This symbol was skipped earlier, but
6130 since it is needed by a reloc, we
6131 must output it now. */
6132 link
= symtab_hdr
->sh_link
;
6133 name
= elf_string_from_elf_section (input_bfd
,
6139 osec
= sec
->output_section
;
6141 elf_section_from_bfd_section (output_bfd
,
6143 if (isym
->st_shndx
== (unsigned short) -1)
6146 isym
->st_value
+= sec
->output_offset
;
6147 if (! finfo
->info
->relocateable
)
6148 isym
->st_value
+= osec
->vma
;
6150 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6152 if (! elf_link_output_sym (finfo
, name
, isym
))
6156 r_symndx
= finfo
->indices
[r_symndx
];
6159 irela
->r_info
= ELF_R_INFO (r_symndx
,
6160 ELF_R_TYPE (irela
->r_info
));
6163 /* Swap out the relocs. */
6164 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6165 BFD_ASSERT (output_rel_hdr
->sh_entsize
6166 == input_rel_hdr
->sh_entsize
);
6167 irela
= finfo
->internal_relocs
;
6168 irelaend
= irela
+ o
->reloc_count
;
6169 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6171 Elf_External_Rel
*erel
;
6173 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6174 + o
->output_section
->reloc_count
);
6175 for (; irela
< irelaend
; irela
++, erel
++)
6177 Elf_Internal_Rel irel
;
6179 irel
.r_offset
= irela
->r_offset
;
6180 irel
.r_info
= irela
->r_info
;
6181 BFD_ASSERT (irela
->r_addend
== 0);
6182 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6187 Elf_External_Rela
*erela
;
6189 BFD_ASSERT (input_rel_hdr
->sh_entsize
6190 == sizeof (Elf_External_Rela
));
6191 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6192 + o
->output_section
->reloc_count
);
6193 for (; irela
< irelaend
; irela
++, erela
++)
6194 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6197 o
->output_section
->reloc_count
+= o
->reloc_count
;
6201 /* Write out the modified section contents. */
6202 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6203 finfo
->contents
, o
->output_offset
,
6204 (o
->_cooked_size
!= 0
6213 /* Generate a reloc when linking an ELF file. This is a reloc
6214 requested by the linker, and does come from any input file. This
6215 is used to build constructor and destructor tables when linking
6219 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6221 struct bfd_link_info
*info
;
6222 asection
*output_section
;
6223 struct bfd_link_order
*link_order
;
6225 const reloc_howto_type
*howto
;
6228 struct elf_link_hash_entry
**rel_hash_ptr
;
6229 Elf_Internal_Shdr
*rel_hdr
;
6231 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6234 bfd_set_error (bfd_error_bad_value
);
6238 /* If this is an inplace reloc, we must write the addend into the
6240 if (howto
->partial_inplace
6241 && link_order
->u
.reloc
.p
->addend
!= 0)
6244 bfd_reloc_status_type rstat
;
6248 size
= bfd_get_reloc_size (howto
);
6249 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6250 if (buf
== (bfd_byte
*) NULL
)
6252 bfd_set_error (bfd_error_no_memory
);
6255 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6256 link_order
->u
.reloc
.p
->addend
, buf
);
6262 case bfd_reloc_outofrange
:
6264 case bfd_reloc_overflow
:
6265 if (! ((*info
->callbacks
->reloc_overflow
)
6267 (link_order
->type
== bfd_section_reloc_link_order
6268 ? bfd_section_name (output_bfd
,
6269 link_order
->u
.reloc
.p
->u
.section
)
6270 : link_order
->u
.reloc
.p
->u
.name
),
6271 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6272 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6279 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6280 (file_ptr
) link_order
->offset
, size
);
6286 /* Figure out the symbol index. */
6287 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6288 + output_section
->reloc_count
);
6289 if (link_order
->type
== bfd_section_reloc_link_order
)
6291 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6294 *rel_hash_ptr
= NULL
;
6298 struct elf_link_hash_entry
*h
;
6300 h
= elf_link_hash_lookup (elf_hash_table (info
),
6301 link_order
->u
.reloc
.p
->u
.name
,
6302 false, false, true);
6305 /* Setting the index to -2 tells elf_link_output_extsym that
6306 this symbol is used by a reloc. */
6313 if (! ((*info
->callbacks
->unattached_reloc
)
6314 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6315 (asection
*) NULL
, (bfd_vma
) 0)))
6321 /* The address of a reloc is relative to the section in a
6322 relocateable file, and is a virtual address in an executable
6324 offset
= link_order
->offset
;
6325 if (! info
->relocateable
)
6326 offset
+= output_section
->vma
;
6328 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6330 if (rel_hdr
->sh_type
== SHT_REL
)
6332 Elf_Internal_Rel irel
;
6333 Elf_External_Rel
*erel
;
6335 irel
.r_offset
= offset
;
6336 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6337 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6338 + output_section
->reloc_count
);
6339 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6343 Elf_Internal_Rela irela
;
6344 Elf_External_Rela
*erela
;
6346 irela
.r_offset
= offset
;
6347 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6348 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6349 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6350 + output_section
->reloc_count
);
6351 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6354 ++output_section
->reloc_count
;