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. Actually, it's OK if we allocated too
1928 much space in the program header. */
1929 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1932 /* Set up program header information. */
1933 i_ehdrp
= elf_elfheader (abfd
);
1934 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1935 i_ehdrp
->e_phoff
= off
;
1936 i_ehdrp
->e_phnum
= phdr_count
;
1938 /* Save the program headers away. I don't think anybody uses this
1939 information right now. */
1940 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1943 * sizeof (Elf_Internal_Phdr
))));
1944 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1946 bfd_set_error (bfd_error_no_memory
);
1947 return (file_ptr
) -1;
1949 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1950 phdr_count
* sizeof (Elf_Internal_Phdr
));
1952 /* Write out the program headers. */
1953 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1954 return (file_ptr
) -1;
1956 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1958 Elf_External_Phdr extphdr
;
1960 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1961 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1962 != sizeof (Elf_External_Phdr
))
1963 return (file_ptr
) -1;
1966 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1969 /* Work out the file positions of all the sections. This is called by
1970 elf_compute_section_file_positions. All the section sizes and VMAs
1971 must be known before this is called.
1973 We do not consider reloc sections at this point, unless they form
1974 part of the loadable image. Reloc sections are assigned file
1975 positions in assign_file_positions_for_relocs, which is called by
1976 write_object_contents and final_link.
1978 If DOSYMS is false, we do not assign file positions for the symbol
1979 table or the string table. */
1982 assign_file_positions_except_relocs (abfd
, dosyms
)
1986 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1987 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1988 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1991 /* Start after the ELF header. */
1992 off
= i_ehdrp
->e_ehsize
;
1994 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1996 Elf_Internal_Shdr
**hdrpp
;
1999 /* We are not creating an executable, which means that we are
2000 not creating a program header, and that the actual order of
2001 the sections in the file is unimportant. */
2002 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2004 Elf_Internal_Shdr
*hdr
;
2007 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2009 hdr
->sh_offset
= -1;
2013 && (i
== tdata
->symtab_section
2014 || i
== tdata
->strtab_section
))
2016 hdr
->sh_offset
= -1;
2020 off
= assign_file_position_for_section (hdr
, off
, true);
2026 bfd_size_type phdr_size
;
2027 bfd_vma maxpagesize
;
2028 Elf_Internal_Shdr
**hdrpp
;
2030 Elf_Internal_Shdr
*first
;
2033 /* We are creating an executable. We must create a program
2034 header. We can't actually create the program header until we
2035 have set the file positions for the sections, but we can
2036 figure out how big it is going to be. */
2037 off
= align_file_position (off
);
2038 phdr_size
= get_program_header_size (abfd
);
2039 if (phdr_size
== (file_ptr
) -1)
2044 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2045 if (maxpagesize
== 0)
2048 /* FIXME: We might want to sort the sections on the sh_addr
2049 field here. For now, we just assume that the linker will
2050 create the sections in an appropriate order. */
2052 /* Assign file positions in two passes. In the first pass, we
2053 assign a file position to every section which forms part of
2054 the executable image. */
2056 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2058 Elf_Internal_Shdr
*hdr
;
2061 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2067 if ((abfd
->flags
& D_PAGED
) != 0)
2069 /* The section VMA must equal the file position modulo
2070 the page size. This is required by the program
2072 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2075 off
= assign_file_position_for_section (hdr
, off
, false);
2078 /* Assign file positions to all the sections which do not form
2079 part of the loadable image, except for the relocs. */
2080 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2082 Elf_Internal_Shdr
*hdr
;
2085 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2087 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2089 hdr
->sh_offset
= -1;
2093 && (i
== tdata
->symtab_section
2094 || i
== tdata
->strtab_section
))
2096 hdr
->sh_offset
= -1;
2100 off
= assign_file_position_for_section (hdr
, off
, true);
2103 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2104 if (phdr_map
== (file_ptr
) -1)
2106 BFD_ASSERT (phdr_map
<= phdr_off
+ phdr_size
);
2109 /* Place the section headers. */
2110 off
= align_file_position (off
);
2111 i_ehdrp
->e_shoff
= off
;
2112 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2114 elf_tdata (abfd
)->next_file_pos
= off
;
2123 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2124 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2125 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2127 struct strtab
*shstrtab
;
2129 i_ehdrp
= elf_elfheader (abfd
);
2130 i_shdrp
= elf_elfsections (abfd
);
2132 shstrtab
= bfd_new_strtab (abfd
);
2136 elf_shstrtab (abfd
) = shstrtab
;
2138 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2139 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2140 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2141 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2143 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2144 i_ehdrp
->e_ident
[EI_DATA
] =
2145 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2146 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2148 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2149 i_ehdrp
->e_ident
[count
] = 0;
2151 if ((abfd
->flags
& DYNAMIC
) != 0)
2152 i_ehdrp
->e_type
= ET_DYN
;
2153 else if ((abfd
->flags
& EXEC_P
) != 0)
2154 i_ehdrp
->e_type
= ET_EXEC
;
2156 i_ehdrp
->e_type
= ET_REL
;
2158 switch (bfd_get_arch (abfd
))
2160 case bfd_arch_unknown
:
2161 i_ehdrp
->e_machine
= EM_NONE
;
2163 case bfd_arch_sparc
:
2165 i_ehdrp
->e_machine
= EM_SPARC64
;
2167 i_ehdrp
->e_machine
= EM_SPARC
;
2171 i_ehdrp
->e_machine
= EM_386
;
2174 i_ehdrp
->e_machine
= EM_68K
;
2177 i_ehdrp
->e_machine
= EM_88K
;
2180 i_ehdrp
->e_machine
= EM_860
;
2182 case bfd_arch_mips
: /* MIPS Rxxxx */
2183 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2186 i_ehdrp
->e_machine
= EM_PARISC
;
2188 case bfd_arch_powerpc
:
2189 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2191 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2193 i_ehdrp
->e_machine
= EM_NONE
;
2195 i_ehdrp
->e_version
= EV_CURRENT
;
2196 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2198 /* no program header, for now. */
2199 i_ehdrp
->e_phoff
= 0;
2200 i_ehdrp
->e_phentsize
= 0;
2201 i_ehdrp
->e_phnum
= 0;
2203 /* each bfd section is section header entry */
2204 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2205 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2207 /* if we're building an executable, we'll need a program header table */
2208 if (abfd
->flags
& EXEC_P
)
2210 /* it all happens later */
2212 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2214 /* elf_build_phdrs() returns a (NULL-terminated) array of
2215 Elf_Internal_Phdrs */
2216 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2217 i_ehdrp
->e_phoff
= outbase
;
2218 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2223 i_ehdrp
->e_phentsize
= 0;
2225 i_ehdrp
->e_phoff
= 0;
2228 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2230 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2232 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2234 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2235 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2236 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2243 swap_out_syms (abfd
)
2246 if (!elf_map_symbols (abfd
))
2249 /* Dump out the symtabs. */
2251 int symcount
= bfd_get_symcount (abfd
);
2252 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2253 struct strtab
*stt
= bfd_new_strtab (abfd
);
2254 Elf_Internal_Shdr
*symtab_hdr
;
2255 Elf_Internal_Shdr
*symstrtab_hdr
;
2256 Elf_External_Sym
*outbound_syms
;
2261 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2262 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2263 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2264 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2265 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2266 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2268 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2269 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2271 outbound_syms
= (Elf_External_Sym
*)
2272 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2275 bfd_set_error (bfd_error_no_memory
);
2278 /* now generate the data (for "contents") */
2280 /* Fill in zeroth symbol and swap it out. */
2281 Elf_Internal_Sym sym
;
2287 sym
.st_shndx
= SHN_UNDEF
;
2288 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2290 for (idx
= 0; idx
< symcount
; idx
++)
2292 Elf_Internal_Sym sym
;
2293 bfd_vma value
= syms
[idx
]->value
;
2294 elf_symbol_type
*type_ptr
;
2296 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2297 /* Section symbols have no names. */
2301 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2302 if (sym
.st_name
== (unsigned long) -1)
2306 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2308 if (bfd_is_com_section (syms
[idx
]->section
))
2310 /* ELF common symbols put the alignment into the `value' field,
2311 and the size into the `size' field. This is backwards from
2312 how BFD handles it, so reverse it here. */
2313 sym
.st_size
= value
;
2314 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2315 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2316 syms
[idx
]->section
);
2320 asection
*sec
= syms
[idx
]->section
;
2323 if (sec
->output_section
)
2325 value
+= sec
->output_offset
;
2326 sec
= sec
->output_section
;
2329 sym
.st_value
= value
;
2330 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2331 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2335 /* Writing this would be a hell of a lot easier if we had
2336 some decent documentation on bfd, and knew what to expect
2337 of the library, and what to demand of applications. For
2338 example, it appears that `objcopy' might not set the
2339 section of a symbol to be a section that is actually in
2341 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2342 BFD_ASSERT (sec2
!= 0);
2343 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2344 BFD_ASSERT (shndx
!= -1);
2348 if (bfd_is_com_section (syms
[idx
]->section
))
2349 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2350 else if (bfd_is_und_section (syms
[idx
]->section
))
2351 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2352 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2355 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2356 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2357 else if (syms
[idx
]->flags
& BSF_FILE
)
2358 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2361 int bind
= STB_LOCAL
;
2362 int type
= STT_OBJECT
;
2363 unsigned int flags
= syms
[idx
]->flags
;
2365 if (flags
& BSF_LOCAL
)
2367 else if (flags
& BSF_WEAK
)
2369 else if (flags
& BSF_GLOBAL
)
2372 if (flags
& BSF_FUNCTION
)
2375 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2379 elf_swap_symbol_out (abfd
, &sym
,
2381 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2384 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2385 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2386 symstrtab_hdr
->sh_size
= stt
->length
;
2387 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2389 symstrtab_hdr
->sh_flags
= 0;
2390 symstrtab_hdr
->sh_addr
= 0;
2391 symstrtab_hdr
->sh_entsize
= 0;
2392 symstrtab_hdr
->sh_link
= 0;
2393 symstrtab_hdr
->sh_info
= 0;
2394 symstrtab_hdr
->sh_addralign
= 1;
2395 symstrtab_hdr
->size
= 0;
2402 write_shdrs_and_ehdr (abfd
)
2405 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2406 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2407 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2408 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2410 struct strtab
*shstrtab
;
2412 i_ehdrp
= elf_elfheader (abfd
);
2413 i_shdrp
= elf_elfsections (abfd
);
2414 shstrtab
= elf_shstrtab (abfd
);
2416 /* swap the header before spitting it out... */
2419 elf_debug_file (i_ehdrp
);
2421 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2422 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2423 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2424 != sizeof (x_ehdr
)))
2427 /* at this point we've concocted all the ELF sections... */
2428 x_shdrp
= (Elf_External_Shdr
*)
2429 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2432 bfd_set_error (bfd_error_no_memory
);
2436 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2439 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2442 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2444 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2445 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2446 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2449 /* need to dump the string table too... */
2454 /* Assign file positions for all the reloc sections which are not part
2455 of the loadable file image. */
2458 assign_file_positions_for_relocs (abfd
)
2463 Elf_Internal_Shdr
**shdrpp
;
2465 off
= elf_tdata (abfd
)->next_file_pos
;
2467 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2468 i
< elf_elfheader (abfd
)->e_shnum
;
2471 Elf_Internal_Shdr
*shdrp
;
2474 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2475 && shdrp
->sh_offset
== -1)
2476 off
= assign_file_position_for_section (shdrp
, off
, true);
2479 elf_tdata (abfd
)->next_file_pos
= off
;
2483 NAME(bfd_elf
,write_object_contents
) (abfd
)
2486 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2487 Elf_Internal_Ehdr
*i_ehdrp
;
2488 Elf_Internal_Shdr
**i_shdrp
;
2491 if (! abfd
->output_has_begun
2492 && ! elf_compute_section_file_positions (abfd
,
2493 (struct bfd_link_info
*) NULL
))
2496 i_shdrp
= elf_elfsections (abfd
);
2497 i_ehdrp
= elf_elfheader (abfd
);
2499 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2500 assign_file_positions_for_relocs (abfd
);
2502 /* After writing the headers, we need to write the sections too... */
2503 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2505 if (bed
->elf_backend_section_processing
)
2506 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2507 if (i_shdrp
[count
]->contents
)
2509 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2510 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2512 != i_shdrp
[count
]->sh_size
))
2517 if (bed
->elf_backend_final_write_processing
)
2518 (*bed
->elf_backend_final_write_processing
) (abfd
,
2519 elf_tdata (abfd
)->linker
);
2521 return write_shdrs_and_ehdr (abfd
);
2524 /* Given an index of a section, retrieve a pointer to it. Note
2525 that for our purposes, sections are indexed by {1, 2, ...} with
2526 0 being an illegal index. */
2528 /* In the original, each ELF section went into exactly one BFD
2529 section. This doesn't really make sense, so we need a real mapping.
2530 The mapping has to hide in the Elf_Internal_Shdr since asection
2531 doesn't have anything like a tdata field... */
2534 section_from_elf_index (abfd
, index
)
2538 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2539 be returned from this routine? */
2541 if (index
== SHN_ABS
)
2542 return bfd_com_section_ptr
; /* not abs? */
2543 if (index
== SHN_COMMON
)
2544 return bfd_com_section_ptr
;
2546 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2550 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2552 switch (hdr
->sh_type
)
2554 /* ELF sections that map to BFD sections */
2559 if (hdr
->rawdata
== NULL
)
2561 if (! bfd_section_from_shdr (abfd
, index
))
2564 return (struct sec
*) hdr
->rawdata
;
2567 return bfd_abs_section_ptr
;
2572 /* given a section, search the header to find them... */
2574 elf_section_from_bfd_section (abfd
, asect
)
2578 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2580 Elf_Internal_Shdr
*hdr
;
2581 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2583 if (asect
->owner
== NULL
)
2585 if (bfd_is_abs_section (asect
))
2587 if (bfd_is_com_section (asect
))
2589 if (bfd_is_und_section (asect
))
2594 BFD_ASSERT (asect
->owner
== abfd
);
2596 for (index
= 0; index
< maxindex
; index
++)
2598 hdr
= i_shdrp
[index
];
2599 switch (hdr
->sh_type
)
2601 /* ELF sections that map to BFD sections */
2611 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2618 /* We sometimes map a reloc section to a BFD section. */
2619 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2620 && (asection
*) hdr
->rawdata
== asect
)
2625 /* We map most string tables to BFD sections. */
2626 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2627 && index
!= elf_onesymtab (abfd
)
2628 && (asection
*) hdr
->rawdata
== asect
)
2634 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2636 if (bed
->elf_backend_section_from_bfd_section
)
2641 if ((*bed
->elf_backend_section_from_bfd_section
)
2642 (abfd
, hdr
, asect
, &retval
))
2652 /* given a symbol, return the bfd index for that symbol. */
2654 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2656 struct symbol_cache_entry
**asym_ptr_ptr
;
2658 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2660 flagword flags
= asym_ptr
->flags
;
2662 /* When gas creates relocations against local labels, it creates its
2663 own symbol for the section, but does put the symbol into the
2664 symbol chain, so udata is 0. When the linker is generating
2665 relocatable output, this section symbol may be for one of the
2666 input sections rather than the output section. */
2667 if (asym_ptr
->udata
== (PTR
) 0
2668 && (flags
& BSF_SECTION_SYM
)
2669 && asym_ptr
->section
)
2673 if (asym_ptr
->section
->output_section
!= NULL
)
2674 indx
= asym_ptr
->section
->output_section
->index
;
2676 indx
= asym_ptr
->section
->index
;
2677 if (elf_section_syms (abfd
)[indx
])
2678 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2681 if (asym_ptr
->udata
)
2682 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2692 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2693 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2702 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2704 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2707 Elf_Internal_Shdr
*hdr
;
2708 long symcount
; /* Number of external ELF symbols */
2709 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2710 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2711 Elf_Internal_Sym i_sym
;
2712 Elf_External_Sym
*x_symp
= NULL
;
2714 /* Read each raw ELF symbol, converting from external ELF form to
2715 internal ELF form, and then using the information to create a
2716 canonical bfd symbol table entry.
2718 Note that we allocate the initial bfd canonical symbol buffer
2719 based on a one-to-one mapping of the ELF symbols to canonical
2720 symbols. We actually use all the ELF symbols, so there will be no
2721 space left over at the end. When we have all the symbols, we
2722 build the caller's pointer vector. */
2725 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2727 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2728 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2731 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2734 sym
= symbase
= NULL
;
2739 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2742 symbase
= ((elf_symbol_type
*)
2743 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2744 if (symbase
== (elf_symbol_type
*) NULL
)
2746 bfd_set_error (bfd_error_no_memory
);
2751 /* Temporarily allocate room for the raw ELF symbols. */
2752 x_symp
= ((Elf_External_Sym
*)
2753 malloc (symcount
* sizeof (Elf_External_Sym
)));
2754 if (x_symp
== NULL
&& symcount
!= 0)
2756 bfd_set_error (bfd_error_no_memory
);
2760 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2761 != symcount
* sizeof (Elf_External_Sym
))
2763 /* Skip first symbol, which is a null dummy. */
2764 for (i
= 1; i
< symcount
; i
++)
2766 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2767 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2768 #ifdef ELF_KEEP_EXTSYM
2769 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2771 sym
->symbol
.the_bfd
= abfd
;
2773 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2776 sym
->symbol
.value
= i_sym
.st_value
;
2778 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2780 sym
->symbol
.section
= section_from_elf_index (abfd
,
2782 if (sym
->symbol
.section
== NULL
)
2784 /* This symbol is in a section for which we did not
2785 create a BFD section. Just use bfd_abs_section,
2786 although it is wrong. FIXME. */
2787 sym
->symbol
.section
= bfd_abs_section_ptr
;
2790 else if (i_sym
.st_shndx
== SHN_ABS
)
2792 sym
->symbol
.section
= bfd_abs_section_ptr
;
2794 else if (i_sym
.st_shndx
== SHN_COMMON
)
2796 sym
->symbol
.section
= bfd_com_section_ptr
;
2797 /* Elf puts the alignment into the `value' field, and
2798 the size into the `size' field. BFD wants to see the
2799 size in the value field, and doesn't care (at the
2800 moment) about the alignment. */
2801 sym
->symbol
.value
= i_sym
.st_size
;
2803 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2805 sym
->symbol
.section
= bfd_und_section_ptr
;
2808 sym
->symbol
.section
= bfd_abs_section_ptr
;
2810 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2812 switch (ELF_ST_BIND (i_sym
.st_info
))
2815 sym
->symbol
.flags
|= BSF_LOCAL
;
2818 sym
->symbol
.flags
|= BSF_GLOBAL
;
2821 sym
->symbol
.flags
|= BSF_WEAK
;
2825 switch (ELF_ST_TYPE (i_sym
.st_info
))
2828 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2831 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2834 sym
->symbol
.flags
|= BSF_FUNCTION
;
2839 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2841 /* Do some backend-specific processing on this symbol. */
2843 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2844 if (ebd
->elf_backend_symbol_processing
)
2845 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2852 /* Do some backend-specific processing on this symbol table. */
2854 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2855 if (ebd
->elf_backend_symbol_table_processing
)
2856 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2859 /* We rely on the zalloc to clear out the final symbol entry. */
2861 symcount
= sym
- symbase
;
2863 /* Fill in the user's symbol pointer vector if needed. */
2871 *symptrs
++ = &sym
->symbol
;
2874 *symptrs
= 0; /* Final null pointer */
2886 /* Return the number of bytes required to hold the symtab vector.
2888 Note that we base it on the count plus 1, since we will null terminate
2889 the vector allocated based on this size. However, the ELF symbol table
2890 always has a dummy entry as symbol #0, so it ends up even. */
2893 elf_get_symtab_upper_bound (abfd
)
2898 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2900 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2901 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2907 elf_get_dynamic_symtab_upper_bound (abfd
)
2912 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2914 if (elf_dynsymtab (abfd
) == 0)
2916 bfd_set_error (bfd_error_invalid_operation
);
2920 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2921 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2927 elf_get_reloc_upper_bound (abfd
, asect
)
2931 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2934 /* Read in and swap the external relocs. */
2937 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2942 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2943 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2944 PTR allocated
= NULL
;
2945 bfd_byte
*native_relocs
;
2951 if (asect
->relocation
!= NULL
2952 || (asect
->flags
& SEC_RELOC
) == 0
2953 || asect
->reloc_count
== 0)
2956 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2957 && (asect
->reloc_count
2958 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2960 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2961 if (allocated
== NULL
)
2963 bfd_set_error (bfd_error_no_memory
);
2967 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2968 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2969 != d
->rel_hdr
.sh_size
))
2972 native_relocs
= (bfd_byte
*) allocated
;
2974 relents
= ((arelent
*)
2975 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2976 if (relents
== NULL
)
2978 bfd_set_error (bfd_error_no_memory
);
2982 entsize
= d
->rel_hdr
.sh_entsize
;
2983 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2984 || entsize
== sizeof (Elf_External_Rela
));
2986 for (i
= 0, relent
= relents
;
2987 i
< asect
->reloc_count
;
2988 i
++, relent
++, native_relocs
+= entsize
)
2990 Elf_Internal_Rela rela
;
2991 Elf_Internal_Rel rel
;
2993 if (entsize
== sizeof (Elf_External_Rela
))
2994 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2997 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2998 rela
.r_offset
= rel
.r_offset
;
2999 rela
.r_info
= rel
.r_info
;
3003 /* The address of an ELF reloc is section relative for an object
3004 file, and absolute for an executable file or shared library.
3005 The address of a BFD reloc is always section relative. */
3006 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3007 relent
->address
= rela
.r_offset
;
3009 relent
->address
= rela
.r_offset
- asect
->vma
;
3011 if (ELF_R_SYM (rela
.r_info
) == 0)
3012 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3017 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3020 /* Canonicalize ELF section symbols. FIXME: Why? */
3021 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3022 relent
->sym_ptr_ptr
= ps
;
3024 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3027 relent
->addend
= rela
.r_addend
;
3029 if (entsize
== sizeof (Elf_External_Rela
))
3030 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3032 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3035 asect
->relocation
= relents
;
3037 if (allocated
!= NULL
)
3043 if (allocated
!= NULL
)
3050 elf_debug_section (str
, num
, hdr
)
3053 Elf_Internal_Shdr
*hdr
;
3055 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3057 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3058 (long) hdr
->sh_name
,
3059 (long) hdr
->sh_type
,
3060 (long) hdr
->sh_flags
);
3062 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3063 (long) hdr
->sh_addr
,
3064 (long) hdr
->sh_offset
,
3065 (long) hdr
->sh_size
);
3067 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3068 (long) hdr
->sh_link
,
3069 (long) hdr
->sh_info
,
3070 (long) hdr
->sh_addralign
);
3071 fprintf (stderr
, "sh_entsize = %ld\n",
3072 (long) hdr
->sh_entsize
);
3073 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3074 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3075 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3080 elf_debug_file (ehdrp
)
3081 Elf_Internal_Ehdr
*ehdrp
;
3083 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3084 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3085 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3086 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3087 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3088 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3089 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3093 /* Canonicalize the relocs. */
3096 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3105 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3108 tblptr
= section
->relocation
;
3109 for (i
= 0; i
< section
->reloc_count
; i
++)
3110 *relptr
++ = tblptr
++;
3114 return section
->reloc_count
;
3118 elf_get_symtab (abfd
, alocation
)
3120 asymbol
**alocation
;
3122 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3125 bfd_get_symcount (abfd
) = symcount
;
3130 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3132 asymbol
**alocation
;
3134 return elf_slurp_symbol_table (abfd
, alocation
, true);
3138 elf_make_empty_symbol (abfd
)
3141 elf_symbol_type
*newsym
;
3143 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3146 bfd_set_error (bfd_error_no_memory
);
3151 newsym
->symbol
.the_bfd
= abfd
;
3152 return &newsym
->symbol
;
3157 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3162 bfd_symbol_info (symbol
, ret
);
3166 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3170 bfd_print_symbol_type how
;
3172 FILE *file
= (FILE *) filep
;
3175 case bfd_print_symbol_name
:
3176 fprintf (file
, "%s", symbol
->name
);
3178 case bfd_print_symbol_more
:
3179 fprintf (file
, "elf ");
3180 fprintf_vma (file
, symbol
->value
);
3181 fprintf (file
, " %lx", (long) symbol
->flags
);
3183 case bfd_print_symbol_all
:
3185 CONST
char *section_name
;
3186 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3187 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3188 fprintf (file
, " %s\t%s",
3198 elf_get_lineno (ignore_abfd
, symbol
)
3202 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3209 elf_set_arch_mach (abfd
, arch
, machine
)
3211 enum bfd_architecture arch
;
3212 unsigned long machine
;
3214 /* If this isn't the right architecture for this backend, and this
3215 isn't the generic backend, fail. */
3216 if (arch
!= get_elf_backend_data (abfd
)->arch
3217 && arch
!= bfd_arch_unknown
3218 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3221 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3225 elf_find_nearest_line (abfd
,
3236 CONST
char **filename_ptr
;
3237 CONST
char **functionname_ptr
;
3238 unsigned int *line_ptr
;
3244 elf_sizeof_headers (abfd
, reloc
)
3250 ret
= sizeof (Elf_External_Ehdr
);
3252 ret
+= get_program_header_size (abfd
);
3257 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3262 bfd_size_type count
;
3264 Elf_Internal_Shdr
*hdr
;
3266 if (! abfd
->output_has_begun
3267 && ! elf_compute_section_file_positions (abfd
,
3268 (struct bfd_link_info
*) NULL
))
3271 hdr
= &elf_section_data (section
)->this_hdr
;
3273 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3275 if (bfd_write (location
, 1, count
, abfd
) != count
)
3282 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3285 Elf_Internal_Rela
*dst
;
3287 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3293 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3296 Elf_Internal_Rel
*dst
;
3298 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3304 /* Core file support */
3306 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3307 #include <sys/procfs.h>
3309 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3310 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3311 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3317 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3324 prstatus_t
*status
= (prstatus_t
*) 0;
3326 if (descsz
== sizeof (prstatus_t
))
3328 newsect
= bfd_make_section (abfd
, ".reg");
3329 if (newsect
== NULL
)
3331 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3332 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3333 newsect
->flags
= SEC_HAS_CONTENTS
;
3334 newsect
->alignment_power
= 2;
3335 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3337 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3343 /* Stash a copy of the prpsinfo structure away for future use. */
3346 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3352 if (descsz
== sizeof (prpsinfo_t
))
3354 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3356 bfd_set_error (bfd_error_no_memory
);
3359 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3365 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3373 newsect
= bfd_make_section (abfd
, ".reg2");
3374 if (newsect
== NULL
)
3376 newsect
->_raw_size
= descsz
;
3377 newsect
->filepos
= filepos
;
3378 newsect
->flags
= SEC_HAS_CONTENTS
;
3379 newsect
->alignment_power
= 2;
3383 #endif /* HAVE_PROCFS */
3385 /* Return a pointer to the args (including the command name) that were
3386 seen by the program that generated the core dump. Note that for
3387 some reason, a spurious space is tacked onto the end of the args
3388 in some (at least one anyway) implementations, so strip it off if
3392 elf_core_file_failing_command (abfd
)
3396 if (core_prpsinfo (abfd
))
3398 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3399 char *scan
= p
->pr_psargs
;
3404 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3408 return p
->pr_psargs
;
3414 /* Return the number of the signal that caused the core dump. Presumably,
3415 since we have a core file, we got a signal of some kind, so don't bother
3416 checking the other process status fields, just return the signal number.
3420 elf_core_file_failing_signal (abfd
)
3424 if (core_prstatus (abfd
))
3426 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3432 /* Check to see if the core file could reasonably be expected to have
3433 come for the current executable file. Note that by default we return
3434 true unless we find something that indicates that there might be a
3439 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3448 /* First, xvecs must match since both are ELF files for the same target. */
3450 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3452 bfd_set_error (bfd_error_system_call
);
3458 /* If no prpsinfo, just return true. Otherwise, grab the last component
3459 of the exec'd pathname from the prpsinfo. */
3461 if (core_prpsinfo (core_bfd
))
3463 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3470 /* Find the last component of the executable pathname. */
3472 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3478 execname
= (char *) exec_bfd
->filename
;
3481 /* See if they match */
3483 return strcmp (execname
, corename
) ? false : true;
3489 #endif /* HAVE_PROCFS */
3492 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3493 the information that would normally be available from the /proc interface
3494 for the process, at the time the process dumped core. Currently this
3495 includes copies of the prstatus, prpsinfo, and fpregset structures.
3497 Since these structures are potentially machine dependent in size and
3498 ordering, bfd provides two levels of support for them. The first level,
3499 available on all machines since it does not require that the host
3500 have /proc support or the relevant include files, is to create a bfd
3501 section for each of the prstatus, prpsinfo, and fpregset structures,
3502 without any interpretation of their contents. With just this support,
3503 the bfd client will have to interpret the structures itself. Even with
3504 /proc support, it might want these full structures for it's own reasons.
3506 In the second level of support, where HAVE_PROCFS is defined, bfd will
3507 pick apart the structures to gather some additional information that
3508 clients may want, such as the general register set, the name of the
3509 exec'ed file and its arguments, the signal (if any) that caused the
3515 elf_corefile_note (abfd
, hdr
)
3517 Elf_Internal_Phdr
*hdr
;
3519 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3520 Elf_Internal_Note i_note
; /* Elf note, internal form */
3521 char *buf
= NULL
; /* Entire note segment contents */
3522 char *namedata
; /* Name portion of the note */
3523 char *descdata
; /* Descriptor portion of the note */
3524 char *sectname
; /* Name to use for new section */
3525 long filepos
; /* File offset to descriptor data */
3528 if (hdr
->p_filesz
> 0
3529 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3530 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3531 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3533 x_note_p
= (Elf_External_Note
*) buf
;
3534 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3536 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3537 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3538 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3539 namedata
= x_note_p
->name
;
3540 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3541 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3542 switch (i_note
.type
)
3545 /* process descdata as prstatus info */
3546 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3548 sectname
= ".prstatus";
3551 /* process descdata as fpregset info */
3552 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3554 sectname
= ".fpregset";
3557 /* process descdata as prpsinfo */
3558 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3560 sectname
= ".prpsinfo";
3563 /* Unknown descriptor, just ignore it. */
3567 if (sectname
!= NULL
)
3569 newsect
= bfd_make_section (abfd
, sectname
);
3570 if (newsect
== NULL
)
3572 newsect
->_raw_size
= i_note
.descsz
;
3573 newsect
->filepos
= filepos
;
3574 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3575 newsect
->alignment_power
= 2;
3577 x_note_p
= (Elf_External_Note
*)
3578 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3585 else if (hdr
->p_filesz
> 0)
3587 bfd_set_error (bfd_error_no_memory
);
3594 /* Core files are simply standard ELF formatted files that partition
3595 the file using the execution view of the file (program header table)
3596 rather than the linking view. In fact, there is no section header
3597 table in a core file.
3599 The process status information (including the contents of the general
3600 register set) and the floating point register set are stored in a
3601 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3602 that allow standard bfd access to the general registers (.reg) and the
3603 floating point registers (.reg2).
3608 elf_core_file_p (abfd
)
3611 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3612 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3613 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3614 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3615 unsigned int phindex
;
3616 struct elf_backend_data
*ebd
;
3618 /* Read in the ELF header in external format. */
3620 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3622 if (bfd_get_error () != bfd_error_system_call
)
3623 bfd_set_error (bfd_error_wrong_format
);
3627 /* Now check to see if we have a valid ELF file, and one that BFD can
3628 make use of. The magic number must match, the address size ('class')
3629 and byte-swapping must match our XVEC entry, and it must have a
3630 program header table (FIXME: See comments re segments at top of this
3633 if (elf_file_p (&x_ehdr
) == false)
3636 bfd_set_error (bfd_error_wrong_format
);
3640 /* FIXME, Check EI_VERSION here ! */
3644 int desired_address_size
= ELFCLASS32
;
3647 int desired_address_size
= ELFCLASS64
;
3650 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3654 /* Switch xvec to match the specified byte order. */
3655 switch (x_ehdr
.e_ident
[EI_DATA
])
3657 case ELFDATA2MSB
: /* Big-endian */
3658 if (abfd
->xvec
->byteorder_big_p
== false)
3661 case ELFDATA2LSB
: /* Little-endian */
3662 if (abfd
->xvec
->byteorder_big_p
== true)
3665 case ELFDATANONE
: /* No data encoding specified */
3666 default: /* Unknown data encoding specified */
3670 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3671 the tdata pointer in the bfd. */
3674 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3675 if (elf_tdata (abfd
) == NULL
)
3677 bfd_set_error (bfd_error_no_memory
);
3681 /* FIXME, `wrong' returns from this point onward, leak memory. */
3683 /* Now that we know the byte order, swap in the rest of the header */
3684 i_ehdrp
= elf_elfheader (abfd
);
3685 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3687 elf_debug_file (i_ehdrp
);
3690 ebd
= get_elf_backend_data (abfd
);
3692 /* Check that the ELF e_machine field matches what this particular
3693 BFD format expects. */
3694 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3696 const bfd_target
* const *target_ptr
;
3698 if (ebd
->elf_machine_code
!= EM_NONE
)
3701 /* This is the generic ELF target. Let it match any ELF target
3702 for which we do not have a specific backend. */
3703 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3705 struct elf_backend_data
*back
;
3707 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3709 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3710 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3712 /* target_ptr is an ELF backend which matches this
3713 object file, so reject the generic ELF target. */
3719 /* If there is no program header, or the type is not a core file, then
3721 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3724 /* Allocate space for a copy of the program header table in
3725 internal form, seek to the program header table in the file,
3726 read it in, and convert it to internal form. As a simple sanity
3727 check, verify that the what BFD thinks is the size of each program
3728 header table entry actually matches the size recorded in the file. */
3730 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3732 i_phdrp
= (Elf_Internal_Phdr
*)
3733 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3736 bfd_set_error (bfd_error_no_memory
);
3739 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3741 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3743 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3746 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3749 /* Once all of the program headers have been read and converted, we
3750 can start processing them. */
3752 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3754 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3755 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3757 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3762 /* Remember the entry point specified in the ELF file header. */
3764 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3769 /* ELF linker code. */
3771 static boolean elf_link_add_object_symbols
3772 PARAMS ((bfd
*, struct bfd_link_info
*));
3773 static boolean elf_link_add_archive_symbols
3774 PARAMS ((bfd
*, struct bfd_link_info
*));
3775 static Elf_Internal_Rela
*elf_link_read_relocs
3776 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3777 static boolean elf_adjust_dynamic_symbol
3778 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3780 /* Given an ELF BFD, add symbols to the global hash table as
3784 elf_bfd_link_add_symbols (abfd
, info
)
3786 struct bfd_link_info
*info
;
3788 switch (bfd_get_format (abfd
))
3791 return elf_link_add_object_symbols (abfd
, info
);
3793 return elf_link_add_archive_symbols (abfd
, info
);
3795 bfd_set_error (bfd_error_wrong_format
);
3800 /* Add symbols from an ELF archive file to the linker hash table. We
3801 don't use _bfd_generic_link_add_archive_symbols because of a
3802 problem which arises on UnixWare. The UnixWare libc.so is an
3803 archive which includes an entry libc.so.1 which defines a bunch of
3804 symbols. The libc.so archive also includes a number of other
3805 object files, which also define symbols, some of which are the same
3806 as those defined in libc.so.1. Correct linking requires that we
3807 consider each object file in turn, and include it if it defines any
3808 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3809 this; it looks through the list of undefined symbols, and includes
3810 any object file which defines them. When this algorithm is used on
3811 UnixWare, it winds up pulling in libc.so.1 early and defining a
3812 bunch of symbols. This means that some of the other objects in the
3813 archive are not included in the link, which is incorrect since they
3814 precede libc.so.1 in the archive.
3816 Fortunately, ELF archive handling is simpler than that done by
3817 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3818 oddities. In ELF, if we find a symbol in the archive map, and the
3819 symbol is currently undefined, we know that we must pull in that
3822 Unfortunately, we do have to make multiple passes over the symbol
3823 table until nothing further is resolved. */
3826 elf_link_add_archive_symbols (abfd
, info
)
3828 struct bfd_link_info
*info
;
3831 boolean
*defined
= NULL
;
3832 boolean
*included
= NULL
;
3836 if (! bfd_has_map (abfd
))
3838 bfd_set_error (bfd_error_no_symbols
);
3842 /* Keep track of all symbols we know to be already defined, and all
3843 files we know to be already included. This is to speed up the
3844 second and subsequent passes. */
3845 c
= bfd_ardata (abfd
)->symdef_count
;
3848 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3849 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3850 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3852 bfd_set_error (bfd_error_no_memory
);
3855 memset (defined
, 0, c
* sizeof (boolean
));
3856 memset (included
, 0, c
* sizeof (boolean
));
3858 symdefs
= bfd_ardata (abfd
)->symdefs
;
3871 symdefend
= symdef
+ c
;
3872 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3874 struct elf_link_hash_entry
*h
;
3876 struct bfd_link_hash_entry
*undefs_tail
;
3879 if (defined
[i
] || included
[i
])
3881 if (symdef
->file_offset
== last
)
3887 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3888 false, false, false);
3889 if (h
== (struct elf_link_hash_entry
*) NULL
)
3891 if (h
->root
.type
!= bfd_link_hash_undefined
)
3897 /* We need to include this archive member. */
3899 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3900 if (element
== (bfd
*) NULL
)
3903 if (! bfd_check_format (element
, bfd_object
))
3906 /* Doublecheck that we have not included this object
3907 already--it should be impossible, but there may be
3908 something wrong with the archive. */
3909 if (element
->archive_pass
!= 0)
3911 bfd_set_error (bfd_error_bad_value
);
3914 element
->archive_pass
= 1;
3916 undefs_tail
= info
->hash
->undefs_tail
;
3918 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3921 if (! elf_link_add_object_symbols (element
, info
))
3924 /* If there are any new undefined symbols, we need to make
3925 another pass through the archive in order to see whether
3926 they can be defined. FIXME: This isn't perfect, because
3927 common symbols wind up on undefs_tail and because an
3928 undefined symbol which is defined later on in this pass
3929 does not require another pass. This isn't a bug, but it
3930 does make the code less efficient than it could be. */
3931 if (undefs_tail
!= info
->hash
->undefs_tail
)
3934 /* Look backward to mark all symbols from this object file
3935 which we have already seen in this pass. */
3939 included
[mark
] = true;
3944 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3946 /* We mark subsequent symbols from this object file as we go
3947 on through the loop. */
3948 last
= symdef
->file_offset
;
3959 if (defined
!= (boolean
*) NULL
)
3961 if (included
!= (boolean
*) NULL
)
3966 /* Record a new dynamic symbol. We record the dynamic symbols as we
3967 read the input files, since we need to have a list of all of them
3968 before we can determine the final sizes of the output sections. */
3971 elf_link_record_dynamic_symbol (info
, h
)
3972 struct bfd_link_info
*info
;
3973 struct elf_link_hash_entry
*h
;
3975 if (h
->dynindx
== -1)
3977 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3978 ++elf_hash_table (info
)->dynsymcount
;
3979 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3980 elf_hash_table (info
)->dynstr
,
3981 h
->root
.root
.string
);
3982 if (h
->dynstr_index
== (unsigned long) -1)
3989 /* Add symbols from an ELF object file to the linker hash table. */
3992 elf_link_add_object_symbols (abfd
, info
)
3994 struct bfd_link_info
*info
;
3996 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3997 const Elf_Internal_Sym
*,
3998 const char **, flagword
*,
3999 asection
**, bfd_vma
*));
4000 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
4001 asection
*, const Elf_Internal_Rela
*));
4003 Elf_Internal_Shdr
*hdr
;
4007 Elf_External_Sym
*buf
= NULL
;
4008 struct elf_link_hash_entry
**sym_hash
;
4010 Elf_External_Dyn
*dynbuf
= NULL
;
4011 struct elf_link_hash_entry
*weaks
;
4012 Elf_External_Sym
*esym
;
4013 Elf_External_Sym
*esymend
;
4015 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4016 collect
= get_elf_backend_data (abfd
)->collect
;
4018 /* A stripped shared library might only have a dynamic symbol table,
4019 not a regular symbol table. In that case we can still go ahead
4020 and link using the dynamic symbol table. */
4021 if (elf_onesymtab (abfd
) == 0
4022 && elf_dynsymtab (abfd
) != 0)
4024 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4025 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4028 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4029 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4031 /* The sh_info field of the symtab header tells us where the
4032 external symbols start. We don't care about the local symbols at
4034 if (elf_bad_symtab (abfd
))
4036 extsymcount
= symcount
;
4041 extsymcount
= symcount
- hdr
->sh_info
;
4042 extsymoff
= hdr
->sh_info
;
4045 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4046 if (buf
== NULL
&& extsymcount
!= 0)
4048 bfd_set_error (bfd_error_no_memory
);
4052 /* We store a pointer to the hash table entry for each external
4054 sym_hash
= ((struct elf_link_hash_entry
**)
4056 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4057 if (sym_hash
== NULL
)
4059 bfd_set_error (bfd_error_no_memory
);
4062 elf_sym_hashes (abfd
) = sym_hash
;
4064 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4068 /* If we are creating a shared library, create all the dynamic
4069 sections immediately. We need to attach them to something,
4070 so we attach them to this BFD, provided it is the right
4071 format. FIXME: If there are no input BFD's of the same
4072 format as the output, we can't make a shared library. */
4074 && elf_hash_table (info
)->dynobj
== NULL
4075 && abfd
->xvec
== info
->hash
->creator
)
4077 if (! elf_link_create_dynamic_sections (abfd
, info
))
4079 elf_hash_table (info
)->dynobj
= abfd
;
4086 unsigned long strindex
;
4090 /* You can't use -r against a dynamic object. Also, there's no
4091 hope of using a dynamic object which does not exactly match
4092 the format of the output file. */
4093 if (info
->relocateable
4094 || info
->hash
->creator
!= abfd
->xvec
)
4096 bfd_set_error (bfd_error_invalid_operation
);
4100 /* Find the name to use in a DT_NEEDED entry that refers to this
4101 object. If the object has a DT_SONAME entry, we use it.
4102 Otherwise, if the generic linker stuck something in
4103 elf_dt_needed_name, we use that. Otherwise, we just use the
4105 name
= bfd_get_filename (abfd
);
4106 if (elf_dt_needed_name (abfd
) != NULL
)
4107 name
= elf_dt_needed_name (abfd
);
4108 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4111 Elf_External_Dyn
*extdyn
;
4112 Elf_External_Dyn
*extdynend
;
4114 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4117 bfd_set_error (bfd_error_no_memory
);
4121 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4122 (file_ptr
) 0, s
->_raw_size
))
4126 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4127 for (; extdyn
< extdynend
; extdyn
++)
4129 Elf_Internal_Dyn dyn
;
4131 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4132 if (dyn
.d_tag
== DT_SONAME
)
4137 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4140 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4141 name
= elf_string_from_elf_section (abfd
, link
,
4154 /* We do not want to include any of the sections in a dynamic
4155 object in the output file. We hack by simply clobbering the
4156 list of sections in the BFD. This could be handled more
4157 cleanly by, say, a new section flag; the existing
4158 SEC_NEVER_LOAD flag is not the one we want, because that one
4159 still implies that the section takes up space in the output
4161 abfd
->sections
= NULL
;
4163 /* If this is the first dynamic object found in the link, create
4164 the special sections required for dynamic linking. We need
4165 to put them somewhere, and attaching them to the first
4166 dynamic object is as good place as any. */
4167 if (elf_hash_table (info
)->dynobj
== NULL
)
4169 if (! elf_link_create_dynamic_sections (abfd
, info
))
4171 elf_hash_table (info
)->dynobj
= abfd
;
4174 /* Add a DT_NEEDED entry for this dynamic object. */
4175 strindex
= bfd_add_to_strtab (abfd
,
4176 elf_hash_table (info
)->dynstr
,
4178 if (strindex
== (unsigned long) -1)
4180 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4185 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4187 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4188 != extsymcount
* sizeof (Elf_External_Sym
)))
4193 esymend
= buf
+ extsymcount
;
4194 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4196 Elf_Internal_Sym sym
;
4202 struct elf_link_hash_entry
*h
= NULL
;
4205 elf_swap_symbol_in (abfd
, esym
, &sym
);
4207 flags
= BSF_NO_FLAGS
;
4209 value
= sym
.st_value
;
4212 bind
= ELF_ST_BIND (sym
.st_info
);
4213 if (bind
== STB_LOCAL
)
4215 /* This should be impossible, since ELF requires that all
4216 global symbols follow all local symbols, and that sh_info
4217 point to the first global symbol. Unfortunatealy, Irix 5
4221 else if (bind
== STB_GLOBAL
)
4223 else if (bind
== STB_WEAK
)
4227 /* Leave it up to the processor backend. */
4230 if (sym
.st_shndx
== SHN_UNDEF
)
4231 sec
= bfd_und_section_ptr
;
4232 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4234 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4239 else if (sym
.st_shndx
== SHN_ABS
)
4240 sec
= bfd_abs_section_ptr
;
4241 else if (sym
.st_shndx
== SHN_COMMON
)
4243 sec
= bfd_com_section_ptr
;
4244 /* What ELF calls the size we call the value. What ELF
4245 calls the value we call the alignment. */
4246 value
= sym
.st_size
;
4250 /* Leave it up to the processor backend. */
4253 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4254 if (name
== (const char *) NULL
)
4257 if (add_symbol_hook
)
4259 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4263 /* The hook function sets the name to NULL if this symbol
4264 should be skipped for some reason. */
4265 if (name
== (const char *) NULL
)
4269 /* Sanity check that all possibilities were handled. */
4270 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4272 bfd_set_error (bfd_error_bad_value
);
4276 if (bfd_is_und_section (sec
)
4277 || bfd_is_com_section (sec
))
4282 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4284 /* We need to look up the symbol now in order to get some of
4285 the dynamic object handling right. We pass the hash
4286 table entry in to _bfd_generic_link_add_one_symbol so
4287 that it does not have to look it up again. */
4288 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4289 true, false, false);
4294 /* If we are looking at a dynamic object, and this is a
4295 definition, we need to see if it has already been defined
4296 by some other object. If it has, we want to use the
4297 existing definition, and we do not want to report a
4298 multiple symbol definition error; we do this by
4299 clobbering sec to be bfd_und_section_ptr. */
4300 if (dynamic
&& definition
)
4302 if (h
->root
.type
== bfd_link_hash_defined
)
4303 sec
= bfd_und_section_ptr
;
4306 /* Similarly, if we are not looking at a dynamic object, and
4307 we have a definition, we want to override any definition
4308 we may have from a dynamic object. Symbols from regular
4309 files always take precedence over symbols from dynamic
4310 objects, even if they are defined after the dynamic
4311 object in the link. */
4314 && h
->root
.type
== bfd_link_hash_defined
4315 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4316 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4317 == bfd_target_elf_flavour
)
4318 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4321 /* Change the hash table entry to undefined, and let
4322 _bfd_generic_link_add_one_symbol do the right thing
4323 with the new definition. */
4324 h
->root
.type
= bfd_link_hash_undefined
;
4325 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4326 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4329 /* If this is a weak definition which we are going to use,
4330 and the symbol is currently undefined, record that the
4331 definition is weak. */
4333 && (flags
& BSF_WEAK
) != 0
4334 && ! bfd_is_und_section (sec
)
4335 && (h
->root
.type
== bfd_link_hash_new
4336 || h
->root
.type
== bfd_link_hash_undefined
4337 || h
->root
.type
== bfd_link_hash_weak
))
4338 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4341 if (! (_bfd_generic_link_add_one_symbol
4342 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4343 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4348 && (flags
& BSF_WEAK
) != 0
4349 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4350 && (*sym_hash
)->weakdef
== NULL
)
4352 /* Keep a list of all weak defined non function symbols from
4353 a dynamic object, using the weakdef field. Later in this
4354 function we will set the weakdef field to the correct
4355 value. We only put non-function symbols from dynamic
4356 objects on this list, because that happens to be the only
4357 time we need to know the normal symbol corresponding to a
4358 weak symbol, and the information is time consuming to
4359 figure out. If the weakdef field is not already NULL,
4360 then this symbol was already defined by some previous
4361 dynamic object, and we will be using that previous
4362 definition anyhow. */
4364 (*sym_hash
)->weakdef
= weaks
;
4368 /* Get the alignment of a common symbol. */
4369 if (sym
.st_shndx
== SHN_COMMON
4370 && h
->root
.type
== bfd_link_hash_common
)
4371 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4373 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4379 /* Remember the symbol size and type. */
4380 if (sym
.st_size
!= 0)
4382 /* FIXME: We should probably somehow give a warning if
4383 the symbol size changes. */
4384 h
->size
= sym
.st_size
;
4386 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4388 /* FIXME: We should probably somehow give a warning if
4389 the symbol type changes. */
4390 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4393 /* Set a flag in the hash table entry indicating the type of
4394 reference or definition we just found. Keep a count of
4395 the number of dynamic symbols we find. A dynamic symbol
4396 is one which is referenced or defined by both a regular
4397 object and a shared object, or one which is referenced or
4398 defined by more than one shared object. */
4399 old_flags
= h
->elf_link_hash_flags
;
4404 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4406 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4408 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4409 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4415 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4417 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4418 if ((old_flags
& new_flag
) != 0
4419 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4420 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4424 h
->elf_link_hash_flags
|= new_flag
;
4425 if (dynsym
&& h
->dynindx
== -1)
4427 if (! elf_link_record_dynamic_symbol (info
, h
))
4433 /* Now set the weakdefs field correctly for all the weak defined
4434 symbols we found. The only way to do this is to search all the
4435 symbols. Since we only need the information for non functions in
4436 dynamic objects, that's the only time we actually put anything on
4437 the list WEAKS. We need this information so that if a regular
4438 object refers to a symbol defined weakly in a dynamic object, the
4439 real symbol in the dynamic object is also put in the dynamic
4440 symbols; we also must arrange for both symbols to point to the
4441 same memory location. We could handle the general case of symbol
4442 aliasing, but a general symbol alias can only be generated in
4443 assembler code, handling it correctly would be very time
4444 consuming, and other ELF linkers don't handle general aliasing
4446 while (weaks
!= NULL
)
4448 struct elf_link_hash_entry
*hlook
;
4451 struct elf_link_hash_entry
**hpp
;
4452 struct elf_link_hash_entry
**hppend
;
4455 weaks
= hlook
->weakdef
;
4456 hlook
->weakdef
= NULL
;
4458 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4459 slook
= hlook
->root
.u
.def
.section
;
4460 vlook
= hlook
->root
.u
.def
.value
;
4462 hpp
= elf_sym_hashes (abfd
);
4463 hppend
= hpp
+ extsymcount
;
4464 for (; hpp
< hppend
; hpp
++)
4466 struct elf_link_hash_entry
*h
;
4470 && h
->root
.type
== bfd_link_hash_defined
4471 && h
->root
.u
.def
.section
== slook
4472 && h
->root
.u
.def
.value
== vlook
)
4476 /* If the weak definition is in the list of dynamic
4477 symbols, make sure the real definition is put there
4479 if (hlook
->dynindx
!= -1
4480 && h
->dynindx
== -1)
4482 if (! elf_link_record_dynamic_symbol (info
, h
))
4497 /* If this object is the same format as the output object, and it is
4498 not a shared library, then let the backend look through the
4501 This is required to build global offset table entries and to
4502 arrange for dynamic relocs. It is not required for the
4503 particular common case of linking non PIC code, even when linking
4504 against shared libraries, but unfortunately there is no way of
4505 knowing whether an object file has been compiled PIC or not.
4506 Looking through the relocs is not particularly time consuming.
4507 The problem is that we must either (1) keep the relocs in memory,
4508 which causes the linker to require additional runtime memory or
4509 (2) read the relocs twice from the input file, which wastes time.
4510 This would be a good case for using mmap.
4512 I have no idea how to handle linking PIC code into a file of a
4513 different format. It probably can't be done. */
4514 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4516 && abfd
->xvec
== info
->hash
->creator
4517 && check_relocs
!= NULL
)
4521 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4523 Elf_Internal_Rela
*internal_relocs
;
4526 if ((o
->flags
& SEC_RELOC
) == 0
4527 || o
->reloc_count
== 0)
4530 /* I believe we can ignore the relocs for any section which
4531 does not form part of the final process image, such as a
4532 debugging section. */
4533 if ((o
->flags
& SEC_ALLOC
) == 0)
4536 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4537 (Elf_Internal_Rela
*) NULL
,
4539 if (internal_relocs
== NULL
)
4542 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4544 if (! info
->keep_memory
)
4545 free (internal_relocs
);
4562 /* Create some sections which will be filled in with dynamic linking
4563 information. The ABFD argument is an input file which is a dynamic
4564 object. The dynamic sections take up virtual memory space when the
4565 final executable is run, so we need to create them before addresses
4566 are assigned to the output sections. We work out the actual
4567 contents and size of these sections later. */
4570 elf_link_create_dynamic_sections (abfd
, info
)
4572 struct bfd_link_info
*info
;
4575 register asection
*s
;
4576 struct elf_link_hash_entry
*h
;
4577 struct elf_backend_data
*bed
;
4579 /* Note that we set the SEC_IN_MEMORY flag for all of these
4581 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4583 /* A dynamically linked executable has a .interp section, but a
4584 shared library does not. */
4587 s
= bfd_make_section (abfd
, ".interp");
4589 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4593 s
= bfd_make_section (abfd
, ".dynsym");
4595 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4596 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4599 /* The first .dynsym symbol is a dummy. */
4600 elf_hash_table (info
)->dynsymcount
= 1;
4602 s
= bfd_make_section (abfd
, ".dynstr");
4604 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4607 /* Create a strtab to hold the dynamic symbol names. */
4608 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4609 if (elf_hash_table (info
)->dynstr
== NULL
)
4612 s
= bfd_make_section (abfd
, ".dynamic");
4614 || ! bfd_set_section_flags (abfd
, s
, flags
)
4615 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4618 /* The special symbol _DYNAMIC is always set to the start of the
4619 .dynamic section. This call occurs before we have processed the
4620 symbols for any dynamic object, so we don't have to worry about
4621 overriding a dynamic definition. We could set _DYNAMIC in a
4622 linker script, but we only want to define it if we are, in fact,
4623 creating a .dynamic section. We don't want to define it if there
4624 is no .dynamic section, since on some ELF platforms the start up
4625 code examines it to decide how to initialize the process. */
4627 if (! (_bfd_generic_link_add_one_symbol
4628 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4629 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4630 (struct bfd_link_hash_entry
**) &h
)))
4632 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4633 h
->type
= STT_OBJECT
;
4636 && ! elf_link_record_dynamic_symbol (info
, h
))
4639 s
= bfd_make_section (abfd
, ".hash");
4641 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4642 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4645 /* Let the backend create the rest of the sections. This lets the
4646 backend set the right flags. The backend will normally create
4647 the .got and .plt sections. */
4648 bed
= get_elf_backend_data (abfd
);
4649 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4652 /* Add an entry to the .dynamic table. */
4655 elf_add_dynamic_entry (info
, tag
, val
)
4656 struct bfd_link_info
*info
;
4660 Elf_Internal_Dyn dyn
;
4664 bfd_byte
*newcontents
;
4666 dynobj
= elf_hash_table (info
)->dynobj
;
4668 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4669 BFD_ASSERT (s
!= NULL
);
4671 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4672 if (s
->contents
== NULL
)
4673 newcontents
= (bfd_byte
*) malloc (newsize
);
4675 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4676 if (newcontents
== NULL
)
4678 bfd_set_error (bfd_error_no_memory
);
4683 dyn
.d_un
.d_val
= val
;
4684 elf_swap_dyn_out (dynobj
, &dyn
,
4685 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4687 s
->_raw_size
= newsize
;
4688 s
->contents
= newcontents
;
4693 /* Read and swap the relocs for a section. They may have been cached.
4694 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4695 they are used as buffers to read into. They are known to be large
4696 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4697 value is allocated using either malloc or bfd_alloc, according to
4698 the KEEP_MEMORY argument. */
4700 static Elf_Internal_Rela
*
4701 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4704 PTR external_relocs
;
4705 Elf_Internal_Rela
*internal_relocs
;
4706 boolean keep_memory
;
4708 Elf_Internal_Shdr
*rel_hdr
;
4710 Elf_Internal_Rela
*alloc2
= NULL
;
4712 if (elf_section_data (o
)->relocs
!= NULL
)
4713 return elf_section_data (o
)->relocs
;
4715 if (o
->reloc_count
== 0)
4718 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4720 if (internal_relocs
== NULL
)
4724 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4726 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4728 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4729 if (internal_relocs
== NULL
)
4731 bfd_set_error (bfd_error_no_memory
);
4736 if (external_relocs
== NULL
)
4738 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4741 bfd_set_error (bfd_error_no_memory
);
4744 external_relocs
= alloc1
;
4747 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4748 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4749 != rel_hdr
->sh_size
))
4752 /* Swap in the relocs. For convenience, we always produce an
4753 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4755 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4757 Elf_External_Rel
*erel
;
4758 Elf_External_Rel
*erelend
;
4759 Elf_Internal_Rela
*irela
;
4761 erel
= (Elf_External_Rel
*) external_relocs
;
4762 erelend
= erel
+ o
->reloc_count
;
4763 irela
= internal_relocs
;
4764 for (; erel
< erelend
; erel
++, irela
++)
4766 Elf_Internal_Rel irel
;
4768 elf_swap_reloc_in (abfd
, erel
, &irel
);
4769 irela
->r_offset
= irel
.r_offset
;
4770 irela
->r_info
= irel
.r_info
;
4771 irela
->r_addend
= 0;
4776 Elf_External_Rela
*erela
;
4777 Elf_External_Rela
*erelaend
;
4778 Elf_Internal_Rela
*irela
;
4780 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4782 erela
= (Elf_External_Rela
*) external_relocs
;
4783 erelaend
= erela
+ o
->reloc_count
;
4784 irela
= internal_relocs
;
4785 for (; erela
< erelaend
; erela
++, irela
++)
4786 elf_swap_reloca_in (abfd
, erela
, irela
);
4789 /* Cache the results for next time, if we can. */
4791 elf_section_data (o
)->relocs
= internal_relocs
;
4796 /* Don't free alloc2, since if it was allocated we are passing it
4797 back (under the name of internal_relocs). */
4799 return internal_relocs
;
4809 /* Record an assignment to a symbol made by a linker script. We need
4810 this in case some dynamic object refers to this symbol. */
4814 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4816 struct bfd_link_info
*info
;
4819 struct elf_link_hash_entry
*h
;
4821 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4825 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4826 h
->type
= STT_OBJECT
;
4828 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4829 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4831 && h
->dynindx
== -1)
4833 if (! elf_link_record_dynamic_symbol (info
, h
))
4836 /* If this is a weak defined symbol, and we know a corresponding
4837 real symbol from the same dynamic object, make sure the real
4838 symbol is also made into a dynamic symbol. */
4839 if (h
->weakdef
!= NULL
4840 && h
->weakdef
->dynindx
== -1)
4842 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4850 /* Array used to determine the number of hash table buckets to use
4851 based on the number of symbols there are. If there are fewer than
4852 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4853 fewer than 37 we use 17 buckets, and so forth. We never use more
4854 than 521 buckets. */
4856 static const size_t elf_buckets
[] =
4858 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4861 /* Set up the sizes and contents of the ELF dynamic sections. This is
4862 called by the ELF linker emulation before_allocation routine. We
4863 must set the sizes of the sections before the linker sets the
4864 addresses of the various sections. */
4867 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
, info
,
4872 struct bfd_link_info
*info
;
4873 asection
**sinterpptr
;
4878 Elf_Internal_Sym isym
;
4881 struct elf_backend_data
*bed
;
4885 dynobj
= elf_hash_table (info
)->dynobj
;
4886 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4888 /* If there were no dynamic objects in the link, there is nothing to
4893 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4894 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4896 /* Set the size of the .dynsym and .hash sections. We counted the
4897 number of dynamic symbols in elf_link_add_object_symbols. We
4898 will build the contents of .dynsym and .hash when we build the
4899 final symbol table, because until then we do not know the correct
4900 value to give the symbols. We built the .dynstr section as we
4901 went along in elf_link_add_object_symbols. */
4902 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4903 BFD_ASSERT (s
!= NULL
);
4904 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4905 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4906 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4908 bfd_set_error (bfd_error_no_memory
);
4912 /* The first entry in .dynsym is a dummy symbol. */
4919 elf_swap_symbol_out (output_bfd
, &isym
,
4920 (Elf_External_Sym
*) s
->contents
);
4922 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4924 bucketcount
= elf_buckets
[i
];
4925 if (dynsymcount
< elf_buckets
[i
+ 1])
4929 s
= bfd_get_section_by_name (dynobj
, ".hash");
4930 BFD_ASSERT (s
!= NULL
);
4931 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4932 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4933 if (s
->contents
== NULL
)
4935 bfd_set_error (bfd_error_no_memory
);
4938 memset (s
->contents
, 0, s
->_raw_size
);
4940 put_word (output_bfd
, bucketcount
, s
->contents
);
4941 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4943 elf_hash_table (info
)->bucketcount
= bucketcount
;
4949 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, soname
);
4950 if (indx
== (unsigned long) -1
4951 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4959 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4960 if (indx
== (unsigned long) -1
4961 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4965 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4966 BFD_ASSERT (s
!= NULL
);
4967 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4968 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4970 /* Find all symbols which were defined in a dynamic object and make
4971 the backend pick a reasonable value for them. */
4972 elf_link_hash_traverse (elf_hash_table (info
),
4973 elf_adjust_dynamic_symbol
,
4976 /* Add some entries to the .dynamic section. We fill in some of the
4977 values later, in elf_bfd_final_link, but we must add the entries
4978 now so that we know the final size of the .dynamic section. */
4979 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4981 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4984 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4986 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4989 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4990 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4991 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4992 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4993 elf_hash_table (info
)->dynstr
->length
)
4994 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4995 sizeof (Elf_External_Sym
)))
4998 /* The backend must work out the sizes of all the other dynamic
5000 bed
= get_elf_backend_data (output_bfd
);
5001 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5004 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
5007 /* Make the backend pick a good value for a dynamic symbol. This is
5008 called via elf_link_hash_traverse, and also calls itself
5012 elf_adjust_dynamic_symbol (h
, data
)
5013 struct elf_link_hash_entry
*h
;
5016 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
5018 struct elf_backend_data
*bed
;
5020 /* If this symbol is not defined by a dynamic object, or is not
5021 referenced by a regular object, ignore it. FIXME: Do we need to
5022 worry about symbols which are defined by one dynamic object and
5023 referenced by another one? */
5024 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5025 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5026 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5029 /* If we've already adjusted this symbol, don't do it again. This
5030 can happen via a recursive call. */
5031 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5034 /* Don't look at this symbol again. Note that we must set this
5035 after checking the above conditions, because we may look at a
5036 symbol once, decide not to do anything, and then get called
5037 recursively later after REF_REGULAR is set below. */
5038 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5040 /* If this is a weak definition, and we know a real definition, and
5041 the real symbol is not itself defined by a regular object file,
5042 then get a good value for the real definition. We handle the
5043 real symbol first, for the convenience of the backend routine.
5045 Note that there is a confusing case here. If the real definition
5046 is defined by a regular object file, we don't get the real symbol
5047 from the dynamic object, but we do get the weak symbol. If the
5048 processor backend uses a COPY reloc, then if some routine in the
5049 dynamic object changes the real symbol, we will not see that
5050 change in the corresponding weak symbol. This is the way other
5051 ELF linkers work as well, and seems to be a result of the shared
5054 I will clarify this issue. Most SVR4 shared libraries define the
5055 variable _timezone and define timezone as a weak synonym. The
5056 tzset call changes _timezone. If you write
5057 extern int timezone;
5059 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5060 you might expect that, since timezone is a synonym for _timezone,
5061 the same number will print both times. However, if the processor
5062 backend uses a COPY reloc, then actually timezone will be copied
5063 into your process image, and, since you define _timezone
5064 yourself, _timezone will not. Thus timezone and _timezone will
5065 wind up at different memory locations. The tzset call will set
5066 _timezone, leaving timezone unchanged. */
5068 if (h
->weakdef
!= NULL
)
5070 struct elf_link_hash_entry
*weakdef
;
5072 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5073 weakdef
= h
->weakdef
;
5074 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5075 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5076 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5078 /* This symbol is defined by a regular object file, so we
5079 will not do anything special. Clear weakdef for the
5080 convenience of the processor backend. */
5085 /* There is an implicit reference by a regular object file
5086 via the weak symbol. */
5087 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5088 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5093 dynobj
= elf_hash_table (info
)->dynobj
;
5094 bed
= get_elf_backend_data (dynobj
);
5095 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5097 /* FIXME: No way to return error. */
5104 /* Final phase of ELF linker. */
5106 /* A structure we use to avoid passing large numbers of arguments. */
5108 struct elf_final_link_info
5110 /* General link information. */
5111 struct bfd_link_info
*info
;
5114 /* Symbol string table. */
5115 struct strtab
*symstrtab
;
5116 /* .dynsym section. */
5117 asection
*dynsym_sec
;
5118 /* .hash section. */
5120 /* Buffer large enough to hold contents of any section. */
5122 /* Buffer large enough to hold external relocs of any section. */
5123 PTR external_relocs
;
5124 /* Buffer large enough to hold internal relocs of any section. */
5125 Elf_Internal_Rela
*internal_relocs
;
5126 /* Buffer large enough to hold external local symbols of any input
5128 Elf_External_Sym
*external_syms
;
5129 /* Buffer large enough to hold internal local symbols of any input
5131 Elf_Internal_Sym
*internal_syms
;
5132 /* Array large enough to hold a symbol index for each local symbol
5133 of any input BFD. */
5135 /* Array large enough to hold a section pointer for each local
5136 symbol of any input BFD. */
5137 asection
**sections
;
5138 /* Buffer to hold swapped out symbols. */
5139 Elf_External_Sym
*symbuf
;
5140 /* Number of swapped out symbols in buffer. */
5141 size_t symbuf_count
;
5142 /* Number of symbols which fit in symbuf. */
5146 static boolean elf_link_output_sym
5147 PARAMS ((struct elf_final_link_info
*, const char *,
5148 Elf_Internal_Sym
*, asection
*));
5149 static boolean elf_link_flush_output_syms
5150 PARAMS ((struct elf_final_link_info
*));
5151 static boolean elf_link_output_extsym
5152 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5153 static boolean elf_link_input_bfd
5154 PARAMS ((struct elf_final_link_info
*, bfd
*));
5155 static boolean elf_reloc_link_order
5156 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5157 struct bfd_link_order
*));
5159 /* Do the final step of an ELF link. */
5162 elf_bfd_final_link (abfd
, info
)
5164 struct bfd_link_info
*info
;
5167 struct elf_final_link_info finfo
;
5168 register asection
*o
;
5169 register struct bfd_link_order
*p
;
5171 size_t max_contents_size
;
5172 size_t max_external_reloc_size
;
5173 size_t max_internal_reloc_count
;
5174 size_t max_sym_count
;
5176 Elf_Internal_Sym elfsym
;
5178 Elf_Internal_Shdr
*symtab_hdr
;
5179 Elf_Internal_Shdr
*symstrtab_hdr
;
5180 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5183 abfd
->flags
|= DYNAMIC
;
5185 dynobj
= elf_hash_table (info
)->dynobj
;
5188 finfo
.output_bfd
= abfd
;
5189 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5190 if (finfo
.symstrtab
== NULL
)
5194 finfo
.dynsym_sec
= NULL
;
5195 finfo
.hash_sec
= NULL
;
5199 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5200 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5201 if (finfo
.dynsym_sec
== NULL
5202 || finfo
.hash_sec
== NULL
)
5205 finfo
.contents
= NULL
;
5206 finfo
.external_relocs
= NULL
;
5207 finfo
.internal_relocs
= NULL
;
5208 finfo
.external_syms
= NULL
;
5209 finfo
.internal_syms
= NULL
;
5210 finfo
.indices
= NULL
;
5211 finfo
.sections
= NULL
;
5212 finfo
.symbuf
= NULL
;
5213 finfo
.symbuf_count
= 0;
5215 /* Count up the number of relocations we will output for each output
5216 section, so that we know the sizes of the reloc sections. We
5217 also figure out some maximum sizes. */
5218 max_contents_size
= 0;
5219 max_external_reloc_size
= 0;
5220 max_internal_reloc_count
= 0;
5222 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5226 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5228 if (p
->type
== bfd_section_reloc_link_order
5229 || p
->type
== bfd_symbol_reloc_link_order
)
5231 else if (p
->type
== bfd_indirect_link_order
)
5235 sec
= p
->u
.indirect
.section
;
5237 if (info
->relocateable
)
5238 o
->reloc_count
+= sec
->reloc_count
;
5240 if (sec
->_raw_size
> max_contents_size
)
5241 max_contents_size
= sec
->_raw_size
;
5242 if (sec
->_cooked_size
> max_contents_size
)
5243 max_contents_size
= sec
->_cooked_size
;
5245 /* We are interested in just local symbols, not all
5247 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5251 if (elf_bad_symtab (sec
->owner
))
5252 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5253 / sizeof (Elf_External_Sym
));
5255 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5257 if (sym_count
> max_sym_count
)
5258 max_sym_count
= sym_count
;
5260 if ((sec
->flags
& SEC_RELOC
) != 0)
5264 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5265 if (ext_size
> max_external_reloc_size
)
5266 max_external_reloc_size
= ext_size
;
5267 if (sec
->reloc_count
> max_internal_reloc_count
)
5268 max_internal_reloc_count
= sec
->reloc_count
;
5274 if (o
->reloc_count
> 0)
5275 o
->flags
|= SEC_RELOC
;
5278 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5279 set it (this is probably a bug) and if it is set
5280 assign_section_numbers will create a reloc section. */
5281 o
->flags
&=~ SEC_RELOC
;
5284 /* If the SEC_ALLOC flag is not set, force the section VMA to
5285 zero. This is done in elf_fake_sections as well, but forcing
5286 the VMA to 0 here will ensure that relocs against these
5287 sections are handled correctly. */
5288 if ((o
->flags
& SEC_ALLOC
) == 0)
5292 /* Figure out the file positions for everything but the symbol table
5293 and the relocs. We set symcount to force assign_section_numbers
5294 to create a symbol table. */
5295 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5296 BFD_ASSERT (! abfd
->output_has_begun
);
5297 if (! elf_compute_section_file_positions (abfd
, info
))
5300 /* That created the reloc sections. Set their sizes, and assign
5301 them file positions, and allocate some buffers. */
5302 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5304 if ((o
->flags
& SEC_RELOC
) != 0)
5306 Elf_Internal_Shdr
*rel_hdr
;
5307 register struct elf_link_hash_entry
**p
, **pend
;
5309 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5311 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5313 /* The contents field must last into write_object_contents,
5314 so we allocate it with bfd_alloc rather than malloc. */
5315 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5316 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5318 bfd_set_error (bfd_error_no_memory
);
5322 p
= ((struct elf_link_hash_entry
**)
5323 malloc (o
->reloc_count
5324 * sizeof (struct elf_link_hash_entry
*)));
5325 if (p
== NULL
&& o
->reloc_count
!= 0)
5327 bfd_set_error (bfd_error_no_memory
);
5330 elf_section_data (o
)->rel_hashes
= p
;
5331 pend
= p
+ o
->reloc_count
;
5332 for (; p
< pend
; p
++)
5335 /* Use the reloc_count field as an index when outputting the
5341 assign_file_positions_for_relocs (abfd
);
5343 /* We have now assigned file positions for all the sections except
5344 .symtab and .strtab. We start the .symtab section at the current
5345 file position, and write directly to it. We build the .strtab
5346 section in memory. When we add .dynsym support, we will build
5347 that in memory as well (.dynsym is smaller than .symtab). */
5349 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5350 /* sh_name is set in prep_headers. */
5351 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5352 symtab_hdr
->sh_flags
= 0;
5353 symtab_hdr
->sh_addr
= 0;
5354 symtab_hdr
->sh_size
= 0;
5355 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5356 /* sh_link is set in assign_section_numbers. */
5357 /* sh_info is set below. */
5358 /* sh_offset is set just below. */
5359 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5361 off
= elf_tdata (abfd
)->next_file_pos
;
5362 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5364 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5365 incorrect. We do not yet know the size of the .symtab section.
5366 We correct next_file_pos below, after we do know the size. */
5368 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5369 continuously seeking to the right position in the file. */
5370 if (! info
->keep_memory
|| max_sym_count
< 20)
5371 finfo
.symbuf_size
= 20;
5373 finfo
.symbuf_size
= max_sym_count
;
5374 finfo
.symbuf
= ((Elf_External_Sym
*)
5375 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5376 if (finfo
.symbuf
== NULL
)
5378 bfd_set_error (bfd_error_no_memory
);
5382 /* Start writing out the symbol table. The first symbol is always a
5384 elfsym
.st_value
= 0;
5387 elfsym
.st_other
= 0;
5388 elfsym
.st_shndx
= SHN_UNDEF
;
5389 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5390 &elfsym
, bfd_und_section_ptr
))
5394 /* Some standard ELF linkers do this, but we don't because it causes
5395 bootstrap comparison failures. */
5396 /* Output a file symbol for the output file as the second symbol.
5397 We output this even if we are discarding local symbols, although
5398 I'm not sure if this is correct. */
5399 elfsym
.st_value
= 0;
5401 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5402 elfsym
.st_other
= 0;
5403 elfsym
.st_shndx
= SHN_ABS
;
5404 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5405 &elfsym
, bfd_abs_section_ptr
))
5409 /* Output a symbol for each section. We output these even if we are
5410 discarding local symbols, since they are used for relocs. These
5411 symbols have no names. We store the index of each one in the
5412 index field of the section, so that we can find it again when
5413 outputting relocs. */
5414 elfsym
.st_value
= 0;
5416 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5417 elfsym
.st_other
= 0;
5418 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5420 o
= section_from_elf_index (abfd
, i
);
5421 if (! bfd_is_abs_section (o
))
5422 o
->target_index
= abfd
->symcount
;
5423 elfsym
.st_shndx
= i
;
5424 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5429 /* Allocate some memory to hold information read in from the input
5431 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5432 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5433 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5434 malloc (max_internal_reloc_count
5435 * sizeof (Elf_Internal_Rela
)));
5436 finfo
.external_syms
= ((Elf_External_Sym
*)
5437 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5438 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5439 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5440 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5441 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5442 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5443 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5444 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5445 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5446 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5447 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5448 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5450 bfd_set_error (bfd_error_no_memory
);
5454 /* Since ELF permits relocations to be against local symbols, we
5455 must have the local symbols available when we do the relocations.
5456 Since we would rather only read the local symbols once, and we
5457 would rather not keep them in memory, we handle all the
5458 relocations for a single input file at the same time.
5460 Unfortunately, there is no way to know the total number of local
5461 symbols until we have seen all of them, and the local symbol
5462 indices precede the global symbol indices. This means that when
5463 we are generating relocateable output, and we see a reloc against
5464 a global symbol, we can not know the symbol index until we have
5465 finished examining all the local symbols to see which ones we are
5466 going to output. To deal with this, we keep the relocations in
5467 memory, and don't output them until the end of the link. This is
5468 an unfortunate waste of memory, but I don't see a good way around
5469 it. Fortunately, it only happens when performing a relocateable
5470 link, which is not the common case. FIXME: If keep_memory is set
5471 we could write the relocs out and then read them again; I don't
5472 know how bad the memory loss will be. */
5474 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5475 sub
->output_has_begun
= false;
5476 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5478 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5480 if (p
->type
== bfd_indirect_link_order
5481 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5482 == bfd_target_elf_flavour
))
5484 sub
= p
->u
.indirect
.section
->owner
;
5485 if (! sub
->output_has_begun
)
5487 if (! elf_link_input_bfd (&finfo
, sub
))
5489 sub
->output_has_begun
= true;
5492 else if (p
->type
== bfd_section_reloc_link_order
5493 || p
->type
== bfd_symbol_reloc_link_order
)
5495 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5500 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5506 /* That wrote out all the local symbols. Finish up the symbol table
5507 with the global symbols. */
5509 /* The sh_info field records the index of the first non local
5511 symtab_hdr
->sh_info
= abfd
->symcount
;
5513 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5515 /* We get the global symbols from the hash table. */
5516 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5519 /* Flush all symbols to the file. */
5520 if (! elf_link_flush_output_syms (&finfo
))
5523 /* Now we know the size of the symtab section. */
5524 off
+= symtab_hdr
->sh_size
;
5526 /* Finish up the symbol string table (.strtab) section. */
5527 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5528 /* sh_name was set in prep_headers. */
5529 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5530 symstrtab_hdr
->sh_flags
= 0;
5531 symstrtab_hdr
->sh_addr
= 0;
5532 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5533 symstrtab_hdr
->sh_entsize
= 0;
5534 symstrtab_hdr
->sh_link
= 0;
5535 symstrtab_hdr
->sh_info
= 0;
5536 /* sh_offset is set just below. */
5537 symstrtab_hdr
->sh_addralign
= 1;
5538 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5540 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5541 elf_tdata (abfd
)->next_file_pos
= off
;
5543 /* Adjust the relocs to have the correct symbol indices. */
5544 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5546 struct elf_link_hash_entry
**rel_hash
;
5547 Elf_Internal_Shdr
*rel_hdr
;
5549 if ((o
->flags
& SEC_RELOC
) == 0)
5552 rel_hash
= elf_section_data (o
)->rel_hashes
;
5553 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5554 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5556 if (*rel_hash
== NULL
)
5559 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5561 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5563 Elf_External_Rel
*erel
;
5564 Elf_Internal_Rel irel
;
5566 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5567 elf_swap_reloc_in (abfd
, erel
, &irel
);
5568 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5569 ELF_R_TYPE (irel
.r_info
));
5570 elf_swap_reloc_out (abfd
, &irel
, erel
);
5574 Elf_External_Rela
*erela
;
5575 Elf_Internal_Rela irela
;
5577 BFD_ASSERT (rel_hdr
->sh_entsize
5578 == sizeof (Elf_External_Rela
));
5580 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5581 elf_swap_reloca_in (abfd
, erela
, &irela
);
5582 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5583 ELF_R_TYPE (irela
.r_info
));
5584 elf_swap_reloca_out (abfd
, &irela
, erela
);
5588 /* Set the reloc_count field to 0 to prevent write_relocs from
5589 trying to swap the relocs out itself. */
5593 /* If we are linking against a dynamic object, finish up the dynamic
5594 linking information. */
5597 Elf_External_Dyn
*dyncon
, *dynconend
;
5599 /* Fix up .dynamic entries. */
5600 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5601 BFD_ASSERT (o
!= NULL
);
5603 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5604 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5605 for (; dyncon
< dynconend
; dyncon
++)
5607 Elf_Internal_Dyn dyn
;
5611 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5633 o
= bfd_get_section_by_name (abfd
, name
);
5634 BFD_ASSERT (o
!= NULL
);
5635 dyn
.d_un
.d_ptr
= o
->vma
;
5636 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5643 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5648 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5650 Elf_Internal_Shdr
*hdr
;
5652 hdr
= elf_elfsections (abfd
)[i
];
5653 if (hdr
->sh_type
== type
5654 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5656 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5657 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5660 if (dyn
.d_un
.d_val
== 0
5661 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5662 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5666 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5671 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5674 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5676 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5678 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5680 BFD_ASSERT (info
->shared
);
5683 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5684 o
->contents
, o
->output_offset
,
5690 if (finfo
.contents
!= NULL
)
5691 free (finfo
.contents
);
5692 if (finfo
.external_relocs
!= NULL
)
5693 free (finfo
.external_relocs
);
5694 if (finfo
.internal_relocs
!= NULL
)
5695 free (finfo
.internal_relocs
);
5696 if (finfo
.external_syms
!= NULL
)
5697 free (finfo
.external_syms
);
5698 if (finfo
.internal_syms
!= NULL
)
5699 free (finfo
.internal_syms
);
5700 if (finfo
.indices
!= NULL
)
5701 free (finfo
.indices
);
5702 if (finfo
.sections
!= NULL
)
5703 free (finfo
.sections
);
5704 if (finfo
.symbuf
!= NULL
)
5705 free (finfo
.symbuf
);
5706 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5708 if ((o
->flags
& SEC_RELOC
) != 0
5709 && elf_section_data (o
)->rel_hashes
!= NULL
)
5710 free (elf_section_data (o
)->rel_hashes
);
5713 elf_tdata (abfd
)->linker
= true;
5718 if (finfo
.contents
!= NULL
)
5719 free (finfo
.contents
);
5720 if (finfo
.external_relocs
!= NULL
)
5721 free (finfo
.external_relocs
);
5722 if (finfo
.internal_relocs
!= NULL
)
5723 free (finfo
.internal_relocs
);
5724 if (finfo
.external_syms
!= NULL
)
5725 free (finfo
.external_syms
);
5726 if (finfo
.internal_syms
!= NULL
)
5727 free (finfo
.internal_syms
);
5728 if (finfo
.indices
!= NULL
)
5729 free (finfo
.indices
);
5730 if (finfo
.sections
!= NULL
)
5731 free (finfo
.sections
);
5732 if (finfo
.symbuf
!= NULL
)
5733 free (finfo
.symbuf
);
5734 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5736 if ((o
->flags
& SEC_RELOC
) != 0
5737 && elf_section_data (o
)->rel_hashes
!= NULL
)
5738 free (elf_section_data (o
)->rel_hashes
);
5744 /* Add a symbol to the output symbol table. */
5747 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5748 struct elf_final_link_info
*finfo
;
5750 Elf_Internal_Sym
*elfsym
;
5751 asection
*input_sec
;
5753 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5754 struct bfd_link_info
*info
,
5759 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5760 elf_backend_link_output_symbol_hook
;
5761 if (output_symbol_hook
!= NULL
)
5763 if (! ((*output_symbol_hook
)
5764 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5768 if (name
== (const char *) NULL
|| *name
== '\0')
5769 elfsym
->st_name
= 0;
5772 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5773 finfo
->symstrtab
, name
);
5774 if (elfsym
->st_name
== (unsigned long) -1)
5778 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5780 if (! elf_link_flush_output_syms (finfo
))
5784 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5785 finfo
->symbuf
+ finfo
->symbuf_count
);
5786 ++finfo
->symbuf_count
;
5788 ++finfo
->output_bfd
->symcount
;
5793 /* Flush the output symbols to the file. */
5796 elf_link_flush_output_syms (finfo
)
5797 struct elf_final_link_info
*finfo
;
5799 Elf_Internal_Shdr
*symtab
;
5801 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5803 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5805 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5806 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5807 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5810 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5812 finfo
->symbuf_count
= 0;
5817 /* Add an external symbol to the symbol table. This is called from
5818 the hash table traversal routine. */
5821 elf_link_output_extsym (h
, data
)
5822 struct elf_link_hash_entry
*h
;
5825 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5827 Elf_Internal_Sym sym
;
5828 asection
*input_sec
;
5830 /* We don't want to output symbols that have never been mentioned by
5831 a regular file, or that we have been told to strip. However, if
5832 h->indx is set to -2, the symbol is used by a reloc and we must
5836 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5837 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5838 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5839 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5841 else if (finfo
->info
->strip
== strip_all
5842 || (finfo
->info
->strip
== strip_some
5843 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5844 h
->root
.root
.string
,
5845 false, false) == NULL
))
5850 /* If we're stripping it, and it's not a dynamic symbol, there's
5851 nothing else to do. */
5852 if (strip
&& h
->dynindx
== -1)
5856 sym
.st_size
= h
->size
;
5858 if (h
->root
.type
== bfd_link_hash_weak
5859 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
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
;