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
, ".rel.", 5) == 0)
1216 this_hdr
->sh_type
= SHT_REL
;
1217 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1219 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1221 this_hdr
->sh_type
= SHT_RELA
;
1222 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1224 else if (strcmp (asect
->name
, ".note") == 0)
1225 this_hdr
->sh_type
= SHT_NOTE
;
1226 else if (strncmp (asect
->name
, ".stab", 5) == 0
1227 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1228 this_hdr
->sh_type
= SHT_STRTAB
;
1229 else if ((asect
->flags
& SEC_ALLOC
) != 0
1230 && (asect
->flags
& SEC_LOAD
) != 0)
1231 this_hdr
->sh_type
= SHT_PROGBITS
;
1232 else if ((asect
->flags
& SEC_ALLOC
) != 0
1233 && ((asect
->flags
& SEC_LOAD
) == 0))
1235 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1236 || strcmp (asect
->name
, ".sbss") == 0);
1237 this_hdr
->sh_type
= SHT_NOBITS
;
1242 this_hdr
->sh_type
= SHT_PROGBITS
;
1245 if ((asect
->flags
& SEC_ALLOC
) != 0)
1246 this_hdr
->sh_flags
|= SHF_ALLOC
;
1247 if ((asect
->flags
& SEC_READONLY
) == 0)
1248 this_hdr
->sh_flags
|= SHF_WRITE
;
1249 if ((asect
->flags
& SEC_CODE
) != 0)
1250 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1252 /* Check for processor-specific section types. */
1254 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1256 if (bed
->elf_backend_fake_sections
)
1257 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1260 /* If the section has relocs, set up a section header for the
1261 SHT_REL[A] section. */
1262 if ((asect
->flags
& SEC_RELOC
) != 0)
1264 Elf_Internal_Shdr
*rela_hdr
;
1265 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1267 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1269 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1270 use_rela_p
? ".rela" : ".rel",
1272 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1273 rela_hdr
->sh_entsize
= (use_rela_p
1274 ? sizeof (Elf_External_Rela
)
1275 : sizeof (Elf_External_Rel
));
1276 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1277 rela_hdr
->sh_flags
= 0;
1278 rela_hdr
->sh_addr
= 0;
1279 rela_hdr
->sh_size
= 0;
1280 rela_hdr
->sh_offset
= 0;
1285 /* Assign all ELF section numbers. The dummy first section is handled here
1286 too. The link/info pointers for the standard section types are filled
1287 in here too, while we're at it. */
1290 assign_section_numbers (abfd
)
1293 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1295 unsigned int section_number
;
1296 Elf_Internal_Shdr
**i_shdrp
;
1300 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1302 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1304 d
->this_idx
= section_number
++;
1305 if ((sec
->flags
& SEC_RELOC
) == 0)
1308 d
->rel_idx
= section_number
++;
1311 t
->shstrtab_section
= section_number
++;
1312 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1313 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1314 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1316 if (abfd
->symcount
> 0)
1318 t
->symtab_section
= section_number
++;
1319 t
->strtab_section
= section_number
++;
1322 elf_elfheader (abfd
)->e_shnum
= section_number
;
1324 /* Set up the list of section header pointers, in agreement with the
1326 i_shdrp
= ((Elf_Internal_Shdr
**)
1327 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1328 if (i_shdrp
== NULL
)
1330 bfd_set_error (bfd_error_no_memory
);
1334 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1335 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1336 if (i_shdrp
[0] == NULL
)
1338 bfd_release (abfd
, i_shdrp
);
1339 bfd_set_error (bfd_error_no_memory
);
1342 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1344 elf_elfsections (abfd
) = i_shdrp
;
1346 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1347 if (abfd
->symcount
> 0)
1349 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1350 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1351 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1353 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1355 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1359 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1360 if (d
->rel_idx
!= 0)
1361 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1363 /* Fill in the sh_link and sh_info fields while we're at it. */
1365 /* sh_link of a reloc section is the section index of the symbol
1366 table. sh_info is the section index of the section to which
1367 the relocation entries apply. */
1368 if (d
->rel_idx
!= 0)
1370 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1371 d
->rel_hdr
.sh_info
= d
->this_idx
;
1374 switch (d
->this_hdr
.sh_type
)
1378 /* A reloc section which we are treating as a normal BFD
1379 section. sh_link is the section index of the symbol
1380 table. sh_info is the section index of the section to
1381 which the relocation entries apply. We assume that an
1382 allocated reloc section uses the dynamic symbol table.
1383 FIXME: How can we be sure? */
1384 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1386 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1388 /* We look up the section the relocs apply to by name. */
1390 if (d
->this_hdr
.sh_type
== SHT_REL
)
1394 s
= bfd_get_section_by_name (abfd
, name
);
1396 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1400 /* We assume that a section named .stab*str is a stabs
1401 string section. We look for a section with the same name
1402 but without the trailing ``str'', and set its sh_link
1403 field to point to this section. */
1404 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1405 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1410 len
= strlen (sec
->name
);
1411 alc
= (char *) malloc (len
- 2);
1414 bfd_set_error (bfd_error_no_memory
);
1417 strncpy (alc
, sec
->name
, len
- 3);
1418 alc
[len
- 3] = '\0';
1419 s
= bfd_get_section_by_name (abfd
, alc
);
1423 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1425 /* This is a .stab section. */
1426 elf_section_data (s
)->this_hdr
.sh_entsize
=
1427 4 + 2 * (ARCH_SIZE
/ 8);
1434 /* sh_link is the section header index of the string table
1435 used for the dynamic entries or symbol table. */
1436 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1438 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1442 /* sh_link is the section header index of the symbol table
1443 this hash table is for. */
1444 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1446 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1454 /* Map symbol from it's internal number to the external number, moving
1455 all local symbols to be at the head of the list. */
1458 sym_is_global (abfd
, sym
)
1462 /* If the backend has a special mapping, use it. */
1463 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1464 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1467 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1469 if (sym
->flags
& BSF_LOCAL
)
1473 if (sym
->section
== 0)
1475 /* Is this valid? */
1480 if (bfd_is_und_section (sym
->section
))
1482 if (bfd_is_com_section (sym
->section
))
1484 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1490 elf_map_symbols (abfd
)
1493 int symcount
= bfd_get_symcount (abfd
);
1494 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1495 asymbol
**sect_syms
;
1497 int num_globals
= 0;
1498 int num_locals2
= 0;
1499 int num_globals2
= 0;
1501 int num_sections
= 0;
1502 Elf_Sym_Extra
*sym_extra
;
1507 fprintf (stderr
, "elf_map_symbols\n");
1511 /* Add local symbols for each section for which there are relocs.
1512 FIXME: How can we tell which sections have relocs at this point?
1513 Will reloc_count always be accurate? Actually, I think most ELF
1514 targets create section symbols for all sections anyhow. */
1515 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1517 if (max_index
< asect
->index
)
1518 max_index
= asect
->index
;
1522 elf_num_section_syms (abfd
) = max_index
;
1523 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1524 elf_section_syms (abfd
) = sect_syms
;
1528 bfd_set_error (bfd_error_no_memory
);
1532 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1534 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1537 bfd_set_error (bfd_error_no_memory
);
1540 sym
->the_bfd
= abfd
;
1541 sym
->name
= asect
->name
;
1542 sym
->value
= asect
->vma
;
1543 sym
->flags
= BSF_SECTION_SYM
;
1544 sym
->section
= asect
;
1545 sect_syms
[asect
->index
] = sym
;
1549 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1550 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1557 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1558 ((symcount
+ num_sections
+ 1)
1559 * sizeof (asymbol
*)));
1561 syms
= (asymbol
**) bfd_alloc (abfd
,
1562 (num_sections
+ 1) * sizeof (asymbol
*));
1565 bfd_set_error (bfd_error_no_memory
);
1569 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1571 if (sect_syms
[asect
->index
])
1572 syms
[symcount
++] = sect_syms
[asect
->index
];
1575 syms
[symcount
] = (asymbol
*) 0;
1576 bfd_set_symtab (abfd
, syms
, symcount
);
1579 elf_sym_extra (abfd
) = sym_extra
1580 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1583 bfd_set_error (bfd_error_no_memory
);
1587 /* Identify and classify all of the symbols. */
1588 for (idx
= 0; idx
< symcount
; idx
++)
1590 if (!sym_is_global (abfd
, syms
[idx
]))
1596 /* Now provide mapping information. Add +1 for skipping over the
1598 for (idx
= 0; idx
< symcount
; idx
++)
1600 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1601 if (!sym_is_global (abfd
, syms
[idx
]))
1602 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1604 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1607 elf_num_locals (abfd
) = num_locals
;
1608 elf_num_globals (abfd
) = num_globals
;
1612 /* Compute the file positions we are going to put the sections at, and
1613 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1614 is not NULL, this is being called by the ELF backend linker. */
1617 elf_compute_section_file_positions (abfd
, link_info
)
1619 struct bfd_link_info
*link_info
;
1621 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1622 Elf_Internal_Shdr
*shstrtab_hdr
;
1624 if (abfd
->output_has_begun
)
1627 /* Do any elf backend specific processing first. */
1628 if (bed
->elf_backend_begin_write_processing
)
1629 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1631 if (! prep_headers (abfd
))
1634 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1636 if (!assign_section_numbers (abfd
))
1639 /* The backend linker builds symbol table information itself. */
1640 if (link_info
== NULL
)
1642 if (! swap_out_syms (abfd
))
1646 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1647 /* sh_name was set in prep_headers. */
1648 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1649 shstrtab_hdr
->sh_flags
= 0;
1650 shstrtab_hdr
->sh_addr
= 0;
1651 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1652 shstrtab_hdr
->sh_entsize
= 0;
1653 shstrtab_hdr
->sh_link
= 0;
1654 shstrtab_hdr
->sh_info
= 0;
1655 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1656 shstrtab_hdr
->sh_addralign
= 1;
1657 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1659 if (!assign_file_positions_except_relocs (abfd
,
1660 link_info
== NULL
? true : false))
1663 abfd
->output_has_begun
= true;
1669 /* Align to the maximum file alignment that could be required for any
1670 ELF data structure. */
1672 static INLINE file_ptr
1673 align_file_position (off
)
1676 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1679 /* Assign a file position to a section, optionally aligning to the
1680 required section alignment. */
1682 static INLINE file_ptr
1683 assign_file_position_for_section (i_shdrp
, offset
, align
)
1684 Elf_Internal_Shdr
*i_shdrp
;
1692 al
= i_shdrp
->sh_addralign
;
1694 offset
= BFD_ALIGN (offset
, al
);
1696 i_shdrp
->sh_offset
= offset
;
1697 if (i_shdrp
->rawdata
!= NULL
)
1698 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1699 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1700 offset
+= i_shdrp
->sh_size
;
1704 /* Get the size of the program header. This is called by the linker
1705 before any of the section VMA's are set, so it can't calculate the
1706 correct value for a strange memory layout. */
1708 static bfd_size_type
1709 get_program_header_size (abfd
)
1715 /* Assume we will need exactly two PT_LOAD segments: one for text
1716 and one for data. */
1719 s
= bfd_get_section_by_name (abfd
, ".interp");
1720 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1722 /* If we have a loadable interpreter section, we need a
1723 PT_INTERP segment. In this case, assume we also need a
1724 PT_PHDR segment, although that may not be true for all
1729 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1731 /* We need a PT_DYNAMIC segment. */
1735 return segs
* sizeof (Elf_External_Phdr
);
1738 /* Create the program header. OFF is the file offset where the
1739 program header should be written. FIRST is the first loadable ELF
1740 section. PHDR_SIZE is the size of the program header as returned
1741 by get_program_header_size. */
1744 map_program_segments (abfd
, off
, first
, phdr_size
)
1747 Elf_Internal_Shdr
*first
;
1748 bfd_size_type phdr_size
;
1750 Elf_Internal_Phdr phdrs
[10];
1751 unsigned int phdr_count
;
1752 Elf_Internal_Phdr
*phdr
;
1753 int phdr_size_adjust
;
1755 Elf_Internal_Shdr
**hdrpp
;
1756 asection
*sinterp
, *sdyn
;
1757 unsigned int last_type
;
1758 Elf_Internal_Ehdr
*i_ehdrp
;
1760 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1761 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1762 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1767 phdr_size_adjust
= 0;
1769 /* If we have a loadable .interp section, we must create a PT_INTERP
1770 segment which must precede all PT_LOAD segments. We assume that
1771 we must also create a PT_PHDR segment, although that may not be
1772 true for all targets. */
1773 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1774 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1776 BFD_ASSERT (first
!= NULL
);
1778 phdr
->p_type
= PT_PHDR
;
1780 phdr
->p_offset
= off
;
1782 /* Account for any adjustment made because of the alignment of
1783 the first loadable section. */
1784 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1785 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1787 /* The program header precedes all loadable sections. This lets
1788 us compute its loadable address. This depends on the linker
1790 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1793 phdr
->p_filesz
= phdr_size
;
1794 phdr
->p_memsz
= phdr_size
;
1796 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1797 phdr
->p_flags
= PF_R
| PF_X
;
1799 phdr
->p_align
= FILE_ALIGN
;
1800 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1802 /* Include the ELF header in the first loadable segment. */
1803 phdr_size_adjust
+= off
;
1808 phdr
->p_type
= PT_INTERP
;
1809 phdr
->p_offset
= sinterp
->filepos
;
1810 phdr
->p_vaddr
= sinterp
->vma
;
1812 phdr
->p_filesz
= sinterp
->_raw_size
;
1813 phdr
->p_memsz
= sinterp
->_raw_size
;
1814 phdr
->p_flags
= PF_R
;
1815 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1821 /* Look through the sections to see how they will be divided into
1822 program segments. The sections must be arranged in order by
1823 sh_addr for this to work correctly. */
1824 phdr
->p_type
= PT_NULL
;
1825 last_type
= SHT_PROGBITS
;
1826 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1827 i
< elf_elfheader (abfd
)->e_shnum
;
1830 Elf_Internal_Shdr
*hdr
;
1834 /* Ignore any section which will not be part of the process
1836 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1839 /* If this section fits in the segment we are constructing, add
1841 if (phdr
->p_type
!= PT_NULL
1842 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1843 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1844 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1846 bfd_size_type adjust
;
1848 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1849 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1850 if (hdr
->sh_type
!= SHT_NOBITS
)
1851 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1852 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1853 phdr
->p_flags
|= PF_W
;
1854 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1855 phdr
->p_flags
|= PF_X
;
1856 last_type
= hdr
->sh_type
;
1860 /* If we have a segment, move to the next one. */
1861 if (phdr
->p_type
!= PT_NULL
)
1867 /* Start a new segment. */
1868 phdr
->p_type
= PT_LOAD
;
1869 phdr
->p_offset
= hdr
->sh_offset
;
1870 phdr
->p_vaddr
= hdr
->sh_addr
;
1872 if (hdr
->sh_type
== SHT_NOBITS
)
1875 phdr
->p_filesz
= hdr
->sh_size
;
1876 phdr
->p_memsz
= hdr
->sh_size
;
1877 phdr
->p_flags
= PF_R
;
1878 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1879 phdr
->p_flags
|= PF_W
;
1880 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1881 phdr
->p_flags
|= PF_X
;
1882 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1886 && (sinterp
->flags
& SEC_LOAD
) != 0)
1888 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1889 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1890 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1891 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1894 last_type
= hdr
->sh_type
;
1897 if (phdr
->p_type
!= PT_NULL
)
1903 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1904 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1905 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1907 phdr
->p_type
= PT_DYNAMIC
;
1908 phdr
->p_offset
= sdyn
->filepos
;
1909 phdr
->p_vaddr
= sdyn
->vma
;
1911 phdr
->p_filesz
= sdyn
->_raw_size
;
1912 phdr
->p_memsz
= sdyn
->_raw_size
;
1913 phdr
->p_flags
= PF_R
;
1914 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1915 phdr
->p_flags
|= PF_W
;
1916 if ((sdyn
->flags
& SEC_CODE
) != 0)
1917 phdr
->p_flags
|= PF_X
;
1918 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1924 /* Make sure the return value from get_program_header_size matches
1925 what we computed here. */
1926 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1929 /* Set up program header information. */
1930 i_ehdrp
= elf_elfheader (abfd
);
1931 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1932 i_ehdrp
->e_phoff
= off
;
1933 i_ehdrp
->e_phnum
= phdr_count
;
1935 /* Save the program headers away. I don't think anybody uses this
1936 information right now. */
1937 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1940 * sizeof (Elf_Internal_Phdr
))));
1941 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1943 bfd_set_error (bfd_error_no_memory
);
1944 return (file_ptr
) -1;
1946 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1947 phdr_count
* sizeof (Elf_Internal_Phdr
));
1949 /* Write out the program headers. */
1950 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1951 return (file_ptr
) -1;
1953 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1955 Elf_External_Phdr extphdr
;
1957 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1958 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1959 != sizeof (Elf_External_Phdr
))
1960 return (file_ptr
) -1;
1963 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1966 /* Work out the file positions of all the sections. This is called by
1967 elf_compute_section_file_positions. All the section sizes and VMAs
1968 must be known before this is called.
1970 We do not consider reloc sections at this point, unless they form
1971 part of the loadable image. Reloc sections are assigned file
1972 positions in assign_file_positions_for_relocs, which is called by
1973 write_object_contents and final_link.
1975 If DOSYMS is false, we do not assign file positions for the symbol
1976 table or the string table. */
1979 assign_file_positions_except_relocs (abfd
, dosyms
)
1983 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1984 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1985 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1988 /* Start after the ELF header. */
1989 off
= i_ehdrp
->e_ehsize
;
1991 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1993 Elf_Internal_Shdr
**hdrpp
;
1996 /* We are not creating an executable, which means that we are
1997 not creating a program header, and that the actual order of
1998 the sections in the file is unimportant. */
1999 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2001 Elf_Internal_Shdr
*hdr
;
2004 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2006 hdr
->sh_offset
= -1;
2010 && (i
== tdata
->symtab_section
2011 || i
== tdata
->strtab_section
))
2013 hdr
->sh_offset
= -1;
2017 off
= assign_file_position_for_section (hdr
, off
, true);
2023 bfd_size_type phdr_size
;
2024 bfd_vma maxpagesize
;
2025 Elf_Internal_Shdr
**hdrpp
;
2027 Elf_Internal_Shdr
*first
;
2030 /* We are creating an executable. We must create a program
2031 header. We can't actually create the program header until we
2032 have set the file positions for the sections, but we can
2033 figure out how big it is going to be. */
2034 off
= align_file_position (off
);
2035 phdr_size
= get_program_header_size (abfd
);
2036 if (phdr_size
== (file_ptr
) -1)
2041 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2042 if (maxpagesize
== 0)
2045 /* FIXME: We might want to sort the sections on the sh_addr
2046 field here. For now, we just assume that the linker will
2047 create the sections in an appropriate order. */
2049 /* Assign file positions in two passes. In the first pass, we
2050 assign a file position to every section which forms part of
2051 the executable image. */
2053 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2055 Elf_Internal_Shdr
*hdr
;
2058 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2064 if ((abfd
->flags
& D_PAGED
) != 0)
2066 /* The section VMA must equal the file position modulo
2067 the page size. This is required by the program
2069 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2072 off
= assign_file_position_for_section (hdr
, off
, false);
2075 /* Assign file positions to all the sections which do not form
2076 part of the loadable image, except for the relocs. */
2077 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2079 Elf_Internal_Shdr
*hdr
;
2082 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2084 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2086 hdr
->sh_offset
= -1;
2090 && (i
== tdata
->symtab_section
2091 || i
== tdata
->strtab_section
))
2093 hdr
->sh_offset
= -1;
2097 off
= assign_file_position_for_section (hdr
, off
, true);
2100 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2101 if (phdr_map
== (file_ptr
) -1)
2103 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2106 /* Place the section headers. */
2107 off
= align_file_position (off
);
2108 i_ehdrp
->e_shoff
= off
;
2109 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2111 elf_tdata (abfd
)->next_file_pos
= off
;
2120 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2121 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2122 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2124 struct strtab
*shstrtab
;
2126 i_ehdrp
= elf_elfheader (abfd
);
2127 i_shdrp
= elf_elfsections (abfd
);
2129 shstrtab
= bfd_new_strtab (abfd
);
2133 elf_shstrtab (abfd
) = shstrtab
;
2135 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2136 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2137 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2138 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2140 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2141 i_ehdrp
->e_ident
[EI_DATA
] =
2142 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2143 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2145 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2146 i_ehdrp
->e_ident
[count
] = 0;
2148 if ((abfd
->flags
& DYNAMIC
) != 0)
2149 i_ehdrp
->e_type
= ET_DYN
;
2150 else if ((abfd
->flags
& EXEC_P
) != 0)
2151 i_ehdrp
->e_type
= ET_EXEC
;
2153 i_ehdrp
->e_type
= ET_REL
;
2155 switch (bfd_get_arch (abfd
))
2157 case bfd_arch_unknown
:
2158 i_ehdrp
->e_machine
= EM_NONE
;
2160 case bfd_arch_sparc
:
2162 i_ehdrp
->e_machine
= EM_SPARC64
;
2164 i_ehdrp
->e_machine
= EM_SPARC
;
2168 i_ehdrp
->e_machine
= EM_386
;
2171 i_ehdrp
->e_machine
= EM_68K
;
2174 i_ehdrp
->e_machine
= EM_88K
;
2177 i_ehdrp
->e_machine
= EM_860
;
2179 case bfd_arch_mips
: /* MIPS Rxxxx */
2180 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2183 i_ehdrp
->e_machine
= EM_PARISC
;
2185 case bfd_arch_powerpc
:
2186 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2188 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2190 i_ehdrp
->e_machine
= EM_NONE
;
2192 i_ehdrp
->e_version
= EV_CURRENT
;
2193 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2195 /* no program header, for now. */
2196 i_ehdrp
->e_phoff
= 0;
2197 i_ehdrp
->e_phentsize
= 0;
2198 i_ehdrp
->e_phnum
= 0;
2200 /* each bfd section is section header entry */
2201 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2202 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2204 /* if we're building an executable, we'll need a program header table */
2205 if (abfd
->flags
& EXEC_P
)
2207 /* it all happens later */
2209 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2211 /* elf_build_phdrs() returns a (NULL-terminated) array of
2212 Elf_Internal_Phdrs */
2213 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2214 i_ehdrp
->e_phoff
= outbase
;
2215 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2220 i_ehdrp
->e_phentsize
= 0;
2222 i_ehdrp
->e_phoff
= 0;
2225 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2227 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2229 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2231 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2232 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2233 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2240 swap_out_syms (abfd
)
2243 if (!elf_map_symbols (abfd
))
2246 /* Dump out the symtabs. */
2248 int symcount
= bfd_get_symcount (abfd
);
2249 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2250 struct strtab
*stt
= bfd_new_strtab (abfd
);
2251 Elf_Internal_Shdr
*symtab_hdr
;
2252 Elf_Internal_Shdr
*symstrtab_hdr
;
2253 Elf_External_Sym
*outbound_syms
;
2258 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2259 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2260 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2261 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2262 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2263 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2265 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2266 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2268 outbound_syms
= (Elf_External_Sym
*)
2269 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2272 bfd_set_error (bfd_error_no_memory
);
2275 /* now generate the data (for "contents") */
2277 /* Fill in zeroth symbol and swap it out. */
2278 Elf_Internal_Sym sym
;
2284 sym
.st_shndx
= SHN_UNDEF
;
2285 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2287 for (idx
= 0; idx
< symcount
; idx
++)
2289 Elf_Internal_Sym sym
;
2290 bfd_vma value
= syms
[idx
]->value
;
2291 elf_symbol_type
*type_ptr
;
2293 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2294 /* Section symbols have no names. */
2298 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2299 if (sym
.st_name
== (unsigned long) -1)
2303 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2305 if (bfd_is_com_section (syms
[idx
]->section
))
2307 /* ELF common symbols put the alignment into the `value' field,
2308 and the size into the `size' field. This is backwards from
2309 how BFD handles it, so reverse it here. */
2310 sym
.st_size
= value
;
2311 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2312 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2313 syms
[idx
]->section
);
2317 asection
*sec
= syms
[idx
]->section
;
2320 if (sec
->output_section
)
2322 value
+= sec
->output_offset
;
2323 sec
= sec
->output_section
;
2326 sym
.st_value
= value
;
2327 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2328 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2332 /* Writing this would be a hell of a lot easier if we had
2333 some decent documentation on bfd, and knew what to expect
2334 of the library, and what to demand of applications. For
2335 example, it appears that `objcopy' might not set the
2336 section of a symbol to be a section that is actually in
2338 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2339 BFD_ASSERT (sec2
!= 0);
2340 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2341 BFD_ASSERT (shndx
!= -1);
2345 if (bfd_is_com_section (syms
[idx
]->section
))
2346 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2347 else if (bfd_is_und_section (syms
[idx
]->section
))
2348 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2349 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2350 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2351 else if (syms
[idx
]->flags
& BSF_FILE
)
2352 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2355 int bind
= STB_LOCAL
;
2356 int type
= STT_OBJECT
;
2357 unsigned int flags
= syms
[idx
]->flags
;
2359 if (flags
& BSF_LOCAL
)
2361 else if (flags
& BSF_WEAK
)
2363 else if (flags
& BSF_GLOBAL
)
2366 if (flags
& BSF_FUNCTION
)
2369 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2373 elf_swap_symbol_out (abfd
, &sym
,
2375 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2378 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2379 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2380 symstrtab_hdr
->sh_size
= stt
->length
;
2381 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2383 symstrtab_hdr
->sh_flags
= 0;
2384 symstrtab_hdr
->sh_addr
= 0;
2385 symstrtab_hdr
->sh_entsize
= 0;
2386 symstrtab_hdr
->sh_link
= 0;
2387 symstrtab_hdr
->sh_info
= 0;
2388 symstrtab_hdr
->sh_addralign
= 1;
2389 symstrtab_hdr
->size
= 0;
2396 write_shdrs_and_ehdr (abfd
)
2399 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2400 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2401 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2402 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2404 struct strtab
*shstrtab
;
2406 i_ehdrp
= elf_elfheader (abfd
);
2407 i_shdrp
= elf_elfsections (abfd
);
2408 shstrtab
= elf_shstrtab (abfd
);
2410 /* swap the header before spitting it out... */
2413 elf_debug_file (i_ehdrp
);
2415 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2416 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2417 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2418 != sizeof (x_ehdr
)))
2421 /* at this point we've concocted all the ELF sections... */
2422 x_shdrp
= (Elf_External_Shdr
*)
2423 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2426 bfd_set_error (bfd_error_no_memory
);
2430 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2433 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2436 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2438 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2439 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2440 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2443 /* need to dump the string table too... */
2448 /* Assign file positions for all the reloc sections which are not part
2449 of the loadable file image. */
2452 assign_file_positions_for_relocs (abfd
)
2457 Elf_Internal_Shdr
**shdrpp
;
2459 off
= elf_tdata (abfd
)->next_file_pos
;
2461 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2462 i
< elf_elfheader (abfd
)->e_shnum
;
2465 Elf_Internal_Shdr
*shdrp
;
2468 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2469 && shdrp
->sh_offset
== -1)
2470 off
= assign_file_position_for_section (shdrp
, off
, true);
2473 elf_tdata (abfd
)->next_file_pos
= off
;
2477 NAME(bfd_elf
,write_object_contents
) (abfd
)
2480 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2481 Elf_Internal_Ehdr
*i_ehdrp
;
2482 Elf_Internal_Shdr
**i_shdrp
;
2485 if (! abfd
->output_has_begun
2486 && ! elf_compute_section_file_positions (abfd
,
2487 (struct bfd_link_info
*) NULL
))
2490 i_shdrp
= elf_elfsections (abfd
);
2491 i_ehdrp
= elf_elfheader (abfd
);
2493 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2494 assign_file_positions_for_relocs (abfd
);
2496 /* After writing the headers, we need to write the sections too... */
2497 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2499 if (bed
->elf_backend_section_processing
)
2500 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2501 if (i_shdrp
[count
]->contents
)
2503 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2504 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2506 != i_shdrp
[count
]->sh_size
))
2511 if (bed
->elf_backend_final_write_processing
)
2512 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
2514 return write_shdrs_and_ehdr (abfd
);
2517 /* Given an index of a section, retrieve a pointer to it. Note
2518 that for our purposes, sections are indexed by {1, 2, ...} with
2519 0 being an illegal index. */
2521 /* In the original, each ELF section went into exactly one BFD
2522 section. This doesn't really make sense, so we need a real mapping.
2523 The mapping has to hide in the Elf_Internal_Shdr since asection
2524 doesn't have anything like a tdata field... */
2527 section_from_elf_index (abfd
, index
)
2531 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2532 be returned from this routine? */
2534 if (index
== SHN_ABS
)
2535 return bfd_com_section_ptr
; /* not abs? */
2536 if (index
== SHN_COMMON
)
2537 return bfd_com_section_ptr
;
2539 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2543 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2545 switch (hdr
->sh_type
)
2547 /* ELF sections that map to BFD sections */
2552 if (hdr
->rawdata
== NULL
)
2554 if (! bfd_section_from_shdr (abfd
, index
))
2557 return (struct sec
*) hdr
->rawdata
;
2560 return bfd_abs_section_ptr
;
2565 /* given a section, search the header to find them... */
2567 elf_section_from_bfd_section (abfd
, asect
)
2571 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2573 Elf_Internal_Shdr
*hdr
;
2574 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2576 if (asect
->owner
== NULL
)
2578 if (bfd_is_abs_section (asect
))
2580 if (bfd_is_com_section (asect
))
2582 if (bfd_is_und_section (asect
))
2587 BFD_ASSERT (asect
->owner
== abfd
);
2589 for (index
= 0; index
< maxindex
; index
++)
2591 hdr
= i_shdrp
[index
];
2592 switch (hdr
->sh_type
)
2594 /* ELF sections that map to BFD sections */
2604 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2611 /* We sometimes map a reloc section to a BFD section. */
2612 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2613 && (asection
*) hdr
->rawdata
== asect
)
2618 /* We map most string tables to BFD sections. */
2619 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2620 && index
!= elf_onesymtab (abfd
)
2621 && (asection
*) hdr
->rawdata
== asect
)
2627 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2629 if (bed
->elf_backend_section_from_bfd_section
)
2634 if ((*bed
->elf_backend_section_from_bfd_section
)
2635 (abfd
, hdr
, asect
, &retval
))
2645 /* given a symbol, return the bfd index for that symbol. */
2647 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2649 struct symbol_cache_entry
**asym_ptr_ptr
;
2651 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2653 flagword flags
= asym_ptr
->flags
;
2655 /* When gas creates relocations against local labels, it creates its
2656 own symbol for the section, but does put the symbol into the
2657 symbol chain, so udata is 0. When the linker is generating
2658 relocatable output, this section symbol may be for one of the
2659 input sections rather than the output section. */
2660 if (asym_ptr
->udata
== (PTR
) 0
2661 && (flags
& BSF_SECTION_SYM
)
2662 && asym_ptr
->section
)
2666 if (asym_ptr
->section
->output_section
!= NULL
)
2667 indx
= asym_ptr
->section
->output_section
->index
;
2669 indx
= asym_ptr
->section
->index
;
2670 if (elf_section_syms (abfd
)[indx
])
2671 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2674 if (asym_ptr
->udata
)
2675 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2685 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2686 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2695 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2697 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2700 Elf_Internal_Shdr
*hdr
;
2701 long symcount
; /* Number of external ELF symbols */
2702 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2703 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2704 Elf_Internal_Sym i_sym
;
2705 Elf_External_Sym
*x_symp
= NULL
;
2707 /* Read each raw ELF symbol, converting from external ELF form to
2708 internal ELF form, and then using the information to create a
2709 canonical bfd symbol table entry.
2711 Note that we allocate the initial bfd canonical symbol buffer
2712 based on a one-to-one mapping of the ELF symbols to canonical
2713 symbols. We actually use all the ELF symbols, so there will be no
2714 space left over at the end. When we have all the symbols, we
2715 build the caller's pointer vector. */
2718 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2720 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2721 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2724 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2727 sym
= symbase
= NULL
;
2732 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2735 symbase
= ((elf_symbol_type
*)
2736 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2737 if (symbase
== (elf_symbol_type
*) NULL
)
2739 bfd_set_error (bfd_error_no_memory
);
2744 /* Temporarily allocate room for the raw ELF symbols. */
2745 x_symp
= ((Elf_External_Sym
*)
2746 malloc (symcount
* sizeof (Elf_External_Sym
)));
2747 if (x_symp
== NULL
&& symcount
!= 0)
2749 bfd_set_error (bfd_error_no_memory
);
2753 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2754 != symcount
* sizeof (Elf_External_Sym
))
2756 /* Skip first symbol, which is a null dummy. */
2757 for (i
= 1; i
< symcount
; i
++)
2759 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2760 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2761 #ifdef ELF_KEEP_EXTSYM
2762 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2764 sym
->symbol
.the_bfd
= abfd
;
2766 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2769 sym
->symbol
.value
= i_sym
.st_value
;
2771 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2773 sym
->symbol
.section
= section_from_elf_index (abfd
,
2775 if (sym
->symbol
.section
== NULL
)
2777 /* This symbol is in a section for which we did not
2778 create a BFD section. Just use bfd_abs_section,
2779 although it is wrong. FIXME. */
2780 sym
->symbol
.section
= bfd_abs_section_ptr
;
2783 else if (i_sym
.st_shndx
== SHN_ABS
)
2785 sym
->symbol
.section
= bfd_abs_section_ptr
;
2787 else if (i_sym
.st_shndx
== SHN_COMMON
)
2789 sym
->symbol
.section
= bfd_com_section_ptr
;
2790 /* Elf puts the alignment into the `value' field, and
2791 the size into the `size' field. BFD wants to see the
2792 size in the value field, and doesn't care (at the
2793 moment) about the alignment. */
2794 sym
->symbol
.value
= i_sym
.st_size
;
2796 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2798 sym
->symbol
.section
= bfd_und_section_ptr
;
2801 sym
->symbol
.section
= bfd_abs_section_ptr
;
2803 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2805 switch (ELF_ST_BIND (i_sym
.st_info
))
2808 sym
->symbol
.flags
|= BSF_LOCAL
;
2811 sym
->symbol
.flags
|= BSF_GLOBAL
;
2814 sym
->symbol
.flags
|= BSF_WEAK
;
2818 switch (ELF_ST_TYPE (i_sym
.st_info
))
2821 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2824 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2827 sym
->symbol
.flags
|= BSF_FUNCTION
;
2832 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2834 /* Do some backend-specific processing on this symbol. */
2836 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2837 if (ebd
->elf_backend_symbol_processing
)
2838 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2845 /* Do some backend-specific processing on this symbol table. */
2847 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2848 if (ebd
->elf_backend_symbol_table_processing
)
2849 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2852 /* We rely on the zalloc to clear out the final symbol entry. */
2854 symcount
= sym
- symbase
;
2856 /* Fill in the user's symbol pointer vector if needed. */
2864 *symptrs
++ = &sym
->symbol
;
2867 *symptrs
= 0; /* Final null pointer */
2879 /* Return the number of bytes required to hold the symtab vector.
2881 Note that we base it on the count plus 1, since we will null terminate
2882 the vector allocated based on this size. However, the ELF symbol table
2883 always has a dummy entry as symbol #0, so it ends up even. */
2886 elf_get_symtab_upper_bound (abfd
)
2891 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2893 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2894 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2900 elf_get_dynamic_symtab_upper_bound (abfd
)
2905 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2907 if (elf_dynsymtab (abfd
) == 0)
2909 bfd_set_error (bfd_error_invalid_operation
);
2913 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2914 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2920 elf_get_reloc_upper_bound (abfd
, asect
)
2924 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2927 /* Read in and swap the external relocs. */
2930 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2935 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2936 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2937 PTR allocated
= NULL
;
2938 bfd_byte
*native_relocs
;
2944 if (asect
->relocation
!= NULL
2945 || (asect
->flags
& SEC_RELOC
) == 0
2946 || asect
->reloc_count
== 0)
2949 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2950 && (asect
->reloc_count
2951 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2953 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2954 if (allocated
== NULL
)
2956 bfd_set_error (bfd_error_no_memory
);
2960 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2961 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2962 != d
->rel_hdr
.sh_size
))
2965 native_relocs
= (bfd_byte
*) allocated
;
2967 relents
= ((arelent
*)
2968 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2969 if (relents
== NULL
)
2971 bfd_set_error (bfd_error_no_memory
);
2975 entsize
= d
->rel_hdr
.sh_entsize
;
2976 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2977 || entsize
== sizeof (Elf_External_Rela
));
2979 for (i
= 0, relent
= relents
;
2980 i
< asect
->reloc_count
;
2981 i
++, relent
++, native_relocs
+= entsize
)
2983 Elf_Internal_Rela rela
;
2984 Elf_Internal_Rel rel
;
2986 if (entsize
== sizeof (Elf_External_Rela
))
2987 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2990 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2991 rela
.r_offset
= rel
.r_offset
;
2992 rela
.r_info
= rel
.r_info
;
2996 /* The address of an ELF reloc is section relative for an object
2997 file, and absolute for an executable file or shared library.
2998 The address of a BFD reloc is always section relative. */
2999 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3000 relent
->address
= rela
.r_offset
;
3002 relent
->address
= rela
.r_offset
- asect
->vma
;
3004 if (ELF_R_SYM (rela
.r_info
) == 0)
3005 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3010 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
3013 /* Canonicalize ELF section symbols. FIXME: Why? */
3014 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3015 relent
->sym_ptr_ptr
= ps
;
3017 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3020 relent
->addend
= rela
.r_addend
;
3022 if (entsize
== sizeof (Elf_External_Rela
))
3023 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3025 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3028 asect
->relocation
= relents
;
3030 if (allocated
!= NULL
)
3036 if (allocated
!= NULL
)
3043 elf_debug_section (str
, num
, hdr
)
3046 Elf_Internal_Shdr
*hdr
;
3048 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3050 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3051 (long) hdr
->sh_name
,
3052 (long) hdr
->sh_type
,
3053 (long) hdr
->sh_flags
);
3055 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3056 (long) hdr
->sh_addr
,
3057 (long) hdr
->sh_offset
,
3058 (long) hdr
->sh_size
);
3060 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3061 (long) hdr
->sh_link
,
3062 (long) hdr
->sh_info
,
3063 (long) hdr
->sh_addralign
);
3064 fprintf (stderr
, "sh_entsize = %ld\n",
3065 (long) hdr
->sh_entsize
);
3066 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3067 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3068 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3073 elf_debug_file (ehdrp
)
3074 Elf_Internal_Ehdr
*ehdrp
;
3076 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3077 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3078 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3079 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3080 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3081 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3082 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3086 /* Canonicalize the relocs. */
3089 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3098 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3101 tblptr
= section
->relocation
;
3102 for (i
= 0; i
< section
->reloc_count
; i
++)
3103 *relptr
++ = tblptr
++;
3107 return section
->reloc_count
;
3111 elf_get_symtab (abfd
, alocation
)
3113 asymbol
**alocation
;
3115 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3118 bfd_get_symcount (abfd
) = symcount
;
3123 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3125 asymbol
**alocation
;
3127 return elf_slurp_symbol_table (abfd
, alocation
, true);
3131 elf_make_empty_symbol (abfd
)
3134 elf_symbol_type
*newsym
;
3136 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3139 bfd_set_error (bfd_error_no_memory
);
3144 newsym
->symbol
.the_bfd
= abfd
;
3145 return &newsym
->symbol
;
3150 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3155 bfd_symbol_info (symbol
, ret
);
3159 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3163 bfd_print_symbol_type how
;
3165 FILE *file
= (FILE *) filep
;
3168 case bfd_print_symbol_name
:
3169 fprintf (file
, "%s", symbol
->name
);
3171 case bfd_print_symbol_more
:
3172 fprintf (file
, "elf ");
3173 fprintf_vma (file
, symbol
->value
);
3174 fprintf (file
, " %lx", (long) symbol
->flags
);
3176 case bfd_print_symbol_all
:
3178 CONST
char *section_name
;
3179 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3180 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3181 fprintf (file
, " %s\t%s",
3191 elf_get_lineno (ignore_abfd
, symbol
)
3195 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3202 elf_set_arch_mach (abfd
, arch
, machine
)
3204 enum bfd_architecture arch
;
3205 unsigned long machine
;
3207 /* If this isn't the right architecture for this backend, and this
3208 isn't the generic backend, fail. */
3209 if (arch
!= get_elf_backend_data (abfd
)->arch
3210 && arch
!= bfd_arch_unknown
3211 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3214 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3218 elf_find_nearest_line (abfd
,
3229 CONST
char **filename_ptr
;
3230 CONST
char **functionname_ptr
;
3231 unsigned int *line_ptr
;
3237 elf_sizeof_headers (abfd
, reloc
)
3243 ret
= sizeof (Elf_External_Ehdr
);
3245 ret
+= get_program_header_size (abfd
);
3250 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3255 bfd_size_type count
;
3257 Elf_Internal_Shdr
*hdr
;
3259 if (! abfd
->output_has_begun
3260 && ! elf_compute_section_file_positions (abfd
,
3261 (struct bfd_link_info
*) NULL
))
3264 hdr
= &elf_section_data (section
)->this_hdr
;
3266 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3268 if (bfd_write (location
, 1, count
, abfd
) != count
)
3275 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3278 Elf_Internal_Rela
*dst
;
3280 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3286 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3289 Elf_Internal_Rel
*dst
;
3291 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3297 /* Core file support */
3299 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3300 #include <sys/procfs.h>
3302 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3303 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3304 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3310 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3317 prstatus_t
*status
= (prstatus_t
*) 0;
3319 if (descsz
== sizeof (prstatus_t
))
3321 newsect
= bfd_make_section (abfd
, ".reg");
3322 if (newsect
== NULL
)
3324 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3325 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3326 newsect
->flags
= SEC_HAS_CONTENTS
;
3327 newsect
->alignment_power
= 2;
3328 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3330 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3336 /* Stash a copy of the prpsinfo structure away for future use. */
3339 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3345 if (descsz
== sizeof (prpsinfo_t
))
3347 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3349 bfd_set_error (bfd_error_no_memory
);
3352 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3358 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3366 newsect
= bfd_make_section (abfd
, ".reg2");
3367 if (newsect
== NULL
)
3369 newsect
->_raw_size
= descsz
;
3370 newsect
->filepos
= filepos
;
3371 newsect
->flags
= SEC_HAS_CONTENTS
;
3372 newsect
->alignment_power
= 2;
3376 #endif /* HAVE_PROCFS */
3378 /* Return a pointer to the args (including the command name) that were
3379 seen by the program that generated the core dump. Note that for
3380 some reason, a spurious space is tacked onto the end of the args
3381 in some (at least one anyway) implementations, so strip it off if
3385 elf_core_file_failing_command (abfd
)
3389 if (core_prpsinfo (abfd
))
3391 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3392 char *scan
= p
->pr_psargs
;
3397 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3401 return p
->pr_psargs
;
3407 /* Return the number of the signal that caused the core dump. Presumably,
3408 since we have a core file, we got a signal of some kind, so don't bother
3409 checking the other process status fields, just return the signal number.
3413 elf_core_file_failing_signal (abfd
)
3417 if (core_prstatus (abfd
))
3419 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3425 /* Check to see if the core file could reasonably be expected to have
3426 come for the current executable file. Note that by default we return
3427 true unless we find something that indicates that there might be a
3432 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3441 /* First, xvecs must match since both are ELF files for the same target. */
3443 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3445 bfd_set_error (bfd_error_system_call
);
3451 /* If no prpsinfo, just return true. Otherwise, grab the last component
3452 of the exec'd pathname from the prpsinfo. */
3454 if (core_prpsinfo (core_bfd
))
3456 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3463 /* Find the last component of the executable pathname. */
3465 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3471 execname
= (char *) exec_bfd
->filename
;
3474 /* See if they match */
3476 return strcmp (execname
, corename
) ? false : true;
3482 #endif /* HAVE_PROCFS */
3485 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3486 the information that would normally be available from the /proc interface
3487 for the process, at the time the process dumped core. Currently this
3488 includes copies of the prstatus, prpsinfo, and fpregset structures.
3490 Since these structures are potentially machine dependent in size and
3491 ordering, bfd provides two levels of support for them. The first level,
3492 available on all machines since it does not require that the host
3493 have /proc support or the relevant include files, is to create a bfd
3494 section for each of the prstatus, prpsinfo, and fpregset structures,
3495 without any interpretation of their contents. With just this support,
3496 the bfd client will have to interpret the structures itself. Even with
3497 /proc support, it might want these full structures for it's own reasons.
3499 In the second level of support, where HAVE_PROCFS is defined, bfd will
3500 pick apart the structures to gather some additional information that
3501 clients may want, such as the general register set, the name of the
3502 exec'ed file and its arguments, the signal (if any) that caused the
3508 elf_corefile_note (abfd
, hdr
)
3510 Elf_Internal_Phdr
*hdr
;
3512 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3513 Elf_Internal_Note i_note
; /* Elf note, internal form */
3514 char *buf
= NULL
; /* Entire note segment contents */
3515 char *namedata
; /* Name portion of the note */
3516 char *descdata
; /* Descriptor portion of the note */
3517 char *sectname
; /* Name to use for new section */
3518 long filepos
; /* File offset to descriptor data */
3521 if (hdr
->p_filesz
> 0
3522 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3523 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3524 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3526 x_note_p
= (Elf_External_Note
*) buf
;
3527 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3529 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3530 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3531 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3532 namedata
= x_note_p
->name
;
3533 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3534 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3535 switch (i_note
.type
)
3538 /* process descdata as prstatus info */
3539 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3541 sectname
= ".prstatus";
3544 /* process descdata as fpregset info */
3545 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3547 sectname
= ".fpregset";
3550 /* process descdata as prpsinfo */
3551 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3553 sectname
= ".prpsinfo";
3556 /* Unknown descriptor, just ignore it. */
3560 if (sectname
!= NULL
)
3562 newsect
= bfd_make_section (abfd
, sectname
);
3563 if (newsect
== NULL
)
3565 newsect
->_raw_size
= i_note
.descsz
;
3566 newsect
->filepos
= filepos
;
3567 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3568 newsect
->alignment_power
= 2;
3570 x_note_p
= (Elf_External_Note
*)
3571 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3578 else if (hdr
->p_filesz
> 0)
3580 bfd_set_error (bfd_error_no_memory
);
3587 /* Core files are simply standard ELF formatted files that partition
3588 the file using the execution view of the file (program header table)
3589 rather than the linking view. In fact, there is no section header
3590 table in a core file.
3592 The process status information (including the contents of the general
3593 register set) and the floating point register set are stored in a
3594 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3595 that allow standard bfd access to the general registers (.reg) and the
3596 floating point registers (.reg2).
3601 elf_core_file_p (abfd
)
3604 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3605 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3606 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3607 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3608 unsigned int phindex
;
3609 struct elf_backend_data
*ebd
;
3611 /* Read in the ELF header in external format. */
3613 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3615 if (bfd_get_error () != bfd_error_system_call
)
3616 bfd_set_error (bfd_error_wrong_format
);
3620 /* Now check to see if we have a valid ELF file, and one that BFD can
3621 make use of. The magic number must match, the address size ('class')
3622 and byte-swapping must match our XVEC entry, and it must have a
3623 program header table (FIXME: See comments re segments at top of this
3626 if (elf_file_p (&x_ehdr
) == false)
3629 bfd_set_error (bfd_error_wrong_format
);
3633 /* FIXME, Check EI_VERSION here ! */
3637 int desired_address_size
= ELFCLASS32
;
3640 int desired_address_size
= ELFCLASS64
;
3643 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3647 /* Switch xvec to match the specified byte order. */
3648 switch (x_ehdr
.e_ident
[EI_DATA
])
3650 case ELFDATA2MSB
: /* Big-endian */
3651 if (abfd
->xvec
->byteorder_big_p
== false)
3654 case ELFDATA2LSB
: /* Little-endian */
3655 if (abfd
->xvec
->byteorder_big_p
== true)
3658 case ELFDATANONE
: /* No data encoding specified */
3659 default: /* Unknown data encoding specified */
3663 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3664 the tdata pointer in the bfd. */
3667 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3668 if (elf_tdata (abfd
) == NULL
)
3670 bfd_set_error (bfd_error_no_memory
);
3674 /* FIXME, `wrong' returns from this point onward, leak memory. */
3676 /* Now that we know the byte order, swap in the rest of the header */
3677 i_ehdrp
= elf_elfheader (abfd
);
3678 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3680 elf_debug_file (i_ehdrp
);
3683 ebd
= get_elf_backend_data (abfd
);
3685 /* Check that the ELF e_machine field matches what this particular
3686 BFD format expects. */
3687 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3689 const bfd_target
* const *target_ptr
;
3691 if (ebd
->elf_machine_code
!= EM_NONE
)
3694 /* This is the generic ELF target. Let it match any ELF target
3695 for which we do not have a specific backend. */
3696 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3698 struct elf_backend_data
*back
;
3700 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3702 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3703 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3705 /* target_ptr is an ELF backend which matches this
3706 object file, so reject the generic ELF target. */
3712 /* If there is no program header, or the type is not a core file, then
3714 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3717 /* Allocate space for a copy of the program header table in
3718 internal form, seek to the program header table in the file,
3719 read it in, and convert it to internal form. As a simple sanity
3720 check, verify that the what BFD thinks is the size of each program
3721 header table entry actually matches the size recorded in the file. */
3723 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3725 i_phdrp
= (Elf_Internal_Phdr
*)
3726 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3729 bfd_set_error (bfd_error_no_memory
);
3732 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3734 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3736 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3739 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3742 /* Once all of the program headers have been read and converted, we
3743 can start processing them. */
3745 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3747 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3748 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3750 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3755 /* Remember the entry point specified in the ELF file header. */
3757 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3762 /* ELF linker code. */
3764 static boolean elf_link_add_object_symbols
3765 PARAMS ((bfd
*, struct bfd_link_info
*));
3766 static boolean elf_link_add_archive_symbols
3767 PARAMS ((bfd
*, struct bfd_link_info
*));
3768 static Elf_Internal_Rela
*elf_link_read_relocs
3769 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3770 static boolean elf_adjust_dynamic_symbol
3771 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3773 /* Given an ELF BFD, add symbols to the global hash table as
3777 elf_bfd_link_add_symbols (abfd
, info
)
3779 struct bfd_link_info
*info
;
3781 switch (bfd_get_format (abfd
))
3784 return elf_link_add_object_symbols (abfd
, info
);
3786 return elf_link_add_archive_symbols (abfd
, info
);
3788 bfd_set_error (bfd_error_wrong_format
);
3793 /* Add symbols from an ELF archive file to the linker hash table. We
3794 don't use _bfd_generic_link_add_archive_symbols because of a
3795 problem which arises on UnixWare. The UnixWare libc.so is an
3796 archive which includes an entry libc.so.1 which defines a bunch of
3797 symbols. The libc.so archive also includes a number of other
3798 object files, which also define symbols, some of which are the same
3799 as those defined in libc.so.1. Correct linking requires that we
3800 consider each object file in turn, and include it if it defines any
3801 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3802 this; it looks through the list of undefined symbols, and includes
3803 any object file which defines them. When this algorithm is used on
3804 UnixWare, it winds up pulling in libc.so.1 early and defining a
3805 bunch of symbols. This means that some of the other objects in the
3806 archive are not included in the link, which is incorrect since they
3807 precede libc.so.1 in the archive.
3809 Fortunately, ELF archive handling is simpler than that done by
3810 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3811 oddities. In ELF, if we find a symbol in the archive map, and the
3812 symbol is currently undefined, we know that we must pull in that
3815 Unfortunately, we do have to make multiple passes over the symbol
3816 table until nothing further is resolved. */
3819 elf_link_add_archive_symbols (abfd
, info
)
3821 struct bfd_link_info
*info
;
3824 boolean
*defined
= NULL
;
3825 boolean
*included
= NULL
;
3829 if (! bfd_has_map (abfd
))
3831 bfd_set_error (bfd_error_no_symbols
);
3835 /* Keep track of all symbols we know to be already defined, and all
3836 files we know to be already included. This is to speed up the
3837 second and subsequent passes. */
3838 c
= bfd_ardata (abfd
)->symdef_count
;
3841 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3842 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3843 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3845 bfd_set_error (bfd_error_no_memory
);
3848 memset (defined
, 0, c
* sizeof (boolean
));
3849 memset (included
, 0, c
* sizeof (boolean
));
3851 symdefs
= bfd_ardata (abfd
)->symdefs
;
3864 symdefend
= symdef
+ c
;
3865 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3867 struct elf_link_hash_entry
*h
;
3869 struct bfd_link_hash_entry
*undefs_tail
;
3872 if (defined
[i
] || included
[i
])
3874 if (symdef
->file_offset
== last
)
3880 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3881 false, false, false);
3882 if (h
== (struct elf_link_hash_entry
*) NULL
)
3884 if (h
->root
.type
!= bfd_link_hash_undefined
)
3890 /* We need to include this archive member. */
3892 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3893 if (element
== (bfd
*) NULL
)
3896 if (! bfd_check_format (element
, bfd_object
))
3899 /* Doublecheck that we have not included this object
3900 already--it should be impossible, but there may be
3901 something wrong with the archive. */
3902 if (element
->archive_pass
!= 0)
3904 bfd_set_error (bfd_error_bad_value
);
3907 element
->archive_pass
= 1;
3909 undefs_tail
= info
->hash
->undefs_tail
;
3911 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3914 if (! elf_link_add_object_symbols (element
, info
))
3917 /* If there are any new undefined symbols, we need to make
3918 another pass through the archive in order to see whether
3919 they can be defined. FIXME: This isn't perfect, because
3920 common symbols wind up on undefs_tail and because an
3921 undefined symbol which is defined later on in this pass
3922 does not require another pass. This isn't a bug, but it
3923 does make the code less efficient than it could be. */
3924 if (undefs_tail
!= info
->hash
->undefs_tail
)
3927 /* Look backward to mark all symbols from this object file
3928 which we have already seen in this pass. */
3932 included
[mark
] = true;
3937 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3939 /* We mark subsequent symbols from this object file as we go
3940 on through the loop. */
3941 last
= symdef
->file_offset
;
3952 if (defined
!= (boolean
*) NULL
)
3954 if (included
!= (boolean
*) NULL
)
3959 /* Record a new dynamic symbol. We record the dynamic symbols as we
3960 read the input files, since we need to have a list of all of them
3961 before we can determine the final sizes of the output sections. */
3964 elf_link_record_dynamic_symbol (info
, h
)
3965 struct bfd_link_info
*info
;
3966 struct elf_link_hash_entry
*h
;
3968 if (h
->dynindx
== -1)
3970 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3971 ++elf_hash_table (info
)->dynsymcount
;
3972 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3973 elf_hash_table (info
)->dynstr
,
3974 h
->root
.root
.string
);
3975 if (h
->dynstr_index
== (unsigned long) -1)
3982 /* Add symbols from an ELF object file to the linker hash table. */
3985 elf_link_add_object_symbols (abfd
, info
)
3987 struct bfd_link_info
*info
;
3989 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3990 const Elf_Internal_Sym
*,
3991 const char **, flagword
*,
3992 asection
**, bfd_vma
*));
3993 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3994 asection
*, const Elf_Internal_Rela
*));
3996 Elf_Internal_Shdr
*hdr
;
4000 Elf_External_Sym
*buf
= NULL
;
4001 struct elf_link_hash_entry
**sym_hash
;
4003 Elf_External_Dyn
*dynbuf
= NULL
;
4004 struct elf_link_hash_entry
*weaks
;
4005 Elf_External_Sym
*esym
;
4006 Elf_External_Sym
*esymend
;
4008 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4009 collect
= get_elf_backend_data (abfd
)->collect
;
4011 /* A stripped shared library might only have a dynamic symbol table,
4012 not a regular symbol table. In that case we can still go ahead
4013 and link using the dynamic symbol table. */
4014 if (elf_onesymtab (abfd
) == 0
4015 && elf_dynsymtab (abfd
) != 0)
4017 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
4018 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
4021 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4022 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4024 /* The sh_info field of the symtab header tells us where the
4025 external symbols start. We don't care about the local symbols at
4027 if (elf_bad_symtab (abfd
))
4029 extsymcount
= symcount
;
4034 extsymcount
= symcount
- hdr
->sh_info
;
4035 extsymoff
= hdr
->sh_info
;
4038 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4039 if (buf
== NULL
&& extsymcount
!= 0)
4041 bfd_set_error (bfd_error_no_memory
);
4045 /* We store a pointer to the hash table entry for each external
4047 sym_hash
= ((struct elf_link_hash_entry
**)
4049 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4050 if (sym_hash
== NULL
)
4052 bfd_set_error (bfd_error_no_memory
);
4055 elf_sym_hashes (abfd
) = sym_hash
;
4057 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4061 /* If we are creating a shared library, create all the dynamic
4062 sections immediately. We need to attach them to something,
4063 so we attach them to this BFD, provided it is the right
4064 format. FIXME: If there are no input BFD's of the same
4065 format as the output, we can't make a shared library. */
4067 && elf_hash_table (info
)->dynobj
== NULL
4068 && abfd
->xvec
== info
->hash
->creator
)
4070 if (! elf_link_create_dynamic_sections (abfd
, info
))
4072 elf_hash_table (info
)->dynobj
= abfd
;
4079 unsigned long strindex
;
4083 /* You can't use -r against a dynamic object. Also, there's no
4084 hope of using a dynamic object which does not exactly match
4085 the format of the output file. */
4086 if (info
->relocateable
4087 || info
->hash
->creator
!= abfd
->xvec
)
4089 bfd_set_error (bfd_error_invalid_operation
);
4093 /* Find the name to use in a DT_NEEDED entry that refers to this
4094 object. If the object has a DT_SONAME entry, we use it.
4095 Otherwise, if the generic linker stuck something in
4096 elf_dt_needed_name, we use that. Otherwise, we just use the
4098 name
= bfd_get_filename (abfd
);
4099 if (elf_dt_needed_name (abfd
) != NULL
)
4100 name
= elf_dt_needed_name (abfd
);
4101 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4104 Elf_External_Dyn
*extdyn
;
4105 Elf_External_Dyn
*extdynend
;
4107 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4110 bfd_set_error (bfd_error_no_memory
);
4114 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4115 (file_ptr
) 0, s
->_raw_size
))
4119 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4120 for (; extdyn
< extdynend
; extdyn
++)
4122 Elf_Internal_Dyn dyn
;
4124 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4125 if (dyn
.d_tag
== DT_SONAME
)
4130 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4133 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4134 name
= elf_string_from_elf_section (abfd
, link
,
4147 /* We do not want to include any of the sections in a dynamic
4148 object in the output file. We hack by simply clobbering the
4149 list of sections in the BFD. This could be handled more
4150 cleanly by, say, a new section flag; the existing
4151 SEC_NEVER_LOAD flag is not the one we want, because that one
4152 still implies that the section takes up space in the output
4154 abfd
->sections
= NULL
;
4156 /* If this is the first dynamic object found in the link, create
4157 the special sections required for dynamic linking. We need
4158 to put them somewhere, and attaching them to the first
4159 dynamic object is as good place as any. */
4160 if (elf_hash_table (info
)->dynobj
== NULL
)
4162 if (! elf_link_create_dynamic_sections (abfd
, info
))
4164 elf_hash_table (info
)->dynobj
= abfd
;
4167 /* Add a DT_NEEDED entry for this dynamic object. */
4168 strindex
= bfd_add_to_strtab (abfd
,
4169 elf_hash_table (info
)->dynstr
,
4171 if (strindex
== (unsigned long) -1)
4173 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4178 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4180 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4181 != extsymcount
* sizeof (Elf_External_Sym
)))
4186 esymend
= buf
+ extsymcount
;
4187 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4189 Elf_Internal_Sym sym
;
4195 struct elf_link_hash_entry
*h
= NULL
;
4198 elf_swap_symbol_in (abfd
, esym
, &sym
);
4200 flags
= BSF_NO_FLAGS
;
4202 value
= sym
.st_value
;
4205 bind
= ELF_ST_BIND (sym
.st_info
);
4206 if (bind
== STB_LOCAL
)
4208 /* This should be impossible, since ELF requires that all
4209 global symbols follow all local symbols, and that sh_info
4210 point to the first global symbol. Unfortunatealy, Irix 5
4214 else if (bind
== STB_GLOBAL
)
4216 else if (bind
== STB_WEAK
)
4220 /* Leave it up to the processor backend. */
4223 if (sym
.st_shndx
== SHN_UNDEF
)
4224 sec
= bfd_und_section_ptr
;
4225 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4227 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4232 else if (sym
.st_shndx
== SHN_ABS
)
4233 sec
= bfd_abs_section_ptr
;
4234 else if (sym
.st_shndx
== SHN_COMMON
)
4236 sec
= bfd_com_section_ptr
;
4237 /* What ELF calls the size we call the value. What ELF
4238 calls the value we call the alignment. */
4239 value
= sym
.st_size
;
4243 /* Leave it up to the processor backend. */
4246 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4247 if (name
== (const char *) NULL
)
4250 if (add_symbol_hook
)
4252 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4256 /* The hook function sets the name to NULL if this symbol
4257 should be skipped for some reason. */
4258 if (name
== (const char *) NULL
)
4262 /* Sanity check that all possibilities were handled. */
4263 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4265 bfd_set_error (bfd_error_bad_value
);
4269 if (bfd_is_und_section (sec
)
4270 || bfd_is_com_section (sec
))
4275 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4277 /* We need to look up the symbol now in order to get some of
4278 the dynamic object handling right. We pass the hash
4279 table entry in to _bfd_generic_link_add_one_symbol so
4280 that it does not have to look it up again. */
4281 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4282 true, false, false);
4287 /* If we are looking at a dynamic object, and this is a
4288 definition, we need to see if it has already been defined
4289 by some other object. If it has, we want to use the
4290 existing definition, and we do not want to report a
4291 multiple symbol definition error; we do this by
4292 clobbering sec to be bfd_und_section_ptr. */
4293 if (dynamic
&& definition
)
4295 if (h
->root
.type
== bfd_link_hash_defined
)
4296 sec
= bfd_und_section_ptr
;
4299 /* Similarly, if we are not looking at a dynamic object, and
4300 we have a definition, we want to override any definition
4301 we may have from a dynamic object. Symbols from regular
4302 files always take precedence over symbols from dynamic
4303 objects, even if they are defined after the dynamic
4304 object in the link. */
4307 && h
->root
.type
== bfd_link_hash_defined
4308 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4309 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4310 == bfd_target_elf_flavour
)
4311 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4314 /* Change the hash table entry to undefined, and let
4315 _bfd_generic_link_add_one_symbol do the right thing
4316 with the new definition. */
4317 h
->root
.type
= bfd_link_hash_undefined
;
4318 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4319 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4322 /* If this is a weak definition which we are going to use,
4323 and the symbol is currently undefined, record that the
4324 definition is weak. */
4326 && (flags
& BSF_WEAK
) != 0
4327 && ! bfd_is_und_section (sec
)
4328 && (h
->root
.type
== bfd_link_hash_new
4329 || h
->root
.type
== bfd_link_hash_undefined
4330 || h
->root
.type
== bfd_link_hash_weak
))
4331 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4334 if (! (_bfd_generic_link_add_one_symbol
4335 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4336 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4341 && (flags
& BSF_WEAK
) != 0
4342 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4343 && (*sym_hash
)->weakdef
== NULL
)
4345 /* Keep a list of all weak defined non function symbols from
4346 a dynamic object, using the weakdef field. Later in this
4347 function we will set the weakdef field to the correct
4348 value. We only put non-function symbols from dynamic
4349 objects on this list, because that happens to be the only
4350 time we need to know the normal symbol corresponding to a
4351 weak symbol, and the information is time consuming to
4352 figure out. If the weakdef field is not already NULL,
4353 then this symbol was already defined by some previous
4354 dynamic object, and we will be using that previous
4355 definition anyhow. */
4357 (*sym_hash
)->weakdef
= weaks
;
4361 /* Get the alignment of a common symbol. */
4362 if (sym
.st_shndx
== SHN_COMMON
4363 && h
->root
.type
== bfd_link_hash_common
)
4364 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4366 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4372 /* Remember the symbol size and type. */
4373 if (sym
.st_size
!= 0)
4375 /* FIXME: We should probably somehow give a warning if
4376 the symbol size changes. */
4377 h
->size
= sym
.st_size
;
4379 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4381 /* FIXME: We should probably somehow give a warning if
4382 the symbol type changes. */
4383 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4386 /* Set a flag in the hash table entry indicating the type of
4387 reference or definition we just found. Keep a count of
4388 the number of dynamic symbols we find. A dynamic symbol
4389 is one which is referenced or defined by both a regular
4390 object and a shared object, or one which is referenced or
4391 defined by more than one shared object. */
4392 old_flags
= h
->elf_link_hash_flags
;
4397 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4399 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4401 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4402 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4408 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4410 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4411 if ((old_flags
& new_flag
) != 0
4412 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4413 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4417 h
->elf_link_hash_flags
|= new_flag
;
4418 if (dynsym
&& h
->dynindx
== -1)
4420 if (! elf_link_record_dynamic_symbol (info
, h
))
4426 /* Now set the weakdefs field correctly for all the weak defined
4427 symbols we found. The only way to do this is to search all the
4428 symbols. Since we only need the information for non functions in
4429 dynamic objects, that's the only time we actually put anything on
4430 the list WEAKS. We need this information so that if a regular
4431 object refers to a symbol defined weakly in a dynamic object, the
4432 real symbol in the dynamic object is also put in the dynamic
4433 symbols; we also must arrange for both symbols to point to the
4434 same memory location. We could handle the general case of symbol
4435 aliasing, but a general symbol alias can only be generated in
4436 assembler code, handling it correctly would be very time
4437 consuming, and other ELF linkers don't handle general aliasing
4439 while (weaks
!= NULL
)
4441 struct elf_link_hash_entry
*hlook
;
4444 struct elf_link_hash_entry
**hpp
;
4445 struct elf_link_hash_entry
**hppend
;
4448 weaks
= hlook
->weakdef
;
4449 hlook
->weakdef
= NULL
;
4451 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4452 slook
= hlook
->root
.u
.def
.section
;
4453 vlook
= hlook
->root
.u
.def
.value
;
4455 hpp
= elf_sym_hashes (abfd
);
4456 hppend
= hpp
+ extsymcount
;
4457 for (; hpp
< hppend
; hpp
++)
4459 struct elf_link_hash_entry
*h
;
4463 && h
->root
.type
== bfd_link_hash_defined
4464 && h
->root
.u
.def
.section
== slook
4465 && h
->root
.u
.def
.value
== vlook
)
4469 /* If the weak definition is in the list of dynamic
4470 symbols, make sure the real definition is put there
4472 if (hlook
->dynindx
!= -1
4473 && h
->dynindx
== -1)
4475 if (! elf_link_record_dynamic_symbol (info
, h
))
4490 /* If this object is the same format as the output object, and it is
4491 not a shared library, then let the backend look through the
4494 This is required to build global offset table entries and to
4495 arrange for dynamic relocs. It is not required for the
4496 particular common case of linking non PIC code, even when linking
4497 against shared libraries, but unfortunately there is no way of
4498 knowing whether an object file has been compiled PIC or not.
4499 Looking through the relocs is not particularly time consuming.
4500 The problem is that we must either (1) keep the relocs in memory,
4501 which causes the linker to require additional runtime memory or
4502 (2) read the relocs twice from the input file, which wastes time.
4503 This would be a good case for using mmap.
4505 I have no idea how to handle linking PIC code into a file of a
4506 different format. It probably can't be done. */
4507 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4509 && abfd
->xvec
== info
->hash
->creator
4510 && check_relocs
!= NULL
)
4514 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4516 Elf_Internal_Rela
*internal_relocs
;
4519 if ((o
->flags
& SEC_RELOC
) == 0
4520 || o
->reloc_count
== 0)
4523 /* I believe we can ignore the relocs for any section which
4524 does not form part of the final process image, such as a
4525 debugging section. */
4526 if ((o
->flags
& SEC_ALLOC
) == 0)
4529 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4530 (Elf_Internal_Rela
*) NULL
,
4532 if (internal_relocs
== NULL
)
4535 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4537 if (! info
->keep_memory
)
4538 free (internal_relocs
);
4555 /* Create some sections which will be filled in with dynamic linking
4556 information. The ABFD argument is an input file which is a dynamic
4557 object. The dynamic sections take up virtual memory space when the
4558 final executable is run, so we need to create them before addresses
4559 are assigned to the output sections. We work out the actual
4560 contents and size of these sections later. */
4563 elf_link_create_dynamic_sections (abfd
, info
)
4565 struct bfd_link_info
*info
;
4568 register asection
*s
;
4569 struct elf_link_hash_entry
*h
;
4570 struct elf_backend_data
*bed
;
4572 /* Note that we set the SEC_IN_MEMORY flag for all of these
4574 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4576 /* A dynamically linked executable has a .interp section, but a
4577 shared library does not. */
4580 s
= bfd_make_section (abfd
, ".interp");
4582 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4586 s
= bfd_make_section (abfd
, ".dynsym");
4588 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4589 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4592 /* The first .dynsym symbol is a dummy. */
4593 elf_hash_table (info
)->dynsymcount
= 1;
4595 s
= bfd_make_section (abfd
, ".dynstr");
4597 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4600 /* Create a strtab to hold the dynamic symbol names. */
4601 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4602 if (elf_hash_table (info
)->dynstr
== NULL
)
4605 s
= bfd_make_section (abfd
, ".dynamic");
4607 || ! bfd_set_section_flags (abfd
, s
, flags
)
4608 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4611 /* The special symbol _DYNAMIC is always set to the start of the
4612 .dynamic section. This call occurs before we have processed the
4613 symbols for any dynamic object, so we don't have to worry about
4614 overriding a dynamic definition. We could set _DYNAMIC in a
4615 linker script, but we only want to define it if we are, in fact,
4616 creating a .dynamic section. We don't want to define it if there
4617 is no .dynamic section, since on some ELF platforms the start up
4618 code examines it to decide how to initialize the process. */
4620 if (! (_bfd_generic_link_add_one_symbol
4621 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4622 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4623 (struct bfd_link_hash_entry
**) &h
)))
4625 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4626 h
->type
= STT_OBJECT
;
4629 && ! elf_link_record_dynamic_symbol (info
, h
))
4632 s
= bfd_make_section (abfd
, ".hash");
4634 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4635 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4638 /* Let the backend create the rest of the sections. This lets the
4639 backend set the right flags. The backend will normally create
4640 the .got and .plt sections. */
4641 bed
= get_elf_backend_data (abfd
);
4642 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4645 /* Add an entry to the .dynamic table. */
4648 elf_add_dynamic_entry (info
, tag
, val
)
4649 struct bfd_link_info
*info
;
4653 Elf_Internal_Dyn dyn
;
4657 bfd_byte
*newcontents
;
4659 dynobj
= elf_hash_table (info
)->dynobj
;
4661 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4662 BFD_ASSERT (s
!= NULL
);
4664 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4665 if (s
->contents
== NULL
)
4666 newcontents
= (bfd_byte
*) malloc (newsize
);
4668 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4669 if (newcontents
== NULL
)
4671 bfd_set_error (bfd_error_no_memory
);
4676 dyn
.d_un
.d_val
= val
;
4677 elf_swap_dyn_out (dynobj
, &dyn
,
4678 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4680 s
->_raw_size
= newsize
;
4681 s
->contents
= newcontents
;
4686 /* Read and swap the relocs for a section. They may have been cached.
4687 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4688 they are used as buffers to read into. They are known to be large
4689 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4690 value is allocated using either malloc or bfd_alloc, according to
4691 the KEEP_MEMORY argument. */
4693 static Elf_Internal_Rela
*
4694 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4697 PTR external_relocs
;
4698 Elf_Internal_Rela
*internal_relocs
;
4699 boolean keep_memory
;
4701 Elf_Internal_Shdr
*rel_hdr
;
4703 Elf_Internal_Rela
*alloc2
= NULL
;
4705 if (elf_section_data (o
)->relocs
!= NULL
)
4706 return elf_section_data (o
)->relocs
;
4708 if (o
->reloc_count
== 0)
4711 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4713 if (internal_relocs
== NULL
)
4717 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4719 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4721 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4722 if (internal_relocs
== NULL
)
4724 bfd_set_error (bfd_error_no_memory
);
4729 if (external_relocs
== NULL
)
4731 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4734 bfd_set_error (bfd_error_no_memory
);
4737 external_relocs
= alloc1
;
4740 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4741 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4742 != rel_hdr
->sh_size
))
4745 /* Swap in the relocs. For convenience, we always produce an
4746 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4748 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4750 Elf_External_Rel
*erel
;
4751 Elf_External_Rel
*erelend
;
4752 Elf_Internal_Rela
*irela
;
4754 erel
= (Elf_External_Rel
*) external_relocs
;
4755 erelend
= erel
+ o
->reloc_count
;
4756 irela
= internal_relocs
;
4757 for (; erel
< erelend
; erel
++, irela
++)
4759 Elf_Internal_Rel irel
;
4761 elf_swap_reloc_in (abfd
, erel
, &irel
);
4762 irela
->r_offset
= irel
.r_offset
;
4763 irela
->r_info
= irel
.r_info
;
4764 irela
->r_addend
= 0;
4769 Elf_External_Rela
*erela
;
4770 Elf_External_Rela
*erelaend
;
4771 Elf_Internal_Rela
*irela
;
4773 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4775 erela
= (Elf_External_Rela
*) external_relocs
;
4776 erelaend
= erela
+ o
->reloc_count
;
4777 irela
= internal_relocs
;
4778 for (; erela
< erelaend
; erela
++, irela
++)
4779 elf_swap_reloca_in (abfd
, erela
, irela
);
4782 /* Cache the results for next time, if we can. */
4784 elf_section_data (o
)->relocs
= internal_relocs
;
4789 /* Don't free alloc2, since if it was allocated we are passing it
4790 back (under the name of internal_relocs). */
4792 return internal_relocs
;
4802 /* Record an assignment to a symbol made by a linker script. We need
4803 this in case some dynamic object refers to this symbol. */
4807 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4809 struct bfd_link_info
*info
;
4812 struct elf_link_hash_entry
*h
;
4814 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4818 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4819 h
->type
= STT_OBJECT
;
4821 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4822 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4824 && h
->dynindx
== -1)
4826 if (! elf_link_record_dynamic_symbol (info
, h
))
4829 /* If this is a weak defined symbol, and we know a corresponding
4830 real symbol from the same dynamic object, make sure the real
4831 symbol is also made into a dynamic symbol. */
4832 if (h
->weakdef
!= NULL
4833 && h
->weakdef
->dynindx
== -1)
4835 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4843 /* Array used to determine the number of hash table buckets to use
4844 based on the number of symbols there are. If there are fewer than
4845 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4846 fewer than 37 we use 17 buckets, and so forth. We never use more
4847 than 521 buckets. */
4849 static const size_t elf_buckets
[] =
4851 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4854 /* Set up the sizes and contents of the ELF dynamic sections. This is
4855 called by the ELF linker emulation before_allocation routine. We
4856 must set the sizes of the sections before the linker sets the
4857 addresses of the various sections. */
4860 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, rpath
, info
, sinterpptr
)
4863 struct bfd_link_info
*info
;
4864 asection
**sinterpptr
;
4869 Elf_Internal_Sym isym
;
4872 struct elf_backend_data
*bed
;
4876 dynobj
= elf_hash_table (info
)->dynobj
;
4877 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4879 /* If there were no dynamic objects in the link, there is nothing to
4884 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4885 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4887 /* Set the size of the .dynsym and .hash sections. We counted the
4888 number of dynamic symbols in elf_link_add_object_symbols. We
4889 will build the contents of .dynsym and .hash when we build the
4890 final symbol table, because until then we do not know the correct
4891 value to give the symbols. We built the .dynstr section as we
4892 went along in elf_link_add_object_symbols. */
4893 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4894 BFD_ASSERT (s
!= NULL
);
4895 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4896 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4897 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4899 bfd_set_error (bfd_error_no_memory
);
4903 /* The first entry in .dynsym is a dummy symbol. */
4910 elf_swap_symbol_out (output_bfd
, &isym
,
4911 (Elf_External_Sym
*) s
->contents
);
4913 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4915 bucketcount
= elf_buckets
[i
];
4916 if (dynsymcount
< elf_buckets
[i
+ 1])
4920 s
= bfd_get_section_by_name (dynobj
, ".hash");
4921 BFD_ASSERT (s
!= NULL
);
4922 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4923 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4924 if (s
->contents
== NULL
)
4926 bfd_set_error (bfd_error_no_memory
);
4929 memset (s
->contents
, 0, s
->_raw_size
);
4931 put_word (output_bfd
, bucketcount
, s
->contents
);
4932 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4934 elf_hash_table (info
)->bucketcount
= bucketcount
;
4940 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4941 if (indx
== (unsigned long) -1
4942 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4946 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4947 BFD_ASSERT (s
!= NULL
);
4948 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4949 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4951 /* Find all symbols which were defined in a dynamic object and make
4952 the backend pick a reasonable value for them. */
4953 elf_link_hash_traverse (elf_hash_table (info
),
4954 elf_adjust_dynamic_symbol
,
4957 /* Add some entries to the .dynamic section. We fill in some of the
4958 values later, in elf_bfd_final_link, but we must add the entries
4959 now so that we know the final size of the .dynamic section. */
4960 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4962 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4965 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4967 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4970 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4971 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4972 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4973 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4974 elf_hash_table (info
)->dynstr
->length
)
4975 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4976 sizeof (Elf_External_Sym
)))
4979 /* The backend must work out the sizes of all the other dynamic
4981 bed
= get_elf_backend_data (output_bfd
);
4982 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4985 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4988 /* Make the backend pick a good value for a dynamic symbol. This is
4989 called via elf_link_hash_traverse, and also calls itself
4993 elf_adjust_dynamic_symbol (h
, data
)
4994 struct elf_link_hash_entry
*h
;
4997 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4999 struct elf_backend_data
*bed
;
5001 /* If this symbol is not defined by a dynamic object, or is not
5002 referenced by a regular object, ignore it. FIXME: Do we need to
5003 worry about symbols which are defined by one dynamic object and
5004 referenced by another one? */
5005 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5006 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
5007 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5010 /* If we've already adjusted this symbol, don't do it again. This
5011 can happen via a recursive call. */
5012 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
5015 /* Don't look at this symbol again. Note that we must set this
5016 after checking the above conditions, because we may look at a
5017 symbol once, decide not to do anything, and then get called
5018 recursively later after REF_REGULAR is set below. */
5019 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5021 /* If this is a weak definition, and we know a real definition, and
5022 the real symbol is not itself defined by a regular object file,
5023 then get a good value for the real definition. We handle the
5024 real symbol first, for the convenience of the backend routine.
5026 Note that there is a confusing case here. If the real definition
5027 is defined by a regular object file, we don't get the real symbol
5028 from the dynamic object, but we do get the weak symbol. If the
5029 processor backend uses a COPY reloc, then if some routine in the
5030 dynamic object changes the real symbol, we will not see that
5031 change in the corresponding weak symbol. This is the way other
5032 ELF linkers work as well, and seems to be a result of the shared
5035 I will clarify this issue. Most SVR4 shared libraries define the
5036 variable _timezone and define timezone as a weak synonym. The
5037 tzset call changes _timezone. If you write
5038 extern int timezone;
5040 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5041 you might expect that, since timezone is a synonym for _timezone,
5042 the same number will print both times. However, if the processor
5043 backend uses a COPY reloc, then actually timezone will be copied
5044 into your process image, and, since you define _timezone
5045 yourself, _timezone will not. Thus timezone and _timezone will
5046 wind up at different memory locations. The tzset call will set
5047 _timezone, leaving timezone unchanged. */
5049 if (h
->weakdef
!= NULL
)
5051 struct elf_link_hash_entry
*weakdef
;
5053 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5054 weakdef
= h
->weakdef
;
5055 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5056 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5057 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
5059 /* This symbol is defined by a regular object file, so we
5060 will not do anything special. Clear weakdef for the
5061 convenience of the processor backend. */
5066 /* There is an implicit reference by a regular object file
5067 via the weak symbol. */
5068 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5069 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5074 dynobj
= elf_hash_table (info
)->dynobj
;
5075 bed
= get_elf_backend_data (dynobj
);
5076 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5078 /* FIXME: No way to return error. */
5085 /* Final phase of ELF linker. */
5087 /* A structure we use to avoid passing large numbers of arguments. */
5089 struct elf_final_link_info
5091 /* General link information. */
5092 struct bfd_link_info
*info
;
5095 /* Symbol string table. */
5096 struct strtab
*symstrtab
;
5097 /* .dynsym section. */
5098 asection
*dynsym_sec
;
5099 /* .hash section. */
5101 /* Buffer large enough to hold contents of any section. */
5103 /* Buffer large enough to hold external relocs of any section. */
5104 PTR external_relocs
;
5105 /* Buffer large enough to hold internal relocs of any section. */
5106 Elf_Internal_Rela
*internal_relocs
;
5107 /* Buffer large enough to hold external local symbols of any input
5109 Elf_External_Sym
*external_syms
;
5110 /* Buffer large enough to hold internal local symbols of any input
5112 Elf_Internal_Sym
*internal_syms
;
5113 /* Array large enough to hold a symbol index for each local symbol
5114 of any input BFD. */
5116 /* Array large enough to hold a section pointer for each local
5117 symbol of any input BFD. */
5118 asection
**sections
;
5119 /* Buffer to hold swapped out symbols. */
5120 Elf_External_Sym
*symbuf
;
5121 /* Number of swapped out symbols in buffer. */
5122 size_t symbuf_count
;
5123 /* Number of symbols which fit in symbuf. */
5127 static boolean elf_link_output_sym
5128 PARAMS ((struct elf_final_link_info
*, const char *,
5129 Elf_Internal_Sym
*, asection
*));
5130 static boolean elf_link_flush_output_syms
5131 PARAMS ((struct elf_final_link_info
*));
5132 static boolean elf_link_output_extsym
5133 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5134 static boolean elf_link_input_bfd
5135 PARAMS ((struct elf_final_link_info
*, bfd
*));
5136 static boolean elf_reloc_link_order
5137 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5138 struct bfd_link_order
*));
5140 /* Do the final step of an ELF link. */
5143 elf_bfd_final_link (abfd
, info
)
5145 struct bfd_link_info
*info
;
5148 struct elf_final_link_info finfo
;
5149 register asection
*o
;
5150 register struct bfd_link_order
*p
;
5152 size_t max_contents_size
;
5153 size_t max_external_reloc_size
;
5154 size_t max_internal_reloc_count
;
5155 size_t max_sym_count
;
5157 Elf_Internal_Sym elfsym
;
5159 Elf_Internal_Shdr
*symtab_hdr
;
5160 Elf_Internal_Shdr
*symstrtab_hdr
;
5161 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5164 abfd
->flags
|= DYNAMIC
;
5166 dynobj
= elf_hash_table (info
)->dynobj
;
5169 finfo
.output_bfd
= abfd
;
5170 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5171 if (finfo
.symstrtab
== NULL
)
5175 finfo
.dynsym_sec
= NULL
;
5176 finfo
.hash_sec
= NULL
;
5180 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5181 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5182 if (finfo
.dynsym_sec
== NULL
5183 || finfo
.hash_sec
== NULL
)
5186 finfo
.contents
= NULL
;
5187 finfo
.external_relocs
= NULL
;
5188 finfo
.internal_relocs
= NULL
;
5189 finfo
.external_syms
= NULL
;
5190 finfo
.internal_syms
= NULL
;
5191 finfo
.indices
= NULL
;
5192 finfo
.sections
= NULL
;
5193 finfo
.symbuf
= NULL
;
5194 finfo
.symbuf_count
= 0;
5196 /* Count up the number of relocations we will output for each output
5197 section, so that we know the sizes of the reloc sections. We
5198 also figure out some maximum sizes. */
5199 max_contents_size
= 0;
5200 max_external_reloc_size
= 0;
5201 max_internal_reloc_count
= 0;
5203 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5207 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5209 if (p
->type
== bfd_section_reloc_link_order
5210 || p
->type
== bfd_symbol_reloc_link_order
)
5212 else if (p
->type
== bfd_indirect_link_order
)
5216 sec
= p
->u
.indirect
.section
;
5218 if (info
->relocateable
)
5219 o
->reloc_count
+= sec
->reloc_count
;
5221 if (sec
->_raw_size
> max_contents_size
)
5222 max_contents_size
= sec
->_raw_size
;
5223 if (sec
->_cooked_size
> max_contents_size
)
5224 max_contents_size
= sec
->_cooked_size
;
5226 /* We are interested in just local symbols, not all
5228 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5232 if (elf_bad_symtab (sec
->owner
))
5233 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5234 / sizeof (Elf_External_Sym
));
5236 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5238 if (sym_count
> max_sym_count
)
5239 max_sym_count
= sym_count
;
5241 if ((sec
->flags
& SEC_RELOC
) != 0)
5245 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5246 if (ext_size
> max_external_reloc_size
)
5247 max_external_reloc_size
= ext_size
;
5248 if (sec
->reloc_count
> max_internal_reloc_count
)
5249 max_internal_reloc_count
= sec
->reloc_count
;
5255 if (o
->reloc_count
> 0)
5256 o
->flags
|= SEC_RELOC
;
5259 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5260 set it (this is probably a bug) and if it is set
5261 assign_section_numbers will create a reloc section. */
5262 o
->flags
&=~ SEC_RELOC
;
5265 /* If the SEC_ALLOC flag is not set, force the section VMA to
5266 zero. This is done in elf_fake_sections as well, but forcing
5267 the VMA to 0 here will ensure that relocs against these
5268 sections are handled correctly. */
5269 if ((o
->flags
& SEC_ALLOC
) == 0)
5273 /* Figure out the file positions for everything but the symbol table
5274 and the relocs. We set symcount to force assign_section_numbers
5275 to create a symbol table. */
5276 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5277 BFD_ASSERT (! abfd
->output_has_begun
);
5278 if (! elf_compute_section_file_positions (abfd
, info
))
5281 /* That created the reloc sections. Set their sizes, and assign
5282 them file positions, and allocate some buffers. */
5283 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5285 if ((o
->flags
& SEC_RELOC
) != 0)
5287 Elf_Internal_Shdr
*rel_hdr
;
5288 register struct elf_link_hash_entry
**p
, **pend
;
5290 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5292 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5294 /* The contents field must last into write_object_contents,
5295 so we allocate it with bfd_alloc rather than malloc. */
5296 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5297 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5299 bfd_set_error (bfd_error_no_memory
);
5303 p
= ((struct elf_link_hash_entry
**)
5304 malloc (o
->reloc_count
5305 * sizeof (struct elf_link_hash_entry
*)));
5306 if (p
== NULL
&& o
->reloc_count
!= 0)
5308 bfd_set_error (bfd_error_no_memory
);
5311 elf_section_data (o
)->rel_hashes
= p
;
5312 pend
= p
+ o
->reloc_count
;
5313 for (; p
< pend
; p
++)
5316 /* Use the reloc_count field as an index when outputting the
5322 assign_file_positions_for_relocs (abfd
);
5324 /* We have now assigned file positions for all the sections except
5325 .symtab and .strtab. We start the .symtab section at the current
5326 file position, and write directly to it. We build the .strtab
5327 section in memory. When we add .dynsym support, we will build
5328 that in memory as well (.dynsym is smaller than .symtab). */
5330 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5331 /* sh_name is set in prep_headers. */
5332 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5333 symtab_hdr
->sh_flags
= 0;
5334 symtab_hdr
->sh_addr
= 0;
5335 symtab_hdr
->sh_size
= 0;
5336 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5337 /* sh_link is set in assign_section_numbers. */
5338 /* sh_info is set below. */
5339 /* sh_offset is set just below. */
5340 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5342 off
= elf_tdata (abfd
)->next_file_pos
;
5343 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5345 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5346 incorrect. We do not yet know the size of the .symtab section.
5347 We correct next_file_pos below, after we do know the size. */
5349 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5350 continuously seeking to the right position in the file. */
5351 if (! info
->keep_memory
|| max_sym_count
< 20)
5352 finfo
.symbuf_size
= 20;
5354 finfo
.symbuf_size
= max_sym_count
;
5355 finfo
.symbuf
= ((Elf_External_Sym
*)
5356 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5357 if (finfo
.symbuf
== NULL
)
5359 bfd_set_error (bfd_error_no_memory
);
5363 /* Start writing out the symbol table. The first symbol is always a
5365 elfsym
.st_value
= 0;
5368 elfsym
.st_other
= 0;
5369 elfsym
.st_shndx
= SHN_UNDEF
;
5370 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5371 &elfsym
, bfd_und_section_ptr
))
5375 /* Some standard ELF linkers do this, but we don't because it causes
5376 bootstrap comparison failures. */
5377 /* Output a file symbol for the output file as the second symbol.
5378 We output this even if we are discarding local symbols, although
5379 I'm not sure if this is correct. */
5380 elfsym
.st_value
= 0;
5382 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5383 elfsym
.st_other
= 0;
5384 elfsym
.st_shndx
= SHN_ABS
;
5385 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5386 &elfsym
, bfd_abs_section_ptr
))
5390 /* Output a symbol for each section. We output these even if we are
5391 discarding local symbols, since they are used for relocs. These
5392 symbols have no names. We store the index of each one in the
5393 index field of the section, so that we can find it again when
5394 outputting relocs. */
5395 elfsym
.st_value
= 0;
5397 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5398 elfsym
.st_other
= 0;
5399 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5401 o
= section_from_elf_index (abfd
, i
);
5402 if (! bfd_is_abs_section (o
))
5403 o
->target_index
= abfd
->symcount
;
5404 elfsym
.st_shndx
= i
;
5405 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5410 /* Allocate some memory to hold information read in from the input
5412 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5413 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5414 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5415 malloc (max_internal_reloc_count
5416 * sizeof (Elf_Internal_Rela
)));
5417 finfo
.external_syms
= ((Elf_External_Sym
*)
5418 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5419 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5420 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5421 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5422 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5423 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5424 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5425 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5426 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5427 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5428 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5429 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5431 bfd_set_error (bfd_error_no_memory
);
5435 /* Since ELF permits relocations to be against local symbols, we
5436 must have the local symbols available when we do the relocations.
5437 Since we would rather only read the local symbols once, and we
5438 would rather not keep them in memory, we handle all the
5439 relocations for a single input file at the same time.
5441 Unfortunately, there is no way to know the total number of local
5442 symbols until we have seen all of them, and the local symbol
5443 indices precede the global symbol indices. This means that when
5444 we are generating relocateable output, and we see a reloc against
5445 a global symbol, we can not know the symbol index until we have
5446 finished examining all the local symbols to see which ones we are
5447 going to output. To deal with this, we keep the relocations in
5448 memory, and don't output them until the end of the link. This is
5449 an unfortunate waste of memory, but I don't see a good way around
5450 it. Fortunately, it only happens when performing a relocateable
5451 link, which is not the common case. FIXME: If keep_memory is set
5452 we could write the relocs out and then read them again; I don't
5453 know how bad the memory loss will be. */
5455 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5456 sub
->output_has_begun
= false;
5457 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5459 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5461 if (p
->type
== bfd_indirect_link_order
5462 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5463 == bfd_target_elf_flavour
))
5465 sub
= p
->u
.indirect
.section
->owner
;
5466 if (! sub
->output_has_begun
)
5468 if (! elf_link_input_bfd (&finfo
, sub
))
5470 sub
->output_has_begun
= true;
5473 else if (p
->type
== bfd_section_reloc_link_order
5474 || p
->type
== bfd_symbol_reloc_link_order
)
5476 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5481 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5487 /* That wrote out all the local symbols. Finish up the symbol table
5488 with the global symbols. */
5490 /* The sh_info field records the index of the first non local
5492 symtab_hdr
->sh_info
= abfd
->symcount
;
5494 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5496 /* We get the global symbols from the hash table. */
5497 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5500 /* Flush all symbols to the file. */
5501 if (! elf_link_flush_output_syms (&finfo
))
5504 /* Now we know the size of the symtab section. */
5505 off
+= symtab_hdr
->sh_size
;
5507 /* Finish up the symbol string table (.strtab) section. */
5508 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5509 /* sh_name was set in prep_headers. */
5510 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5511 symstrtab_hdr
->sh_flags
= 0;
5512 symstrtab_hdr
->sh_addr
= 0;
5513 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5514 symstrtab_hdr
->sh_entsize
= 0;
5515 symstrtab_hdr
->sh_link
= 0;
5516 symstrtab_hdr
->sh_info
= 0;
5517 /* sh_offset is set just below. */
5518 symstrtab_hdr
->sh_addralign
= 1;
5519 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5521 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5522 elf_tdata (abfd
)->next_file_pos
= off
;
5524 /* Adjust the relocs to have the correct symbol indices. */
5525 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5527 struct elf_link_hash_entry
**rel_hash
;
5528 Elf_Internal_Shdr
*rel_hdr
;
5530 if ((o
->flags
& SEC_RELOC
) == 0)
5533 rel_hash
= elf_section_data (o
)->rel_hashes
;
5534 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5535 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5537 if (*rel_hash
== NULL
)
5540 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5542 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5544 Elf_External_Rel
*erel
;
5545 Elf_Internal_Rel irel
;
5547 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5548 elf_swap_reloc_in (abfd
, erel
, &irel
);
5549 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5550 ELF_R_TYPE (irel
.r_info
));
5551 elf_swap_reloc_out (abfd
, &irel
, erel
);
5555 Elf_External_Rela
*erela
;
5556 Elf_Internal_Rela irela
;
5558 BFD_ASSERT (rel_hdr
->sh_entsize
5559 == sizeof (Elf_External_Rela
));
5561 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5562 elf_swap_reloca_in (abfd
, erela
, &irela
);
5563 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5564 ELF_R_TYPE (irela
.r_info
));
5565 elf_swap_reloca_out (abfd
, &irela
, erela
);
5569 /* Set the reloc_count field to 0 to prevent write_relocs from
5570 trying to swap the relocs out itself. */
5574 /* If we are linking against a dynamic object, finish up the dynamic
5575 linking information. */
5578 Elf_External_Dyn
*dyncon
, *dynconend
;
5580 /* Fix up .dynamic entries. */
5581 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5582 BFD_ASSERT (o
!= NULL
);
5584 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5585 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5586 for (; dyncon
< dynconend
; dyncon
++)
5588 Elf_Internal_Dyn dyn
;
5592 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5614 o
= bfd_get_section_by_name (abfd
, name
);
5615 BFD_ASSERT (o
!= NULL
);
5616 dyn
.d_un
.d_ptr
= o
->vma
;
5617 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5624 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5629 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5631 Elf_Internal_Shdr
*hdr
;
5633 hdr
= elf_elfsections (abfd
)[i
];
5634 if (hdr
->sh_type
== type
5635 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5637 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5638 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5641 if (dyn
.d_un
.d_val
== 0
5642 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5643 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5647 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5652 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5655 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5657 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5659 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5661 BFD_ASSERT (info
->shared
);
5664 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5665 o
->contents
, o
->output_offset
,
5671 /* Now backend stuff. */
5672 if (bed
->elf_backend_final_write_processing
)
5673 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5675 if (finfo
.contents
!= NULL
)
5676 free (finfo
.contents
);
5677 if (finfo
.external_relocs
!= NULL
)
5678 free (finfo
.external_relocs
);
5679 if (finfo
.internal_relocs
!= NULL
)
5680 free (finfo
.internal_relocs
);
5681 if (finfo
.external_syms
!= NULL
)
5682 free (finfo
.external_syms
);
5683 if (finfo
.internal_syms
!= NULL
)
5684 free (finfo
.internal_syms
);
5685 if (finfo
.indices
!= NULL
)
5686 free (finfo
.indices
);
5687 if (finfo
.sections
!= NULL
)
5688 free (finfo
.sections
);
5689 if (finfo
.symbuf
!= NULL
)
5690 free (finfo
.symbuf
);
5691 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5693 if ((o
->flags
& SEC_RELOC
) != 0
5694 && elf_section_data (o
)->rel_hashes
!= NULL
)
5695 free (elf_section_data (o
)->rel_hashes
);
5701 if (finfo
.contents
!= NULL
)
5702 free (finfo
.contents
);
5703 if (finfo
.external_relocs
!= NULL
)
5704 free (finfo
.external_relocs
);
5705 if (finfo
.internal_relocs
!= NULL
)
5706 free (finfo
.internal_relocs
);
5707 if (finfo
.external_syms
!= NULL
)
5708 free (finfo
.external_syms
);
5709 if (finfo
.internal_syms
!= NULL
)
5710 free (finfo
.internal_syms
);
5711 if (finfo
.indices
!= NULL
)
5712 free (finfo
.indices
);
5713 if (finfo
.sections
!= NULL
)
5714 free (finfo
.sections
);
5715 if (finfo
.symbuf
!= NULL
)
5716 free (finfo
.symbuf
);
5717 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5719 if ((o
->flags
& SEC_RELOC
) != 0
5720 && elf_section_data (o
)->rel_hashes
!= NULL
)
5721 free (elf_section_data (o
)->rel_hashes
);
5727 /* Add a symbol to the output symbol table. */
5730 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5731 struct elf_final_link_info
*finfo
;
5733 Elf_Internal_Sym
*elfsym
;
5734 asection
*input_sec
;
5736 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5737 struct bfd_link_info
*info
,
5742 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5743 elf_backend_link_output_symbol_hook
;
5744 if (output_symbol_hook
!= NULL
)
5746 if (! ((*output_symbol_hook
)
5747 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5751 if (name
== (const char *) NULL
|| *name
== '\0')
5752 elfsym
->st_name
= 0;
5755 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5756 finfo
->symstrtab
, name
);
5757 if (elfsym
->st_name
== (unsigned long) -1)
5761 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5763 if (! elf_link_flush_output_syms (finfo
))
5767 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5768 finfo
->symbuf
+ finfo
->symbuf_count
);
5769 ++finfo
->symbuf_count
;
5771 ++finfo
->output_bfd
->symcount
;
5776 /* Flush the output symbols to the file. */
5779 elf_link_flush_output_syms (finfo
)
5780 struct elf_final_link_info
*finfo
;
5782 Elf_Internal_Shdr
*symtab
;
5784 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5786 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5788 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5789 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5790 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5793 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5795 finfo
->symbuf_count
= 0;
5800 /* Add an external symbol to the symbol table. This is called from
5801 the hash table traversal routine. */
5804 elf_link_output_extsym (h
, data
)
5805 struct elf_link_hash_entry
*h
;
5808 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5810 Elf_Internal_Sym sym
;
5811 asection
*input_sec
;
5813 /* We don't want to output symbols that have never been mentioned by
5814 a regular file, or that we have been told to strip. However, if
5815 h->indx is set to -2, the symbol is used by a reloc and we must
5819 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5820 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5821 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5822 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5824 else if (finfo
->info
->strip
== strip_all
5825 || (finfo
->info
->strip
== strip_some
5826 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5827 h
->root
.root
.string
,
5828 false, false) == NULL
))
5833 /* If we're stripping it, and it's not a dynamic symbol, there's
5834 nothing else to do. */
5835 if (strip
&& h
->dynindx
== -1)
5839 sym
.st_size
= h
->size
;
5841 if (h
->root
.type
== bfd_link_hash_weak
5842 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0
5843 && ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
5844 | ELF_LINK_HASH_REF_DYNAMIC
))
5846 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5848 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5850 switch (h
->root
.type
)
5853 case bfd_link_hash_new
:
5857 case bfd_link_hash_undefined
:
5858 input_sec
= bfd_und_section_ptr
;
5859 sym
.st_shndx
= SHN_UNDEF
;
5862 case bfd_link_hash_weak
:
5863 input_sec
= bfd_und_section_ptr
;
5864 sym
.st_shndx
= SHN_UNDEF
;
5867 case bfd_link_hash_defined
:
5870 input_sec
= h
->root
.u
.def
.section
;
5871 if (input_sec
->output_section
!= NULL
)
5873 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5874 input_sec
->output_section
);
5875 if (sym
.st_shndx
== (unsigned short) -1)
5877 /* FIXME: No way to handle errors. */
5881 /* ELF symbols in relocateable files are section relative,
5882 but in nonrelocateable files they are virtual
5884 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5885 if (! finfo
->info
->relocateable
)
5886 sym
.st_value
+= input_sec
->output_section
->vma
;
5890 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5891 == bfd_target_elf_flavour
5892 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5893 sym
.st_shndx
= SHN_UNDEF
;
5894 input_sec
= bfd_und_section_ptr
;
5899 case bfd_link_hash_common
:
5900 input_sec
= bfd_com_section_ptr
;
5901 sym
.st_shndx
= SHN_COMMON
;
5902 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
5905 case bfd_link_hash_indirect
:
5906 case bfd_link_hash_warning
:
5907 /* I have no idea how these should be handled. */
5911 /* If this symbol should be put in the .dynsym section, then put it
5912 there now. We have already know the symbol index. We also fill
5913 in the entry in the .hash section. */
5914 if (h
->dynindx
!= -1)
5916 struct elf_backend_data
*bed
;
5919 bfd_byte
*bucketpos
;
5922 sym
.st_name
= h
->dynstr_index
;
5924 /* Give the processor backend a chance to tweak the symbol
5925 value, and also to finish up anything that needs to be done
5927 bed
= get_elf_backend_data (finfo
->output_bfd
);
5928 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5929 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5931 /* FIXME: No way to return error. */
5935 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5936 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5939 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5940 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5941 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5942 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5943 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5944 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5945 put_word (finfo
->output_bfd
, chain
,
5946 ((bfd_byte
*) finfo
->hash_sec
->contents
5947 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5950 /* If we're stripping it, then it was just a dynamic symbol, and
5951 there's nothing else to do. */
5955 h
->indx
= finfo
->output_bfd
->symcount
;
5957 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5959 /* FIXME: No way to return error. */
5966 /* Link an input file into the linker output file. This function
5967 handles all the sections and relocations of the input file at once.
5968 This is so that we only have to read the local symbols once, and
5969 don't have to keep them in memory. */
5972 elf_link_input_bfd (finfo
, input_bfd
)
5973 struct elf_final_link_info
*finfo
;
5976 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5977 bfd
*, asection
*, bfd_byte
*,
5978 Elf_Internal_Rela
*,
5980 asection
**, char *));
5982 Elf_Internal_Shdr
*symtab_hdr
;
5985 Elf_External_Sym
*esym
;
5986 Elf_External_Sym
*esymend
;
5987 Elf_Internal_Sym
*isym
;
5989 asection
**ppsection
;
5992 output_bfd
= finfo
->output_bfd
;
5994 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5996 /* If this is a dynamic object, we don't want to do anything here:
5997 we don't want the local symbols, and we don't want the section
5999 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
6002 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6003 if (elf_bad_symtab (input_bfd
))
6005 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6010 locsymcount
= symtab_hdr
->sh_info
;
6011 extsymoff
= symtab_hdr
->sh_info
;
6014 /* Read the local symbols. */
6016 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
6017 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
6018 locsymcount
, input_bfd
)
6019 != locsymcount
* sizeof (Elf_External_Sym
))))
6022 /* Swap in the local symbols and write out the ones which we know
6023 are going into the output file. */
6024 esym
= finfo
->external_syms
;
6025 esymend
= esym
+ locsymcount
;
6026 isym
= finfo
->internal_syms
;
6027 pindex
= finfo
->indices
;
6028 ppsection
= finfo
->sections
;
6029 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6035 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6038 if (elf_bad_symtab (input_bfd
))
6040 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6047 if (isym
->st_shndx
== SHN_UNDEF
)
6048 isec
= bfd_und_section_ptr
;
6049 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6051 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6055 else if (isym
->st_shndx
== SHN_ABS
)
6056 isec
= bfd_abs_section_ptr
;
6057 else if (isym
->st_shndx
== SHN_COMMON
)
6058 isec
= bfd_com_section_ptr
;
6067 /* Don't output the first, undefined, symbol. */
6068 if (esym
== finfo
->external_syms
)
6071 /* If we are stripping all symbols, we don't want to output this
6073 if (finfo
->info
->strip
== strip_all
)
6076 /* We never output section symbols. Instead, we use the section
6077 symbol of the corresponding section in the output file. */
6078 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6081 /* If we are discarding all local symbols, we don't want to
6082 output this one. If we are generating a relocateable output
6083 file, then some of the local symbols may be required by
6084 relocs; we output them below as we discover that they are
6086 if (finfo
->info
->discard
== discard_all
)
6089 /* Get the name of the symbol. */
6090 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6095 /* See if we are discarding symbols with this name. */
6096 if ((finfo
->info
->strip
== strip_some
6097 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6099 || (finfo
->info
->discard
== discard_l
6100 && strncmp (name
, finfo
->info
->lprefix
,
6101 finfo
->info
->lprefix_len
) == 0))
6104 /* If we get here, we are going to output this symbol. */
6106 /* Adjust the section index for the output file. */
6107 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
6108 isec
->output_section
);
6109 if (isym
->st_shndx
== (unsigned short) -1)
6112 *pindex
= output_bfd
->symcount
;
6114 /* ELF symbols in relocateable files are section relative, but
6115 in executable files they are virtual addresses. Note that
6116 this code assumes that all ELF sections have an associated
6117 BFD section with a reasonable value for output_offset; below
6118 we assume that they also have a reasonable value for
6119 output_section. Any special sections must be set up to meet
6120 these requirements. */
6121 oldval
= isym
->st_value
;
6122 isym
->st_value
+= isec
->output_offset
;
6123 if (! finfo
->info
->relocateable
)
6124 isym
->st_value
+= isec
->output_section
->vma
;
6126 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
6129 /* Restore the old value for reloc handling. */
6130 isym
->st_value
= oldval
;
6133 /* Relocate the contents of each section. */
6134 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6136 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6139 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6140 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6142 /* Section was created by elf_link_create_dynamic_sections.
6143 FIXME: This test is fragile. */
6147 /* Read the contents of the section. */
6148 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6149 (file_ptr
) 0, o
->_raw_size
))
6152 if ((o
->flags
& SEC_RELOC
) != 0)
6154 Elf_Internal_Rela
*internal_relocs
;
6156 /* Get the swapped relocs. */
6157 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6158 finfo
->external_relocs
,
6159 finfo
->internal_relocs
,
6161 if (internal_relocs
== NULL
6162 && o
->reloc_count
> 0)
6165 /* Relocate the section by invoking a back end routine.
6167 The back end routine is responsible for adjusting the
6168 section contents as necessary, and (if using Rela relocs
6169 and generating a relocateable output file) adjusting the
6170 reloc addend as necessary.
6172 The back end routine does not have to worry about setting
6173 the reloc address or the reloc symbol index.
6175 The back end routine is given a pointer to the swapped in
6176 internal symbols, and can access the hash table entries
6177 for the external symbols via elf_sym_hashes (input_bfd).
6179 When generating relocateable output, the back end routine
6180 must handle STB_LOCAL/STT_SECTION symbols specially. The
6181 output symbol is going to be a section symbol
6182 corresponding to the output section, which will require
6183 the addend to be adjusted. */
6185 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6189 finfo
->internal_syms
,
6191 finfo
->symstrtab
->tab
))
6194 if (finfo
->info
->relocateable
)
6196 Elf_Internal_Rela
*irela
;
6197 Elf_Internal_Rela
*irelaend
;
6198 struct elf_link_hash_entry
**rel_hash
;
6199 Elf_Internal_Shdr
*input_rel_hdr
;
6200 Elf_Internal_Shdr
*output_rel_hdr
;
6202 /* Adjust the reloc addresses and symbol indices. */
6204 irela
= internal_relocs
;
6205 irelaend
= irela
+ o
->reloc_count
;
6206 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6207 + o
->output_section
->reloc_count
);
6208 for (; irela
< irelaend
; irela
++, rel_hash
++)
6211 Elf_Internal_Sym
*isym
;
6214 irela
->r_offset
+= o
->output_offset
;
6216 r_symndx
= ELF_R_SYM (irela
->r_info
);
6221 if (r_symndx
>= locsymcount
6222 || (elf_bad_symtab (input_bfd
)
6223 && finfo
->sections
[r_symndx
] == NULL
))
6227 /* This is a reloc against a global symbol. We
6228 have not yet output all the local symbols, so
6229 we do not know the symbol index of any global
6230 symbol. We set the rel_hash entry for this
6231 reloc to point to the global hash table entry
6232 for this symbol. The symbol index is then
6233 set at the end of elf_bfd_final_link. */
6234 indx
= r_symndx
- extsymoff
;
6235 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6237 /* Setting the index to -2 tells
6238 elf_link_output_extsym that this symbol is
6240 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6241 (*rel_hash
)->indx
= -2;
6246 /* This is a reloc against a local symbol. */
6249 isym
= finfo
->internal_syms
+ r_symndx
;
6250 sec
= finfo
->sections
[r_symndx
];
6251 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6253 /* I suppose the backend ought to fill in the
6254 section of any STT_SECTION symbol against a
6255 processor specific section. */
6256 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6258 else if (sec
== NULL
|| sec
->owner
== NULL
)
6260 bfd_set_error (bfd_error_bad_value
);
6265 r_symndx
= sec
->output_section
->target_index
;
6272 if (finfo
->indices
[r_symndx
] == -1)
6278 if (finfo
->info
->strip
== strip_all
)
6280 /* You can't do ld -r -s. */
6281 bfd_set_error (bfd_error_invalid_operation
);
6285 /* This symbol was skipped earlier, but
6286 since it is needed by a reloc, we
6287 must output it now. */
6288 link
= symtab_hdr
->sh_link
;
6289 name
= elf_string_from_elf_section (input_bfd
,
6295 osec
= sec
->output_section
;
6297 elf_section_from_bfd_section (output_bfd
,
6299 if (isym
->st_shndx
== (unsigned short) -1)
6302 isym
->st_value
+= sec
->output_offset
;
6303 if (! finfo
->info
->relocateable
)
6304 isym
->st_value
+= osec
->vma
;
6306 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6308 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6312 r_symndx
= finfo
->indices
[r_symndx
];
6315 irela
->r_info
= ELF_R_INFO (r_symndx
,
6316 ELF_R_TYPE (irela
->r_info
));
6319 /* Swap out the relocs. */
6320 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6321 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6322 BFD_ASSERT (output_rel_hdr
->sh_entsize
6323 == input_rel_hdr
->sh_entsize
);
6324 irela
= internal_relocs
;
6325 irelaend
= irela
+ o
->reloc_count
;
6326 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6328 Elf_External_Rel
*erel
;
6330 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6331 + o
->output_section
->reloc_count
);
6332 for (; irela
< irelaend
; irela
++, erel
++)
6334 Elf_Internal_Rel irel
;
6336 irel
.r_offset
= irela
->r_offset
;
6337 irel
.r_info
= irela
->r_info
;
6338 BFD_ASSERT (irela
->r_addend
== 0);
6339 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6344 Elf_External_Rela
*erela
;
6346 BFD_ASSERT (input_rel_hdr
->sh_entsize
6347 == sizeof (Elf_External_Rela
));
6348 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6349 + o
->output_section
->reloc_count
);
6350 for (; irela
< irelaend
; irela
++, erela
++)
6351 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6354 o
->output_section
->reloc_count
+= o
->reloc_count
;
6358 /* Write out the modified section contents. */
6359 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6360 finfo
->contents
, o
->output_offset
,
6361 (o
->_cooked_size
!= 0
6370 /* Generate a reloc when linking an ELF file. This is a reloc
6371 requested by the linker, and does come from any input file. This
6372 is used to build constructor and destructor tables when linking
6376 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6378 struct bfd_link_info
*info
;
6379 asection
*output_section
;
6380 struct bfd_link_order
*link_order
;
6382 const reloc_howto_type
*howto
;
6385 struct elf_link_hash_entry
**rel_hash_ptr
;
6386 Elf_Internal_Shdr
*rel_hdr
;
6388 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6391 bfd_set_error (bfd_error_bad_value
);
6395 /* If this is an inplace reloc, we must write the addend into the
6397 if (howto
->partial_inplace
6398 && link_order
->u
.reloc
.p
->addend
!= 0)
6401 bfd_reloc_status_type rstat
;
6405 size
= bfd_get_reloc_size (howto
);
6406 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6407 if (buf
== (bfd_byte
*) NULL
)
6409 bfd_set_error (bfd_error_no_memory
);
6412 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6413 link_order
->u
.reloc
.p
->addend
, buf
);
6419 case bfd_reloc_outofrange
:
6421 case bfd_reloc_overflow
:
6422 if (! ((*info
->callbacks
->reloc_overflow
)
6424 (link_order
->type
== bfd_section_reloc_link_order
6425 ? bfd_section_name (output_bfd
,
6426 link_order
->u
.reloc
.p
->u
.section
)
6427 : link_order
->u
.reloc
.p
->u
.name
),
6428 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6429 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6436 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6437 (file_ptr
) link_order
->offset
, size
);
6443 /* Figure out the symbol index. */
6444 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6445 + output_section
->reloc_count
);
6446 if (link_order
->type
== bfd_section_reloc_link_order
)
6448 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6451 *rel_hash_ptr
= NULL
;
6455 struct elf_link_hash_entry
*h
;
6457 h
= elf_link_hash_lookup (elf_hash_table (info
),
6458 link_order
->u
.reloc
.p
->u
.name
,
6459 false, false, true);
6462 /* Setting the index to -2 tells elf_link_output_extsym that
6463 this symbol is used by a reloc. */
6470 if (! ((*info
->callbacks
->unattached_reloc
)
6471 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6472 (asection
*) NULL
, (bfd_vma
) 0)))
6478 /* The address of a reloc is relative to the section in a
6479 relocateable file, and is a virtual address in an executable
6481 offset
= link_order
->offset
;
6482 if (! info
->relocateable
)
6483 offset
+= output_section
->vma
;
6485 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6487 if (rel_hdr
->sh_type
== SHT_REL
)
6489 Elf_Internal_Rel irel
;
6490 Elf_External_Rel
*erel
;
6492 irel
.r_offset
= offset
;
6493 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6494 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6495 + output_section
->reloc_count
);
6496 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6500 Elf_Internal_Rela irela
;
6501 Elf_External_Rela
*erela
;
6503 irela
.r_offset
= offset
;
6504 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6505 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6506 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6507 + output_section
->reloc_count
);
6508 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6511 ++output_section
->reloc_count
;