1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
98 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
99 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
100 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
101 #define elf_get_symtab NAME(bfd_elf,get_symtab)
102 #define elf_canonicalize_dynamic_symtab \
103 NAME(bfd_elf,canonicalize_dynamic_symtab)
104 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
105 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
106 #define elf_print_symbol NAME(bfd_elf,print_symbol)
107 #define elf_get_lineno NAME(bfd_elf,get_lineno)
108 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
109 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
110 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
111 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
112 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
113 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
114 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
115 #define write_relocs NAME(bfd_elf,_write_relocs)
116 #define elf_find_section NAME(bfd_elf,find_section)
117 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
118 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
119 #define elf_link_create_dynamic_sections \
120 NAME(bfd_elf,link_create_dynamic_sections)
121 #define elf_link_record_dynamic_symbol \
122 NAME(bfd_elf,link_record_dynamic_symbol)
123 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
126 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
127 #define ELF_R_SYM(X) ELF64_R_SYM(X)
128 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
129 #define ELFCLASS ELFCLASS64
131 #define LOG_FILE_ALIGN 3
134 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
135 #define ELF_R_SYM(X) ELF32_R_SYM(X)
136 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
137 #define ELFCLASS ELFCLASS32
139 #define LOG_FILE_ALIGN 2
142 /* Forward declarations of static functions */
144 static unsigned long bfd_add_to_strtab
145 PARAMS ((bfd
*, struct strtab
*, const char *));
146 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
148 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
150 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
152 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
154 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
155 struct symbol_cache_entry
**));
157 static boolean elf_compute_section_file_positions
158 PARAMS ((bfd
*, struct bfd_link_info
*));
159 static boolean prep_headers
PARAMS ((bfd
*));
160 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
161 static boolean assign_section_numbers
PARAMS ((bfd
*));
162 static file_ptr align_file_position
PARAMS ((file_ptr
));
163 static file_ptr assign_file_position_for_section
164 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
165 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
166 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
167 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
168 static file_ptr map_program_segments
169 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
171 static boolean elf_map_symbols
PARAMS ((bfd
*));
172 static boolean swap_out_syms
PARAMS ((bfd
*));
174 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
177 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
178 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
181 #define elf_string_from_elf_strtab(abfd,strindex) \
182 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
185 /* Structure swapping routines */
187 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
188 can be handled by explicitly specifying 32 bits or "the long type". */
190 #define put_word bfd_h_put_64
191 #define get_word bfd_h_get_64
194 #define put_word bfd_h_put_32
195 #define get_word bfd_h_get_32
198 /* Translate an ELF symbol in external format into an ELF symbol in internal
202 elf_swap_symbol_in (abfd
, src
, dst
)
204 Elf_External_Sym
*src
;
205 Elf_Internal_Sym
*dst
;
207 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
208 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
209 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
210 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
211 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
212 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
215 /* Translate an ELF symbol in internal format into an ELF symbol in external
219 elf_swap_symbol_out (abfd
, src
, dst
)
221 Elf_Internal_Sym
*src
;
222 Elf_External_Sym
*dst
;
224 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
225 put_word (abfd
, src
->st_value
, dst
->st_value
);
226 put_word (abfd
, src
->st_size
, dst
->st_size
);
227 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
228 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
229 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
233 /* Translate an ELF file header in external format into an ELF file header in
237 elf_swap_ehdr_in (abfd
, src
, dst
)
239 Elf_External_Ehdr
*src
;
240 Elf_Internal_Ehdr
*dst
;
242 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
243 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
244 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
245 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
246 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
247 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
248 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
249 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
250 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
251 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
252 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
253 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
254 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
255 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
258 /* Translate an ELF file header in internal format into an ELF file header in
262 elf_swap_ehdr_out (abfd
, src
, dst
)
264 Elf_Internal_Ehdr
*src
;
265 Elf_External_Ehdr
*dst
;
267 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
268 /* note that all elements of dst are *arrays of unsigned char* already... */
269 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
270 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
271 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
272 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
273 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
274 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
275 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
276 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
277 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
278 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
279 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
280 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
281 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
285 /* Translate an ELF section header table entry in external format into an
286 ELF section header table entry in internal format. */
289 elf_swap_shdr_in (abfd
, src
, dst
)
291 Elf_External_Shdr
*src
;
292 Elf_Internal_Shdr
*dst
;
294 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
295 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
296 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
297 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
298 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
299 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
300 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
301 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
302 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
303 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
304 /* we haven't done any processing on it yet, so... */
305 dst
->rawdata
= (void *) 0;
308 /* Translate an ELF section header table entry in internal format into an
309 ELF section header table entry in external format. */
312 elf_swap_shdr_out (abfd
, src
, dst
)
314 Elf_Internal_Shdr
*src
;
315 Elf_External_Shdr
*dst
;
317 /* note that all elements of dst are *arrays of unsigned char* already... */
318 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
319 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
320 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
321 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
322 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
323 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
324 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
325 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
326 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
327 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
331 /* Translate an ELF program header table entry in external format into an
332 ELF program header table entry in internal format. */
335 elf_swap_phdr_in (abfd
, src
, dst
)
337 Elf_External_Phdr
*src
;
338 Elf_Internal_Phdr
*dst
;
340 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
341 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
342 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
343 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
344 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
345 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
346 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
347 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
351 elf_swap_phdr_out (abfd
, src
, dst
)
353 Elf_Internal_Phdr
*src
;
354 Elf_External_Phdr
*dst
;
356 /* note that all elements of dst are *arrays of unsigned char* already... */
357 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
358 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
359 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
360 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
361 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
362 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
363 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
364 put_word (abfd
, src
->p_align
, dst
->p_align
);
367 /* Translate an ELF reloc from external format to internal format. */
369 elf_swap_reloc_in (abfd
, src
, dst
)
371 Elf_External_Rel
*src
;
372 Elf_Internal_Rel
*dst
;
374 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
375 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
379 elf_swap_reloca_in (abfd
, src
, dst
)
381 Elf_External_Rela
*src
;
382 Elf_Internal_Rela
*dst
;
384 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
385 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
386 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
389 /* Translate an ELF reloc from internal format to external format. */
391 elf_swap_reloc_out (abfd
, src
, dst
)
393 Elf_Internal_Rel
*src
;
394 Elf_External_Rel
*dst
;
396 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
397 put_word (abfd
, src
->r_info
, dst
->r_info
);
401 elf_swap_reloca_out (abfd
, src
, dst
)
403 Elf_Internal_Rela
*src
;
404 Elf_External_Rela
*dst
;
406 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
407 put_word (abfd
, src
->r_info
, dst
->r_info
);
408 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
412 elf_swap_dyn_in (abfd
, src
, dst
)
414 const Elf_External_Dyn
*src
;
415 Elf_Internal_Dyn
*dst
;
417 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
418 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
422 elf_swap_dyn_out (abfd
, src
, dst
)
424 const Elf_Internal_Dyn
*src
;
425 Elf_External_Dyn
*dst
;
427 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
428 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
431 /* String table creation/manipulation routines */
433 static struct strtab
*
434 bfd_new_strtab (abfd
)
439 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
442 bfd_set_error (bfd_error_no_memory
);
445 ss
->tab
= malloc (1);
448 bfd_set_error (bfd_error_no_memory
);
459 bfd_add_to_strtab (abfd
, ss
, str
)
464 /* should search first, but for now: */
465 /* include the trailing NUL */
466 int ln
= strlen (str
) + 1;
468 /* FIXME: This is slow. Also, we could combine this with the a.out
469 string table building and use a hash table, although it might not
470 be worth it since ELF symbols don't include debugging information
471 and thus have much less overlap. */
472 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
475 bfd_set_error (bfd_error_no_memory
);
476 return (unsigned long) -1;
479 strcpy (ss
->tab
+ ss
->length
, str
);
483 return ss
->length
- ln
;
487 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
493 /* should search first, but for now: */
494 /* include the trailing NUL */
495 int ln
= strlen (str
) + strlen (str2
) + 1;
497 /* should this be using obstacks? */
499 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
501 ss
->tab
= malloc (ln
);
503 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
504 strcpy (ss
->tab
+ ss
->length
, str
);
505 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
509 return ss
->length
- ln
;
512 /* ELF .o/exec file reading */
514 /* Create a new bfd section from an ELF section header. */
517 bfd_section_from_shdr (abfd
, shindex
)
519 unsigned int shindex
;
521 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
522 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
525 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
527 switch (hdr
->sh_type
)
530 /* Inactive section. Throw it away. */
533 case SHT_PROGBITS
: /* Normal section with contents. */
534 case SHT_DYNAMIC
: /* Dynamic linking information. */
535 case SHT_NOBITS
: /* .bss section. */
536 case SHT_HASH
: /* .hash section. */
537 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
539 case SHT_SYMTAB
: /* A symbol table */
540 if (elf_onesymtab (abfd
) == shindex
)
543 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
544 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
545 elf_onesymtab (abfd
) = shindex
;
546 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
547 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
548 abfd
->flags
|= HAS_SYMS
;
550 /* Sometimes a shared object will map in the symbol table. If
551 SHF_ALLOC is set, and this is a shared object, then we also
552 treat this section as a BFD section. We can not base the
553 decision purely on SHF_ALLOC, because that flag is sometimes
554 set in a relocateable object file, which would confuse the
556 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
557 && (abfd
->flags
& DYNAMIC
) != 0
558 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
563 case SHT_DYNSYM
: /* A dynamic symbol table */
564 if (elf_dynsymtab (abfd
) == shindex
)
567 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
568 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
569 elf_dynsymtab (abfd
) = shindex
;
570 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
571 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
572 abfd
->flags
|= HAS_SYMS
;
574 /* Besides being a symbol table, we also treat this as a regular
575 section, so that objcopy can handle it. */
576 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
578 case SHT_STRTAB
: /* A string table */
579 if (hdr
->rawdata
!= NULL
)
581 if (ehdr
->e_shstrndx
== shindex
)
583 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
584 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
585 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
591 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
593 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
594 if (hdr2
->sh_link
== shindex
)
596 if (! bfd_section_from_shdr (abfd
, i
))
598 if (elf_onesymtab (abfd
) == i
)
600 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
601 elf_elfsections (abfd
)[shindex
] =
602 &elf_tdata (abfd
)->strtab_hdr
;
605 if (elf_dynsymtab (abfd
) == i
)
607 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
608 elf_elfsections (abfd
)[shindex
] =
609 &elf_tdata (abfd
)->dynstrtab_hdr
;
610 /* We also treat this as a regular section, so
611 that objcopy can handle it. */
614 #if 0 /* Not handling other string tables specially right now. */
615 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
616 /* We have a strtab for some random other section. */
617 newsect
= (asection
*) hdr2
->rawdata
;
620 hdr
->rawdata
= (PTR
) newsect
;
621 hdr2
= &elf_section_data (newsect
)->str_hdr
;
623 elf_elfsections (abfd
)[shindex
] = hdr2
;
629 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
633 /* *These* do a lot of work -- but build no sections! */
635 asection
*target_sect
;
636 Elf_Internal_Shdr
*hdr2
;
637 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
639 /* Get the symbol table. */
640 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
643 /* If this reloc section does not use the main symbol table we
644 don't treat it as a reloc section. BFD can't adequately
645 represent such a section, so at least for now, we don't
646 try. We just present it as a normal section. */
647 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
648 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
650 /* Don't allow REL relocations on a machine that uses RELA and
652 /* @@ Actually, the generic ABI does suggest that both might be
653 used in one file. But the four ABI Processor Supplements I
654 have access to right now all specify that only one is used on
655 each of those architectures. It's conceivable that, e.g., a
656 bunch of absolute 32-bit relocs might be more compact in REL
657 form even on a RELA machine... */
658 BFD_ASSERT (use_rela_p
659 ? (hdr
->sh_type
== SHT_RELA
660 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
661 : (hdr
->sh_type
== SHT_REL
662 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
664 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
666 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
667 if (target_sect
== NULL
668 || elf_section_data (target_sect
) == NULL
)
671 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
673 elf_elfsections (abfd
)[shindex
] = hdr2
;
674 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
675 target_sect
->flags
|= SEC_RELOC
;
676 target_sect
->relocation
= NULL
;
677 target_sect
->rel_filepos
= hdr
->sh_offset
;
678 abfd
->flags
|= HAS_RELOC
;
685 fprintf (stderr
, "Note Sections not yet supported.\n");
692 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
697 /* Check for any processor-specific section types. */
699 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
701 if (bed
->elf_backend_section_from_shdr
)
702 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
711 elf_new_section_hook (abfd
, sec
)
716 struct bfd_elf_section_data
*sdata
;
718 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
721 bfd_set_error (bfd_error_no_memory
);
724 sec
->used_by_bfd
= (PTR
) sdata
;
725 memset (sdata
, 0, sizeof (*sdata
));
729 /* Create a new bfd section from an ELF program header.
731 Since program segments have no names, we generate a synthetic name
732 of the form segment<NUM>, where NUM is generally the index in the
733 program header table. For segments that are split (see below) we
734 generate the names segment<NUM>a and segment<NUM>b.
736 Note that some program segments may have a file size that is different than
737 (less than) the memory size. All this means is that at execution the
738 system must allocate the amount of memory specified by the memory size,
739 but only initialize it with the first "file size" bytes read from the
740 file. This would occur for example, with program segments consisting
741 of combined data+bss.
743 To handle the above situation, this routine generates TWO bfd sections
744 for the single program segment. The first has the length specified by
745 the file size of the segment, and the second has the length specified
746 by the difference between the two sizes. In effect, the segment is split
747 into it's initialized and uninitialized parts.
752 bfd_section_from_phdr (abfd
, hdr
, index
)
754 Elf_Internal_Phdr
*hdr
;
762 split
= ((hdr
->p_memsz
> 0) &&
763 (hdr
->p_filesz
> 0) &&
764 (hdr
->p_memsz
> hdr
->p_filesz
));
765 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
766 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
769 bfd_set_error (bfd_error_no_memory
);
772 strcpy (name
, namebuf
);
773 newsect
= bfd_make_section (abfd
, name
);
776 newsect
->vma
= hdr
->p_vaddr
;
777 newsect
->_raw_size
= hdr
->p_filesz
;
778 newsect
->filepos
= hdr
->p_offset
;
779 newsect
->flags
|= SEC_HAS_CONTENTS
;
780 if (hdr
->p_type
== PT_LOAD
)
782 newsect
->flags
|= SEC_ALLOC
;
783 newsect
->flags
|= SEC_LOAD
;
784 if (hdr
->p_flags
& PF_X
)
786 /* FIXME: all we known is that it has execute PERMISSION,
788 newsect
->flags
|= SEC_CODE
;
791 if (!(hdr
->p_flags
& PF_W
))
793 newsect
->flags
|= SEC_READONLY
;
798 sprintf (namebuf
, "segment%db", index
);
799 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
802 bfd_set_error (bfd_error_no_memory
);
805 strcpy (name
, namebuf
);
806 newsect
= bfd_make_section (abfd
, name
);
809 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
810 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
811 if (hdr
->p_type
== PT_LOAD
)
813 newsect
->flags
|= SEC_ALLOC
;
814 if (hdr
->p_flags
& PF_X
)
815 newsect
->flags
|= SEC_CODE
;
817 if (!(hdr
->p_flags
& PF_W
))
818 newsect
->flags
|= SEC_READONLY
;
824 /* Begin processing a given object.
826 First we validate the file by reading in the ELF header and checking
829 static INLINE boolean
831 Elf_External_Ehdr
*x_ehdrp
;
833 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
834 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
835 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
836 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
839 /* Check to see if the file associated with ABFD matches the target vector
842 Note that we may be called several times with the same ABFD, but different
843 target vectors, most of which will not match. We have to avoid leaving
844 any side effects in ABFD, or any data it points to (like tdata), if the
845 file does not match the target vector. */
851 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
852 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
853 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
854 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
855 unsigned int shindex
;
856 char *shstrtab
; /* Internal copy of section header stringtab */
857 struct elf_backend_data
*ebd
;
858 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
859 struct elf_obj_tdata
*new_tdata
= NULL
;
861 /* Read in the ELF header in external format. */
863 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
865 if (bfd_get_error () != bfd_error_system_call
)
866 goto got_wrong_format_error
;
871 /* Now check to see if we have a valid ELF file, and one that BFD can
872 make use of. The magic number must match, the address size ('class')
873 and byte-swapping must match our XVEC entry, and it must have a
874 section header table (FIXME: See comments re sections at top of this
877 if ((elf_file_p (&x_ehdr
) == false) ||
878 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
879 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
880 goto got_wrong_format_error
;
882 /* Check that file's byte order matches xvec's */
883 switch (x_ehdr
.e_ident
[EI_DATA
])
885 case ELFDATA2MSB
: /* Big-endian */
886 if (!abfd
->xvec
->header_byteorder_big_p
)
887 goto got_wrong_format_error
;
889 case ELFDATA2LSB
: /* Little-endian */
890 if (abfd
->xvec
->header_byteorder_big_p
)
891 goto got_wrong_format_error
;
893 case ELFDATANONE
: /* No data encoding specified */
894 default: /* Unknown data encoding specified */
895 goto got_wrong_format_error
;
898 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
899 the tdata pointer in the bfd. */
901 new_tdata
= ((struct elf_obj_tdata
*)
902 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
903 if (new_tdata
== NULL
)
904 goto got_no_memory_error
;
905 elf_tdata (abfd
) = new_tdata
;
907 /* Now that we know the byte order, swap in the rest of the header */
908 i_ehdrp
= elf_elfheader (abfd
);
909 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
911 elf_debug_file (i_ehdrp
);
914 /* If there is no section header table, we're hosed. */
915 if (i_ehdrp
->e_shoff
== 0)
916 goto got_wrong_format_error
;
918 /* As a simple sanity check, verify that the what BFD thinks is the
919 size of each section header table entry actually matches the size
920 recorded in the file. */
921 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
922 goto got_wrong_format_error
;
924 ebd
= get_elf_backend_data (abfd
);
926 /* Check that the ELF e_machine field matches what this particular
927 BFD format expects. */
928 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
930 const bfd_target
* const *target_ptr
;
932 if (ebd
->elf_machine_code
!= EM_NONE
)
933 goto got_wrong_format_error
;
935 /* This is the generic ELF target. Let it match any ELF target
936 for which we do not have a specific backend. */
937 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
939 struct elf_backend_data
*back
;
941 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
943 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
944 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
946 /* target_ptr is an ELF backend which matches this
947 object file, so reject the generic ELF target. */
948 goto got_wrong_format_error
;
953 if (i_ehdrp
->e_type
== ET_EXEC
)
954 abfd
->flags
|= EXEC_P
;
955 else if (i_ehdrp
->e_type
== ET_DYN
)
956 abfd
->flags
|= DYNAMIC
;
958 if (i_ehdrp
->e_phnum
> 0)
959 abfd
->flags
|= D_PAGED
;
961 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
964 /* Remember the entry point specified in the ELF file header. */
965 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
967 /* Allocate space for a copy of the section header table in
968 internal form, seek to the section header table in the file,
969 read it in, and convert it to internal form. */
970 i_shdrp
= ((Elf_Internal_Shdr
*)
971 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
972 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
974 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
975 if (!i_shdrp
|| !elf_elfsections (abfd
))
976 goto got_no_memory_error
;
977 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
979 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
981 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
983 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
984 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
986 if (i_ehdrp
->e_shstrndx
)
988 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
992 /* Read in the string table containing the names of the sections. We
993 will need the base pointer to this table later. */
994 /* We read this inline now, so that we don't have to go through
995 bfd_section_from_shdr with it (since this particular strtab is
996 used to find all of the ELF section names.) */
998 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
1002 /* Once all of the section headers have been read and converted, we
1003 can start processing them. Note that the first section header is
1004 a dummy placeholder entry, so we ignore it. */
1006 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1008 if (! bfd_section_from_shdr (abfd
, shindex
))
1012 /* Let the backend double check the format and override global
1014 if (ebd
->elf_backend_object_p
)
1016 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
1017 goto got_wrong_format_error
;
1020 return (abfd
->xvec
);
1022 got_wrong_format_error
:
1023 bfd_set_error (bfd_error_wrong_format
);
1025 got_no_memory_error
:
1026 bfd_set_error (bfd_error_no_memory
);
1029 if (new_tdata
!= NULL
1030 && new_tdata
->elf_sect_ptr
!= NULL
)
1031 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1032 if (i_shdrp
!= NULL
)
1033 bfd_release (abfd
, i_shdrp
);
1034 if (new_tdata
!= NULL
)
1035 bfd_release (abfd
, new_tdata
);
1036 elf_tdata (abfd
) = preserved_tdata
;
1041 /* ELF .o/exec file writing */
1043 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1044 of the symbol if there is one. */
1045 static INLINE elf_symbol_type
*
1046 elf_symbol_from (ignore_abfd
, symbol
)
1050 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1053 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1056 return (elf_symbol_type
*) symbol
;
1060 write_relocs (abfd
, sec
, xxx
)
1065 Elf_Internal_Shdr
*rela_hdr
;
1066 Elf_External_Rela
*outbound_relocas
;
1067 Elf_External_Rel
*outbound_relocs
;
1069 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1070 asymbol
*last_sym
= 0;
1071 int last_sym_idx
= 9999999; /* should always be written before use */
1073 if ((sec
->flags
& SEC_RELOC
) == 0)
1076 /* The linker backend writes the relocs out itself, and sets the
1077 reloc_count field to zero to inhibit writing them here. Also,
1078 sometimes the SEC_RELOC flag gets set even when there aren't any
1080 if (sec
->reloc_count
== 0)
1083 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1085 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1086 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1087 if (!rela_hdr
->contents
)
1089 bfd_set_error (bfd_error_no_memory
);
1090 abort (); /* FIXME */
1093 /* orelocation has the data, reloc_count has the count... */
1096 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1098 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1100 Elf_Internal_Rela dst_rela
;
1101 Elf_External_Rela
*src_rela
;
1106 ptr
= sec
->orelocation
[idx
];
1107 src_rela
= outbound_relocas
+ idx
;
1108 if (!(abfd
->flags
& EXEC_P
))
1109 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1111 dst_rela
.r_offset
= ptr
->address
;
1113 sym
= *ptr
->sym_ptr_ptr
;
1114 if (sym
== last_sym
)
1119 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1121 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1123 dst_rela
.r_addend
= ptr
->addend
;
1124 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1128 /* REL relocations */
1130 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1132 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1134 Elf_Internal_Rel dst_rel
;
1135 Elf_External_Rel
*src_rel
;
1140 ptr
= sec
->orelocation
[idx
];
1141 sym
= *ptr
->sym_ptr_ptr
;
1142 src_rel
= outbound_relocs
+ idx
;
1143 if (!(abfd
->flags
& EXEC_P
))
1144 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1146 dst_rel
.r_offset
= ptr
->address
;
1148 if (sym
== last_sym
)
1153 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1155 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1157 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1162 /* Set up an ELF internal section header for a section. */
1166 elf_fake_sections (abfd
, asect
, ignore
)
1171 Elf_Internal_Shdr
*this_hdr
;
1173 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1175 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1177 if (this_hdr
->sh_name
== (unsigned long) -1)
1178 abort (); /* FIXME */
1180 this_hdr
->sh_flags
= 0;
1181 if ((asect
->flags
& SEC_ALLOC
) != 0)
1182 this_hdr
->sh_addr
= asect
->vma
;
1184 this_hdr
->sh_addr
= 0;
1185 this_hdr
->sh_offset
= 0;
1186 this_hdr
->sh_size
= asect
->_raw_size
;
1187 this_hdr
->sh_link
= 0;
1188 this_hdr
->sh_info
= 0;
1189 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1190 this_hdr
->sh_entsize
= 0;
1192 this_hdr
->rawdata
= (PTR
) asect
;
1193 this_hdr
->contents
= NULL
;
1196 /* FIXME: This should not be based on section names. */
1197 if (strcmp (asect
->name
, ".dynstr") == 0)
1198 this_hdr
->sh_type
= SHT_STRTAB
;
1199 else if (strcmp (asect
->name
, ".hash") == 0)
1201 this_hdr
->sh_type
= SHT_HASH
;
1202 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1204 else if (strcmp (asect
->name
, ".dynsym") == 0)
1206 this_hdr
->sh_type
= SHT_DYNSYM
;
1207 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1209 else if (strcmp (asect
->name
, ".dynamic") == 0)
1211 this_hdr
->sh_type
= SHT_DYNAMIC
;
1212 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1214 else if (strncmp (asect
->name
, ".rela", 5) == 0
1215 && get_elf_backend_data (abfd
)->use_rela_p
)
1217 this_hdr
->sh_type
= SHT_RELA
;
1218 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1220 else if (strncmp (asect
->name
, ".rel", 4) == 0
1221 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1223 this_hdr
->sh_type
= SHT_REL
;
1224 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1226 else if (strcmp (asect
->name
, ".note") == 0)
1227 this_hdr
->sh_type
= SHT_NOTE
;
1228 else if (strncmp (asect
->name
, ".stab", 5) == 0
1229 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1230 this_hdr
->sh_type
= SHT_STRTAB
;
1231 else if ((asect
->flags
& SEC_ALLOC
) != 0
1232 && (asect
->flags
& SEC_LOAD
) != 0)
1233 this_hdr
->sh_type
= SHT_PROGBITS
;
1234 else if ((asect
->flags
& SEC_ALLOC
) != 0
1235 && ((asect
->flags
& SEC_LOAD
) == 0))
1237 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1238 || strcmp (asect
->name
, ".sbss") == 0);
1239 this_hdr
->sh_type
= SHT_NOBITS
;
1244 this_hdr
->sh_type
= SHT_PROGBITS
;
1247 if ((asect
->flags
& SEC_ALLOC
) != 0)
1248 this_hdr
->sh_flags
|= SHF_ALLOC
;
1249 if ((asect
->flags
& SEC_READONLY
) == 0)
1250 this_hdr
->sh_flags
|= SHF_WRITE
;
1251 if ((asect
->flags
& SEC_CODE
) != 0)
1252 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1254 /* Check for processor-specific section types. */
1256 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1258 if (bed
->elf_backend_fake_sections
)
1259 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1262 /* If the section has relocs, set up a section header for the
1263 SHT_REL[A] section. */
1264 if ((asect
->flags
& SEC_RELOC
) != 0)
1266 Elf_Internal_Shdr
*rela_hdr
;
1267 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1269 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1271 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1272 use_rela_p
? ".rela" : ".rel",
1274 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1275 rela_hdr
->sh_entsize
= (use_rela_p
1276 ? sizeof (Elf_External_Rela
)
1277 : sizeof (Elf_External_Rel
));
1278 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1279 rela_hdr
->sh_flags
= 0;
1280 rela_hdr
->sh_addr
= 0;
1281 rela_hdr
->sh_size
= 0;
1282 rela_hdr
->sh_offset
= 0;
1287 /* Assign all ELF section numbers. The dummy first section is handled here
1288 too. The link/info pointers for the standard section types are filled
1289 in here too, while we're at it. */
1292 assign_section_numbers (abfd
)
1295 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1297 unsigned int section_number
;
1298 Elf_Internal_Shdr
**i_shdrp
;
1302 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1304 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1306 d
->this_idx
= section_number
++;
1307 if ((sec
->flags
& SEC_RELOC
) == 0)
1310 d
->rel_idx
= section_number
++;
1313 t
->shstrtab_section
= section_number
++;
1314 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1315 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1316 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1318 if (abfd
->symcount
> 0)
1320 t
->symtab_section
= section_number
++;
1321 t
->strtab_section
= section_number
++;
1324 elf_elfheader (abfd
)->e_shnum
= section_number
;
1326 /* Set up the list of section header pointers, in agreement with the
1328 i_shdrp
= ((Elf_Internal_Shdr
**)
1329 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1330 if (i_shdrp
== NULL
)
1332 bfd_set_error (bfd_error_no_memory
);
1336 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1337 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1338 if (i_shdrp
[0] == NULL
)
1340 bfd_release (abfd
, i_shdrp
);
1341 bfd_set_error (bfd_error_no_memory
);
1344 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1346 elf_elfsections (abfd
) = i_shdrp
;
1348 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1349 if (abfd
->symcount
> 0)
1351 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1352 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1353 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1355 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1357 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1361 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1362 if (d
->rel_idx
!= 0)
1363 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1365 /* Fill in the sh_link and sh_info fields while we're at it. */
1367 /* sh_link of a reloc section is the section index of the symbol
1368 table. sh_info is the section index of the section to which
1369 the relocation entries apply. */
1370 if (d
->rel_idx
!= 0)
1372 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1373 d
->rel_hdr
.sh_info
= d
->this_idx
;
1376 switch (d
->this_hdr
.sh_type
)
1380 /* A reloc section which we are treating as a normal BFD
1381 section. sh_link is the section index of the symbol
1382 table. sh_info is the section index of the section to
1383 which the relocation entries apply. We assume that an
1384 allocated reloc section uses the dynamic symbol table.
1385 FIXME: How can we be sure? */
1386 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1388 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1390 /* We look up the section the relocs apply to by name. */
1392 if (d
->this_hdr
.sh_type
== SHT_REL
)
1396 s
= bfd_get_section_by_name (abfd
, name
);
1398 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1402 /* We assume that a section named .stab*str is a stabs
1403 string section. We look for a section with the same name
1404 but without the trailing ``str'', and set its sh_link
1405 field to point to this section. */
1406 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1407 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1412 len
= strlen (sec
->name
);
1413 alc
= (char *) malloc (len
- 2);
1416 bfd_set_error (bfd_error_no_memory
);
1419 strncpy (alc
, sec
->name
, len
- 3);
1420 alc
[len
- 3] = '\0';
1421 s
= bfd_get_section_by_name (abfd
, alc
);
1425 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1427 /* This is a .stab section. */
1428 elf_section_data (s
)->this_hdr
.sh_entsize
=
1429 4 + 2 * (ARCH_SIZE
/ 8);
1436 /* sh_link is the section header index of the string table
1437 used for the dynamic entries or symbol table. */
1438 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1440 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1444 /* sh_link is the section header index of the symbol table
1445 this hash table is for. */
1446 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1448 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1456 /* Map symbol from it's internal number to the external number, moving
1457 all local symbols to be at the head of the list. */
1460 sym_is_global (abfd
, sym
)
1464 /* If the backend has a special mapping, use it. */
1465 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1466 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1469 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1471 if (sym
->flags
& BSF_LOCAL
)
1475 if (sym
->section
== 0)
1477 /* Is this valid? */
1482 if (bfd_is_und_section (sym
->section
))
1484 if (bfd_is_com_section (sym
->section
))
1486 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1492 elf_map_symbols (abfd
)
1495 int symcount
= bfd_get_symcount (abfd
);
1496 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1497 asymbol
**sect_syms
;
1499 int num_globals
= 0;
1500 int num_locals2
= 0;
1501 int num_globals2
= 0;
1503 int num_sections
= 0;
1504 Elf_Sym_Extra
*sym_extra
;
1509 fprintf (stderr
, "elf_map_symbols\n");
1513 /* Add local symbols for each section for which there are relocs.
1514 FIXME: How can we tell which sections have relocs at this point?
1515 Will reloc_count always be accurate? Actually, I think most ELF
1516 targets create section symbols for all sections anyhow. */
1517 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1519 if (max_index
< asect
->index
)
1520 max_index
= asect
->index
;
1524 elf_num_section_syms (abfd
) = max_index
;
1525 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1526 elf_section_syms (abfd
) = sect_syms
;
1530 bfd_set_error (bfd_error_no_memory
);
1534 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1536 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1539 bfd_set_error (bfd_error_no_memory
);
1542 sym
->the_bfd
= abfd
;
1543 sym
->name
= asect
->name
;
1544 sym
->value
= asect
->vma
;
1545 sym
->flags
= BSF_SECTION_SYM
;
1546 sym
->section
= asect
;
1547 sect_syms
[asect
->index
] = sym
;
1551 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1552 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1559 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1560 ((symcount
+ num_sections
+ 1)
1561 * sizeof (asymbol
*)));
1563 syms
= (asymbol
**) bfd_alloc (abfd
,
1564 (num_sections
+ 1) * sizeof (asymbol
*));
1567 bfd_set_error (bfd_error_no_memory
);
1571 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1573 if (sect_syms
[asect
->index
])
1574 syms
[symcount
++] = sect_syms
[asect
->index
];
1577 syms
[symcount
] = (asymbol
*) 0;
1578 bfd_set_symtab (abfd
, syms
, symcount
);
1581 elf_sym_extra (abfd
) = sym_extra
1582 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1585 bfd_set_error (bfd_error_no_memory
);
1589 /* Identify and classify all of the symbols. */
1590 for (idx
= 0; idx
< symcount
; idx
++)
1592 if (!sym_is_global (abfd
, syms
[idx
]))
1598 /* Now provide mapping information. Add +1 for skipping over the
1600 for (idx
= 0; idx
< symcount
; idx
++)
1602 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1603 if (!sym_is_global (abfd
, syms
[idx
]))
1604 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1606 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1609 elf_num_locals (abfd
) = num_locals
;
1610 elf_num_globals (abfd
) = num_globals
;
1614 /* Compute the file positions we are going to put the sections at, and
1615 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1616 is not NULL, this is being called by the ELF backend linker. */
1619 elf_compute_section_file_positions (abfd
, link_info
)
1621 struct bfd_link_info
*link_info
;
1623 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1624 Elf_Internal_Shdr
*shstrtab_hdr
;
1626 if (abfd
->output_has_begun
)
1629 /* Do any elf backend specific processing first. */
1630 if (bed
->elf_backend_begin_write_processing
)
1631 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1633 if (! prep_headers (abfd
))
1636 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1638 if (!assign_section_numbers (abfd
))
1641 /* The backend linker builds symbol table information itself. */
1642 if (link_info
== NULL
)
1644 if (! swap_out_syms (abfd
))
1648 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1649 /* sh_name was set in prep_headers. */
1650 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1651 shstrtab_hdr
->sh_flags
= 0;
1652 shstrtab_hdr
->sh_addr
= 0;
1653 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1654 shstrtab_hdr
->sh_entsize
= 0;
1655 shstrtab_hdr
->sh_link
= 0;
1656 shstrtab_hdr
->sh_info
= 0;
1657 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1658 shstrtab_hdr
->sh_addralign
= 1;
1659 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1661 if (!assign_file_positions_except_relocs (abfd
,
1662 link_info
== NULL
? true : false))
1665 abfd
->output_has_begun
= true;
1671 /* Align to the maximum file alignment that could be required for any
1672 ELF data structure. */
1674 static INLINE file_ptr
1675 align_file_position (off
)
1678 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1681 /* Assign a file position to a section, optionally aligning to the
1682 required section alignment. */
1684 static INLINE file_ptr
1685 assign_file_position_for_section (i_shdrp
, offset
, align
)
1686 Elf_Internal_Shdr
*i_shdrp
;
1694 al
= i_shdrp
->sh_addralign
;
1696 offset
= BFD_ALIGN (offset
, al
);
1698 i_shdrp
->sh_offset
= offset
;
1699 if (i_shdrp
->rawdata
!= NULL
)
1700 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1701 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1702 offset
+= i_shdrp
->sh_size
;
1706 /* Get the size of the program header. This is called by the linker
1707 before any of the section VMA's are set, so it can't calculate the
1708 correct value for a strange memory layout. */
1710 static bfd_size_type
1711 get_program_header_size (abfd
)
1717 /* Assume we will need exactly two PT_LOAD segments: one for text
1718 and one for data. */
1721 s
= bfd_get_section_by_name (abfd
, ".interp");
1722 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1724 /* If we have a loadable interpreter section, we need a
1725 PT_INTERP segment. In this case, assume we also need a
1726 PT_PHDR segment, although that may not be true for all
1731 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1733 /* We need a PT_DYNAMIC segment. */
1737 return segs
* sizeof (Elf_External_Phdr
);
1740 /* Create the program header. OFF is the file offset where the
1741 program header should be written. FIRST is the first loadable ELF
1742 section. PHDR_SIZE is the size of the program header as returned
1743 by get_program_header_size. */
1746 map_program_segments (abfd
, off
, first
, phdr_size
)
1749 Elf_Internal_Shdr
*first
;
1750 bfd_size_type phdr_size
;
1752 Elf_Internal_Phdr phdrs
[10];
1753 unsigned int phdr_count
;
1754 Elf_Internal_Phdr
*phdr
;
1755 int phdr_size_adjust
;
1757 Elf_Internal_Shdr
**hdrpp
;
1758 asection
*sinterp
, *sdyn
;
1759 unsigned int last_type
;
1760 Elf_Internal_Ehdr
*i_ehdrp
;
1762 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1763 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1764 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1769 phdr_size_adjust
= 0;
1771 /* If we have a loadable .interp section, we must create a PT_INTERP
1772 segment which must precede all PT_LOAD segments. We assume that
1773 we must also create a PT_PHDR segment, although that may not be
1774 true for all targets. */
1775 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1776 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1778 BFD_ASSERT (first
!= NULL
);
1780 phdr
->p_type
= PT_PHDR
;
1782 phdr
->p_offset
= off
;
1784 /* Account for any adjustment made because of the alignment of
1785 the first loadable section. */
1786 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1787 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1789 /* The program header precedes all loadable sections. This lets
1790 us compute its loadable address. This depends on the linker
1792 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1795 phdr
->p_filesz
= phdr_size
;
1796 phdr
->p_memsz
= phdr_size
;
1798 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1799 phdr
->p_flags
= PF_R
| PF_X
;
1801 phdr
->p_align
= FILE_ALIGN
;
1802 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1804 /* Include the ELF header in the first loadable segment. */
1805 phdr_size_adjust
+= off
;
1810 phdr
->p_type
= PT_INTERP
;
1811 phdr
->p_offset
= sinterp
->filepos
;
1812 phdr
->p_vaddr
= sinterp
->vma
;
1814 phdr
->p_filesz
= sinterp
->_raw_size
;
1815 phdr
->p_memsz
= sinterp
->_raw_size
;
1816 phdr
->p_flags
= PF_R
;
1817 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1823 /* Look through the sections to see how they will be divided into
1824 program segments. The sections must be arranged in order by
1825 sh_addr for this to work correctly. */
1826 phdr
->p_type
= PT_NULL
;
1827 last_type
= SHT_PROGBITS
;
1828 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1829 i
< elf_elfheader (abfd
)->e_shnum
;
1832 Elf_Internal_Shdr
*hdr
;
1836 /* Ignore any section which will not be part of the process
1838 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1841 /* If this section fits in the segment we are constructing, add
1843 if (phdr
->p_type
!= PT_NULL
1844 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1845 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1846 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1848 bfd_size_type adjust
;
1850 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1851 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1852 if (hdr
->sh_type
!= SHT_NOBITS
)
1853 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1854 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1855 phdr
->p_flags
|= PF_W
;
1856 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1857 phdr
->p_flags
|= PF_X
;
1858 last_type
= hdr
->sh_type
;
1862 /* If we have a segment, move to the next one. */
1863 if (phdr
->p_type
!= PT_NULL
)
1869 /* Start a new segment. */
1870 phdr
->p_type
= PT_LOAD
;
1871 phdr
->p_offset
= hdr
->sh_offset
;
1872 phdr
->p_vaddr
= hdr
->sh_addr
;
1874 if (hdr
->sh_type
== SHT_NOBITS
)
1877 phdr
->p_filesz
= hdr
->sh_size
;
1878 phdr
->p_memsz
= hdr
->sh_size
;
1879 phdr
->p_flags
= PF_R
;
1880 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1881 phdr
->p_flags
|= PF_W
;
1882 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1883 phdr
->p_flags
|= PF_X
;
1884 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1888 && (sinterp
->flags
& SEC_LOAD
) != 0)
1890 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1891 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1892 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1893 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1896 last_type
= hdr
->sh_type
;
1899 if (phdr
->p_type
!= PT_NULL
)
1905 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1906 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1907 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1909 phdr
->p_type
= PT_DYNAMIC
;
1910 phdr
->p_offset
= sdyn
->filepos
;
1911 phdr
->p_vaddr
= sdyn
->vma
;
1913 phdr
->p_filesz
= sdyn
->_raw_size
;
1914 phdr
->p_memsz
= sdyn
->_raw_size
;
1915 phdr
->p_flags
= PF_R
;
1916 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1917 phdr
->p_flags
|= PF_W
;
1918 if ((sdyn
->flags
& SEC_CODE
) != 0)
1919 phdr
->p_flags
|= PF_X
;
1920 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1926 /* Make sure the return value from get_program_header_size matches
1927 what we computed here. */
1928 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1931 /* Set up program header information. */
1932 i_ehdrp
= elf_elfheader (abfd
);
1933 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1934 i_ehdrp
->e_phoff
= off
;
1935 i_ehdrp
->e_phnum
= phdr_count
;
1937 /* Save the program headers away. I don't think anybody uses this
1938 information right now. */
1939 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1942 * sizeof (Elf_Internal_Phdr
))));
1943 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1945 bfd_set_error (bfd_error_no_memory
);
1946 return (file_ptr
) -1;
1948 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1949 phdr_count
* sizeof (Elf_Internal_Phdr
));
1951 /* Write out the program headers. */
1952 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1953 return (file_ptr
) -1;
1955 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1957 Elf_External_Phdr extphdr
;
1959 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1960 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1961 != sizeof (Elf_External_Phdr
))
1962 return (file_ptr
) -1;
1965 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1968 /* Work out the file positions of all the sections. This is called by
1969 elf_compute_section_file_positions. All the section sizes and VMAs
1970 must be known before this is called.
1972 We do not consider reloc sections at this point, unless they form
1973 part of the loadable image. Reloc sections are assigned file
1974 positions in assign_file_positions_for_relocs, which is called by
1975 write_object_contents and final_link.
1977 If DOSYMS is false, we do not assign file positions for the symbol
1978 table or the string table. */
1981 assign_file_positions_except_relocs (abfd
, dosyms
)
1985 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1986 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1987 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1990 /* Start after the ELF header. */
1991 off
= i_ehdrp
->e_ehsize
;
1993 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1995 Elf_Internal_Shdr
**hdrpp
;
1998 /* We are not creating an executable, which means that we are
1999 not creating a program header, and that the actual order of
2000 the sections in the file is unimportant. */
2001 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2003 Elf_Internal_Shdr
*hdr
;
2006 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2008 hdr
->sh_offset
= -1;
2012 && (i
== tdata
->symtab_section
2013 || i
== tdata
->strtab_section
))
2015 hdr
->sh_offset
= -1;
2019 off
= assign_file_position_for_section (hdr
, off
, true);
2025 bfd_size_type phdr_size
;
2026 bfd_vma maxpagesize
;
2027 Elf_Internal_Shdr
**hdrpp
;
2029 Elf_Internal_Shdr
*first
;
2032 /* We are creating an executable. We must create a program
2033 header. We can't actually create the program header until we
2034 have set the file positions for the sections, but we can
2035 figure out how big it is going to be. */
2036 off
= align_file_position (off
);
2037 phdr_size
= get_program_header_size (abfd
);
2038 if (phdr_size
== (file_ptr
) -1)
2043 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2044 if (maxpagesize
== 0)
2047 /* FIXME: We might want to sort the sections on the sh_addr
2048 field here. For now, we just assume that the linker will
2049 create the sections in an appropriate order. */
2051 /* Assign file positions in two passes. In the first pass, we
2052 assign a file position to every section which forms part of
2053 the executable image. */
2055 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2057 Elf_Internal_Shdr
*hdr
;
2060 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2066 if ((abfd
->flags
& D_PAGED
) != 0)
2068 /* The section VMA must equal the file position modulo
2069 the page size. This is required by the program
2071 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2074 off
= assign_file_position_for_section (hdr
, off
, false);
2077 /* Assign file positions to all the sections which do not form
2078 part of the loadable image, except for the relocs. */
2079 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2081 Elf_Internal_Shdr
*hdr
;
2084 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2086 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2088 hdr
->sh_offset
= -1;
2092 && (i
== tdata
->symtab_section
2093 || i
== tdata
->strtab_section
))
2095 hdr
->sh_offset
= -1;
2099 off
= assign_file_position_for_section (hdr
, off
, true);
2102 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2103 if (phdr_map
== (file_ptr
) -1)
2105 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2108 /* Place the section headers. */
2109 off
= align_file_position (off
);
2110 i_ehdrp
->e_shoff
= off
;
2111 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2113 elf_tdata (abfd
)->next_file_pos
= off
;
2122 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2123 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2124 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2126 struct strtab
*shstrtab
;
2128 i_ehdrp
= elf_elfheader (abfd
);
2129 i_shdrp
= elf_elfsections (abfd
);
2131 shstrtab
= bfd_new_strtab (abfd
);
2135 elf_shstrtab (abfd
) = shstrtab
;
2137 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2138 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2139 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2140 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2142 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2143 i_ehdrp
->e_ident
[EI_DATA
] =
2144 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2145 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2147 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2148 i_ehdrp
->e_ident
[count
] = 0;
2150 if ((abfd
->flags
& DYNAMIC
) != 0)
2151 i_ehdrp
->e_type
= ET_DYN
;
2152 else if ((abfd
->flags
& EXEC_P
) != 0)
2153 i_ehdrp
->e_type
= ET_EXEC
;
2155 i_ehdrp
->e_type
= ET_REL
;
2157 switch (bfd_get_arch (abfd
))
2159 case bfd_arch_unknown
:
2160 i_ehdrp
->e_machine
= EM_NONE
;
2162 case bfd_arch_sparc
:
2164 i_ehdrp
->e_machine
= EM_SPARC64
;
2166 i_ehdrp
->e_machine
= EM_SPARC
;
2170 i_ehdrp
->e_machine
= EM_386
;
2173 i_ehdrp
->e_machine
= EM_68K
;
2176 i_ehdrp
->e_machine
= EM_88K
;
2179 i_ehdrp
->e_machine
= EM_860
;
2181 case bfd_arch_mips
: /* MIPS Rxxxx */
2182 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2185 i_ehdrp
->e_machine
= EM_PARISC
;
2187 case bfd_arch_powerpc
:
2188 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2190 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2192 i_ehdrp
->e_machine
= EM_NONE
;
2194 i_ehdrp
->e_version
= EV_CURRENT
;
2195 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2197 /* no program header, for now. */
2198 i_ehdrp
->e_phoff
= 0;
2199 i_ehdrp
->e_phentsize
= 0;
2200 i_ehdrp
->e_phnum
= 0;
2202 /* each bfd section is section header entry */
2203 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2204 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2206 /* if we're building an executable, we'll need a program header table */
2207 if (abfd
->flags
& EXEC_P
)
2209 /* it all happens later */
2211 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2213 /* elf_build_phdrs() returns a (NULL-terminated) array of
2214 Elf_Internal_Phdrs */
2215 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2216 i_ehdrp
->e_phoff
= outbase
;
2217 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2222 i_ehdrp
->e_phentsize
= 0;
2224 i_ehdrp
->e_phoff
= 0;
2227 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2229 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2231 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2233 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2234 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2235 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2242 swap_out_syms (abfd
)
2245 if (!elf_map_symbols (abfd
))
2248 /* Dump out the symtabs. */
2250 int symcount
= bfd_get_symcount (abfd
);
2251 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2252 struct strtab
*stt
= bfd_new_strtab (abfd
);
2253 Elf_Internal_Shdr
*symtab_hdr
;
2254 Elf_Internal_Shdr
*symstrtab_hdr
;
2255 Elf_External_Sym
*outbound_syms
;
2260 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2261 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2262 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2263 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2264 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2265 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2267 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2268 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2270 outbound_syms
= (Elf_External_Sym
*)
2271 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2274 bfd_set_error (bfd_error_no_memory
);
2277 /* now generate the data (for "contents") */
2279 /* Fill in zeroth symbol and swap it out. */
2280 Elf_Internal_Sym sym
;
2286 sym
.st_shndx
= SHN_UNDEF
;
2287 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2289 for (idx
= 0; idx
< symcount
; idx
++)
2291 Elf_Internal_Sym sym
;
2292 bfd_vma value
= syms
[idx
]->value
;
2293 elf_symbol_type
*type_ptr
;
2295 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2296 /* Section symbols have no names. */
2300 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2301 if (sym
.st_name
== (unsigned long) -1)
2305 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2307 if (bfd_is_com_section (syms
[idx
]->section
))
2309 /* ELF common symbols put the alignment into the `value' field,
2310 and the size into the `size' field. This is backwards from
2311 how BFD handles it, so reverse it here. */
2312 sym
.st_size
= value
;
2313 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2314 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2315 syms
[idx
]->section
);
2319 asection
*sec
= syms
[idx
]->section
;
2322 if (sec
->output_section
)
2324 value
+= sec
->output_offset
;
2325 sec
= sec
->output_section
;
2328 sym
.st_value
= value
;
2329 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2330 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2334 /* Writing this would be a hell of a lot easier if we had
2335 some decent documentation on bfd, and knew what to expect
2336 of the library, and what to demand of applications. For
2337 example, it appears that `objcopy' might not set the
2338 section of a symbol to be a section that is actually in
2340 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2341 BFD_ASSERT (sec2
!= 0);
2342 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2343 BFD_ASSERT (shndx
!= -1);
2347 if (bfd_is_com_section (syms
[idx
]->section
))
2348 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2349 else if (bfd_is_und_section (syms
[idx
]->section
))
2350 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2351 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2352 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2353 else if (syms
[idx
]->flags
& BSF_FILE
)
2354 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2357 int bind
= STB_LOCAL
;
2358 int type
= STT_OBJECT
;
2359 unsigned int flags
= syms
[idx
]->flags
;
2361 if (flags
& BSF_LOCAL
)
2363 else if (flags
& BSF_WEAK
)
2365 else if (flags
& BSF_GLOBAL
)
2368 if (flags
& BSF_FUNCTION
)
2371 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2375 elf_swap_symbol_out (abfd
, &sym
,
2377 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2380 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2381 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2382 symstrtab_hdr
->sh_size
= stt
->length
;
2383 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2385 symstrtab_hdr
->sh_flags
= 0;
2386 symstrtab_hdr
->sh_addr
= 0;
2387 symstrtab_hdr
->sh_entsize
= 0;
2388 symstrtab_hdr
->sh_link
= 0;
2389 symstrtab_hdr
->sh_info
= 0;
2390 symstrtab_hdr
->sh_addralign
= 1;
2391 symstrtab_hdr
->size
= 0;
2398 write_shdrs_and_ehdr (abfd
)
2401 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2402 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2403 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2404 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2406 struct strtab
*shstrtab
;
2408 i_ehdrp
= elf_elfheader (abfd
);
2409 i_shdrp
= elf_elfsections (abfd
);
2410 shstrtab
= elf_shstrtab (abfd
);
2412 /* swap the header before spitting it out... */
2415 elf_debug_file (i_ehdrp
);
2417 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2418 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2419 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2420 != sizeof (x_ehdr
)))
2423 /* at this point we've concocted all the ELF sections... */
2424 x_shdrp
= (Elf_External_Shdr
*)
2425 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2428 bfd_set_error (bfd_error_no_memory
);
2432 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2435 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2438 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2440 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2441 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2442 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2445 /* need to dump the string table too... */
2450 /* Assign file positions for all the reloc sections which are not part
2451 of the loadable file image. */
2454 assign_file_positions_for_relocs (abfd
)
2459 Elf_Internal_Shdr
**shdrpp
;
2461 off
= elf_tdata (abfd
)->next_file_pos
;
2463 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2464 i
< elf_elfheader (abfd
)->e_shnum
;
2467 Elf_Internal_Shdr
*shdrp
;
2470 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2471 && shdrp
->sh_offset
== -1)
2472 off
= assign_file_position_for_section (shdrp
, off
, true);
2475 elf_tdata (abfd
)->next_file_pos
= off
;
2479 NAME(bfd_elf
,write_object_contents
) (abfd
)
2482 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2483 Elf_Internal_Ehdr
*i_ehdrp
;
2484 Elf_Internal_Shdr
**i_shdrp
;
2487 if (! abfd
->output_has_begun
2488 && ! elf_compute_section_file_positions (abfd
,
2489 (struct bfd_link_info
*) NULL
))
2492 i_shdrp
= elf_elfsections (abfd
);
2493 i_ehdrp
= elf_elfheader (abfd
);
2495 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2496 assign_file_positions_for_relocs (abfd
);
2498 /* After writing the headers, we need to write the sections too... */
2499 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2501 if (bed
->elf_backend_section_processing
)
2502 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2503 if (i_shdrp
[count
]->contents
)
2505 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2506 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2508 != i_shdrp
[count
]->sh_size
))
2513 if (bed
->elf_backend_final_write_processing
)
2514 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
2516 return write_shdrs_and_ehdr (abfd
);
2519 /* Given an index of a section, retrieve a pointer to it. Note
2520 that for our purposes, sections are indexed by {1, 2, ...} with
2521 0 being an illegal index. */
2523 /* In the original, each ELF section went into exactly one BFD
2524 section. This doesn't really make sense, so we need a real mapping.
2525 The mapping has to hide in the Elf_Internal_Shdr since asection
2526 doesn't have anything like a tdata field... */
2529 section_from_elf_index (abfd
, index
)
2533 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2534 be returned from this routine? */
2536 if (index
== SHN_ABS
)
2537 return bfd_com_section_ptr
; /* not abs? */
2538 if (index
== SHN_COMMON
)
2539 return bfd_com_section_ptr
;
2541 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2545 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2547 switch (hdr
->sh_type
)
2549 /* ELF sections that map to BFD sections */
2554 if (hdr
->rawdata
== NULL
)
2556 if (! bfd_section_from_shdr (abfd
, index
))
2559 return (struct sec
*) hdr
->rawdata
;
2562 return bfd_abs_section_ptr
;
2567 /* given a section, search the header to find them... */
2569 elf_section_from_bfd_section (abfd
, asect
)
2573 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2575 Elf_Internal_Shdr
*hdr
;
2576 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2578 if (asect
->owner
== NULL
)
2580 if (bfd_is_abs_section (asect
))
2582 if (bfd_is_com_section (asect
))
2584 if (bfd_is_und_section (asect
))
2589 BFD_ASSERT (asect
->owner
== abfd
);
2591 for (index
= 0; index
< maxindex
; index
++)
2593 hdr
= i_shdrp
[index
];
2594 switch (hdr
->sh_type
)
2596 /* ELF sections that map to BFD sections */
2606 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2613 /* We sometimes map a reloc section to a BFD section. */
2614 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2615 && (asection
*) hdr
->rawdata
== asect
)
2620 /* We map most string tables to BFD sections. */
2621 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2622 && index
!= elf_onesymtab (abfd
)
2623 && (asection
*) hdr
->rawdata
== asect
)
2629 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2631 if (bed
->elf_backend_section_from_bfd_section
)
2636 if ((*bed
->elf_backend_section_from_bfd_section
)
2637 (abfd
, hdr
, asect
, &retval
))
2647 /* given a symbol, return the bfd index for that symbol. */
2649 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2651 struct symbol_cache_entry
**asym_ptr_ptr
;
2653 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2655 flagword flags
= asym_ptr
->flags
;
2657 /* When gas creates relocations against local labels, it creates its
2658 own symbol for the section, but does put the symbol into the
2659 symbol chain, so udata is 0. When the linker is generating
2660 relocatable output, this section symbol may be for one of the
2661 input sections rather than the output section. */
2662 if (asym_ptr
->udata
== (PTR
) 0
2663 && (flags
& BSF_SECTION_SYM
)
2664 && asym_ptr
->section
)
2668 if (asym_ptr
->section
->output_section
!= NULL
)
2669 indx
= asym_ptr
->section
->output_section
->index
;
2671 indx
= asym_ptr
->section
->index
;
2672 if (elf_section_syms (abfd
)[indx
])
2673 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2676 if (asym_ptr
->udata
)
2677 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2687 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2688 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2697 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2699 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2702 Elf_Internal_Shdr
*hdr
;
2703 long symcount
; /* Number of external ELF symbols */
2704 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2705 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2706 Elf_Internal_Sym i_sym
;
2707 Elf_External_Sym
*x_symp
= NULL
;
2709 /* Read each raw ELF symbol, converting from external ELF form to
2710 internal ELF form, and then using the information to create a
2711 canonical bfd symbol table entry.
2713 Note that we allocate the initial bfd canonical symbol buffer
2714 based on a one-to-one mapping of the ELF symbols to canonical
2715 symbols. We actually use all the ELF symbols, so there will be no
2716 space left over at the end. When we have all the symbols, we
2717 build the caller's pointer vector. */
2720 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2722 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2723 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2726 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2729 sym
= symbase
= NULL
;
2734 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2737 symbase
= ((elf_symbol_type
*)
2738 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2739 if (symbase
== (elf_symbol_type
*) NULL
)
2741 bfd_set_error (bfd_error_no_memory
);
2746 /* Temporarily allocate room for the raw ELF symbols. */
2747 x_symp
= ((Elf_External_Sym
*)
2748 malloc (symcount
* sizeof (Elf_External_Sym
)));
2749 if (x_symp
== NULL
&& symcount
!= 0)
2751 bfd_set_error (bfd_error_no_memory
);
2755 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2756 != symcount
* sizeof (Elf_External_Sym
))
2758 /* Skip first symbol, which is a null dummy. */
2759 for (i
= 1; i
< symcount
; i
++)
2761 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2762 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2763 #ifdef ELF_KEEP_EXTSYM
2764 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2766 sym
->symbol
.the_bfd
= abfd
;
2768 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2771 sym
->symbol
.value
= i_sym
.st_value
;
2773 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2775 sym
->symbol
.section
= section_from_elf_index (abfd
,
2777 if (sym
->symbol
.section
== NULL
)
2779 /* This symbol is in a section for which we did not
2780 create a BFD section. Just use bfd_abs_section,
2781 although it is wrong. FIXME. */
2782 sym
->symbol
.section
= bfd_abs_section_ptr
;
2785 else if (i_sym
.st_shndx
== SHN_ABS
)
2787 sym
->symbol
.section
= bfd_abs_section_ptr
;
2789 else if (i_sym
.st_shndx
== SHN_COMMON
)
2791 sym
->symbol
.section
= bfd_com_section_ptr
;
2792 /* Elf puts the alignment into the `value' field, and
2793 the size into the `size' field. BFD wants to see the
2794 size in the value field, and doesn't care (at the
2795 moment) about the alignment. */
2796 sym
->symbol
.value
= i_sym
.st_size
;
2798 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2800 sym
->symbol
.section
= bfd_und_section_ptr
;
2803 sym
->symbol
.section
= bfd_abs_section_ptr
;
2805 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2807 switch (ELF_ST_BIND (i_sym
.st_info
))
2810 sym
->symbol
.flags
|= BSF_LOCAL
;
2813 sym
->symbol
.flags
|= BSF_GLOBAL
;
2816 sym
->symbol
.flags
|= BSF_WEAK
;
2820 switch (ELF_ST_TYPE (i_sym
.st_info
))
2823 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2826 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2829 sym
->symbol
.flags
|= BSF_FUNCTION
;
2834 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2836 /* Do some backend-specific processing on this symbol. */
2838 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2839 if (ebd
->elf_backend_symbol_processing
)
2840 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2847 /* Do some backend-specific processing on this symbol table. */
2849 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2850 if (ebd
->elf_backend_symbol_table_processing
)
2851 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2854 /* We rely on the zalloc to clear out the final symbol entry. */
2856 symcount
= sym
- symbase
;
2858 /* Fill in the user's symbol pointer vector if needed. */
2866 *symptrs
++ = &sym
->symbol
;
2869 *symptrs
= 0; /* Final null pointer */
2881 /* Return the number of bytes required to hold the symtab vector.
2883 Note that we base it on the count plus 1, since we will null terminate
2884 the vector allocated based on this size. However, the ELF symbol table
2885 always has a dummy entry as symbol #0, so it ends up even. */
2888 elf_get_symtab_upper_bound (abfd
)
2893 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2895 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2896 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2902 elf_get_dynamic_symtab_upper_bound (abfd
)
2907 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2909 if (elf_dynsymtab (abfd
) == 0)
2911 bfd_set_error (bfd_error_invalid_operation
);
2915 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2916 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2922 elf_get_reloc_upper_bound (abfd
, asect
)
2926 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2929 /* Read in and swap the external relocs. */
2932 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2937 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2938 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2939 PTR allocated
= NULL
;
2940 bfd_byte
*native_relocs
;
2946 if (asect
->relocation
!= NULL
2947 || (asect
->flags
& SEC_RELOC
) == 0
2948 || asect
->reloc_count
== 0)
2951 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2952 && (asect
->reloc_count
2953 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2955 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2956 if (allocated
== NULL
)
2958 bfd_set_error (bfd_error_no_memory
);
2962 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2963 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2964 != d
->rel_hdr
.sh_size
))
2967 native_relocs
= (bfd_byte
*) allocated
;
2969 relents
= ((arelent
*)
2970 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2971 if (relents
== NULL
)
2973 bfd_set_error (bfd_error_no_memory
);
2977 entsize
= d
->rel_hdr
.sh_entsize
;
2978 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2979 || entsize
== sizeof (Elf_External_Rela
));
2981 for (i
= 0, relent
= relents
;
2982 i
< asect
->reloc_count
;
2983 i
++, relent
++, native_relocs
+= entsize
)
2985 Elf_Internal_Rela rela
;
2986 Elf_Internal_Rel rel
;
2988 if (entsize
== sizeof (Elf_External_Rela
))
2989 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2992 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2993 rela
.r_offset
= rel
.r_offset
;
2994 rela
.r_info
= rel
.r_info
;
2998 /* The address of an ELF reloc is section relative for an object
2999 file, and absolute for an executable file or shared library.
3000 The address of a BFD reloc is always section relative. */
3001 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3002 relent
->address
= rela
.r_offset
;
3004 relent
->address
= rela
.r_offset
- asect
->vma
;
3006 if (ELF_R_SYM (rela
.r_info
) == 0)
3007 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3012 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3015 /* Canonicalize ELF section symbols. FIXME: Why? */
3016 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3017 relent
->sym_ptr_ptr
= ps
;
3019 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3022 relent
->addend
= rela
.r_addend
;
3024 if (entsize
== sizeof (Elf_External_Rela
))
3025 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3027 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3030 asect
->relocation
= relents
;
3032 if (allocated
!= NULL
)
3038 if (allocated
!= NULL
)
3045 elf_debug_section (str
, num
, hdr
)
3048 Elf_Internal_Shdr
*hdr
;
3050 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3052 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3053 (long) hdr
->sh_name
,
3054 (long) hdr
->sh_type
,
3055 (long) hdr
->sh_flags
);
3057 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3058 (long) hdr
->sh_addr
,
3059 (long) hdr
->sh_offset
,
3060 (long) hdr
->sh_size
);
3062 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3063 (long) hdr
->sh_link
,
3064 (long) hdr
->sh_info
,
3065 (long) hdr
->sh_addralign
);
3066 fprintf (stderr
, "sh_entsize = %ld\n",
3067 (long) hdr
->sh_entsize
);
3068 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3069 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3070 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3075 elf_debug_file (ehdrp
)
3076 Elf_Internal_Ehdr
*ehdrp
;
3078 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3079 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3080 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3081 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3082 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3083 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3084 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3088 /* Canonicalize the relocs. */
3091 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3100 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3103 tblptr
= section
->relocation
;
3104 for (i
= 0; i
< section
->reloc_count
; i
++)
3105 *relptr
++ = tblptr
++;
3109 return section
->reloc_count
;
3113 elf_get_symtab (abfd
, alocation
)
3115 asymbol
**alocation
;
3117 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3120 bfd_get_symcount (abfd
) = symcount
;
3125 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3127 asymbol
**alocation
;
3129 return elf_slurp_symbol_table (abfd
, alocation
, true);
3133 elf_make_empty_symbol (abfd
)
3136 elf_symbol_type
*newsym
;
3138 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3141 bfd_set_error (bfd_error_no_memory
);
3146 newsym
->symbol
.the_bfd
= abfd
;
3147 return &newsym
->symbol
;
3152 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3157 bfd_symbol_info (symbol
, ret
);
3161 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3165 bfd_print_symbol_type how
;
3167 FILE *file
= (FILE *) filep
;
3170 case bfd_print_symbol_name
:
3171 fprintf (file
, "%s", symbol
->name
);
3173 case bfd_print_symbol_more
:
3174 fprintf (file
, "elf ");
3175 fprintf_vma (file
, symbol
->value
);
3176 fprintf (file
, " %lx", (long) symbol
->flags
);
3178 case bfd_print_symbol_all
:
3180 CONST
char *section_name
;
3181 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3182 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3183 fprintf (file
, " %s\t%s",
3193 elf_get_lineno (ignore_abfd
, symbol
)
3197 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3204 elf_set_arch_mach (abfd
, arch
, machine
)
3206 enum bfd_architecture arch
;
3207 unsigned long machine
;
3209 /* If this isn't the right architecture for this backend, and this
3210 isn't the generic backend, fail. */
3211 if (arch
!= get_elf_backend_data (abfd
)->arch
3212 && arch
!= bfd_arch_unknown
3213 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3216 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3220 elf_find_nearest_line (abfd
,
3231 CONST
char **filename_ptr
;
3232 CONST
char **functionname_ptr
;
3233 unsigned int *line_ptr
;
3239 elf_sizeof_headers (abfd
, reloc
)
3245 ret
= sizeof (Elf_External_Ehdr
);
3247 ret
+= get_program_header_size (abfd
);
3252 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3257 bfd_size_type count
;
3259 Elf_Internal_Shdr
*hdr
;
3261 if (! abfd
->output_has_begun
3262 && ! elf_compute_section_file_positions (abfd
,
3263 (struct bfd_link_info
*) NULL
))
3266 hdr
= &elf_section_data (section
)->this_hdr
;
3268 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3270 if (bfd_write (location
, 1, count
, abfd
) != count
)
3277 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3280 Elf_Internal_Rela
*dst
;
3282 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3288 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3291 Elf_Internal_Rel
*dst
;
3293 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3299 /* Core file support */
3301 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3302 #include <sys/procfs.h>
3304 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3305 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3306 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3312 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3319 prstatus_t
*status
= (prstatus_t
*) 0;
3321 if (descsz
== sizeof (prstatus_t
))
3323 newsect
= bfd_make_section (abfd
, ".reg");
3324 if (newsect
== NULL
)
3326 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3327 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3328 newsect
->flags
= SEC_HAS_CONTENTS
;
3329 newsect
->alignment_power
= 2;
3330 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3332 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3338 /* Stash a copy of the prpsinfo structure away for future use. */
3341 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3347 if (descsz
== sizeof (prpsinfo_t
))
3349 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3351 bfd_set_error (bfd_error_no_memory
);
3354 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3360 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3368 newsect
= bfd_make_section (abfd
, ".reg2");
3369 if (newsect
== NULL
)
3371 newsect
->_raw_size
= descsz
;
3372 newsect
->filepos
= filepos
;
3373 newsect
->flags
= SEC_HAS_CONTENTS
;
3374 newsect
->alignment_power
= 2;
3378 #endif /* HAVE_PROCFS */
3380 /* Return a pointer to the args (including the command name) that were
3381 seen by the program that generated the core dump. Note that for
3382 some reason, a spurious space is tacked onto the end of the args
3383 in some (at least one anyway) implementations, so strip it off if
3387 elf_core_file_failing_command (abfd
)
3391 if (core_prpsinfo (abfd
))
3393 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3394 char *scan
= p
->pr_psargs
;
3399 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3403 return p
->pr_psargs
;
3409 /* Return the number of the signal that caused the core dump. Presumably,
3410 since we have a core file, we got a signal of some kind, so don't bother
3411 checking the other process status fields, just return the signal number.
3415 elf_core_file_failing_signal (abfd
)
3419 if (core_prstatus (abfd
))
3421 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3427 /* Check to see if the core file could reasonably be expected to have
3428 come for the current executable file. Note that by default we return
3429 true unless we find something that indicates that there might be a
3434 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3443 /* First, xvecs must match since both are ELF files for the same target. */
3445 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3447 bfd_set_error (bfd_error_system_call
);
3453 /* If no prpsinfo, just return true. Otherwise, grab the last component
3454 of the exec'd pathname from the prpsinfo. */
3456 if (core_prpsinfo (core_bfd
))
3458 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3465 /* Find the last component of the executable pathname. */
3467 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3473 execname
= (char *) exec_bfd
->filename
;
3476 /* See if they match */
3478 return strcmp (execname
, corename
) ? false : true;
3484 #endif /* HAVE_PROCFS */
3487 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3488 the information that would normally be available from the /proc interface
3489 for the process, at the time the process dumped core. Currently this
3490 includes copies of the prstatus, prpsinfo, and fpregset structures.
3492 Since these structures are potentially machine dependent in size and
3493 ordering, bfd provides two levels of support for them. The first level,
3494 available on all machines since it does not require that the host
3495 have /proc support or the relevant include files, is to create a bfd
3496 section for each of the prstatus, prpsinfo, and fpregset structures,
3497 without any interpretation of their contents. With just this support,
3498 the bfd client will have to interpret the structures itself. Even with
3499 /proc support, it might want these full structures for it's own reasons.
3501 In the second level of support, where HAVE_PROCFS is defined, bfd will
3502 pick apart the structures to gather some additional information that
3503 clients may want, such as the general register set, the name of the
3504 exec'ed file and its arguments, the signal (if any) that caused the
3510 elf_corefile_note (abfd
, hdr
)
3512 Elf_Internal_Phdr
*hdr
;
3514 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3515 Elf_Internal_Note i_note
; /* Elf note, internal form */
3516 char *buf
= NULL
; /* Entire note segment contents */
3517 char *namedata
; /* Name portion of the note */
3518 char *descdata
; /* Descriptor portion of the note */
3519 char *sectname
; /* Name to use for new section */
3520 long filepos
; /* File offset to descriptor data */
3523 if (hdr
->p_filesz
> 0
3524 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3525 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3526 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3528 x_note_p
= (Elf_External_Note
*) buf
;
3529 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3531 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3532 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3533 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3534 namedata
= x_note_p
->name
;
3535 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3536 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3537 switch (i_note
.type
)
3540 /* process descdata as prstatus info */
3541 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3543 sectname
= ".prstatus";
3546 /* process descdata as fpregset info */
3547 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3549 sectname
= ".fpregset";
3552 /* process descdata as prpsinfo */
3553 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3555 sectname
= ".prpsinfo";
3558 /* Unknown descriptor, just ignore it. */
3562 if (sectname
!= NULL
)
3564 newsect
= bfd_make_section (abfd
, sectname
);
3565 if (newsect
== NULL
)
3567 newsect
->_raw_size
= i_note
.descsz
;
3568 newsect
->filepos
= filepos
;
3569 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3570 newsect
->alignment_power
= 2;
3572 x_note_p
= (Elf_External_Note
*)
3573 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3580 else if (hdr
->p_filesz
> 0)
3582 bfd_set_error (bfd_error_no_memory
);
3589 /* Core files are simply standard ELF formatted files that partition
3590 the file using the execution view of the file (program header table)
3591 rather than the linking view. In fact, there is no section header
3592 table in a core file.
3594 The process status information (including the contents of the general
3595 register set) and the floating point register set are stored in a
3596 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3597 that allow standard bfd access to the general registers (.reg) and the
3598 floating point registers (.reg2).
3603 elf_core_file_p (abfd
)
3606 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3607 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3608 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3609 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3610 unsigned int phindex
;
3611 struct elf_backend_data
*ebd
;
3613 /* Read in the ELF header in external format. */
3615 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3617 if (bfd_get_error () != bfd_error_system_call
)
3618 bfd_set_error (bfd_error_wrong_format
);
3622 /* Now check to see if we have a valid ELF file, and one that BFD can
3623 make use of. The magic number must match, the address size ('class')
3624 and byte-swapping must match our XVEC entry, and it must have a
3625 program header table (FIXME: See comments re segments at top of this
3628 if (elf_file_p (&x_ehdr
) == false)
3631 bfd_set_error (bfd_error_wrong_format
);
3635 /* FIXME, Check EI_VERSION here ! */
3639 int desired_address_size
= ELFCLASS32
;
3642 int desired_address_size
= ELFCLASS64
;
3645 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3649 /* Switch xvec to match the specified byte order. */
3650 switch (x_ehdr
.e_ident
[EI_DATA
])
3652 case ELFDATA2MSB
: /* Big-endian */
3653 if (abfd
->xvec
->byteorder_big_p
== false)
3656 case ELFDATA2LSB
: /* Little-endian */
3657 if (abfd
->xvec
->byteorder_big_p
== true)
3660 case ELFDATANONE
: /* No data encoding specified */
3661 default: /* Unknown data encoding specified */
3665 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3666 the tdata pointer in the bfd. */
3669 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3670 if (elf_tdata (abfd
) == NULL
)
3672 bfd_set_error (bfd_error_no_memory
);
3676 /* FIXME, `wrong' returns from this point onward, leak memory. */
3678 /* Now that we know the byte order, swap in the rest of the header */
3679 i_ehdrp
= elf_elfheader (abfd
);
3680 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3682 elf_debug_file (i_ehdrp
);
3685 ebd
= get_elf_backend_data (abfd
);
3687 /* Check that the ELF e_machine field matches what this particular
3688 BFD format expects. */
3689 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3691 const bfd_target
* const *target_ptr
;
3693 if (ebd
->elf_machine_code
!= EM_NONE
)
3696 /* This is the generic ELF target. Let it match any ELF target
3697 for which we do not have a specific backend. */
3698 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3700 struct elf_backend_data
*back
;
3702 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3704 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3705 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3707 /* target_ptr is an ELF backend which matches this
3708 object file, so reject the generic ELF target. */
3714 /* If there is no program header, or the type is not a core file, then
3716 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3719 /* Allocate space for a copy of the program header table in
3720 internal form, seek to the program header table in the file,
3721 read it in, and convert it to internal form. As a simple sanity
3722 check, verify that the what BFD thinks is the size of each program
3723 header table entry actually matches the size recorded in the file. */
3725 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3727 i_phdrp
= (Elf_Internal_Phdr
*)
3728 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3731 bfd_set_error (bfd_error_no_memory
);
3734 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3736 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3738 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3741 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3744 /* Once all of the program headers have been read and converted, we
3745 can start processing them. */
3747 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3749 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3750 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3752 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3757 /* Remember the entry point specified in the ELF file header. */
3759 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3764 /* ELF linker code. */
3766 static boolean elf_link_add_object_symbols
3767 PARAMS ((bfd
*, struct bfd_link_info
*));
3768 static boolean elf_link_add_archive_symbols
3769 PARAMS ((bfd
*, struct bfd_link_info
*));
3770 static Elf_Internal_Rela
*elf_link_read_relocs
3771 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3772 static boolean elf_adjust_dynamic_symbol
3773 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3775 /* Given an ELF BFD, add symbols to the global hash table as
3779 elf_bfd_link_add_symbols (abfd
, info
)
3781 struct bfd_link_info
*info
;
3783 switch (bfd_get_format (abfd
))
3786 return elf_link_add_object_symbols (abfd
, info
);
3788 return elf_link_add_archive_symbols (abfd
, info
);
3790 bfd_set_error (bfd_error_wrong_format
);
3795 /* Add symbols from an ELF archive file to the linker hash table. We
3796 don't use _bfd_generic_link_add_archive_symbols because of a
3797 problem which arises on UnixWare. The UnixWare libc.so is an
3798 archive which includes an entry libc.so.1 which defines a bunch of
3799 symbols. The libc.so archive also includes a number of other
3800 object files, which also define symbols, some of which are the same
3801 as those defined in libc.so.1. Correct linking requires that we
3802 consider each object file in turn, and include it if it defines any
3803 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3804 this; it looks through the list of undefined symbols, and includes
3805 any object file which defines them. When this algorithm is used on
3806 UnixWare, it winds up pulling in libc.so.1 early and defining a
3807 bunch of symbols. This means that some of the other objects in the
3808 archive are not included in the link, which is incorrect since they
3809 precede libc.so.1 in the archive.
3811 Fortunately, ELF archive handling is simpler than that done by
3812 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3813 oddities. In ELF, if we find a symbol in the archive map, and the
3814 symbol is currently undefined, we know that we must pull in that
3817 Unfortunately, we do have to make multiple passes over the symbol
3818 table until nothing further is resolved. */
3821 elf_link_add_archive_symbols (abfd
, info
)
3823 struct bfd_link_info
*info
;
3826 boolean
*defined
= NULL
;
3827 boolean
*included
= NULL
;
3831 if (! bfd_has_map (abfd
))
3833 bfd_set_error (bfd_error_no_symbols
);
3837 /* Keep track of all symbols we know to be already defined, and all
3838 files we know to be already included. This is to speed up the
3839 second and subsequent passes. */
3840 c
= bfd_ardata (abfd
)->symdef_count
;
3843 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3844 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3845 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3847 bfd_set_error (bfd_error_no_memory
);
3850 memset (defined
, 0, c
* sizeof (boolean
));
3851 memset (included
, 0, c
* sizeof (boolean
));
3853 symdefs
= bfd_ardata (abfd
)->symdefs
;
3866 symdefend
= symdef
+ c
;
3867 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3869 struct elf_link_hash_entry
*h
;
3871 struct bfd_link_hash_entry
*undefs_tail
;
3874 if (defined
[i
] || included
[i
])
3876 if (symdef
->file_offset
== last
)
3882 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3883 false, false, false);
3884 if (h
== (struct elf_link_hash_entry
*) NULL
)
3886 if (h
->root
.type
!= bfd_link_hash_undefined
)
3892 /* We need to include this archive member. */
3894 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3895 if (element
== (bfd
*) NULL
)
3898 if (! bfd_check_format (element
, bfd_object
))
3901 /* Doublecheck that we have not included this object
3902 already--it should be impossible, but there may be
3903 something wrong with the archive. */
3904 if (element
->archive_pass
!= 0)
3906 bfd_set_error (bfd_error_bad_value
);
3909 element
->archive_pass
= 1;
3911 undefs_tail
= info
->hash
->undefs_tail
;
3913 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3916 if (! elf_link_add_object_symbols (element
, info
))
3919 /* If there are any new undefined symbols, we need to make
3920 another pass through the archive in order to see whether
3921 they can be defined. FIXME: This isn't perfect, because
3922 common symbols wind up on undefs_tail and because an
3923 undefined symbol which is defined later on in this pass
3924 does not require another pass. This isn't a bug, but it
3925 does make the code less efficient than it could be. */
3926 if (undefs_tail
!= info
->hash
->undefs_tail
)
3929 /* Look backward to mark all symbols from this object file
3930 which we have already seen in this pass. */
3934 included
[mark
] = true;
3939 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3941 /* We mark subsequent symbols from this object file as we go
3942 on through the loop. */
3943 last
= symdef
->file_offset
;
3954 if (defined
!= (boolean
*) NULL
)
3956 if (included
!= (boolean
*) NULL
)
3961 /* Record a new dynamic symbol. We record the dynamic symbols as we
3962 read the input files, since we need to have a list of all of them
3963 before we can determine the final sizes of the output sections. */
3966 elf_link_record_dynamic_symbol (info
, h
)
3967 struct bfd_link_info
*info
;
3968 struct elf_link_hash_entry
*h
;
3970 if (h
->dynindx
== -1)
3972 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3973 ++elf_hash_table (info
)->dynsymcount
;
3974 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3975 elf_hash_table (info
)->dynstr
,
3976 h
->root
.root
.string
);
3977 if (h
->dynstr_index
== (unsigned long) -1)
3984 /* Add symbols from an ELF object file to the linker hash table. */
3987 elf_link_add_object_symbols (abfd
, info
)
3989 struct bfd_link_info
*info
;
3991 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3992 const Elf_Internal_Sym
*,
3993 const char **, flagword
*,
3994 asection
**, bfd_vma
*));
3995 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3996 asection
*, const Elf_Internal_Rela
*));
3998 Elf_Internal_Shdr
*hdr
;
4002 Elf_External_Sym
*buf
= NULL
;
4003 struct elf_link_hash_entry
**sym_hash
;
4005 Elf_External_Dyn
*dynbuf
= NULL
;
4006 struct elf_link_hash_entry
*weaks
;
4007 Elf_External_Sym
*esym
;
4008 Elf_External_Sym
*esymend
;
4010 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4011 collect
= get_elf_backend_data (abfd
)->collect
;
4013 /* A stripped shared library might only have a dynamic symbol table,
4014 not a regular symbol table. In that case we can still go ahead
4015 and link using the dynamic symbol table. */
4016 if (elf_onesymtab (abfd
) == 0
4017 && elf_dynsymtab (abfd
) != 0)
4019 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4020 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4023 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4024 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4026 /* The sh_info field of the symtab header tells us where the
4027 external symbols start. We don't care about the local symbols at
4029 if (elf_bad_symtab (abfd
))
4031 extsymcount
= symcount
;
4036 extsymcount
= symcount
- hdr
->sh_info
;
4037 extsymoff
= hdr
->sh_info
;
4040 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4041 if (buf
== NULL
&& extsymcount
!= 0)
4043 bfd_set_error (bfd_error_no_memory
);
4047 /* We store a pointer to the hash table entry for each external
4049 sym_hash
= ((struct elf_link_hash_entry
**)
4051 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4052 if (sym_hash
== NULL
)
4054 bfd_set_error (bfd_error_no_memory
);
4057 elf_sym_hashes (abfd
) = sym_hash
;
4059 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4063 /* If we are creating a shared library, create all the dynamic
4064 sections immediately. We need to attach them to something,
4065 so we attach them to this BFD, provided it is the right
4066 format. FIXME: If there are no input BFD's of the same
4067 format as the output, we can't make a shared library. */
4069 && elf_hash_table (info
)->dynobj
== NULL
4070 && abfd
->xvec
== info
->hash
->creator
)
4072 if (! elf_link_create_dynamic_sections (abfd
, info
))
4074 elf_hash_table (info
)->dynobj
= abfd
;
4081 unsigned long strindex
;
4085 /* You can't use -r against a dynamic object. Also, there's no
4086 hope of using a dynamic object which does not exactly match
4087 the format of the output file. */
4088 if (info
->relocateable
4089 || info
->hash
->creator
!= abfd
->xvec
)
4091 bfd_set_error (bfd_error_invalid_operation
);
4095 /* Find the name to use in a DT_NEEDED entry that refers to this
4096 object. If the object has a DT_SONAME entry, we use it.
4097 Otherwise, if the generic linker stuck something in
4098 elf_dt_needed_name, we use that. Otherwise, we just use the
4100 name
= bfd_get_filename (abfd
);
4101 if (elf_dt_needed_name (abfd
) != NULL
)
4102 name
= elf_dt_needed_name (abfd
);
4103 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4106 Elf_External_Dyn
*extdyn
;
4107 Elf_External_Dyn
*extdynend
;
4109 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4112 bfd_set_error (bfd_error_no_memory
);
4116 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4117 (file_ptr
) 0, s
->_raw_size
))
4121 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4122 for (; extdyn
< extdynend
; extdyn
++)
4124 Elf_Internal_Dyn dyn
;
4126 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4127 if (dyn
.d_tag
== DT_SONAME
)
4132 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4135 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4136 name
= elf_string_from_elf_section (abfd
, link
,
4149 /* We do not want to include any of the sections in a dynamic
4150 object in the output file. We hack by simply clobbering the
4151 list of sections in the BFD. This could be handled more
4152 cleanly by, say, a new section flag; the existing
4153 SEC_NEVER_LOAD flag is not the one we want, because that one
4154 still implies that the section takes up space in the output
4156 abfd
->sections
= NULL
;
4158 /* If this is the first dynamic object found in the link, create
4159 the special sections required for dynamic linking. We need
4160 to put them somewhere, and attaching them to the first
4161 dynamic object is as good place as any. */
4162 if (elf_hash_table (info
)->dynobj
== NULL
)
4164 if (! elf_link_create_dynamic_sections (abfd
, info
))
4166 elf_hash_table (info
)->dynobj
= abfd
;
4169 /* Add a DT_NEEDED entry for this dynamic object. */
4170 strindex
= bfd_add_to_strtab (abfd
,
4171 elf_hash_table (info
)->dynstr
,
4173 if (strindex
== (unsigned long) -1)
4175 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4180 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4182 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4183 != extsymcount
* sizeof (Elf_External_Sym
)))
4188 esymend
= buf
+ extsymcount
;
4189 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4191 Elf_Internal_Sym sym
;
4197 struct elf_link_hash_entry
*h
= NULL
;
4200 elf_swap_symbol_in (abfd
, esym
, &sym
);
4202 flags
= BSF_NO_FLAGS
;
4204 value
= sym
.st_value
;
4207 bind
= ELF_ST_BIND (sym
.st_info
);
4208 if (bind
== STB_LOCAL
)
4210 /* This should be impossible, since ELF requires that all
4211 global symbols follow all local symbols, and that sh_info
4212 point to the first global symbol. Unfortunatealy, Irix 5
4216 else if (bind
== STB_GLOBAL
)
4218 else if (bind
== STB_WEAK
)
4222 /* Leave it up to the processor backend. */
4225 if (sym
.st_shndx
== SHN_UNDEF
)
4226 sec
= bfd_und_section_ptr
;
4227 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4229 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4234 else if (sym
.st_shndx
== SHN_ABS
)
4235 sec
= bfd_abs_section_ptr
;
4236 else if (sym
.st_shndx
== SHN_COMMON
)
4238 sec
= bfd_com_section_ptr
;
4239 /* What ELF calls the size we call the value. What ELF
4240 calls the value we call the alignment. */
4241 value
= sym
.st_size
;
4245 /* Leave it up to the processor backend. */
4248 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4249 if (name
== (const char *) NULL
)
4252 if (add_symbol_hook
)
4254 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4258 /* The hook function sets the name to NULL if this symbol
4259 should be skipped for some reason. */
4260 if (name
== (const char *) NULL
)
4264 /* Sanity check that all possibilities were handled. */
4265 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4267 bfd_set_error (bfd_error_bad_value
);
4271 if (bfd_is_und_section (sec
)
4272 || bfd_is_com_section (sec
))
4277 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4279 /* We need to look up the symbol now in order to get some of
4280 the dynamic object handling right. We pass the hash
4281 table entry in to _bfd_generic_link_add_one_symbol so
4282 that it does not have to look it up again. */
4283 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4284 true, false, false);
4289 /* If we are looking at a dynamic object, and this is a
4290 definition, we need to see if it has already been defined
4291 by some other object. If it has, we want to use the
4292 existing definition, and we do not want to report a
4293 multiple symbol definition error; we do this by
4294 clobbering sec to be bfd_und_section_ptr. */
4295 if (dynamic
&& definition
)
4297 if (h
->root
.type
== bfd_link_hash_defined
)
4298 sec
= bfd_und_section_ptr
;
4301 /* Similarly, if we are not looking at a dynamic object, and
4302 we have a definition, we want to override any definition
4303 we may have from a dynamic object. Symbols from regular
4304 files always take precedence over symbols from dynamic
4305 objects, even if they are defined after the dynamic
4306 object in the link. */
4309 && h
->root
.type
== bfd_link_hash_defined
4310 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4311 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4312 == bfd_target_elf_flavour
)
4313 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4316 /* Change the hash table entry to undefined, and let
4317 _bfd_generic_link_add_one_symbol do the right thing
4318 with the new definition. */
4319 h
->root
.type
= bfd_link_hash_undefined
;
4320 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4321 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4324 /* If this is a weak definition which we are going to use,
4325 and the symbol is currently undefined, record that the
4326 definition is weak. */
4328 && (flags
& BSF_WEAK
) != 0
4329 && ! bfd_is_und_section (sec
)
4330 && (h
->root
.type
== bfd_link_hash_new
4331 || h
->root
.type
== bfd_link_hash_undefined
4332 || h
->root
.type
== bfd_link_hash_weak
))
4333 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4336 if (! (_bfd_generic_link_add_one_symbol
4337 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4338 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4343 && (flags
& BSF_WEAK
) != 0
4344 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4345 && (*sym_hash
)->weakdef
== NULL
)
4347 /* Keep a list of all weak defined non function symbols from
4348 a dynamic object, using the weakdef field. Later in this
4349 function we will set the weakdef field to the correct
4350 value. We only put non-function symbols from dynamic
4351 objects on this list, because that happens to be the only
4352 time we need to know the normal symbol corresponding to a
4353 weak symbol, and the information is time consuming to
4354 figure out. If the weakdef field is not already NULL,
4355 then this symbol was already defined by some previous
4356 dynamic object, and we will be using that previous
4357 definition anyhow. */
4359 (*sym_hash
)->weakdef
= weaks
;
4363 /* Get the alignment of a common symbol. */
4364 if (sym
.st_shndx
== SHN_COMMON
4365 && h
->root
.type
== bfd_link_hash_common
)
4366 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4368 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4374 /* Remember the symbol size and type. */
4375 if (sym
.st_size
!= 0)
4377 /* FIXME: We should probably somehow give a warning if
4378 the symbol size changes. */
4379 h
->size
= sym
.st_size
;
4381 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4383 /* FIXME: We should probably somehow give a warning if
4384 the symbol type changes. */
4385 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4388 /* Set a flag in the hash table entry indicating the type of
4389 reference or definition we just found. Keep a count of
4390 the number of dynamic symbols we find. A dynamic symbol
4391 is one which is referenced or defined by both a regular
4392 object and a shared object, or one which is referenced or
4393 defined by more than one shared object. */
4394 old_flags
= h
->elf_link_hash_flags
;
4399 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4401 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4403 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4404 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4410 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4412 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4413 if ((old_flags
& new_flag
) != 0
4414 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4415 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4419 h
->elf_link_hash_flags
|= new_flag
;
4420 if (dynsym
&& h
->dynindx
== -1)
4422 if (! elf_link_record_dynamic_symbol (info
, h
))
4428 /* Now set the weakdefs field correctly for all the weak defined
4429 symbols we found. The only way to do this is to search all the
4430 symbols. Since we only need the information for non functions in
4431 dynamic objects, that's the only time we actually put anything on
4432 the list WEAKS. We need this information so that if a regular
4433 object refers to a symbol defined weakly in a dynamic object, the
4434 real symbol in the dynamic object is also put in the dynamic
4435 symbols; we also must arrange for both symbols to point to the
4436 same memory location. We could handle the general case of symbol
4437 aliasing, but a general symbol alias can only be generated in
4438 assembler code, handling it correctly would be very time
4439 consuming, and other ELF linkers don't handle general aliasing
4441 while (weaks
!= NULL
)
4443 struct elf_link_hash_entry
*hlook
;
4446 struct elf_link_hash_entry
**hpp
;
4447 struct elf_link_hash_entry
**hppend
;
4450 weaks
= hlook
->weakdef
;
4451 hlook
->weakdef
= NULL
;
4453 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4454 slook
= hlook
->root
.u
.def
.section
;
4455 vlook
= hlook
->root
.u
.def
.value
;
4457 hpp
= elf_sym_hashes (abfd
);
4458 hppend
= hpp
+ extsymcount
;
4459 for (; hpp
< hppend
; hpp
++)
4461 struct elf_link_hash_entry
*h
;
4465 && h
->root
.type
== bfd_link_hash_defined
4466 && h
->root
.u
.def
.section
== slook
4467 && h
->root
.u
.def
.value
== vlook
)
4471 /* If the weak definition is in the list of dynamic
4472 symbols, make sure the real definition is put there
4474 if (hlook
->dynindx
!= -1
4475 && h
->dynindx
== -1)
4477 if (! elf_link_record_dynamic_symbol (info
, h
))
4492 /* If this object is the same format as the output object, and it is
4493 not a shared library, then let the backend look through the
4496 This is required to build global offset table entries and to
4497 arrange for dynamic relocs. It is not required for the
4498 particular common case of linking non PIC code, even when linking
4499 against shared libraries, but unfortunately there is no way of
4500 knowing whether an object file has been compiled PIC or not.
4501 Looking through the relocs is not particularly time consuming.
4502 The problem is that we must either (1) keep the relocs in memory,
4503 which causes the linker to require additional runtime memory or
4504 (2) read the relocs twice from the input file, which wastes time.
4505 This would be a good case for using mmap.
4507 I have no idea how to handle linking PIC code into a file of a
4508 different format. It probably can't be done. */
4509 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4511 && abfd
->xvec
== info
->hash
->creator
4512 && check_relocs
!= NULL
)
4516 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4518 Elf_Internal_Rela
*internal_relocs
;
4521 if ((o
->flags
& SEC_RELOC
) == 0
4522 || o
->reloc_count
== 0)
4525 /* I believe we can ignore the relocs for any section which
4526 does not form part of the final process image, such as a
4527 debugging section. */
4528 if ((o
->flags
& SEC_ALLOC
) == 0)
4531 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4532 (Elf_Internal_Rela
*) NULL
,
4534 if (internal_relocs
== NULL
)
4537 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4539 if (! info
->keep_memory
)
4540 free (internal_relocs
);
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 /* A dynamically linked executable has a .interp section, but a
4579 shared library does not. */
4582 s
= bfd_make_section (abfd
, ".interp");
4584 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4588 s
= bfd_make_section (abfd
, ".dynsym");
4590 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4591 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4594 /* The first .dynsym symbol is a dummy. */
4595 elf_hash_table (info
)->dynsymcount
= 1;
4597 s
= bfd_make_section (abfd
, ".dynstr");
4599 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4602 /* Create a strtab to hold the dynamic symbol names. */
4603 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4604 if (elf_hash_table (info
)->dynstr
== NULL
)
4607 s
= bfd_make_section (abfd
, ".dynamic");
4609 || ! bfd_set_section_flags (abfd
, s
, flags
)
4610 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4613 /* The special symbol _DYNAMIC is always set to the start of the
4614 .dynamic section. This call occurs before we have processed the
4615 symbols for any dynamic object, so we don't have to worry about
4616 overriding a dynamic definition. We could set _DYNAMIC in a
4617 linker script, but we only want to define it if we are, in fact,
4618 creating a .dynamic section. We don't want to define it if there
4619 is no .dynamic section, since on some ELF platforms the start up
4620 code examines it to decide how to initialize the process. */
4622 if (! (_bfd_generic_link_add_one_symbol
4623 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4624 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4625 (struct bfd_link_hash_entry
**) &h
)))
4627 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4628 h
->type
= STT_OBJECT
;
4631 && ! elf_link_record_dynamic_symbol (info
, h
))
4634 s
= bfd_make_section (abfd
, ".hash");
4636 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4637 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4640 /* Let the backend create the rest of the sections. This lets the
4641 backend set the right flags. The backend will normally create
4642 the .got and .plt sections. */
4643 bed
= get_elf_backend_data (abfd
);
4644 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4647 /* Add an entry to the .dynamic table. */
4650 elf_add_dynamic_entry (info
, tag
, val
)
4651 struct bfd_link_info
*info
;
4655 Elf_Internal_Dyn dyn
;
4659 bfd_byte
*newcontents
;
4661 dynobj
= elf_hash_table (info
)->dynobj
;
4663 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4664 BFD_ASSERT (s
!= NULL
);
4666 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4667 if (s
->contents
== NULL
)
4668 newcontents
= (bfd_byte
*) malloc (newsize
);
4670 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4671 if (newcontents
== NULL
)
4673 bfd_set_error (bfd_error_no_memory
);
4678 dyn
.d_un
.d_val
= val
;
4679 elf_swap_dyn_out (dynobj
, &dyn
,
4680 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4682 s
->_raw_size
= newsize
;
4683 s
->contents
= newcontents
;
4688 /* Read and swap the relocs for a section. They may have been cached.
4689 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4690 they are used as buffers to read into. They are known to be large
4691 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4692 value is allocated using either malloc or bfd_alloc, according to
4693 the KEEP_MEMORY argument. */
4695 static Elf_Internal_Rela
*
4696 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4699 PTR external_relocs
;
4700 Elf_Internal_Rela
*internal_relocs
;
4701 boolean keep_memory
;
4703 Elf_Internal_Shdr
*rel_hdr
;
4705 Elf_Internal_Rela
*alloc2
= NULL
;
4707 if (elf_section_data (o
)->relocs
!= NULL
)
4708 return elf_section_data (o
)->relocs
;
4710 if (o
->reloc_count
== 0)
4713 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4715 if (internal_relocs
== NULL
)
4719 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4721 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4723 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4724 if (internal_relocs
== NULL
)
4726 bfd_set_error (bfd_error_no_memory
);
4731 if (external_relocs
== NULL
)
4733 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4736 bfd_set_error (bfd_error_no_memory
);
4739 external_relocs
= alloc1
;
4742 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4743 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4744 != rel_hdr
->sh_size
))
4747 /* Swap in the relocs. For convenience, we always produce an
4748 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4750 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4752 Elf_External_Rel
*erel
;
4753 Elf_External_Rel
*erelend
;
4754 Elf_Internal_Rela
*irela
;
4756 erel
= (Elf_External_Rel
*) external_relocs
;
4757 erelend
= erel
+ o
->reloc_count
;
4758 irela
= internal_relocs
;
4759 for (; erel
< erelend
; erel
++, irela
++)
4761 Elf_Internal_Rel irel
;
4763 elf_swap_reloc_in (abfd
, erel
, &irel
);
4764 irela
->r_offset
= irel
.r_offset
;
4765 irela
->r_info
= irel
.r_info
;
4766 irela
->r_addend
= 0;
4771 Elf_External_Rela
*erela
;
4772 Elf_External_Rela
*erelaend
;
4773 Elf_Internal_Rela
*irela
;
4775 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4777 erela
= (Elf_External_Rela
*) external_relocs
;
4778 erelaend
= erela
+ o
->reloc_count
;
4779 irela
= internal_relocs
;
4780 for (; erela
< erelaend
; erela
++, irela
++)
4781 elf_swap_reloca_in (abfd
, erela
, irela
);
4784 /* Cache the results for next time, if we can. */
4786 elf_section_data (o
)->relocs
= internal_relocs
;
4791 /* Don't free alloc2, since if it was allocated we are passing it
4792 back (under the name of internal_relocs). */
4794 return internal_relocs
;
4804 /* Record an assignment to a symbol made by a linker script. We need
4805 this in case some dynamic object refers to this symbol. */
4809 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4811 struct bfd_link_info
*info
;
4814 struct elf_link_hash_entry
*h
;
4816 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4820 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4821 h
->type
= STT_OBJECT
;
4823 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4824 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4826 && h
->dynindx
== -1)
4828 if (! elf_link_record_dynamic_symbol (info
, h
))
4831 /* If this is a weak defined symbol, and we know a corresponding
4832 real symbol from the same dynamic object, make sure the real
4833 symbol is also made into a dynamic symbol. */
4834 if (h
->weakdef
!= NULL
4835 && h
->weakdef
->dynindx
== -1)
4837 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4845 /* Array used to determine the number of hash table buckets to use
4846 based on the number of symbols there are. If there are fewer than
4847 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4848 fewer than 37 we use 17 buckets, and so forth. We never use more
4849 than 521 buckets. */
4851 static const size_t elf_buckets
[] =
4853 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4856 /* Set up the sizes and contents of the ELF dynamic sections. This is
4857 called by the ELF linker emulation before_allocation routine. We
4858 must set the sizes of the sections before the linker sets the
4859 addresses of the various sections. */
4862 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
, info
,
4867 struct bfd_link_info
*info
;
4868 asection
**sinterpptr
;
4873 Elf_Internal_Sym isym
;
4876 struct elf_backend_data
*bed
;
4880 dynobj
= elf_hash_table (info
)->dynobj
;
4881 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4883 /* If there were no dynamic objects in the link, there is nothing to
4888 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4889 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4891 /* Set the size of the .dynsym and .hash sections. We counted the
4892 number of dynamic symbols in elf_link_add_object_symbols. We
4893 will build the contents of .dynsym and .hash when we build the
4894 final symbol table, because until then we do not know the correct
4895 value to give the symbols. We built the .dynstr section as we
4896 went along in elf_link_add_object_symbols. */
4897 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4898 BFD_ASSERT (s
!= NULL
);
4899 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4900 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4901 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4903 bfd_set_error (bfd_error_no_memory
);
4907 /* The first entry in .dynsym is a dummy symbol. */
4914 elf_swap_symbol_out (output_bfd
, &isym
,
4915 (Elf_External_Sym
*) s
->contents
);
4917 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4919 bucketcount
= elf_buckets
[i
];
4920 if (dynsymcount
< elf_buckets
[i
+ 1])
4924 s
= bfd_get_section_by_name (dynobj
, ".hash");
4925 BFD_ASSERT (s
!= NULL
);
4926 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4927 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4928 if (s
->contents
== NULL
)
4930 bfd_set_error (bfd_error_no_memory
);
4933 memset (s
->contents
, 0, s
->_raw_size
);
4935 put_word (output_bfd
, bucketcount
, s
->contents
);
4936 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4938 elf_hash_table (info
)->bucketcount
= bucketcount
;
4944 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, soname
);
4945 if (indx
== (unsigned long) -1
4946 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4954 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4955 if (indx
== (unsigned long) -1
4956 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4960 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4961 BFD_ASSERT (s
!= NULL
);
4962 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4963 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4965 /* Find all symbols which were defined in a dynamic object and make
4966 the backend pick a reasonable value for them. */
4967 elf_link_hash_traverse (elf_hash_table (info
),
4968 elf_adjust_dynamic_symbol
,
4971 /* Add some entries to the .dynamic section. We fill in some of the
4972 values later, in elf_bfd_final_link, but we must add the entries
4973 now so that we know the final size of the .dynamic section. */
4974 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4976 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4979 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4981 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4984 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4985 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4986 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4987 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4988 elf_hash_table (info
)->dynstr
->length
)
4989 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4990 sizeof (Elf_External_Sym
)))
4993 /* The backend must work out the sizes of all the other dynamic
4995 bed
= get_elf_backend_data (output_bfd
);
4996 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4999 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
5002 /* Make the backend pick a good value for a dynamic symbol. This is
5003 called via elf_link_hash_traverse, and also calls itself
5007 elf_adjust_dynamic_symbol (h
, data
)
5008 struct elf_link_hash_entry
*h
;
5011 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5013 struct elf_backend_data
*bed
;
5015 /* If this symbol is not defined by a dynamic object, or is not
5016 referenced by a regular object, ignore it. FIXME: Do we need to
5017 worry about symbols which are defined by one dynamic object and
5018 referenced by another one? */
5019 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5020 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5021 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5024 /* If we've already adjusted this symbol, don't do it again. This
5025 can happen via a recursive call. */
5026 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5029 /* Don't look at this symbol again. Note that we must set this
5030 after checking the above conditions, because we may look at a
5031 symbol once, decide not to do anything, and then get called
5032 recursively later after REF_REGULAR is set below. */
5033 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5035 /* If this is a weak definition, and we know a real definition, and
5036 the real symbol is not itself defined by a regular object file,
5037 then get a good value for the real definition. We handle the
5038 real symbol first, for the convenience of the backend routine.
5040 Note that there is a confusing case here. If the real definition
5041 is defined by a regular object file, we don't get the real symbol
5042 from the dynamic object, but we do get the weak symbol. If the
5043 processor backend uses a COPY reloc, then if some routine in the
5044 dynamic object changes the real symbol, we will not see that
5045 change in the corresponding weak symbol. This is the way other
5046 ELF linkers work as well, and seems to be a result of the shared
5049 I will clarify this issue. Most SVR4 shared libraries define the
5050 variable _timezone and define timezone as a weak synonym. The
5051 tzset call changes _timezone. If you write
5052 extern int timezone;
5054 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5055 you might expect that, since timezone is a synonym for _timezone,
5056 the same number will print both times. However, if the processor
5057 backend uses a COPY reloc, then actually timezone will be copied
5058 into your process image, and, since you define _timezone
5059 yourself, _timezone will not. Thus timezone and _timezone will
5060 wind up at different memory locations. The tzset call will set
5061 _timezone, leaving timezone unchanged. */
5063 if (h
->weakdef
!= NULL
)
5065 struct elf_link_hash_entry
*weakdef
;
5067 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5068 weakdef
= h
->weakdef
;
5069 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5070 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5071 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5073 /* This symbol is defined by a regular object file, so we
5074 will not do anything special. Clear weakdef for the
5075 convenience of the processor backend. */
5080 /* There is an implicit reference by a regular object file
5081 via the weak symbol. */
5082 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5083 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5088 dynobj
= elf_hash_table (info
)->dynobj
;
5089 bed
= get_elf_backend_data (dynobj
);
5090 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5092 /* FIXME: No way to return error. */
5099 /* Final phase of ELF linker. */
5101 /* A structure we use to avoid passing large numbers of arguments. */
5103 struct elf_final_link_info
5105 /* General link information. */
5106 struct bfd_link_info
*info
;
5109 /* Symbol string table. */
5110 struct strtab
*symstrtab
;
5111 /* .dynsym section. */
5112 asection
*dynsym_sec
;
5113 /* .hash section. */
5115 /* Buffer large enough to hold contents of any section. */
5117 /* Buffer large enough to hold external relocs of any section. */
5118 PTR external_relocs
;
5119 /* Buffer large enough to hold internal relocs of any section. */
5120 Elf_Internal_Rela
*internal_relocs
;
5121 /* Buffer large enough to hold external local symbols of any input
5123 Elf_External_Sym
*external_syms
;
5124 /* Buffer large enough to hold internal local symbols of any input
5126 Elf_Internal_Sym
*internal_syms
;
5127 /* Array large enough to hold a symbol index for each local symbol
5128 of any input BFD. */
5130 /* Array large enough to hold a section pointer for each local
5131 symbol of any input BFD. */
5132 asection
**sections
;
5133 /* Buffer to hold swapped out symbols. */
5134 Elf_External_Sym
*symbuf
;
5135 /* Number of swapped out symbols in buffer. */
5136 size_t symbuf_count
;
5137 /* Number of symbols which fit in symbuf. */
5141 static boolean elf_link_output_sym
5142 PARAMS ((struct elf_final_link_info
*, const char *,
5143 Elf_Internal_Sym
*, asection
*));
5144 static boolean elf_link_flush_output_syms
5145 PARAMS ((struct elf_final_link_info
*));
5146 static boolean elf_link_output_extsym
5147 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5148 static boolean elf_link_input_bfd
5149 PARAMS ((struct elf_final_link_info
*, bfd
*));
5150 static boolean elf_reloc_link_order
5151 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5152 struct bfd_link_order
*));
5154 /* Do the final step of an ELF link. */
5157 elf_bfd_final_link (abfd
, info
)
5159 struct bfd_link_info
*info
;
5162 struct elf_final_link_info finfo
;
5163 register asection
*o
;
5164 register struct bfd_link_order
*p
;
5166 size_t max_contents_size
;
5167 size_t max_external_reloc_size
;
5168 size_t max_internal_reloc_count
;
5169 size_t max_sym_count
;
5171 Elf_Internal_Sym elfsym
;
5173 Elf_Internal_Shdr
*symtab_hdr
;
5174 Elf_Internal_Shdr
*symstrtab_hdr
;
5175 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5178 abfd
->flags
|= DYNAMIC
;
5180 dynobj
= elf_hash_table (info
)->dynobj
;
5183 finfo
.output_bfd
= abfd
;
5184 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5185 if (finfo
.symstrtab
== NULL
)
5189 finfo
.dynsym_sec
= NULL
;
5190 finfo
.hash_sec
= NULL
;
5194 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5195 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5196 if (finfo
.dynsym_sec
== NULL
5197 || finfo
.hash_sec
== NULL
)
5200 finfo
.contents
= NULL
;
5201 finfo
.external_relocs
= NULL
;
5202 finfo
.internal_relocs
= NULL
;
5203 finfo
.external_syms
= NULL
;
5204 finfo
.internal_syms
= NULL
;
5205 finfo
.indices
= NULL
;
5206 finfo
.sections
= NULL
;
5207 finfo
.symbuf
= NULL
;
5208 finfo
.symbuf_count
= 0;
5210 /* Count up the number of relocations we will output for each output
5211 section, so that we know the sizes of the reloc sections. We
5212 also figure out some maximum sizes. */
5213 max_contents_size
= 0;
5214 max_external_reloc_size
= 0;
5215 max_internal_reloc_count
= 0;
5217 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5221 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5223 if (p
->type
== bfd_section_reloc_link_order
5224 || p
->type
== bfd_symbol_reloc_link_order
)
5226 else if (p
->type
== bfd_indirect_link_order
)
5230 sec
= p
->u
.indirect
.section
;
5232 if (info
->relocateable
)
5233 o
->reloc_count
+= sec
->reloc_count
;
5235 if (sec
->_raw_size
> max_contents_size
)
5236 max_contents_size
= sec
->_raw_size
;
5237 if (sec
->_cooked_size
> max_contents_size
)
5238 max_contents_size
= sec
->_cooked_size
;
5240 /* We are interested in just local symbols, not all
5242 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5246 if (elf_bad_symtab (sec
->owner
))
5247 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5248 / sizeof (Elf_External_Sym
));
5250 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5252 if (sym_count
> max_sym_count
)
5253 max_sym_count
= sym_count
;
5255 if ((sec
->flags
& SEC_RELOC
) != 0)
5259 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5260 if (ext_size
> max_external_reloc_size
)
5261 max_external_reloc_size
= ext_size
;
5262 if (sec
->reloc_count
> max_internal_reloc_count
)
5263 max_internal_reloc_count
= sec
->reloc_count
;
5269 if (o
->reloc_count
> 0)
5270 o
->flags
|= SEC_RELOC
;
5273 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5274 set it (this is probably a bug) and if it is set
5275 assign_section_numbers will create a reloc section. */
5276 o
->flags
&=~ SEC_RELOC
;
5279 /* If the SEC_ALLOC flag is not set, force the section VMA to
5280 zero. This is done in elf_fake_sections as well, but forcing
5281 the VMA to 0 here will ensure that relocs against these
5282 sections are handled correctly. */
5283 if ((o
->flags
& SEC_ALLOC
) == 0)
5287 /* Figure out the file positions for everything but the symbol table
5288 and the relocs. We set symcount to force assign_section_numbers
5289 to create a symbol table. */
5290 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5291 BFD_ASSERT (! abfd
->output_has_begun
);
5292 if (! elf_compute_section_file_positions (abfd
, info
))
5295 /* That created the reloc sections. Set their sizes, and assign
5296 them file positions, and allocate some buffers. */
5297 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5299 if ((o
->flags
& SEC_RELOC
) != 0)
5301 Elf_Internal_Shdr
*rel_hdr
;
5302 register struct elf_link_hash_entry
**p
, **pend
;
5304 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5306 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5308 /* The contents field must last into write_object_contents,
5309 so we allocate it with bfd_alloc rather than malloc. */
5310 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5311 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5313 bfd_set_error (bfd_error_no_memory
);
5317 p
= ((struct elf_link_hash_entry
**)
5318 malloc (o
->reloc_count
5319 * sizeof (struct elf_link_hash_entry
*)));
5320 if (p
== NULL
&& o
->reloc_count
!= 0)
5322 bfd_set_error (bfd_error_no_memory
);
5325 elf_section_data (o
)->rel_hashes
= p
;
5326 pend
= p
+ o
->reloc_count
;
5327 for (; p
< pend
; p
++)
5330 /* Use the reloc_count field as an index when outputting the
5336 assign_file_positions_for_relocs (abfd
);
5338 /* We have now assigned file positions for all the sections except
5339 .symtab and .strtab. We start the .symtab section at the current
5340 file position, and write directly to it. We build the .strtab
5341 section in memory. When we add .dynsym support, we will build
5342 that in memory as well (.dynsym is smaller than .symtab). */
5344 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5345 /* sh_name is set in prep_headers. */
5346 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5347 symtab_hdr
->sh_flags
= 0;
5348 symtab_hdr
->sh_addr
= 0;
5349 symtab_hdr
->sh_size
= 0;
5350 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5351 /* sh_link is set in assign_section_numbers. */
5352 /* sh_info is set below. */
5353 /* sh_offset is set just below. */
5354 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5356 off
= elf_tdata (abfd
)->next_file_pos
;
5357 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5359 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5360 incorrect. We do not yet know the size of the .symtab section.
5361 We correct next_file_pos below, after we do know the size. */
5363 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5364 continuously seeking to the right position in the file. */
5365 if (! info
->keep_memory
|| max_sym_count
< 20)
5366 finfo
.symbuf_size
= 20;
5368 finfo
.symbuf_size
= max_sym_count
;
5369 finfo
.symbuf
= ((Elf_External_Sym
*)
5370 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5371 if (finfo
.symbuf
== NULL
)
5373 bfd_set_error (bfd_error_no_memory
);
5377 /* Start writing out the symbol table. The first symbol is always a
5379 elfsym
.st_value
= 0;
5382 elfsym
.st_other
= 0;
5383 elfsym
.st_shndx
= SHN_UNDEF
;
5384 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5385 &elfsym
, bfd_und_section_ptr
))
5389 /* Some standard ELF linkers do this, but we don't because it causes
5390 bootstrap comparison failures. */
5391 /* Output a file symbol for the output file as the second symbol.
5392 We output this even if we are discarding local symbols, although
5393 I'm not sure if this is correct. */
5394 elfsym
.st_value
= 0;
5396 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5397 elfsym
.st_other
= 0;
5398 elfsym
.st_shndx
= SHN_ABS
;
5399 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5400 &elfsym
, bfd_abs_section_ptr
))
5404 /* Output a symbol for each section. We output these even if we are
5405 discarding local symbols, since they are used for relocs. These
5406 symbols have no names. We store the index of each one in the
5407 index field of the section, so that we can find it again when
5408 outputting relocs. */
5409 elfsym
.st_value
= 0;
5411 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5412 elfsym
.st_other
= 0;
5413 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5415 o
= section_from_elf_index (abfd
, i
);
5416 if (! bfd_is_abs_section (o
))
5417 o
->target_index
= abfd
->symcount
;
5418 elfsym
.st_shndx
= i
;
5419 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5424 /* Allocate some memory to hold information read in from the input
5426 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5427 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5428 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5429 malloc (max_internal_reloc_count
5430 * sizeof (Elf_Internal_Rela
)));
5431 finfo
.external_syms
= ((Elf_External_Sym
*)
5432 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5433 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5434 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5435 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5436 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5437 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5438 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5439 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5440 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5441 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5442 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5443 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5445 bfd_set_error (bfd_error_no_memory
);
5449 /* Since ELF permits relocations to be against local symbols, we
5450 must have the local symbols available when we do the relocations.
5451 Since we would rather only read the local symbols once, and we
5452 would rather not keep them in memory, we handle all the
5453 relocations for a single input file at the same time.
5455 Unfortunately, there is no way to know the total number of local
5456 symbols until we have seen all of them, and the local symbol
5457 indices precede the global symbol indices. This means that when
5458 we are generating relocateable output, and we see a reloc against
5459 a global symbol, we can not know the symbol index until we have
5460 finished examining all the local symbols to see which ones we are
5461 going to output. To deal with this, we keep the relocations in
5462 memory, and don't output them until the end of the link. This is
5463 an unfortunate waste of memory, but I don't see a good way around
5464 it. Fortunately, it only happens when performing a relocateable
5465 link, which is not the common case. FIXME: If keep_memory is set
5466 we could write the relocs out and then read them again; I don't
5467 know how bad the memory loss will be. */
5469 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5470 sub
->output_has_begun
= false;
5471 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5473 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5475 if (p
->type
== bfd_indirect_link_order
5476 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5477 == bfd_target_elf_flavour
))
5479 sub
= p
->u
.indirect
.section
->owner
;
5480 if (! sub
->output_has_begun
)
5482 if (! elf_link_input_bfd (&finfo
, sub
))
5484 sub
->output_has_begun
= true;
5487 else if (p
->type
== bfd_section_reloc_link_order
5488 || p
->type
== bfd_symbol_reloc_link_order
)
5490 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5495 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5501 /* That wrote out all the local symbols. Finish up the symbol table
5502 with the global symbols. */
5504 /* The sh_info field records the index of the first non local
5506 symtab_hdr
->sh_info
= abfd
->symcount
;
5508 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5510 /* We get the global symbols from the hash table. */
5511 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5514 /* Flush all symbols to the file. */
5515 if (! elf_link_flush_output_syms (&finfo
))
5518 /* Now we know the size of the symtab section. */
5519 off
+= symtab_hdr
->sh_size
;
5521 /* Finish up the symbol string table (.strtab) section. */
5522 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5523 /* sh_name was set in prep_headers. */
5524 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5525 symstrtab_hdr
->sh_flags
= 0;
5526 symstrtab_hdr
->sh_addr
= 0;
5527 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5528 symstrtab_hdr
->sh_entsize
= 0;
5529 symstrtab_hdr
->sh_link
= 0;
5530 symstrtab_hdr
->sh_info
= 0;
5531 /* sh_offset is set just below. */
5532 symstrtab_hdr
->sh_addralign
= 1;
5533 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5535 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5536 elf_tdata (abfd
)->next_file_pos
= off
;
5538 /* Adjust the relocs to have the correct symbol indices. */
5539 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5541 struct elf_link_hash_entry
**rel_hash
;
5542 Elf_Internal_Shdr
*rel_hdr
;
5544 if ((o
->flags
& SEC_RELOC
) == 0)
5547 rel_hash
= elf_section_data (o
)->rel_hashes
;
5548 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5549 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5551 if (*rel_hash
== NULL
)
5554 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5556 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5558 Elf_External_Rel
*erel
;
5559 Elf_Internal_Rel irel
;
5561 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5562 elf_swap_reloc_in (abfd
, erel
, &irel
);
5563 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5564 ELF_R_TYPE (irel
.r_info
));
5565 elf_swap_reloc_out (abfd
, &irel
, erel
);
5569 Elf_External_Rela
*erela
;
5570 Elf_Internal_Rela irela
;
5572 BFD_ASSERT (rel_hdr
->sh_entsize
5573 == sizeof (Elf_External_Rela
));
5575 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5576 elf_swap_reloca_in (abfd
, erela
, &irela
);
5577 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5578 ELF_R_TYPE (irela
.r_info
));
5579 elf_swap_reloca_out (abfd
, &irela
, erela
);
5583 /* Set the reloc_count field to 0 to prevent write_relocs from
5584 trying to swap the relocs out itself. */
5588 /* If we are linking against a dynamic object, finish up the dynamic
5589 linking information. */
5592 Elf_External_Dyn
*dyncon
, *dynconend
;
5594 /* Fix up .dynamic entries. */
5595 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5596 BFD_ASSERT (o
!= NULL
);
5598 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5599 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5600 for (; dyncon
< dynconend
; dyncon
++)
5602 Elf_Internal_Dyn dyn
;
5606 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5628 o
= bfd_get_section_by_name (abfd
, name
);
5629 BFD_ASSERT (o
!= NULL
);
5630 dyn
.d_un
.d_ptr
= o
->vma
;
5631 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5638 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5643 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5645 Elf_Internal_Shdr
*hdr
;
5647 hdr
= elf_elfsections (abfd
)[i
];
5648 if (hdr
->sh_type
== type
5649 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5651 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5652 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5655 if (dyn
.d_un
.d_val
== 0
5656 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5657 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5661 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5666 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5669 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5671 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5673 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5675 BFD_ASSERT (info
->shared
);
5678 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5679 o
->contents
, o
->output_offset
,
5685 /* Now backend stuff. */
5686 if (bed
->elf_backend_final_write_processing
)
5687 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5689 if (finfo
.contents
!= NULL
)
5690 free (finfo
.contents
);
5691 if (finfo
.external_relocs
!= NULL
)
5692 free (finfo
.external_relocs
);
5693 if (finfo
.internal_relocs
!= NULL
)
5694 free (finfo
.internal_relocs
);
5695 if (finfo
.external_syms
!= NULL
)
5696 free (finfo
.external_syms
);
5697 if (finfo
.internal_syms
!= NULL
)
5698 free (finfo
.internal_syms
);
5699 if (finfo
.indices
!= NULL
)
5700 free (finfo
.indices
);
5701 if (finfo
.sections
!= NULL
)
5702 free (finfo
.sections
);
5703 if (finfo
.symbuf
!= NULL
)
5704 free (finfo
.symbuf
);
5705 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5707 if ((o
->flags
& SEC_RELOC
) != 0
5708 && elf_section_data (o
)->rel_hashes
!= NULL
)
5709 free (elf_section_data (o
)->rel_hashes
);
5715 if (finfo
.contents
!= NULL
)
5716 free (finfo
.contents
);
5717 if (finfo
.external_relocs
!= NULL
)
5718 free (finfo
.external_relocs
);
5719 if (finfo
.internal_relocs
!= NULL
)
5720 free (finfo
.internal_relocs
);
5721 if (finfo
.external_syms
!= NULL
)
5722 free (finfo
.external_syms
);
5723 if (finfo
.internal_syms
!= NULL
)
5724 free (finfo
.internal_syms
);
5725 if (finfo
.indices
!= NULL
)
5726 free (finfo
.indices
);
5727 if (finfo
.sections
!= NULL
)
5728 free (finfo
.sections
);
5729 if (finfo
.symbuf
!= NULL
)
5730 free (finfo
.symbuf
);
5731 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5733 if ((o
->flags
& SEC_RELOC
) != 0
5734 && elf_section_data (o
)->rel_hashes
!= NULL
)
5735 free (elf_section_data (o
)->rel_hashes
);
5741 /* Add a symbol to the output symbol table. */
5744 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5745 struct elf_final_link_info
*finfo
;
5747 Elf_Internal_Sym
*elfsym
;
5748 asection
*input_sec
;
5750 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5751 struct bfd_link_info
*info
,
5756 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5757 elf_backend_link_output_symbol_hook
;
5758 if (output_symbol_hook
!= NULL
)
5760 if (! ((*output_symbol_hook
)
5761 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5765 if (name
== (const char *) NULL
|| *name
== '\0')
5766 elfsym
->st_name
= 0;
5769 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5770 finfo
->symstrtab
, name
);
5771 if (elfsym
->st_name
== (unsigned long) -1)
5775 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5777 if (! elf_link_flush_output_syms (finfo
))
5781 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5782 finfo
->symbuf
+ finfo
->symbuf_count
);
5783 ++finfo
->symbuf_count
;
5785 ++finfo
->output_bfd
->symcount
;
5790 /* Flush the output symbols to the file. */
5793 elf_link_flush_output_syms (finfo
)
5794 struct elf_final_link_info
*finfo
;
5796 Elf_Internal_Shdr
*symtab
;
5798 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5800 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5802 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5803 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5804 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5807 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5809 finfo
->symbuf_count
= 0;
5814 /* Add an external symbol to the symbol table. This is called from
5815 the hash table traversal routine. */
5818 elf_link_output_extsym (h
, data
)
5819 struct elf_link_hash_entry
*h
;
5822 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5824 Elf_Internal_Sym sym
;
5825 asection
*input_sec
;
5827 /* We don't want to output symbols that have never been mentioned by
5828 a regular file, or that we have been told to strip. However, if
5829 h->indx is set to -2, the symbol is used by a reloc and we must
5833 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5834 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5835 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5836 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5838 else if (finfo
->info
->strip
== strip_all
5839 || (finfo
->info
->strip
== strip_some
5840 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5841 h
->root
.root
.string
,
5842 false, false) == NULL
))
5847 /* If we're stripping it, and it's not a dynamic symbol, there's
5848 nothing else to do. */
5849 if (strip
&& h
->dynindx
== -1)
5853 sym
.st_size
= h
->size
;
5855 if (h
->root
.type
== bfd_link_hash_weak
5856 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0
5857 && ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
5858 | ELF_LINK_HASH_REF_DYNAMIC
))
5860 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5862 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5864 switch (h
->root
.type
)
5867 case bfd_link_hash_new
:
5871 case bfd_link_hash_undefined
:
5872 input_sec
= bfd_und_section_ptr
;
5873 sym
.st_shndx
= SHN_UNDEF
;
5876 case bfd_link_hash_weak
:
5877 input_sec
= bfd_und_section_ptr
;
5878 sym
.st_shndx
= SHN_UNDEF
;
5881 case bfd_link_hash_defined
:
5884 input_sec
= h
->root
.u
.def
.section
;
5885 if (input_sec
->output_section
!= NULL
)
5887 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5888 input_sec
->output_section
);
5889 if (sym
.st_shndx
== (unsigned short) -1)
5891 /* FIXME: No way to handle errors. */
5895 /* ELF symbols in relocateable files are section relative,
5896 but in nonrelocateable files they are virtual
5898 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5899 if (! finfo
->info
->relocateable
)
5900 sym
.st_value
+= input_sec
->output_section
->vma
;
5904 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5905 == bfd_target_elf_flavour
5906 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5907 sym
.st_shndx
= SHN_UNDEF
;
5908 input_sec
= bfd_und_section_ptr
;
5913 case bfd_link_hash_common
:
5914 input_sec
= bfd_com_section_ptr
;
5915 sym
.st_shndx
= SHN_COMMON
;
5916 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
5919 case bfd_link_hash_indirect
:
5920 case bfd_link_hash_warning
:
5921 /* I have no idea how these should be handled. */
5925 /* If this symbol should be put in the .dynsym section, then put it
5926 there now. We have already know the symbol index. We also fill
5927 in the entry in the .hash section. */
5928 if (h
->dynindx
!= -1)
5930 struct elf_backend_data
*bed
;
5933 bfd_byte
*bucketpos
;
5936 sym
.st_name
= h
->dynstr_index
;
5938 /* Give the processor backend a chance to tweak the symbol
5939 value, and also to finish up anything that needs to be done
5941 bed
= get_elf_backend_data (finfo
->output_bfd
);
5942 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5943 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5945 /* FIXME: No way to return error. */
5949 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5950 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5953 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5954 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5955 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5956 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5957 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5958 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5959 put_word (finfo
->output_bfd
, chain
,
5960 ((bfd_byte
*) finfo
->hash_sec
->contents
5961 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5964 /* If we're stripping it, then it was just a dynamic symbol, and
5965 there's nothing else to do. */
5969 h
->indx
= finfo
->output_bfd
->symcount
;
5971 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5973 /* FIXME: No way to return error. */
5980 /* Link an input file into the linker output file. This function
5981 handles all the sections and relocations of the input file at once.
5982 This is so that we only have to read the local symbols once, and
5983 don't have to keep them in memory. */
5986 elf_link_input_bfd (finfo
, input_bfd
)
5987 struct elf_final_link_info
*finfo
;
5990 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5991 bfd
*, asection
*, bfd_byte
*,
5992 Elf_Internal_Rela
*,
5994 asection
**, char *));
5996 Elf_Internal_Shdr
*symtab_hdr
;
5999 Elf_External_Sym
*esym
;
6000 Elf_External_Sym
*esymend
;
6001 Elf_Internal_Sym
*isym
;
6003 asection
**ppsection
;
6006 output_bfd
= finfo
->output_bfd
;
6008 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
6010 /* If this is a dynamic object, we don't want to do anything here:
6011 we don't want the local symbols, and we don't want the section
6013 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6016 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6017 if (elf_bad_symtab (input_bfd
))
6019 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6024 locsymcount
= symtab_hdr
->sh_info
;
6025 extsymoff
= symtab_hdr
->sh_info
;
6028 /* Read the local symbols. */
6030 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6031 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6032 locsymcount
, input_bfd
)
6033 != locsymcount
* sizeof (Elf_External_Sym
))))
6036 /* Swap in the local symbols and write out the ones which we know
6037 are going into the output file. */
6038 esym
= finfo
->external_syms
;
6039 esymend
= esym
+ locsymcount
;
6040 isym
= finfo
->internal_syms
;
6041 pindex
= finfo
->indices
;
6042 ppsection
= finfo
->sections
;
6043 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6049 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6052 if (elf_bad_symtab (input_bfd
))
6054 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6061 if (isym
->st_shndx
== SHN_UNDEF
)
6062 isec
= bfd_und_section_ptr
;
6063 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6065 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6069 else if (isym
->st_shndx
== SHN_ABS
)
6070 isec
= bfd_abs_section_ptr
;
6071 else if (isym
->st_shndx
== SHN_COMMON
)
6072 isec
= bfd_com_section_ptr
;
6081 /* Don't output the first, undefined, symbol. */
6082 if (esym
== finfo
->external_syms
)
6085 /* If we are stripping all symbols, we don't want to output this
6087 if (finfo
->info
->strip
== strip_all
)
6090 /* We never output section symbols. Instead, we use the section
6091 symbol of the corresponding section in the output file. */
6092 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6095 /* If we are discarding all local symbols, we don't want to
6096 output this one. If we are generating a relocateable output
6097 file, then some of the local symbols may be required by
6098 relocs; we output them below as we discover that they are
6100 if (finfo
->info
->discard
== discard_all
)
6103 /* Get the name of the symbol. */
6104 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6109 /* See if we are discarding symbols with this name. */
6110 if ((finfo
->info
->strip
== strip_some
6111 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6113 || (finfo
->info
->discard
== discard_l
6114 && strncmp (name
, finfo
->info
->lprefix
,
6115 finfo
->info
->lprefix_len
) == 0))
6118 /* If we get here, we are going to output this symbol. */
6120 /* Adjust the section index for the output file. */
6121 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
6122 isec
->output_section
);
6123 if (isym
->st_shndx
== (unsigned short) -1)
6126 *pindex
= output_bfd
->symcount
;
6128 /* ELF symbols in relocateable files are section relative, but
6129 in executable files they are virtual addresses. Note that
6130 this code assumes that all ELF sections have an associated
6131 BFD section with a reasonable value for output_offset; below
6132 we assume that they also have a reasonable value for
6133 output_section. Any special sections must be set up to meet
6134 these requirements. */
6135 oldval
= isym
->st_value
;
6136 isym
->st_value
+= isec
->output_offset
;
6137 if (! finfo
->info
->relocateable
)
6138 isym
->st_value
+= isec
->output_section
->vma
;
6140 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
6143 /* Restore the old value for reloc handling. */
6144 isym
->st_value
= oldval
;
6147 /* Relocate the contents of each section. */
6148 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6150 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6153 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6154 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6156 /* Section was created by elf_link_create_dynamic_sections.
6157 FIXME: This test is fragile. */
6161 /* Read the contents of the section. */
6162 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6163 (file_ptr
) 0, o
->_raw_size
))
6166 if ((o
->flags
& SEC_RELOC
) != 0)
6168 Elf_Internal_Rela
*internal_relocs
;
6170 /* Get the swapped relocs. */
6171 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6172 finfo
->external_relocs
,
6173 finfo
->internal_relocs
,
6175 if (internal_relocs
== NULL
6176 && o
->reloc_count
> 0)
6179 /* Relocate the section by invoking a back end routine.
6181 The back end routine is responsible for adjusting the
6182 section contents as necessary, and (if using Rela relocs
6183 and generating a relocateable output file) adjusting the
6184 reloc addend as necessary.
6186 The back end routine does not have to worry about setting
6187 the reloc address or the reloc symbol index.
6189 The back end routine is given a pointer to the swapped in
6190 internal symbols, and can access the hash table entries
6191 for the external symbols via elf_sym_hashes (input_bfd).
6193 When generating relocateable output, the back end routine
6194 must handle STB_LOCAL/STT_SECTION symbols specially. The
6195 output symbol is going to be a section symbol
6196 corresponding to the output section, which will require
6197 the addend to be adjusted. */
6199 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6203 finfo
->internal_syms
,
6205 finfo
->symstrtab
->tab
))
6208 if (finfo
->info
->relocateable
)
6210 Elf_Internal_Rela
*irela
;
6211 Elf_Internal_Rela
*irelaend
;
6212 struct elf_link_hash_entry
**rel_hash
;
6213 Elf_Internal_Shdr
*input_rel_hdr
;
6214 Elf_Internal_Shdr
*output_rel_hdr
;
6216 /* Adjust the reloc addresses and symbol indices. */
6218 irela
= internal_relocs
;
6219 irelaend
= irela
+ o
->reloc_count
;
6220 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6221 + o
->output_section
->reloc_count
);
6222 for (; irela
< irelaend
; irela
++, rel_hash
++)
6225 Elf_Internal_Sym
*isym
;
6228 irela
->r_offset
+= o
->output_offset
;
6230 r_symndx
= ELF_R_SYM (irela
->r_info
);
6235 if (r_symndx
>= locsymcount
6236 || (elf_bad_symtab (input_bfd
)
6237 && finfo
->sections
[r_symndx
] == NULL
))
6241 /* This is a reloc against a global symbol. We
6242 have not yet output all the local symbols, so
6243 we do not know the symbol index of any global
6244 symbol. We set the rel_hash entry for this
6245 reloc to point to the global hash table entry
6246 for this symbol. The symbol index is then
6247 set at the end of elf_bfd_final_link. */
6248 indx
= r_symndx
- extsymoff
;
6249 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6251 /* Setting the index to -2 tells
6252 elf_link_output_extsym that this symbol is
6254 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6255 (*rel_hash
)->indx
= -2;
6260 /* This is a reloc against a local symbol. */
6263 isym
= finfo
->internal_syms
+ r_symndx
;
6264 sec
= finfo
->sections
[r_symndx
];
6265 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6267 /* I suppose the backend ought to fill in the
6268 section of any STT_SECTION symbol against a
6269 processor specific section. */
6270 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6272 else if (sec
== NULL
|| sec
->owner
== NULL
)
6274 bfd_set_error (bfd_error_bad_value
);
6279 r_symndx
= sec
->output_section
->target_index
;
6286 if (finfo
->indices
[r_symndx
] == -1)
6292 if (finfo
->info
->strip
== strip_all
)
6294 /* You can't do ld -r -s. */
6295 bfd_set_error (bfd_error_invalid_operation
);
6299 /* This symbol was skipped earlier, but
6300 since it is needed by a reloc, we
6301 must output it now. */
6302 link
= symtab_hdr
->sh_link
;
6303 name
= elf_string_from_elf_section (input_bfd
,
6309 osec
= sec
->output_section
;
6311 elf_section_from_bfd_section (output_bfd
,
6313 if (isym
->st_shndx
== (unsigned short) -1)
6316 isym
->st_value
+= sec
->output_offset
;
6317 if (! finfo
->info
->relocateable
)
6318 isym
->st_value
+= osec
->vma
;
6320 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6322 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6326 r_symndx
= finfo
->indices
[r_symndx
];
6329 irela
->r_info
= ELF_R_INFO (r_symndx
,
6330 ELF_R_TYPE (irela
->r_info
));
6333 /* Swap out the relocs. */
6334 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6335 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6336 BFD_ASSERT (output_rel_hdr
->sh_entsize
6337 == input_rel_hdr
->sh_entsize
);
6338 irela
= internal_relocs
;
6339 irelaend
= irela
+ o
->reloc_count
;
6340 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6342 Elf_External_Rel
*erel
;
6344 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6345 + o
->output_section
->reloc_count
);
6346 for (; irela
< irelaend
; irela
++, erel
++)
6348 Elf_Internal_Rel irel
;
6350 irel
.r_offset
= irela
->r_offset
;
6351 irel
.r_info
= irela
->r_info
;
6352 BFD_ASSERT (irela
->r_addend
== 0);
6353 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6358 Elf_External_Rela
*erela
;
6360 BFD_ASSERT (input_rel_hdr
->sh_entsize
6361 == sizeof (Elf_External_Rela
));
6362 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6363 + o
->output_section
->reloc_count
);
6364 for (; irela
< irelaend
; irela
++, erela
++)
6365 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6368 o
->output_section
->reloc_count
+= o
->reloc_count
;
6372 /* Write out the modified section contents. */
6373 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6374 finfo
->contents
, o
->output_offset
,
6375 (o
->_cooked_size
!= 0
6384 /* Generate a reloc when linking an ELF file. This is a reloc
6385 requested by the linker, and does come from any input file. This
6386 is used to build constructor and destructor tables when linking
6390 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6392 struct bfd_link_info
*info
;
6393 asection
*output_section
;
6394 struct bfd_link_order
*link_order
;
6396 const reloc_howto_type
*howto
;
6399 struct elf_link_hash_entry
**rel_hash_ptr
;
6400 Elf_Internal_Shdr
*rel_hdr
;
6402 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6405 bfd_set_error (bfd_error_bad_value
);
6409 /* If this is an inplace reloc, we must write the addend into the
6411 if (howto
->partial_inplace
6412 && link_order
->u
.reloc
.p
->addend
!= 0)
6415 bfd_reloc_status_type rstat
;
6419 size
= bfd_get_reloc_size (howto
);
6420 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6421 if (buf
== (bfd_byte
*) NULL
)
6423 bfd_set_error (bfd_error_no_memory
);
6426 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6427 link_order
->u
.reloc
.p
->addend
, buf
);
6433 case bfd_reloc_outofrange
:
6435 case bfd_reloc_overflow
:
6436 if (! ((*info
->callbacks
->reloc_overflow
)
6438 (link_order
->type
== bfd_section_reloc_link_order
6439 ? bfd_section_name (output_bfd
,
6440 link_order
->u
.reloc
.p
->u
.section
)
6441 : link_order
->u
.reloc
.p
->u
.name
),
6442 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6443 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6450 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6451 (file_ptr
) link_order
->offset
, size
);
6457 /* Figure out the symbol index. */
6458 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6459 + output_section
->reloc_count
);
6460 if (link_order
->type
== bfd_section_reloc_link_order
)
6462 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6465 *rel_hash_ptr
= NULL
;
6469 struct elf_link_hash_entry
*h
;
6471 h
= elf_link_hash_lookup (elf_hash_table (info
),
6472 link_order
->u
.reloc
.p
->u
.name
,
6473 false, false, true);
6476 /* Setting the index to -2 tells elf_link_output_extsym that
6477 this symbol is used by a reloc. */
6484 if (! ((*info
->callbacks
->unattached_reloc
)
6485 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6486 (asection
*) NULL
, (bfd_vma
) 0)))
6492 /* The address of a reloc is relative to the section in a
6493 relocateable file, and is a virtual address in an executable
6495 offset
= link_order
->offset
;
6496 if (! info
->relocateable
)
6497 offset
+= output_section
->vma
;
6499 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6501 if (rel_hdr
->sh_type
== SHT_REL
)
6503 Elf_Internal_Rel irel
;
6504 Elf_External_Rel
*erel
;
6506 irel
.r_offset
= offset
;
6507 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6508 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6509 + output_section
->reloc_count
);
6510 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6514 Elf_Internal_Rela irela
;
6515 Elf_External_Rela
*erela
;
6517 irela
.r_offset
= offset
;
6518 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6519 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6520 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6521 + output_section
->reloc_count
);
6522 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6525 ++output_section
->reloc_count
;