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
;
551 case SHT_DYNSYM
: /* A dynamic symbol table */
552 if (elf_dynsymtab (abfd
) == shindex
)
555 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
556 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
557 elf_dynsymtab (abfd
) = shindex
;
558 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
559 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
560 abfd
->flags
|= HAS_SYMS
;
562 /* Besides being a symbol table, we also treat this as a regular
563 section, so that objcopy can handle it. */
564 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
566 case SHT_STRTAB
: /* A string table */
567 if (hdr
->rawdata
!= NULL
)
569 if (ehdr
->e_shstrndx
== shindex
)
571 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
572 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
573 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
579 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
581 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
582 if (hdr2
->sh_link
== shindex
)
584 if (! bfd_section_from_shdr (abfd
, i
))
586 if (elf_onesymtab (abfd
) == i
)
588 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
589 elf_elfsections (abfd
)[shindex
] =
590 &elf_tdata (abfd
)->strtab_hdr
;
593 if (elf_dynsymtab (abfd
) == i
)
595 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
596 elf_elfsections (abfd
)[shindex
] =
597 &elf_tdata (abfd
)->dynstrtab_hdr
;
598 /* We also treat this as a regular section, so
599 that objcopy can handle it. */
602 #if 0 /* Not handling other string tables specially right now. */
603 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
604 /* We have a strtab for some random other section. */
605 newsect
= (asection
*) hdr2
->rawdata
;
608 hdr
->rawdata
= (PTR
) newsect
;
609 hdr2
= &elf_section_data (newsect
)->str_hdr
;
611 elf_elfsections (abfd
)[shindex
] = hdr2
;
617 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
621 /* *These* do a lot of work -- but build no sections! */
623 asection
*target_sect
;
624 Elf_Internal_Shdr
*hdr2
;
625 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
627 /* Get the symbol table. */
628 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
631 /* If this reloc section does not use the main symbol table we
632 don't treat it as a reloc section. BFD can't adequately
633 represent such a section, so at least for now, we don't
634 try. We just present it as a normal section. */
635 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
636 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
638 /* Don't allow REL relocations on a machine that uses RELA and
640 /* @@ Actually, the generic ABI does suggest that both might be
641 used in one file. But the four ABI Processor Supplements I
642 have access to right now all specify that only one is used on
643 each of those architectures. It's conceivable that, e.g., a
644 bunch of absolute 32-bit relocs might be more compact in REL
645 form even on a RELA machine... */
646 BFD_ASSERT (use_rela_p
647 ? (hdr
->sh_type
== SHT_RELA
648 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
649 : (hdr
->sh_type
== SHT_REL
650 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
652 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
654 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
655 if (target_sect
== NULL
656 || elf_section_data (target_sect
) == NULL
)
659 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
661 elf_elfsections (abfd
)[shindex
] = hdr2
;
662 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
663 target_sect
->flags
|= SEC_RELOC
;
664 target_sect
->relocation
= NULL
;
665 target_sect
->rel_filepos
= hdr
->sh_offset
;
666 abfd
->flags
|= HAS_RELOC
;
673 fprintf (stderr
, "Note Sections not yet supported.\n");
680 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
685 /* Check for any processor-specific section types. */
687 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
689 if (bed
->elf_backend_section_from_shdr
)
690 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
699 elf_new_section_hook (abfd
, sec
)
704 struct bfd_elf_section_data
*sdata
;
706 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
709 bfd_set_error (bfd_error_no_memory
);
712 sec
->used_by_bfd
= (PTR
) sdata
;
713 memset (sdata
, 0, sizeof (*sdata
));
717 /* Create a new bfd section from an ELF program header.
719 Since program segments have no names, we generate a synthetic name
720 of the form segment<NUM>, where NUM is generally the index in the
721 program header table. For segments that are split (see below) we
722 generate the names segment<NUM>a and segment<NUM>b.
724 Note that some program segments may have a file size that is different than
725 (less than) the memory size. All this means is that at execution the
726 system must allocate the amount of memory specified by the memory size,
727 but only initialize it with the first "file size" bytes read from the
728 file. This would occur for example, with program segments consisting
729 of combined data+bss.
731 To handle the above situation, this routine generates TWO bfd sections
732 for the single program segment. The first has the length specified by
733 the file size of the segment, and the second has the length specified
734 by the difference between the two sizes. In effect, the segment is split
735 into it's initialized and uninitialized parts.
740 bfd_section_from_phdr (abfd
, hdr
, index
)
742 Elf_Internal_Phdr
*hdr
;
750 split
= ((hdr
->p_memsz
> 0) &&
751 (hdr
->p_filesz
> 0) &&
752 (hdr
->p_memsz
> hdr
->p_filesz
));
753 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
754 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
757 bfd_set_error (bfd_error_no_memory
);
760 strcpy (name
, namebuf
);
761 newsect
= bfd_make_section (abfd
, name
);
764 newsect
->vma
= hdr
->p_vaddr
;
765 newsect
->_raw_size
= hdr
->p_filesz
;
766 newsect
->filepos
= hdr
->p_offset
;
767 newsect
->flags
|= SEC_HAS_CONTENTS
;
768 if (hdr
->p_type
== PT_LOAD
)
770 newsect
->flags
|= SEC_ALLOC
;
771 newsect
->flags
|= SEC_LOAD
;
772 if (hdr
->p_flags
& PF_X
)
774 /* FIXME: all we known is that it has execute PERMISSION,
776 newsect
->flags
|= SEC_CODE
;
779 if (!(hdr
->p_flags
& PF_W
))
781 newsect
->flags
|= SEC_READONLY
;
786 sprintf (namebuf
, "segment%db", index
);
787 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
790 bfd_set_error (bfd_error_no_memory
);
793 strcpy (name
, namebuf
);
794 newsect
= bfd_make_section (abfd
, name
);
797 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
798 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
799 if (hdr
->p_type
== PT_LOAD
)
801 newsect
->flags
|= SEC_ALLOC
;
802 if (hdr
->p_flags
& PF_X
)
803 newsect
->flags
|= SEC_CODE
;
805 if (!(hdr
->p_flags
& PF_W
))
806 newsect
->flags
|= SEC_READONLY
;
812 /* Begin processing a given object.
814 First we validate the file by reading in the ELF header and checking
817 static INLINE boolean
819 Elf_External_Ehdr
*x_ehdrp
;
821 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
822 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
823 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
824 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
827 /* Check to see if the file associated with ABFD matches the target vector
830 Note that we may be called several times with the same ABFD, but different
831 target vectors, most of which will not match. We have to avoid leaving
832 any side effects in ABFD, or any data it points to (like tdata), if the
833 file does not match the target vector. */
839 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
840 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
841 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
842 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
843 unsigned int shindex
;
844 char *shstrtab
; /* Internal copy of section header stringtab */
845 struct elf_backend_data
*ebd
;
846 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
847 struct elf_obj_tdata
*new_tdata
= NULL
;
849 /* Read in the ELF header in external format. */
851 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
853 if (bfd_get_error () != bfd_error_system_call
)
854 goto got_wrong_format_error
;
859 /* Now check to see if we have a valid ELF file, and one that BFD can
860 make use of. The magic number must match, the address size ('class')
861 and byte-swapping must match our XVEC entry, and it must have a
862 section header table (FIXME: See comments re sections at top of this
865 if ((elf_file_p (&x_ehdr
) == false) ||
866 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
867 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
868 goto got_wrong_format_error
;
870 /* Check that file's byte order matches xvec's */
871 switch (x_ehdr
.e_ident
[EI_DATA
])
873 case ELFDATA2MSB
: /* Big-endian */
874 if (!abfd
->xvec
->header_byteorder_big_p
)
875 goto got_wrong_format_error
;
877 case ELFDATA2LSB
: /* Little-endian */
878 if (abfd
->xvec
->header_byteorder_big_p
)
879 goto got_wrong_format_error
;
881 case ELFDATANONE
: /* No data encoding specified */
882 default: /* Unknown data encoding specified */
883 goto got_wrong_format_error
;
886 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
887 the tdata pointer in the bfd. */
889 new_tdata
= ((struct elf_obj_tdata
*)
890 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
891 if (new_tdata
== NULL
)
892 goto got_no_memory_error
;
893 elf_tdata (abfd
) = new_tdata
;
895 /* Now that we know the byte order, swap in the rest of the header */
896 i_ehdrp
= elf_elfheader (abfd
);
897 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
899 elf_debug_file (i_ehdrp
);
902 /* If there is no section header table, we're hosed. */
903 if (i_ehdrp
->e_shoff
== 0)
904 goto got_wrong_format_error
;
906 /* As a simple sanity check, verify that the what BFD thinks is the
907 size of each section header table entry actually matches the size
908 recorded in the file. */
909 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
910 goto got_wrong_format_error
;
912 ebd
= get_elf_backend_data (abfd
);
914 /* Check that the ELF e_machine field matches what this particular
915 BFD format expects. */
916 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
918 const bfd_target
* const *target_ptr
;
920 if (ebd
->elf_machine_code
!= EM_NONE
)
921 goto got_wrong_format_error
;
923 /* This is the generic ELF target. Let it match any ELF target
924 for which we do not have a specific backend. */
925 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
927 struct elf_backend_data
*back
;
929 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
931 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
932 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
934 /* target_ptr is an ELF backend which matches this
935 object file, so reject the generic ELF target. */
936 goto got_wrong_format_error
;
941 if (i_ehdrp
->e_type
== ET_EXEC
)
942 abfd
->flags
|= EXEC_P
;
943 else if (i_ehdrp
->e_type
== ET_DYN
)
944 abfd
->flags
|= DYNAMIC
;
946 if (i_ehdrp
->e_phnum
> 0)
947 abfd
->flags
|= D_PAGED
;
949 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
952 /* Remember the entry point specified in the ELF file header. */
953 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
955 /* Allocate space for a copy of the section header table in
956 internal form, seek to the section header table in the file,
957 read it in, and convert it to internal form. */
958 i_shdrp
= ((Elf_Internal_Shdr
*)
959 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
960 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
962 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
963 if (!i_shdrp
|| !elf_elfsections (abfd
))
964 goto got_no_memory_error
;
965 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
967 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
969 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
971 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
972 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
974 if (i_ehdrp
->e_shstrndx
)
976 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
980 /* Read in the string table containing the names of the sections. We
981 will need the base pointer to this table later. */
982 /* We read this inline now, so that we don't have to go through
983 bfd_section_from_shdr with it (since this particular strtab is
984 used to find all of the ELF section names.) */
986 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
990 /* Once all of the section headers have been read and converted, we
991 can start processing them. Note that the first section header is
992 a dummy placeholder entry, so we ignore it. */
994 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
996 if (! bfd_section_from_shdr (abfd
, shindex
))
1000 /* Let the backend double check the format and override global
1002 if (ebd
->elf_backend_object_p
)
1004 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
1005 goto got_wrong_format_error
;
1008 return (abfd
->xvec
);
1010 got_wrong_format_error
:
1011 bfd_set_error (bfd_error_wrong_format
);
1013 got_no_memory_error
:
1014 bfd_set_error (bfd_error_no_memory
);
1017 if (new_tdata
!= NULL
1018 && new_tdata
->elf_sect_ptr
!= NULL
)
1019 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1020 if (i_shdrp
!= NULL
)
1021 bfd_release (abfd
, i_shdrp
);
1022 if (new_tdata
!= NULL
)
1023 bfd_release (abfd
, new_tdata
);
1024 elf_tdata (abfd
) = preserved_tdata
;
1029 /* ELF .o/exec file writing */
1031 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1032 of the symbol if there is one. */
1033 static INLINE elf_symbol_type
*
1034 elf_symbol_from (ignore_abfd
, symbol
)
1038 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1041 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1044 return (elf_symbol_type
*) symbol
;
1048 write_relocs (abfd
, sec
, xxx
)
1053 Elf_Internal_Shdr
*rela_hdr
;
1054 Elf_External_Rela
*outbound_relocas
;
1055 Elf_External_Rel
*outbound_relocs
;
1057 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1058 asymbol
*last_sym
= 0;
1059 int last_sym_idx
= 9999999; /* should always be written before use */
1061 if ((sec
->flags
& SEC_RELOC
) == 0)
1064 /* The linker backend writes the relocs out itself, and sets the
1065 reloc_count field to zero to inhibit writing them here. Also,
1066 sometimes the SEC_RELOC flag gets set even when there aren't any
1068 if (sec
->reloc_count
== 0)
1071 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1073 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1074 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1075 if (!rela_hdr
->contents
)
1077 bfd_set_error (bfd_error_no_memory
);
1078 abort (); /* FIXME */
1081 /* orelocation has the data, reloc_count has the count... */
1084 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1086 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1088 Elf_Internal_Rela dst_rela
;
1089 Elf_External_Rela
*src_rela
;
1094 ptr
= sec
->orelocation
[idx
];
1095 src_rela
= outbound_relocas
+ idx
;
1096 if (!(abfd
->flags
& EXEC_P
))
1097 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1099 dst_rela
.r_offset
= ptr
->address
;
1101 sym
= *ptr
->sym_ptr_ptr
;
1102 if (sym
== last_sym
)
1107 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1109 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1111 dst_rela
.r_addend
= ptr
->addend
;
1112 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1116 /* REL relocations */
1118 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1120 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1122 Elf_Internal_Rel dst_rel
;
1123 Elf_External_Rel
*src_rel
;
1128 ptr
= sec
->orelocation
[idx
];
1129 sym
= *ptr
->sym_ptr_ptr
;
1130 src_rel
= outbound_relocs
+ idx
;
1131 if (!(abfd
->flags
& EXEC_P
))
1132 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1134 dst_rel
.r_offset
= ptr
->address
;
1136 if (sym
== last_sym
)
1141 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1143 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1145 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1150 /* Set up an ELF internal section header for a section. */
1154 elf_fake_sections (abfd
, asect
, ignore
)
1159 Elf_Internal_Shdr
*this_hdr
;
1161 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1163 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1165 if (this_hdr
->sh_name
== (unsigned long) -1)
1166 abort (); /* FIXME */
1168 this_hdr
->sh_flags
= 0;
1169 if ((asect
->flags
& SEC_ALLOC
) != 0)
1170 this_hdr
->sh_addr
= asect
->vma
;
1172 this_hdr
->sh_addr
= 0;
1173 this_hdr
->sh_offset
= 0;
1174 this_hdr
->sh_size
= asect
->_raw_size
;
1175 this_hdr
->sh_link
= 0;
1176 this_hdr
->sh_info
= 0;
1177 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1178 this_hdr
->sh_entsize
= 0;
1180 this_hdr
->rawdata
= (PTR
) asect
;
1181 this_hdr
->contents
= NULL
;
1184 /* FIXME: This should not be based on section names. */
1185 if (strcmp (asect
->name
, ".dynstr") == 0)
1186 this_hdr
->sh_type
= SHT_STRTAB
;
1187 else if (strcmp (asect
->name
, ".hash") == 0)
1189 this_hdr
->sh_type
= SHT_HASH
;
1190 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1192 else if (strcmp (asect
->name
, ".dynsym") == 0)
1194 this_hdr
->sh_type
= SHT_DYNSYM
;
1195 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1197 else if (strcmp (asect
->name
, ".dynamic") == 0)
1199 this_hdr
->sh_type
= SHT_DYNAMIC
;
1200 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1202 else if (strncmp (asect
->name
, ".rel.", 5) == 0)
1204 this_hdr
->sh_type
= SHT_REL
;
1205 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1207 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1209 this_hdr
->sh_type
= SHT_RELA
;
1210 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1212 else if (strcmp (asect
->name
, ".note") == 0)
1213 this_hdr
->sh_type
= SHT_NOTE
;
1214 else if (strncmp (asect
->name
, ".stab", 5) == 0
1215 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1216 this_hdr
->sh_type
= SHT_STRTAB
;
1217 else if ((asect
->flags
& SEC_ALLOC
) != 0
1218 && (asect
->flags
& SEC_LOAD
) != 0)
1219 this_hdr
->sh_type
= SHT_PROGBITS
;
1220 else if ((asect
->flags
& SEC_ALLOC
) != 0
1221 && ((asect
->flags
& SEC_LOAD
) == 0))
1223 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1224 || strcmp (asect
->name
, ".sbss") == 0);
1225 this_hdr
->sh_type
= SHT_NOBITS
;
1230 this_hdr
->sh_type
= SHT_PROGBITS
;
1233 if ((asect
->flags
& SEC_ALLOC
) != 0)
1234 this_hdr
->sh_flags
|= SHF_ALLOC
;
1235 if ((asect
->flags
& SEC_READONLY
) == 0)
1236 this_hdr
->sh_flags
|= SHF_WRITE
;
1237 if ((asect
->flags
& SEC_CODE
) != 0)
1238 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1240 /* Check for processor-specific section types. */
1242 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1244 if (bed
->elf_backend_fake_sections
)
1245 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1248 /* If the section has relocs, set up a section header for the
1249 SHT_REL[A] section. */
1250 if ((asect
->flags
& SEC_RELOC
) != 0)
1252 Elf_Internal_Shdr
*rela_hdr
;
1253 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1255 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1257 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1258 use_rela_p
? ".rela" : ".rel",
1260 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1261 rela_hdr
->sh_entsize
= (use_rela_p
1262 ? sizeof (Elf_External_Rela
)
1263 : sizeof (Elf_External_Rel
));
1264 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1265 rela_hdr
->sh_flags
= 0;
1266 rela_hdr
->sh_addr
= 0;
1267 rela_hdr
->sh_size
= 0;
1268 rela_hdr
->sh_offset
= 0;
1273 /* Assign all ELF section numbers. The dummy first section is handled here
1274 too. The link/info pointers for the standard section types are filled
1275 in here too, while we're at it. */
1278 assign_section_numbers (abfd
)
1281 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1283 unsigned int section_number
;
1284 Elf_Internal_Shdr
**i_shdrp
;
1288 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1290 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1292 d
->this_idx
= section_number
++;
1293 if ((sec
->flags
& SEC_RELOC
) == 0)
1296 d
->rel_idx
= section_number
++;
1299 t
->shstrtab_section
= section_number
++;
1300 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1301 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1302 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1304 if (abfd
->symcount
> 0)
1306 t
->symtab_section
= section_number
++;
1307 t
->strtab_section
= section_number
++;
1310 elf_elfheader (abfd
)->e_shnum
= section_number
;
1312 /* Set up the list of section header pointers, in agreement with the
1314 i_shdrp
= ((Elf_Internal_Shdr
**)
1315 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1316 if (i_shdrp
== NULL
)
1318 bfd_set_error (bfd_error_no_memory
);
1322 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1323 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1324 if (i_shdrp
[0] == NULL
)
1326 bfd_release (abfd
, i_shdrp
);
1327 bfd_set_error (bfd_error_no_memory
);
1330 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1332 elf_elfsections (abfd
) = i_shdrp
;
1334 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1335 if (abfd
->symcount
> 0)
1337 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1338 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1339 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1341 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1343 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1347 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1348 if (d
->rel_idx
!= 0)
1349 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1351 /* Fill in the sh_link and sh_info fields while we're at it. */
1353 /* sh_link of a reloc section is the section index of the symbol
1354 table. sh_info is the section index of the section to which
1355 the relocation entries apply. */
1356 if (d
->rel_idx
!= 0)
1358 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1359 d
->rel_hdr
.sh_info
= d
->this_idx
;
1362 switch (d
->this_hdr
.sh_type
)
1366 /* A reloc section which we are treating as a normal BFD
1367 section. sh_link is the section index of the symbol
1368 table. sh_info is the section index of the section to
1369 which the relocation entries apply. We assume that an
1370 allocated reloc section uses the dynamic symbol table.
1371 FIXME: How can we be sure? */
1372 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1374 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1376 /* We look up the section the relocs apply to by name. */
1378 if (d
->this_hdr
.sh_type
== SHT_REL
)
1382 s
= bfd_get_section_by_name (abfd
, name
);
1384 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1388 /* We assume that a section named .stab*str is a stabs
1389 string section. We look for a section with the same name
1390 but without the trailing ``str'', and set its sh_link
1391 field to point to this section. */
1392 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1393 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1398 len
= strlen (sec
->name
);
1399 alc
= (char *) malloc (len
- 2);
1402 bfd_set_error (bfd_error_no_memory
);
1405 strncpy (alc
, sec
->name
, len
- 3);
1406 alc
[len
- 3] = '\0';
1407 s
= bfd_get_section_by_name (abfd
, alc
);
1411 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1413 /* This is a .stab section. */
1414 elf_section_data (s
)->this_hdr
.sh_entsize
=
1415 4 + 2 * (ARCH_SIZE
/ 8);
1422 /* sh_link is the section header index of the string table
1423 used for the dynamic entries or symbol table. */
1424 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1426 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1430 /* sh_link is the section header index of the symbol table
1431 this hash table is for. */
1432 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1434 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1442 /* Map symbol from it's internal number to the external number, moving
1443 all local symbols to be at the head of the list. */
1446 sym_is_global (abfd
, sym
)
1450 /* If the backend has a special mapping, use it. */
1451 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1452 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1455 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1457 if (sym
->flags
& BSF_LOCAL
)
1461 if (sym
->section
== 0)
1463 /* Is this valid? */
1468 if (bfd_is_und_section (sym
->section
))
1470 if (bfd_is_com_section (sym
->section
))
1472 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1478 elf_map_symbols (abfd
)
1481 int symcount
= bfd_get_symcount (abfd
);
1482 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1483 asymbol
**sect_syms
;
1485 int num_globals
= 0;
1486 int num_locals2
= 0;
1487 int num_globals2
= 0;
1489 int num_sections
= 0;
1490 Elf_Sym_Extra
*sym_extra
;
1495 fprintf (stderr
, "elf_map_symbols\n");
1499 /* Add local symbols for each section for which there are relocs.
1500 FIXME: How can we tell which sections have relocs at this point?
1501 Will reloc_count always be accurate? Actually, I think most ELF
1502 targets create section symbols for all sections anyhow. */
1503 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1505 if (max_index
< asect
->index
)
1506 max_index
= asect
->index
;
1510 elf_num_section_syms (abfd
) = max_index
;
1511 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1512 elf_section_syms (abfd
) = sect_syms
;
1516 bfd_set_error (bfd_error_no_memory
);
1520 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1522 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1525 bfd_set_error (bfd_error_no_memory
);
1528 sym
->the_bfd
= abfd
;
1529 sym
->name
= asect
->name
;
1530 sym
->value
= asect
->vma
;
1531 sym
->flags
= BSF_SECTION_SYM
;
1532 sym
->section
= asect
;
1533 sect_syms
[asect
->index
] = sym
;
1537 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1538 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1545 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1546 ((symcount
+ num_sections
+ 1)
1547 * sizeof (asymbol
*)));
1549 syms
= (asymbol
**) bfd_alloc (abfd
,
1550 (num_sections
+ 1) * sizeof (asymbol
*));
1553 bfd_set_error (bfd_error_no_memory
);
1557 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1559 if (sect_syms
[asect
->index
])
1560 syms
[symcount
++] = sect_syms
[asect
->index
];
1563 syms
[symcount
] = (asymbol
*) 0;
1564 bfd_set_symtab (abfd
, syms
, symcount
);
1567 elf_sym_extra (abfd
) = sym_extra
1568 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1571 bfd_set_error (bfd_error_no_memory
);
1575 /* Identify and classify all of the symbols. */
1576 for (idx
= 0; idx
< symcount
; idx
++)
1578 if (!sym_is_global (abfd
, syms
[idx
]))
1584 /* Now provide mapping information. Add +1 for skipping over the
1586 for (idx
= 0; idx
< symcount
; idx
++)
1588 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1589 if (!sym_is_global (abfd
, syms
[idx
]))
1590 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1592 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1595 elf_num_locals (abfd
) = num_locals
;
1596 elf_num_globals (abfd
) = num_globals
;
1600 /* Compute the file positions we are going to put the sections at, and
1601 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1602 is not NULL, this is being called by the ELF backend linker. */
1605 elf_compute_section_file_positions (abfd
, link_info
)
1607 struct bfd_link_info
*link_info
;
1609 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1610 Elf_Internal_Shdr
*shstrtab_hdr
;
1612 if (abfd
->output_has_begun
)
1615 /* Do any elf backend specific processing first. */
1616 if (bed
->elf_backend_begin_write_processing
)
1617 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1619 if (! prep_headers (abfd
))
1622 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1624 if (!assign_section_numbers (abfd
))
1627 /* The backend linker builds symbol table information itself. */
1628 if (link_info
== NULL
)
1630 if (! swap_out_syms (abfd
))
1634 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1635 /* sh_name was set in prep_headers. */
1636 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1637 shstrtab_hdr
->sh_flags
= 0;
1638 shstrtab_hdr
->sh_addr
= 0;
1639 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1640 shstrtab_hdr
->sh_entsize
= 0;
1641 shstrtab_hdr
->sh_link
= 0;
1642 shstrtab_hdr
->sh_info
= 0;
1643 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1644 shstrtab_hdr
->sh_addralign
= 1;
1645 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1647 if (!assign_file_positions_except_relocs (abfd
,
1648 link_info
== NULL
? true : false))
1651 abfd
->output_has_begun
= true;
1657 /* Align to the maximum file alignment that could be required for any
1658 ELF data structure. */
1660 static INLINE file_ptr
1661 align_file_position (off
)
1664 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1667 /* Assign a file position to a section, optionally aligning to the
1668 required section alignment. */
1670 static INLINE file_ptr
1671 assign_file_position_for_section (i_shdrp
, offset
, align
)
1672 Elf_Internal_Shdr
*i_shdrp
;
1680 al
= i_shdrp
->sh_addralign
;
1682 offset
= BFD_ALIGN (offset
, al
);
1684 i_shdrp
->sh_offset
= offset
;
1685 if (i_shdrp
->rawdata
!= NULL
)
1686 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1687 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1688 offset
+= i_shdrp
->sh_size
;
1692 /* Get the size of the program header. This is called by the linker
1693 before any of the section VMA's are set, so it can't calculate the
1694 correct value for a strange memory layout. */
1696 static bfd_size_type
1697 get_program_header_size (abfd
)
1703 /* Assume we will need exactly two PT_LOAD segments: one for text
1704 and one for data. */
1707 s
= bfd_get_section_by_name (abfd
, ".interp");
1708 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1710 /* If we have a loadable interpreter section, we need a
1711 PT_INTERP segment. In this case, assume we also need a
1712 PT_PHDR segment, although that may not be true for all
1717 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1719 /* We need a PT_DYNAMIC segment. */
1723 return segs
* sizeof (Elf_External_Phdr
);
1726 /* Create the program header. OFF is the file offset where the
1727 program header should be written. FIRST is the first loadable ELF
1728 section. PHDR_SIZE is the size of the program header as returned
1729 by get_program_header_size. */
1732 map_program_segments (abfd
, off
, first
, phdr_size
)
1735 Elf_Internal_Shdr
*first
;
1736 bfd_size_type phdr_size
;
1738 Elf_Internal_Phdr phdrs
[10];
1739 unsigned int phdr_count
;
1740 Elf_Internal_Phdr
*phdr
;
1741 int phdr_size_adjust
;
1743 Elf_Internal_Shdr
**hdrpp
;
1744 asection
*sinterp
, *sdyn
;
1745 unsigned int last_type
;
1746 Elf_Internal_Ehdr
*i_ehdrp
;
1748 BFD_ASSERT ((abfd
->flags
& EXEC_P
) != 0);
1749 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1750 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1755 phdr_size_adjust
= 0;
1757 /* If we have a loadable .interp section, we must create a PT_INTERP
1758 segment which must precede all PT_LOAD segments. We assume that
1759 we must also create a PT_PHDR segment, although that may not be
1760 true for all targets. */
1761 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1762 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1764 BFD_ASSERT (first
!= NULL
);
1766 phdr
->p_type
= PT_PHDR
;
1768 phdr
->p_offset
= off
;
1770 /* Account for any adjustment made because of the alignment of
1771 the first loadable section. */
1772 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1773 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1775 /* The program header precedes all loadable sections. This lets
1776 us compute its loadable address. This depends on the linker
1778 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1781 phdr
->p_filesz
= phdr_size
;
1782 phdr
->p_memsz
= phdr_size
;
1784 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1785 phdr
->p_flags
= PF_R
| PF_X
;
1787 phdr
->p_align
= FILE_ALIGN
;
1788 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1790 /* Include the ELF header in the first loadable segment. */
1791 phdr_size_adjust
+= off
;
1796 phdr
->p_type
= PT_INTERP
;
1797 phdr
->p_offset
= sinterp
->filepos
;
1798 phdr
->p_vaddr
= sinterp
->vma
;
1800 phdr
->p_filesz
= sinterp
->_raw_size
;
1801 phdr
->p_memsz
= sinterp
->_raw_size
;
1802 phdr
->p_flags
= PF_R
;
1803 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1809 /* Look through the sections to see how they will be divided into
1810 program segments. The sections must be arranged in order by
1811 sh_addr for this to work correctly. */
1812 phdr
->p_type
= PT_NULL
;
1813 last_type
= SHT_PROGBITS
;
1814 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1815 i
< elf_elfheader (abfd
)->e_shnum
;
1818 Elf_Internal_Shdr
*hdr
;
1822 /* Ignore any section which will not be part of the process
1824 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1827 /* If this section fits in the segment we are constructing, add
1829 if (phdr
->p_type
!= PT_NULL
1830 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1831 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1832 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1834 bfd_size_type adjust
;
1836 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1837 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1838 if (hdr
->sh_type
!= SHT_NOBITS
)
1839 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1840 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1841 phdr
->p_flags
|= PF_W
;
1842 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1843 phdr
->p_flags
|= PF_X
;
1844 last_type
= hdr
->sh_type
;
1848 /* If we have a segment, move to the next one. */
1849 if (phdr
->p_type
!= PT_NULL
)
1855 /* Start a new segment. */
1856 phdr
->p_type
= PT_LOAD
;
1857 phdr
->p_offset
= hdr
->sh_offset
;
1858 phdr
->p_vaddr
= hdr
->sh_addr
;
1860 if (hdr
->sh_type
== SHT_NOBITS
)
1863 phdr
->p_filesz
= hdr
->sh_size
;
1864 phdr
->p_memsz
= hdr
->sh_size
;
1865 phdr
->p_flags
= PF_R
;
1866 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1867 phdr
->p_flags
|= PF_W
;
1868 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1869 phdr
->p_flags
|= PF_X
;
1870 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1874 && (sinterp
->flags
& SEC_LOAD
) != 0)
1876 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1877 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1878 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1879 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1882 last_type
= hdr
->sh_type
;
1885 if (phdr
->p_type
!= PT_NULL
)
1891 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1892 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1893 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1895 phdr
->p_type
= PT_DYNAMIC
;
1896 phdr
->p_offset
= sdyn
->filepos
;
1897 phdr
->p_vaddr
= sdyn
->vma
;
1899 phdr
->p_filesz
= sdyn
->_raw_size
;
1900 phdr
->p_memsz
= sdyn
->_raw_size
;
1901 phdr
->p_flags
= PF_R
;
1902 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1903 phdr
->p_flags
|= PF_W
;
1904 if ((sdyn
->flags
& SEC_CODE
) != 0)
1905 phdr
->p_flags
|= PF_X
;
1906 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1912 /* Make sure the return value from get_program_header_size matches
1913 what we computed here. */
1914 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1917 /* Set up program header information. */
1918 i_ehdrp
= elf_elfheader (abfd
);
1919 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1920 i_ehdrp
->e_phoff
= off
;
1921 i_ehdrp
->e_phnum
= phdr_count
;
1923 /* Save the program headers away. I don't think anybody uses this
1924 information right now. */
1925 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1928 * sizeof (Elf_Internal_Phdr
))));
1929 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1931 bfd_set_error (bfd_error_no_memory
);
1932 return (file_ptr
) -1;
1934 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1935 phdr_count
* sizeof (Elf_Internal_Phdr
));
1937 /* Write out the program headers. */
1938 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1939 return (file_ptr
) -1;
1941 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1943 Elf_External_Phdr extphdr
;
1945 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1946 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1947 != sizeof (Elf_External_Phdr
))
1948 return (file_ptr
) -1;
1951 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1954 /* Work out the file positions of all the sections. This is called by
1955 elf_compute_section_file_positions. All the section sizes and VMAs
1956 must be known before this is called.
1958 We do not consider reloc sections at this point, unless they form
1959 part of the loadable image. Reloc sections are assigned file
1960 positions in assign_file_positions_for_relocs, which is called by
1961 write_object_contents and final_link.
1963 If DOSYMS is false, we do not assign file positions for the symbol
1964 table or the string table. */
1967 assign_file_positions_except_relocs (abfd
, dosyms
)
1971 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1972 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1973 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1976 /* Start after the ELF header. */
1977 off
= i_ehdrp
->e_ehsize
;
1979 if ((abfd
->flags
& EXEC_P
) == 0)
1981 Elf_Internal_Shdr
**hdrpp
;
1984 /* We are not creating an executable, which means that we are
1985 not creating a program header, and that the actual order of
1986 the sections in the file is unimportant. */
1987 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1989 Elf_Internal_Shdr
*hdr
;
1992 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1994 hdr
->sh_offset
= -1;
1998 && (i
== tdata
->symtab_section
1999 || i
== tdata
->strtab_section
))
2001 hdr
->sh_offset
= -1;
2005 off
= assign_file_position_for_section (hdr
, off
, true);
2011 bfd_size_type phdr_size
;
2012 bfd_vma maxpagesize
;
2013 Elf_Internal_Shdr
**hdrpp
;
2015 Elf_Internal_Shdr
*first
;
2018 /* We are creating an executable. We must create a program
2019 header. We can't actually create the program header until we
2020 have set the file positions for the sections, but we can
2021 figure out how big it is going to be. */
2022 off
= align_file_position (off
);
2023 phdr_size
= get_program_header_size (abfd
);
2024 if (phdr_size
== (file_ptr
) -1)
2029 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2030 if (maxpagesize
== 0)
2033 /* FIXME: We might want to sort the sections on the sh_addr
2034 field here. For now, we just assume that the linker will
2035 create the sections in an appropriate order. */
2037 /* Assign file positions in two passes. In the first pass, we
2038 assign a file position to every section which forms part of
2039 the executable image. */
2041 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2043 Elf_Internal_Shdr
*hdr
;
2046 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2052 if ((abfd
->flags
& D_PAGED
) != 0)
2054 /* The section VMA must equal the file position modulo
2055 the page size. This is required by the program
2057 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2060 off
= assign_file_position_for_section (hdr
, off
, false);
2063 /* Assign file positions to all the sections which do not form
2064 part of the loadable image, except for the relocs. */
2065 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2067 Elf_Internal_Shdr
*hdr
;
2070 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2072 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2074 hdr
->sh_offset
= -1;
2078 && (i
== tdata
->symtab_section
2079 || i
== tdata
->strtab_section
))
2081 hdr
->sh_offset
= -1;
2085 off
= assign_file_position_for_section (hdr
, off
, true);
2088 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2089 if (phdr_map
== (file_ptr
) -1)
2091 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2094 /* Place the section headers. */
2095 off
= align_file_position (off
);
2096 i_ehdrp
->e_shoff
= off
;
2097 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2099 elf_tdata (abfd
)->next_file_pos
= off
;
2108 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2109 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2110 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2112 struct strtab
*shstrtab
;
2114 i_ehdrp
= elf_elfheader (abfd
);
2115 i_shdrp
= elf_elfsections (abfd
);
2117 shstrtab
= bfd_new_strtab (abfd
);
2121 elf_shstrtab (abfd
) = shstrtab
;
2123 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2124 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2125 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2126 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2128 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2129 i_ehdrp
->e_ident
[EI_DATA
] =
2130 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2131 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2133 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2134 i_ehdrp
->e_ident
[count
] = 0;
2136 if ((abfd
->flags
& DYNAMIC
) != 0)
2137 i_ehdrp
->e_type
= ET_DYN
;
2138 else if ((abfd
->flags
& EXEC_P
) != 0)
2139 i_ehdrp
->e_type
= ET_EXEC
;
2141 i_ehdrp
->e_type
= ET_REL
;
2143 switch (bfd_get_arch (abfd
))
2145 case bfd_arch_unknown
:
2146 i_ehdrp
->e_machine
= EM_NONE
;
2148 case bfd_arch_sparc
:
2150 i_ehdrp
->e_machine
= EM_SPARC64
;
2152 i_ehdrp
->e_machine
= EM_SPARC
;
2156 i_ehdrp
->e_machine
= EM_386
;
2159 i_ehdrp
->e_machine
= EM_68K
;
2162 i_ehdrp
->e_machine
= EM_88K
;
2165 i_ehdrp
->e_machine
= EM_860
;
2167 case bfd_arch_mips
: /* MIPS Rxxxx */
2168 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2171 i_ehdrp
->e_machine
= EM_PARISC
;
2173 case bfd_arch_powerpc
:
2174 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2176 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2178 i_ehdrp
->e_machine
= EM_NONE
;
2180 i_ehdrp
->e_version
= EV_CURRENT
;
2181 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2183 /* no program header, for now. */
2184 i_ehdrp
->e_phoff
= 0;
2185 i_ehdrp
->e_phentsize
= 0;
2186 i_ehdrp
->e_phnum
= 0;
2188 /* each bfd section is section header entry */
2189 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2190 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2192 /* if we're building an executable, we'll need a program header table */
2193 if (abfd
->flags
& EXEC_P
)
2195 /* it all happens later */
2197 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2199 /* elf_build_phdrs() returns a (NULL-terminated) array of
2200 Elf_Internal_Phdrs */
2201 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2202 i_ehdrp
->e_phoff
= outbase
;
2203 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2208 i_ehdrp
->e_phentsize
= 0;
2210 i_ehdrp
->e_phoff
= 0;
2213 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2215 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2217 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2219 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2220 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2221 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2228 swap_out_syms (abfd
)
2231 if (!elf_map_symbols (abfd
))
2234 /* Dump out the symtabs. */
2236 int symcount
= bfd_get_symcount (abfd
);
2237 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2238 struct strtab
*stt
= bfd_new_strtab (abfd
);
2239 Elf_Internal_Shdr
*symtab_hdr
;
2240 Elf_Internal_Shdr
*symstrtab_hdr
;
2241 Elf_External_Sym
*outbound_syms
;
2246 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2247 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2248 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2249 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2250 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2251 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2253 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2254 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2256 outbound_syms
= (Elf_External_Sym
*)
2257 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2260 bfd_set_error (bfd_error_no_memory
);
2263 /* now generate the data (for "contents") */
2265 /* Fill in zeroth symbol and swap it out. */
2266 Elf_Internal_Sym sym
;
2272 sym
.st_shndx
= SHN_UNDEF
;
2273 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2275 for (idx
= 0; idx
< symcount
; idx
++)
2277 Elf_Internal_Sym sym
;
2278 bfd_vma value
= syms
[idx
]->value
;
2279 elf_symbol_type
*type_ptr
;
2281 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2282 /* Section symbols have no names. */
2286 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2287 if (sym
.st_name
== (unsigned long) -1)
2291 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2293 if (bfd_is_com_section (syms
[idx
]->section
))
2295 /* ELF common symbols put the alignment into the `value' field,
2296 and the size into the `size' field. This is backwards from
2297 how BFD handles it, so reverse it here. */
2298 sym
.st_size
= value
;
2299 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2300 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2301 syms
[idx
]->section
);
2305 asection
*sec
= syms
[idx
]->section
;
2308 if (sec
->output_section
)
2310 value
+= sec
->output_offset
;
2311 sec
= sec
->output_section
;
2314 sym
.st_value
= value
;
2315 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2316 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2320 /* Writing this would be a hell of a lot easier if we had
2321 some decent documentation on bfd, and knew what to expect
2322 of the library, and what to demand of applications. For
2323 example, it appears that `objcopy' might not set the
2324 section of a symbol to be a section that is actually in
2326 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2327 BFD_ASSERT (sec2
!= 0);
2328 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2329 BFD_ASSERT (shndx
!= -1);
2333 if (bfd_is_com_section (syms
[idx
]->section
))
2334 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2335 else if (bfd_is_und_section (syms
[idx
]->section
))
2336 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2337 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2338 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2339 else if (syms
[idx
]->flags
& BSF_FILE
)
2340 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2343 int bind
= STB_LOCAL
;
2344 int type
= STT_OBJECT
;
2345 unsigned int flags
= syms
[idx
]->flags
;
2347 if (flags
& BSF_LOCAL
)
2349 else if (flags
& BSF_WEAK
)
2351 else if (flags
& BSF_GLOBAL
)
2354 if (flags
& BSF_FUNCTION
)
2357 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2361 elf_swap_symbol_out (abfd
, &sym
,
2363 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2366 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2367 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2368 symstrtab_hdr
->sh_size
= stt
->length
;
2369 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2371 symstrtab_hdr
->sh_flags
= 0;
2372 symstrtab_hdr
->sh_addr
= 0;
2373 symstrtab_hdr
->sh_entsize
= 0;
2374 symstrtab_hdr
->sh_link
= 0;
2375 symstrtab_hdr
->sh_info
= 0;
2376 symstrtab_hdr
->sh_addralign
= 1;
2377 symstrtab_hdr
->size
= 0;
2384 write_shdrs_and_ehdr (abfd
)
2387 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2388 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2389 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2390 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2392 struct strtab
*shstrtab
;
2394 i_ehdrp
= elf_elfheader (abfd
);
2395 i_shdrp
= elf_elfsections (abfd
);
2396 shstrtab
= elf_shstrtab (abfd
);
2398 /* swap the header before spitting it out... */
2401 elf_debug_file (i_ehdrp
);
2403 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2404 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2405 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2406 != sizeof (x_ehdr
)))
2409 /* at this point we've concocted all the ELF sections... */
2410 x_shdrp
= (Elf_External_Shdr
*)
2411 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2414 bfd_set_error (bfd_error_no_memory
);
2418 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2421 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2424 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2426 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2427 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2428 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2431 /* need to dump the string table too... */
2436 /* Assign file positions for all the reloc sections which are not part
2437 of the loadable file image. */
2440 assign_file_positions_for_relocs (abfd
)
2445 Elf_Internal_Shdr
**shdrpp
;
2447 off
= elf_tdata (abfd
)->next_file_pos
;
2449 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2450 i
< elf_elfheader (abfd
)->e_shnum
;
2453 Elf_Internal_Shdr
*shdrp
;
2456 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2457 && shdrp
->sh_offset
== -1)
2458 off
= assign_file_position_for_section (shdrp
, off
, true);
2461 elf_tdata (abfd
)->next_file_pos
= off
;
2465 NAME(bfd_elf
,write_object_contents
) (abfd
)
2468 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2469 Elf_Internal_Ehdr
*i_ehdrp
;
2470 Elf_Internal_Shdr
**i_shdrp
;
2473 if (! abfd
->output_has_begun
2474 && ! elf_compute_section_file_positions (abfd
,
2475 (struct bfd_link_info
*) NULL
))
2478 i_shdrp
= elf_elfsections (abfd
);
2479 i_ehdrp
= elf_elfheader (abfd
);
2481 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2482 assign_file_positions_for_relocs (abfd
);
2484 /* After writing the headers, we need to write the sections too... */
2485 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2487 if (bed
->elf_backend_section_processing
)
2488 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2489 if (i_shdrp
[count
]->contents
)
2491 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2492 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2494 != i_shdrp
[count
]->sh_size
))
2499 if (bed
->elf_backend_final_write_processing
)
2500 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
2502 return write_shdrs_and_ehdr (abfd
);
2505 /* Given an index of a section, retrieve a pointer to it. Note
2506 that for our purposes, sections are indexed by {1, 2, ...} with
2507 0 being an illegal index. */
2509 /* In the original, each ELF section went into exactly one BFD
2510 section. This doesn't really make sense, so we need a real mapping.
2511 The mapping has to hide in the Elf_Internal_Shdr since asection
2512 doesn't have anything like a tdata field... */
2515 section_from_elf_index (abfd
, index
)
2519 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2520 be returned from this routine? */
2522 if (index
== SHN_ABS
)
2523 return bfd_com_section_ptr
; /* not abs? */
2524 if (index
== SHN_COMMON
)
2525 return bfd_com_section_ptr
;
2527 if (index
> elf_elfheader (abfd
)->e_shnum
)
2531 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2533 switch (hdr
->sh_type
)
2535 /* ELF sections that map to BFD sections */
2540 if (hdr
->rawdata
== NULL
)
2542 if (! bfd_section_from_shdr (abfd
, index
))
2545 return (struct sec
*) hdr
->rawdata
;
2548 return bfd_abs_section_ptr
;
2553 /* given a section, search the header to find them... */
2555 elf_section_from_bfd_section (abfd
, asect
)
2559 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2561 Elf_Internal_Shdr
*hdr
;
2562 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2564 if (asect
->owner
== NULL
)
2566 if (bfd_is_abs_section (asect
))
2568 if (bfd_is_com_section (asect
))
2570 if (bfd_is_und_section (asect
))
2575 BFD_ASSERT (asect
->owner
== abfd
);
2577 for (index
= 0; index
< maxindex
; index
++)
2579 hdr
= i_shdrp
[index
];
2580 switch (hdr
->sh_type
)
2582 /* ELF sections that map to BFD sections */
2591 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2598 /* We sometimes map a reloc section to a BFD section. */
2599 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2600 && (asection
*) hdr
->rawdata
== asect
)
2605 /* We map most string tables to BFD sections. */
2606 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2607 && index
!= elf_onesymtab (abfd
)
2608 && (asection
*) hdr
->rawdata
== asect
)
2614 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2616 if (bed
->elf_backend_section_from_bfd_section
)
2621 if ((*bed
->elf_backend_section_from_bfd_section
)
2622 (abfd
, hdr
, asect
, &retval
))
2632 /* given a symbol, return the bfd index for that symbol. */
2634 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2636 struct symbol_cache_entry
**asym_ptr_ptr
;
2638 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2640 flagword flags
= asym_ptr
->flags
;
2642 /* When gas creates relocations against local labels, it creates its
2643 own symbol for the section, but does put the symbol into the
2644 symbol chain, so udata is 0. When the linker is generating
2645 relocatable output, this section symbol may be for one of the
2646 input sections rather than the output section. */
2647 if (asym_ptr
->udata
== (PTR
) 0
2648 && (flags
& BSF_SECTION_SYM
)
2649 && asym_ptr
->section
)
2653 if (asym_ptr
->section
->output_section
!= NULL
)
2654 indx
= asym_ptr
->section
->output_section
->index
;
2656 indx
= asym_ptr
->section
->index
;
2657 if (elf_section_syms (abfd
)[indx
])
2658 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2661 if (asym_ptr
->udata
)
2662 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2672 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2673 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2682 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2684 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2687 Elf_Internal_Shdr
*hdr
;
2688 long symcount
; /* Number of external ELF symbols */
2689 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2690 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2691 Elf_Internal_Sym i_sym
;
2692 Elf_External_Sym
*x_symp
= NULL
;
2694 /* Read each raw ELF symbol, converting from external ELF form to
2695 internal ELF form, and then using the information to create a
2696 canonical bfd symbol table entry.
2698 Note that we allocate the initial bfd canonical symbol buffer
2699 based on a one-to-one mapping of the ELF symbols to canonical
2700 symbols. We actually use all the ELF symbols, so there will be no
2701 space left over at the end. When we have all the symbols, we
2702 build the caller's pointer vector. */
2705 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2707 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2708 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2711 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2714 sym
= symbase
= NULL
;
2719 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2722 symbase
= ((elf_symbol_type
*)
2723 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2724 if (symbase
== (elf_symbol_type
*) NULL
)
2726 bfd_set_error (bfd_error_no_memory
);
2731 /* Temporarily allocate room for the raw ELF symbols. */
2732 x_symp
= ((Elf_External_Sym
*)
2733 malloc (symcount
* sizeof (Elf_External_Sym
)));
2734 if (x_symp
== NULL
&& symcount
!= 0)
2736 bfd_set_error (bfd_error_no_memory
);
2740 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2741 != symcount
* sizeof (Elf_External_Sym
))
2743 /* Skip first symbol, which is a null dummy. */
2744 for (i
= 1; i
< symcount
; i
++)
2746 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2747 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2748 #ifdef ELF_KEEP_EXTSYM
2749 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2751 sym
->symbol
.the_bfd
= abfd
;
2753 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2756 sym
->symbol
.value
= i_sym
.st_value
;
2758 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2760 sym
->symbol
.section
= section_from_elf_index (abfd
,
2762 if (sym
->symbol
.section
== NULL
)
2764 /* This symbol is in a section for which we did not
2765 create a BFD section. Just use bfd_abs_section,
2766 although it is wrong. FIXME. */
2767 sym
->symbol
.section
= bfd_abs_section_ptr
;
2770 else if (i_sym
.st_shndx
== SHN_ABS
)
2772 sym
->symbol
.section
= bfd_abs_section_ptr
;
2774 else if (i_sym
.st_shndx
== SHN_COMMON
)
2776 sym
->symbol
.section
= bfd_com_section_ptr
;
2777 /* Elf puts the alignment into the `value' field, and
2778 the size into the `size' field. BFD wants to see the
2779 size in the value field, and doesn't care (at the
2780 moment) about the alignment. */
2781 sym
->symbol
.value
= i_sym
.st_size
;
2783 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2785 sym
->symbol
.section
= bfd_und_section_ptr
;
2788 sym
->symbol
.section
= bfd_abs_section_ptr
;
2790 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2792 switch (ELF_ST_BIND (i_sym
.st_info
))
2795 sym
->symbol
.flags
|= BSF_LOCAL
;
2798 sym
->symbol
.flags
|= BSF_GLOBAL
;
2801 sym
->symbol
.flags
|= BSF_WEAK
;
2805 switch (ELF_ST_TYPE (i_sym
.st_info
))
2808 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2811 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2814 sym
->symbol
.flags
|= BSF_FUNCTION
;
2819 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2821 /* Do some backend-specific processing on this symbol. */
2823 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2824 if (ebd
->elf_backend_symbol_processing
)
2825 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2832 /* Do some backend-specific processing on this symbol table. */
2834 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2835 if (ebd
->elf_backend_symbol_table_processing
)
2836 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2839 /* We rely on the zalloc to clear out the final symbol entry. */
2841 symcount
= sym
- symbase
;
2843 /* Fill in the user's symbol pointer vector if needed. */
2851 *symptrs
++ = &sym
->symbol
;
2854 *symptrs
= 0; /* Final null pointer */
2866 /* Return the number of bytes required to hold the symtab vector.
2868 Note that we base it on the count plus 1, since we will null terminate
2869 the vector allocated based on this size. However, the ELF symbol table
2870 always has a dummy entry as symbol #0, so it ends up even. */
2873 elf_get_symtab_upper_bound (abfd
)
2878 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2880 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2881 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2887 elf_get_dynamic_symtab_upper_bound (abfd
)
2892 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2894 if (elf_dynsymtab (abfd
) == 0)
2896 bfd_set_error (bfd_error_invalid_operation
);
2900 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2901 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2907 elf_get_reloc_upper_bound (abfd
, asect
)
2911 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2914 /* Read in and swap the external relocs. */
2917 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2922 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2923 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2924 PTR allocated
= NULL
;
2925 bfd_byte
*native_relocs
;
2931 if (asect
->relocation
!= NULL
)
2934 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2935 && (asect
->reloc_count
2936 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2938 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2939 if (allocated
== NULL
)
2941 bfd_set_error (bfd_error_no_memory
);
2945 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2946 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2947 != d
->rel_hdr
.sh_size
))
2950 native_relocs
= (bfd_byte
*) allocated
;
2952 relents
= ((arelent
*)
2953 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2954 if (relents
== NULL
)
2956 bfd_set_error (bfd_error_no_memory
);
2960 entsize
= d
->rel_hdr
.sh_entsize
;
2961 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2962 || entsize
== sizeof (Elf_External_Rela
));
2964 for (i
= 0, relent
= relents
;
2965 i
< asect
->reloc_count
;
2966 i
++, relent
++, native_relocs
+= entsize
)
2968 Elf_Internal_Rela rela
;
2969 Elf_Internal_Rel rel
;
2971 if (entsize
== sizeof (Elf_External_Rela
))
2972 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2975 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2976 rela
.r_offset
= rel
.r_offset
;
2977 rela
.r_info
= rel
.r_info
;
2981 /* The address of an ELF reloc is section relative for an object
2982 file, and absolute for an executable file or shared library.
2983 The address of a BFD reloc is always section relative. */
2984 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2985 relent
->address
= rela
.r_offset
;
2987 relent
->address
= rela
.r_offset
- asect
->vma
;
2989 if (ELF_R_SYM (rela
.r_info
) == 0)
2990 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2995 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
2998 /* Canonicalize ELF section symbols. FIXME: Why? */
2999 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3000 relent
->sym_ptr_ptr
= ps
;
3002 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3005 relent
->addend
= rela
.r_addend
;
3007 if (entsize
== sizeof (Elf_External_Rela
))
3008 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3010 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3013 asect
->relocation
= relents
;
3015 if (allocated
!= NULL
)
3021 if (allocated
!= NULL
)
3028 elf_debug_section (str
, num
, hdr
)
3031 Elf_Internal_Shdr
*hdr
;
3033 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3035 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3036 (long) hdr
->sh_name
,
3037 (long) hdr
->sh_type
,
3038 (long) hdr
->sh_flags
);
3040 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3041 (long) hdr
->sh_addr
,
3042 (long) hdr
->sh_offset
,
3043 (long) hdr
->sh_size
);
3045 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3046 (long) hdr
->sh_link
,
3047 (long) hdr
->sh_info
,
3048 (long) hdr
->sh_addralign
);
3049 fprintf (stderr
, "sh_entsize = %ld\n",
3050 (long) hdr
->sh_entsize
);
3051 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3052 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3053 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3058 elf_debug_file (ehdrp
)
3059 Elf_Internal_Ehdr
*ehdrp
;
3061 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3062 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3063 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3064 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3065 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3066 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3067 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3071 /* Canonicalize the relocs. */
3074 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3083 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3086 tblptr
= section
->relocation
;
3087 for (i
= 0; i
< section
->reloc_count
; i
++)
3088 *relptr
++ = tblptr
++;
3092 return section
->reloc_count
;
3096 elf_get_symtab (abfd
, alocation
)
3098 asymbol
**alocation
;
3100 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3103 bfd_get_symcount (abfd
) = symcount
;
3108 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3110 asymbol
**alocation
;
3112 return elf_slurp_symbol_table (abfd
, alocation
, true);
3116 elf_make_empty_symbol (abfd
)
3119 elf_symbol_type
*newsym
;
3121 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3124 bfd_set_error (bfd_error_no_memory
);
3129 newsym
->symbol
.the_bfd
= abfd
;
3130 return &newsym
->symbol
;
3135 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3140 bfd_symbol_info (symbol
, ret
);
3144 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3148 bfd_print_symbol_type how
;
3150 FILE *file
= (FILE *) filep
;
3153 case bfd_print_symbol_name
:
3154 fprintf (file
, "%s", symbol
->name
);
3156 case bfd_print_symbol_more
:
3157 fprintf (file
, "elf ");
3158 fprintf_vma (file
, symbol
->value
);
3159 fprintf (file
, " %lx", (long) symbol
->flags
);
3161 case bfd_print_symbol_all
:
3163 CONST
char *section_name
;
3164 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3165 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3166 fprintf (file
, " %s\t%s",
3176 elf_get_lineno (ignore_abfd
, symbol
)
3180 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3187 elf_set_arch_mach (abfd
, arch
, machine
)
3189 enum bfd_architecture arch
;
3190 unsigned long machine
;
3192 /* If this isn't the right architecture for this backend, and this
3193 isn't the generic backend, fail. */
3194 if (arch
!= get_elf_backend_data (abfd
)->arch
3195 && arch
!= bfd_arch_unknown
3196 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3199 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3203 elf_find_nearest_line (abfd
,
3214 CONST
char **filename_ptr
;
3215 CONST
char **functionname_ptr
;
3216 unsigned int *line_ptr
;
3222 elf_sizeof_headers (abfd
, reloc
)
3228 ret
= sizeof (Elf_External_Ehdr
);
3230 ret
+= get_program_header_size (abfd
);
3235 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3240 bfd_size_type count
;
3242 Elf_Internal_Shdr
*hdr
;
3244 if (! abfd
->output_has_begun
3245 && ! elf_compute_section_file_positions (abfd
,
3246 (struct bfd_link_info
*) NULL
))
3249 hdr
= &elf_section_data (section
)->this_hdr
;
3251 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3253 if (bfd_write (location
, 1, count
, abfd
) != count
)
3260 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3263 Elf_Internal_Rela
*dst
;
3265 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3271 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3274 Elf_Internal_Rel
*dst
;
3276 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3282 /* Core file support */
3284 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3285 #include <sys/procfs.h>
3287 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3288 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3289 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3295 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3302 prstatus_t
*status
= (prstatus_t
*) 0;
3304 if (descsz
== sizeof (prstatus_t
))
3306 newsect
= bfd_make_section (abfd
, ".reg");
3307 if (newsect
== NULL
)
3309 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3310 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3311 newsect
->flags
= SEC_HAS_CONTENTS
;
3312 newsect
->alignment_power
= 2;
3313 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3315 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3321 /* Stash a copy of the prpsinfo structure away for future use. */
3324 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3330 if (descsz
== sizeof (prpsinfo_t
))
3332 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3334 bfd_set_error (bfd_error_no_memory
);
3337 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3343 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3351 newsect
= bfd_make_section (abfd
, ".reg2");
3352 if (newsect
== NULL
)
3354 newsect
->_raw_size
= descsz
;
3355 newsect
->filepos
= filepos
;
3356 newsect
->flags
= SEC_HAS_CONTENTS
;
3357 newsect
->alignment_power
= 2;
3361 #endif /* HAVE_PROCFS */
3363 /* Return a pointer to the args (including the command name) that were
3364 seen by the program that generated the core dump. Note that for
3365 some reason, a spurious space is tacked onto the end of the args
3366 in some (at least one anyway) implementations, so strip it off if
3370 elf_core_file_failing_command (abfd
)
3374 if (core_prpsinfo (abfd
))
3376 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3377 char *scan
= p
->pr_psargs
;
3382 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3386 return p
->pr_psargs
;
3392 /* Return the number of the signal that caused the core dump. Presumably,
3393 since we have a core file, we got a signal of some kind, so don't bother
3394 checking the other process status fields, just return the signal number.
3398 elf_core_file_failing_signal (abfd
)
3402 if (core_prstatus (abfd
))
3404 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3410 /* Check to see if the core file could reasonably be expected to have
3411 come for the current executable file. Note that by default we return
3412 true unless we find something that indicates that there might be a
3417 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3426 /* First, xvecs must match since both are ELF files for the same target. */
3428 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3430 bfd_set_error (bfd_error_system_call
);
3436 /* If no prpsinfo, just return true. Otherwise, grab the last component
3437 of the exec'd pathname from the prpsinfo. */
3439 if (core_prpsinfo (core_bfd
))
3441 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3448 /* Find the last component of the executable pathname. */
3450 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3456 execname
= (char *) exec_bfd
->filename
;
3459 /* See if they match */
3461 return strcmp (execname
, corename
) ? false : true;
3467 #endif /* HAVE_PROCFS */
3470 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3471 the information that would normally be available from the /proc interface
3472 for the process, at the time the process dumped core. Currently this
3473 includes copies of the prstatus, prpsinfo, and fpregset structures.
3475 Since these structures are potentially machine dependent in size and
3476 ordering, bfd provides two levels of support for them. The first level,
3477 available on all machines since it does not require that the host
3478 have /proc support or the relevant include files, is to create a bfd
3479 section for each of the prstatus, prpsinfo, and fpregset structures,
3480 without any interpretation of their contents. With just this support,
3481 the bfd client will have to interpret the structures itself. Even with
3482 /proc support, it might want these full structures for it's own reasons.
3484 In the second level of support, where HAVE_PROCFS is defined, bfd will
3485 pick apart the structures to gather some additional information that
3486 clients may want, such as the general register set, the name of the
3487 exec'ed file and its arguments, the signal (if any) that caused the
3493 elf_corefile_note (abfd
, hdr
)
3495 Elf_Internal_Phdr
*hdr
;
3497 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3498 Elf_Internal_Note i_note
; /* Elf note, internal form */
3499 char *buf
= NULL
; /* Entire note segment contents */
3500 char *namedata
; /* Name portion of the note */
3501 char *descdata
; /* Descriptor portion of the note */
3502 char *sectname
; /* Name to use for new section */
3503 long filepos
; /* File offset to descriptor data */
3506 if (hdr
->p_filesz
> 0
3507 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3508 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3509 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3511 x_note_p
= (Elf_External_Note
*) buf
;
3512 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3514 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3515 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3516 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3517 namedata
= x_note_p
->name
;
3518 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3519 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3520 switch (i_note
.type
)
3523 /* process descdata as prstatus info */
3524 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3526 sectname
= ".prstatus";
3529 /* process descdata as fpregset info */
3530 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3532 sectname
= ".fpregset";
3535 /* process descdata as prpsinfo */
3536 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3538 sectname
= ".prpsinfo";
3541 /* Unknown descriptor, just ignore it. */
3545 if (sectname
!= NULL
)
3547 newsect
= bfd_make_section (abfd
, sectname
);
3548 if (newsect
== NULL
)
3550 newsect
->_raw_size
= i_note
.descsz
;
3551 newsect
->filepos
= filepos
;
3552 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3553 newsect
->alignment_power
= 2;
3555 x_note_p
= (Elf_External_Note
*)
3556 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3563 else if (hdr
->p_filesz
> 0)
3565 bfd_set_error (bfd_error_no_memory
);
3572 /* Core files are simply standard ELF formatted files that partition
3573 the file using the execution view of the file (program header table)
3574 rather than the linking view. In fact, there is no section header
3575 table in a core file.
3577 The process status information (including the contents of the general
3578 register set) and the floating point register set are stored in a
3579 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3580 that allow standard bfd access to the general registers (.reg) and the
3581 floating point registers (.reg2).
3586 elf_core_file_p (abfd
)
3589 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3590 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3591 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3592 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3593 unsigned int phindex
;
3594 struct elf_backend_data
*ebd
;
3596 /* Read in the ELF header in external format. */
3598 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3600 if (bfd_get_error () != bfd_error_system_call
)
3601 bfd_set_error (bfd_error_wrong_format
);
3605 /* Now check to see if we have a valid ELF file, and one that BFD can
3606 make use of. The magic number must match, the address size ('class')
3607 and byte-swapping must match our XVEC entry, and it must have a
3608 program header table (FIXME: See comments re segments at top of this
3611 if (elf_file_p (&x_ehdr
) == false)
3614 bfd_set_error (bfd_error_wrong_format
);
3618 /* FIXME, Check EI_VERSION here ! */
3622 int desired_address_size
= ELFCLASS32
;
3625 int desired_address_size
= ELFCLASS64
;
3628 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3632 /* Switch xvec to match the specified byte order. */
3633 switch (x_ehdr
.e_ident
[EI_DATA
])
3635 case ELFDATA2MSB
: /* Big-endian */
3636 if (abfd
->xvec
->byteorder_big_p
== false)
3639 case ELFDATA2LSB
: /* Little-endian */
3640 if (abfd
->xvec
->byteorder_big_p
== true)
3643 case ELFDATANONE
: /* No data encoding specified */
3644 default: /* Unknown data encoding specified */
3648 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3649 the tdata pointer in the bfd. */
3652 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3653 if (elf_tdata (abfd
) == NULL
)
3655 bfd_set_error (bfd_error_no_memory
);
3659 /* FIXME, `wrong' returns from this point onward, leak memory. */
3661 /* Now that we know the byte order, swap in the rest of the header */
3662 i_ehdrp
= elf_elfheader (abfd
);
3663 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3665 elf_debug_file (i_ehdrp
);
3668 ebd
= get_elf_backend_data (abfd
);
3670 /* Check that the ELF e_machine field matches what this particular
3671 BFD format expects. */
3672 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3674 const bfd_target
* const *target_ptr
;
3676 if (ebd
->elf_machine_code
!= EM_NONE
)
3679 /* This is the generic ELF target. Let it match any ELF target
3680 for which we do not have a specific backend. */
3681 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3683 struct elf_backend_data
*back
;
3685 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3687 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3688 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3690 /* target_ptr is an ELF backend which matches this
3691 object file, so reject the generic ELF target. */
3697 /* If there is no program header, or the type is not a core file, then
3699 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3702 /* Allocate space for a copy of the program header table in
3703 internal form, seek to the program header table in the file,
3704 read it in, and convert it to internal form. As a simple sanity
3705 check, verify that the what BFD thinks is the size of each program
3706 header table entry actually matches the size recorded in the file. */
3708 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3710 i_phdrp
= (Elf_Internal_Phdr
*)
3711 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3714 bfd_set_error (bfd_error_no_memory
);
3717 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3719 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3721 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3724 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3727 /* Once all of the program headers have been read and converted, we
3728 can start processing them. */
3730 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3732 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3733 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3735 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3740 /* Remember the entry point specified in the ELF file header. */
3742 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3747 /* ELF linker code. */
3749 static boolean elf_link_add_object_symbols
3750 PARAMS ((bfd
*, struct bfd_link_info
*));
3751 static boolean elf_link_add_archive_symbols
3752 PARAMS ((bfd
*, struct bfd_link_info
*));
3753 static Elf_Internal_Rela
*elf_link_read_relocs
3754 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3755 static boolean elf_adjust_dynamic_symbol
3756 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3758 /* Given an ELF BFD, add symbols to the global hash table as
3762 elf_bfd_link_add_symbols (abfd
, info
)
3764 struct bfd_link_info
*info
;
3766 switch (bfd_get_format (abfd
))
3769 return elf_link_add_object_symbols (abfd
, info
);
3771 return elf_link_add_archive_symbols (abfd
, info
);
3773 bfd_set_error (bfd_error_wrong_format
);
3778 /* Add symbols from an ELF archive file to the linker hash table. We
3779 don't use _bfd_generic_link_add_archive_symbols because of a
3780 problem which arises on UnixWare. The UnixWare libc.so is an
3781 archive which includes an entry libc.so.1 which defines a bunch of
3782 symbols. The libc.so archive also includes a number of other
3783 object files, which also define symbols, some of which are the same
3784 as those defined in libc.so.1. Correct linking requires that we
3785 consider each object file in turn, and include it if it defines any
3786 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3787 this; it looks through the list of undefined symbols, and includes
3788 any object file which defines them. When this algorithm is used on
3789 UnixWare, it winds up pulling in libc.so.1 early and defining a
3790 bunch of symbols. This means that some of the other objects in the
3791 archive are not included in the link, which is incorrect since they
3792 precede libc.so.1 in the archive.
3794 Fortunately, ELF archive handling is simpler than that done by
3795 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3796 oddities. In ELF, if we find a symbol in the archive map, and the
3797 symbol is currently undefined, we know that we must pull in that
3800 Unfortunately, we do have to make multiple passes over the symbol
3801 table until nothing further is resolved. */
3804 elf_link_add_archive_symbols (abfd
, info
)
3806 struct bfd_link_info
*info
;
3809 boolean
*defined
= NULL
;
3810 boolean
*included
= NULL
;
3814 if (! bfd_has_map (abfd
))
3816 bfd_set_error (bfd_error_no_symbols
);
3820 /* Keep track of all symbols we know to be already defined, and all
3821 files we know to be already included. This is to speed up the
3822 second and subsequent passes. */
3823 c
= bfd_ardata (abfd
)->symdef_count
;
3826 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3827 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3828 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3830 bfd_set_error (bfd_error_no_memory
);
3833 memset (defined
, 0, c
* sizeof (boolean
));
3834 memset (included
, 0, c
* sizeof (boolean
));
3836 symdefs
= bfd_ardata (abfd
)->symdefs
;
3849 symdefend
= symdef
+ c
;
3850 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3852 struct elf_link_hash_entry
*h
;
3854 struct bfd_link_hash_entry
*undefs_tail
;
3857 if (defined
[i
] || included
[i
])
3859 if (symdef
->file_offset
== last
)
3865 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3866 false, false, false);
3867 if (h
== (struct elf_link_hash_entry
*) NULL
)
3869 if (h
->root
.type
!= bfd_link_hash_undefined
)
3875 /* We need to include this archive member. */
3877 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3878 if (element
== (bfd
*) NULL
)
3881 if (! bfd_check_format (element
, bfd_object
))
3884 /* Doublecheck that we have not included this object
3885 already--it should be impossible, but there may be
3886 something wrong with the archive. */
3887 if (element
->archive_pass
!= 0)
3889 bfd_set_error (bfd_error_bad_value
);
3892 element
->archive_pass
= 1;
3894 undefs_tail
= info
->hash
->undefs_tail
;
3896 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3899 if (! elf_link_add_object_symbols (element
, info
))
3902 /* If there are any new undefined symbols, we need to make
3903 another pass through the archive in order to see whether
3904 they can be defined. FIXME: This isn't perfect, because
3905 common symbols wind up on undefs_tail and because an
3906 undefined symbol which is defined later on in this pass
3907 does not require another pass. This isn't a bug, but it
3908 does make the code less efficient than it could be. */
3909 if (undefs_tail
!= info
->hash
->undefs_tail
)
3912 /* Look backward to mark all symbols from this object file
3913 which we have already seen in this pass. */
3917 included
[mark
] = true;
3922 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3924 /* We mark subsequent symbols from this object file as we go
3925 on through the loop. */
3926 last
= symdef
->file_offset
;
3937 if (defined
!= (boolean
*) NULL
)
3939 if (included
!= (boolean
*) NULL
)
3944 /* Record a new dynamic symbol. We record the dynamic symbols as we
3945 read the input files, since we need to have a list of all of them
3946 before we can determine the final sizes of the output sections. */
3949 elf_link_record_dynamic_symbol (info
, h
)
3950 struct bfd_link_info
*info
;
3951 struct elf_link_hash_entry
*h
;
3953 if (h
->dynindx
== -1)
3955 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3956 ++elf_hash_table (info
)->dynsymcount
;
3957 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3958 elf_hash_table (info
)->dynstr
,
3959 h
->root
.root
.string
);
3960 if (h
->dynstr_index
== (unsigned long) -1)
3967 /* Add symbols from an ELF object file to the linker hash table. */
3970 elf_link_add_object_symbols (abfd
, info
)
3972 struct bfd_link_info
*info
;
3974 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3975 const Elf_Internal_Sym
*,
3976 const char **, flagword
*,
3977 asection
**, bfd_vma
*));
3978 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3979 asection
*, const Elf_Internal_Rela
*));
3981 Elf_Internal_Shdr
*hdr
;
3985 Elf_External_Sym
*buf
= NULL
;
3986 struct elf_link_hash_entry
**sym_hash
;
3988 Elf_External_Dyn
*dynbuf
= NULL
;
3989 struct elf_link_hash_entry
*weaks
;
3990 Elf_External_Sym
*esym
;
3991 Elf_External_Sym
*esymend
;
3993 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
3994 collect
= get_elf_backend_data (abfd
)->collect
;
3996 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3997 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3999 /* The sh_info field of the symtab header tells us where the
4000 external symbols start. We don't care about the local symbols at
4002 if (elf_bad_symtab (abfd
))
4004 extsymcount
= symcount
;
4009 extsymcount
= symcount
- hdr
->sh_info
;
4010 extsymoff
= hdr
->sh_info
;
4013 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4014 if (buf
== NULL
&& extsymcount
!= 0)
4016 bfd_set_error (bfd_error_no_memory
);
4020 /* We store a pointer to the hash table entry for each external
4022 sym_hash
= ((struct elf_link_hash_entry
**)
4024 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4025 if (sym_hash
== NULL
)
4027 bfd_set_error (bfd_error_no_memory
);
4030 elf_sym_hashes (abfd
) = sym_hash
;
4032 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4036 /* If we are creating a shared library, create all the dynamic
4037 sections immediately. We need to attach them to something,
4038 so we attach them to this BFD, provided it is the right
4039 format. FIXME: If there are no input BFD's of the same
4040 format as the output, we can't make a shared library. */
4042 && elf_hash_table (info
)->dynobj
== NULL
4043 && abfd
->xvec
== info
->hash
->creator
)
4045 if (! elf_link_create_dynamic_sections (abfd
, info
))
4047 elf_hash_table (info
)->dynobj
= abfd
;
4054 unsigned long strindex
;
4058 /* You can't use -r against a dynamic object. Also, there's no
4059 hope of using a dynamic object which does not exactly match
4060 the format of the output file. */
4061 if (info
->relocateable
4062 || info
->hash
->creator
!= abfd
->xvec
)
4064 bfd_set_error (bfd_error_invalid_operation
);
4068 /* Find the name to use in a DT_NEEDED entry that refers to this
4069 object. If the object has a DT_SONAME entry, we use it.
4070 Otherwise, if the generic linker stuck something in
4071 elf_dt_needed_name, we use that. Otherwise, we just use the
4073 name
= bfd_get_filename (abfd
);
4074 if (elf_dt_needed_name (abfd
) != NULL
)
4075 name
= elf_dt_needed_name (abfd
);
4076 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4079 Elf_External_Dyn
*extdyn
;
4080 Elf_External_Dyn
*extdynend
;
4082 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4085 bfd_set_error (bfd_error_no_memory
);
4089 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4090 (file_ptr
) 0, s
->_raw_size
))
4094 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4095 for (; extdyn
< extdynend
; extdyn
++)
4097 Elf_Internal_Dyn dyn
;
4099 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4100 if (dyn
.d_tag
== DT_SONAME
)
4105 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4108 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4109 name
= elf_string_from_elf_section (abfd
, link
,
4122 /* We do not want to include any of the sections in a dynamic
4123 object in the output file. We hack by simply clobbering the
4124 list of sections in the BFD. This could be handled more
4125 cleanly by, say, a new section flag; the existing
4126 SEC_NEVER_LOAD flag is not the one we want, because that one
4127 still implies that the section takes up space in the output
4129 abfd
->sections
= NULL
;
4131 /* If this is the first dynamic object found in the link, create
4132 the special sections required for dynamic linking. We need
4133 to put them somewhere, and attaching them to the first
4134 dynamic object is as good place as any. */
4135 if (elf_hash_table (info
)->dynobj
== NULL
)
4137 if (! elf_link_create_dynamic_sections (abfd
, info
))
4139 elf_hash_table (info
)->dynobj
= abfd
;
4142 /* Add a DT_NEEDED entry for this dynamic object. */
4143 strindex
= bfd_add_to_strtab (abfd
,
4144 elf_hash_table (info
)->dynstr
,
4146 if (strindex
== (unsigned long) -1)
4148 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4153 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4155 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4156 != extsymcount
* sizeof (Elf_External_Sym
)))
4161 esymend
= buf
+ extsymcount
;
4162 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4164 Elf_Internal_Sym sym
;
4170 struct elf_link_hash_entry
*h
= NULL
;
4173 elf_swap_symbol_in (abfd
, esym
, &sym
);
4175 flags
= BSF_NO_FLAGS
;
4177 value
= sym
.st_value
;
4180 bind
= ELF_ST_BIND (sym
.st_info
);
4181 if (bind
== STB_LOCAL
)
4183 /* This should be impossible, since ELF requires that all
4184 global symbols follow all local symbols, and that sh_info
4185 point to the first global symbol. Unfortunatealy, Irix 5
4189 else if (bind
== STB_GLOBAL
)
4191 else if (bind
== STB_WEAK
)
4195 /* Leave it up to the processor backend. */
4198 if (sym
.st_shndx
== SHN_UNDEF
)
4199 sec
= bfd_und_section_ptr
;
4200 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4202 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4207 else if (sym
.st_shndx
== SHN_ABS
)
4208 sec
= bfd_abs_section_ptr
;
4209 else if (sym
.st_shndx
== SHN_COMMON
)
4211 sec
= bfd_com_section_ptr
;
4212 /* What ELF calls the size we call the value. What ELF
4213 calls the value we call the alignment. */
4214 value
= sym
.st_size
;
4218 /* Leave it up to the processor backend. */
4221 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4222 if (name
== (const char *) NULL
)
4225 if (add_symbol_hook
)
4227 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4231 /* The hook function sets the name to NULL if this symbol
4232 should be skipped for some reason. */
4233 if (name
== (const char *) NULL
)
4237 /* Sanity check that all possibilities were handled. */
4238 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4240 bfd_set_error (bfd_error_bad_value
);
4244 if (bfd_is_und_section (sec
)
4245 || bfd_is_com_section (sec
))
4250 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4252 /* We need to look up the symbol now in order to get some of
4253 the dynamic object handling right. We pass the hash
4254 table entry in to _bfd_generic_link_add_one_symbol so
4255 that it does not have to look it up again. */
4256 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4257 true, false, false);
4262 /* If we are looking at a dynamic object, and this is a
4263 definition, we need to see if it has already been defined
4264 by some other object. If it has, we want to use the
4265 existing definition, and we do not want to report a
4266 multiple symbol definition error; we do this by
4267 clobbering sec to be bfd_und_section_ptr. */
4268 if (dynamic
&& definition
)
4270 if (h
->root
.type
== bfd_link_hash_defined
)
4271 sec
= bfd_und_section_ptr
;
4274 /* Similarly, if we are not looking at a dynamic object, and
4275 we have a definition, we want to override any definition
4276 we may have from a dynamic object. Symbols from regular
4277 files always take precedence over symbols from dynamic
4278 objects, even if they are defined after the dynamic
4279 object in the link. */
4282 && h
->root
.type
== bfd_link_hash_defined
4283 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4284 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4285 == bfd_target_elf_flavour
)
4286 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4289 /* Change the hash table entry to undefined, and let
4290 _bfd_generic_link_add_one_symbol do the right thing
4291 with the new definition. */
4292 h
->root
.type
= bfd_link_hash_undefined
;
4293 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4294 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4297 /* If this is a weak definition which we are going to use,
4298 and the symbol is currently undefined, record that the
4299 definition is weak. */
4301 && (flags
& BSF_WEAK
) != 0
4302 && ! bfd_is_und_section (sec
)
4303 && (h
->root
.type
== bfd_link_hash_new
4304 || h
->root
.type
== bfd_link_hash_undefined
4305 || h
->root
.type
== bfd_link_hash_weak
))
4306 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4309 if (! (_bfd_generic_link_add_one_symbol
4310 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4311 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4316 && (flags
& BSF_WEAK
) != 0
4317 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4318 && (*sym_hash
)->weakdef
== NULL
)
4320 /* Keep a list of all weak defined non function symbols from
4321 a dynamic object, using the weakdef field. Later in this
4322 function we will set the weakdef field to the correct
4323 value. We only put non-function symbols from dynamic
4324 objects on this list, because that happens to be the only
4325 time we need to know the normal symbol corresponding to a
4326 weak symbol, and the information is time consuming to
4327 figure out. If the weakdef field is not already NULL,
4328 then this symbol was already defined by some previous
4329 dynamic object, and we will be using that previous
4330 definition anyhow. */
4332 (*sym_hash
)->weakdef
= weaks
;
4336 /* Get the alignment of a common symbol. */
4337 if (sym
.st_shndx
== SHN_COMMON
4338 && h
->root
.type
== bfd_link_hash_common
)
4339 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4341 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4347 /* Remember the symbol size and type. */
4348 if (sym
.st_size
!= 0)
4350 /* FIXME: We should probably somehow give a warning if
4351 the symbol size changes. */
4352 h
->size
= sym
.st_size
;
4354 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4356 /* FIXME: We should probably somehow give a warning if
4357 the symbol type changes. */
4358 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4361 /* Set a flag in the hash table entry indicating the type of
4362 reference or definition we just found. Keep a count of
4363 the number of dynamic symbols we find. A dynamic symbol
4364 is one which is referenced or defined by both a regular
4365 object and a shared object, or one which is referenced or
4366 defined by more than one shared object. */
4367 old_flags
= h
->elf_link_hash_flags
;
4372 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4374 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4376 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4377 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4383 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4385 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4386 if ((old_flags
& new_flag
) != 0
4387 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4388 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4392 h
->elf_link_hash_flags
|= new_flag
;
4393 if (dynsym
&& h
->dynindx
== -1)
4395 if (! elf_link_record_dynamic_symbol (info
, h
))
4401 /* Now set the weakdefs field correctly for all the weak defined
4402 symbols we found. The only way to do this is to search all the
4403 symbols. Since we only need the information for non functions in
4404 dynamic objects, that's the only time we actually put anything on
4405 the list WEAKS. We need this information so that if a regular
4406 object refers to a symbol defined weakly in a dynamic object, the
4407 real symbol in the dynamic object is also put in the dynamic
4408 symbols; we also must arrange for both symbols to point to the
4409 same memory location. We could handle the general case of symbol
4410 aliasing, but a general symbol alias can only be generated in
4411 assembler code, handling it correctly would be very time
4412 consuming, and other ELF linkers don't handle general aliasing
4414 while (weaks
!= NULL
)
4416 struct elf_link_hash_entry
*hlook
;
4419 struct elf_link_hash_entry
**hpp
;
4420 struct elf_link_hash_entry
**hppend
;
4423 weaks
= hlook
->weakdef
;
4424 hlook
->weakdef
= NULL
;
4426 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4427 slook
= hlook
->root
.u
.def
.section
;
4428 vlook
= hlook
->root
.u
.def
.value
;
4430 hpp
= elf_sym_hashes (abfd
);
4431 hppend
= hpp
+ extsymcount
;
4432 for (; hpp
< hppend
; hpp
++)
4434 struct elf_link_hash_entry
*h
;
4438 && h
->root
.type
== bfd_link_hash_defined
4439 && h
->root
.u
.def
.section
== slook
4440 && h
->root
.u
.def
.value
== vlook
)
4444 /* If the weak definition is in the list of dynamic
4445 symbols, make sure the real definition is put there
4447 if (hlook
->dynindx
!= -1
4448 && h
->dynindx
== -1)
4450 if (! elf_link_record_dynamic_symbol (info
, h
))
4465 /* If this object is the same format as the output object, and it is
4466 not a shared library, then let the backend look through the
4469 This is required to build global offset table entries and to
4470 arrange for dynamic relocs. It is not required for the
4471 particular common case of linking non PIC code, even when linking
4472 against shared libraries, but unfortunately there is no way of
4473 knowing whether an object file has been compiled PIC or not.
4474 Looking through the relocs is not particularly time consuming.
4475 The problem is that we must either (1) keep the relocs in memory,
4476 which causes the linker to require additional runtime memory or
4477 (2) read the relocs twice from the input file, which wastes time.
4478 This would be a good case for using mmap.
4480 I have no idea how to handle linking PIC code into a file of a
4481 different format. It probably can't be done. */
4482 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4484 && abfd
->xvec
== info
->hash
->creator
4485 && check_relocs
!= NULL
)
4489 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4491 Elf_Internal_Rela
*internal_relocs
;
4494 if ((o
->flags
& SEC_RELOC
) == 0
4495 || o
->reloc_count
== 0)
4498 /* I believe we can ignore the relocs for any section which
4499 does not form part of the final process image, such as a
4500 debugging section. */
4501 if ((o
->flags
& SEC_ALLOC
) == 0)
4504 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4505 (Elf_Internal_Rela
*) NULL
,
4507 if (internal_relocs
== NULL
)
4510 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4512 if (! info
->keep_memory
)
4513 free (internal_relocs
);
4530 /* Create some sections which will be filled in with dynamic linking
4531 information. The ABFD argument is an input file which is a dynamic
4532 object. The dynamic sections take up virtual memory space when the
4533 final executable is run, so we need to create them before addresses
4534 are assigned to the output sections. We work out the actual
4535 contents and size of these sections later. */
4538 elf_link_create_dynamic_sections (abfd
, info
)
4540 struct bfd_link_info
*info
;
4543 register asection
*s
;
4544 struct elf_link_hash_entry
*h
;
4545 struct elf_backend_data
*bed
;
4547 /* Note that we set the SEC_IN_MEMORY flag for all of these
4549 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4551 /* A dynamically linked executable has a .interp section, but a
4552 shared library does not. */
4555 s
= bfd_make_section (abfd
, ".interp");
4557 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4561 s
= bfd_make_section (abfd
, ".dynsym");
4563 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4564 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4567 /* The first .dynsym symbol is a dummy. */
4568 elf_hash_table (info
)->dynsymcount
= 1;
4570 s
= bfd_make_section (abfd
, ".dynstr");
4572 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4575 /* Create a strtab to hold the dynamic symbol names. */
4576 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4577 if (elf_hash_table (info
)->dynstr
== NULL
)
4580 s
= bfd_make_section (abfd
, ".dynamic");
4582 || ! bfd_set_section_flags (abfd
, s
, flags
)
4583 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4586 /* The special symbol _DYNAMIC is always set to the start of the
4587 .dynamic section. This call occurs before we have processed the
4588 symbols for any dynamic object, so we don't have to worry about
4589 overriding a dynamic definition. We could set _DYNAMIC in a
4590 linker script, but we only want to define it if we are, in fact,
4591 creating a .dynamic section. We don't want to define it if there
4592 is no .dynamic section, since on some ELF platforms the start up
4593 code examines it to decide how to initialize the process. */
4595 if (! (_bfd_generic_link_add_one_symbol
4596 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4597 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4598 (struct bfd_link_hash_entry
**) &h
)))
4600 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4603 && ! elf_link_record_dynamic_symbol (info
, h
))
4606 s
= bfd_make_section (abfd
, ".hash");
4608 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4609 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4612 /* Let the backend create the rest of the sections. This lets the
4613 backend set the right flags. The backend will normally create
4614 the .got and .plt sections. */
4615 bed
= get_elf_backend_data (abfd
);
4616 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4619 /* Add an entry to the .dynamic table. */
4622 elf_add_dynamic_entry (info
, tag
, val
)
4623 struct bfd_link_info
*info
;
4627 Elf_Internal_Dyn dyn
;
4631 bfd_byte
*newcontents
;
4633 dynobj
= elf_hash_table (info
)->dynobj
;
4635 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4636 BFD_ASSERT (s
!= NULL
);
4638 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4639 if (s
->contents
== NULL
)
4640 newcontents
= (bfd_byte
*) malloc (newsize
);
4642 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4643 if (newcontents
== NULL
)
4645 bfd_set_error (bfd_error_no_memory
);
4650 dyn
.d_un
.d_val
= val
;
4651 elf_swap_dyn_out (dynobj
, &dyn
,
4652 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4654 s
->_raw_size
= newsize
;
4655 s
->contents
= newcontents
;
4660 /* Read and swap the relocs for a section. They may have been cached.
4661 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4662 they are used as buffers to read into. They are known to be large
4663 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4664 value is allocated using either malloc or bfd_alloc, according to
4665 the KEEP_MEMORY argument. */
4667 static Elf_Internal_Rela
*
4668 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4671 PTR external_relocs
;
4672 Elf_Internal_Rela
*internal_relocs
;
4673 boolean keep_memory
;
4675 Elf_Internal_Shdr
*rel_hdr
;
4677 Elf_Internal_Rela
*alloc2
= NULL
;
4679 if (elf_section_data (o
)->relocs
!= NULL
)
4680 return elf_section_data (o
)->relocs
;
4682 if (o
->reloc_count
== 0)
4685 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4687 if (internal_relocs
== NULL
)
4691 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4693 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4695 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4696 if (internal_relocs
== NULL
)
4698 bfd_set_error (bfd_error_no_memory
);
4703 if (external_relocs
== NULL
)
4705 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4708 bfd_set_error (bfd_error_no_memory
);
4711 external_relocs
= alloc1
;
4714 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4715 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4716 != rel_hdr
->sh_size
))
4719 /* Swap in the relocs. For convenience, we always produce an
4720 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4722 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4724 Elf_External_Rel
*erel
;
4725 Elf_External_Rel
*erelend
;
4726 Elf_Internal_Rela
*irela
;
4728 erel
= (Elf_External_Rel
*) external_relocs
;
4729 erelend
= erel
+ o
->reloc_count
;
4730 irela
= internal_relocs
;
4731 for (; erel
< erelend
; erel
++, irela
++)
4733 Elf_Internal_Rel irel
;
4735 elf_swap_reloc_in (abfd
, erel
, &irel
);
4736 irela
->r_offset
= irel
.r_offset
;
4737 irela
->r_info
= irel
.r_info
;
4738 irela
->r_addend
= 0;
4743 Elf_External_Rela
*erela
;
4744 Elf_External_Rela
*erelaend
;
4745 Elf_Internal_Rela
*irela
;
4747 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4749 erela
= (Elf_External_Rela
*) external_relocs
;
4750 erelaend
= erela
+ o
->reloc_count
;
4751 irela
= internal_relocs
;
4752 for (; erela
< erelaend
; erela
++, irela
++)
4753 elf_swap_reloca_in (abfd
, erela
, irela
);
4756 /* Cache the results for next time, if we can. */
4758 elf_section_data (o
)->relocs
= internal_relocs
;
4763 /* Don't free alloc2, since if it was allocated we are passing it
4764 back (under the name of internal_relocs). */
4766 return internal_relocs
;
4776 /* Record an assignment to a symbol made by a linker script. We need
4777 this in case some dynamic object refers to this symbol. */
4781 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4783 struct bfd_link_info
*info
;
4786 struct elf_link_hash_entry
*h
;
4788 /* This is called after we have examined all the input objects. If
4789 we are generating a shared library, we always output these
4790 symbols. Otherwise, if the symbol does not exist, it merely
4791 means that no object refers to it, and we can just ignore it at
4793 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4794 info
->shared
, info
->shared
, false);
4796 return ! info
->shared
;
4798 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4800 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4801 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4803 && h
->dynindx
== -1)
4805 if (! elf_link_record_dynamic_symbol (info
, h
))
4808 /* If this is a weak defined symbol, and we know a corresponding
4809 real symbol from the same dynamic object, make sure the real
4810 symbol is also made into a dynamic symbol. */
4811 if (h
->weakdef
!= NULL
4812 && h
->weakdef
->dynindx
== -1)
4814 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4822 /* Array used to determine the number of hash table buckets to use
4823 based on the number of symbols there are. If there are fewer than
4824 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4825 fewer than 37 we use 17 buckets, and so forth. We never use more
4826 than 521 buckets. */
4828 static const size_t elf_buckets
[] =
4830 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4833 /* Set up the sizes and contents of the ELF dynamic sections. This is
4834 called by the ELF linker emulation before_allocation routine. We
4835 must set the sizes of the sections before the linker sets the
4836 addresses of the various sections. */
4839 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, rpath
, info
, sinterpptr
)
4842 struct bfd_link_info
*info
;
4843 asection
**sinterpptr
;
4848 Elf_Internal_Sym isym
;
4851 struct elf_backend_data
*bed
;
4855 dynobj
= elf_hash_table (info
)->dynobj
;
4856 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4858 /* If there were no dynamic objects in the link, there is nothing to
4863 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4864 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4866 /* Set the size of the .dynsym and .hash sections. We counted the
4867 number of dynamic symbols in elf_link_add_object_symbols. We
4868 will build the contents of .dynsym and .hash when we build the
4869 final symbol table, because until then we do not know the correct
4870 value to give the symbols. We built the .dynstr section as we
4871 went along in elf_link_add_object_symbols. */
4872 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4873 BFD_ASSERT (s
!= NULL
);
4874 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4875 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4876 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4878 bfd_set_error (bfd_error_no_memory
);
4882 /* The first entry in .dynsym is a dummy symbol. */
4889 elf_swap_symbol_out (output_bfd
, &isym
,
4890 (Elf_External_Sym
*) s
->contents
);
4892 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4894 bucketcount
= elf_buckets
[i
];
4895 if (dynsymcount
< elf_buckets
[i
+ 1])
4899 s
= bfd_get_section_by_name (dynobj
, ".hash");
4900 BFD_ASSERT (s
!= NULL
);
4901 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4902 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4903 if (s
->contents
== NULL
)
4905 bfd_set_error (bfd_error_no_memory
);
4908 memset (s
->contents
, 0, s
->_raw_size
);
4910 put_word (output_bfd
, bucketcount
, s
->contents
);
4911 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4913 elf_hash_table (info
)->bucketcount
= bucketcount
;
4919 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4920 if (indx
== (unsigned long) -1
4921 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4925 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4926 BFD_ASSERT (s
!= NULL
);
4927 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4928 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4930 /* Find all symbols which were defined in a dynamic object and make
4931 the backend pick a reasonable value for them. */
4932 elf_link_hash_traverse (elf_hash_table (info
),
4933 elf_adjust_dynamic_symbol
,
4936 /* Add some entries to the .dynamic section. We fill in some of the
4937 values later, in elf_bfd_final_link, but we must add the entries
4938 now so that we know the final size of the .dynamic section. */
4939 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4941 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4944 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4946 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4949 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4950 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4951 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4952 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4953 elf_hash_table (info
)->dynstr
->length
)
4954 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4955 sizeof (Elf_External_Sym
)))
4958 /* The backend must work out the sizes of all the other dynamic
4960 bed
= get_elf_backend_data (output_bfd
);
4961 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4964 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4967 /* Make the backend pick a good value for a dynamic symbol. This is
4968 called via elf_link_hash_traverse, and also calls itself
4972 elf_adjust_dynamic_symbol (h
, data
)
4973 struct elf_link_hash_entry
*h
;
4976 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4978 struct elf_backend_data
*bed
;
4980 /* If this symbol is not defined by a dynamic object, or is not
4981 referenced by a regular object, ignore it. FIXME: Do we need to
4982 worry about symbols which are defined by one dynamic object and
4983 referenced by another one? */
4984 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4985 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4986 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4989 /* If we've already adjusted this symbol, don't do it again. This
4990 can happen via a recursive call. */
4991 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4994 /* Don't look at this symbol again. Note that we must set this
4995 after checking the above conditions, because we may look at a
4996 symbol once, decide not to do anything, and then get called
4997 recursively later after REF_REGULAR is set below. */
4998 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
5000 /* If this is a weak definition, and we know a real definition, and
5001 the real symbol is not itself defined by a regular object file,
5002 then get a good value for the real definition. We handle the
5003 real symbol first, for the convenience of the backend routine.
5005 Note that there is a confusing case here. If the real definition
5006 is defined by a regular object file, we don't get the real symbol
5007 from the dynamic object, but we do get the weak symbol. If the
5008 processor backend uses a COPY reloc, then if some routine in the
5009 dynamic object changes the real symbol, we will not see that
5010 change in the corresponding weak symbol. This is the way other
5011 ELF linkers work as well, and seems to be a result of the shared
5014 I will clarify this issue. Most SVR4 shared libraries define the
5015 variable _timezone and define timezone as a weak synonym. The
5016 tzset call changes _timezone. If you write
5017 extern int timezone;
5019 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5020 you might expect that, since timezone is a synonym for _timezone,
5021 the same number will print both times. However, if the processor
5022 backend uses a COPY reloc, then actually timezone will be copied
5023 into your process image, and, since you define _timezone
5024 yourself, _timezone will not. Thus timezone and _timezone will
5025 wind up at different memory locations. The tzset call will set
5026 _timezone, leaving timezone unchanged. */
5028 if (h
->weakdef
!= NULL
)
5030 struct elf_link_hash_entry
*weakdef
;
5032 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
5033 weakdef
= h
->weakdef
;
5034 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
5035 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
5036 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
5037 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5039 /* This symbol is defined or referenced by a regular object
5040 file, so we will not do anything special. Clear weakdef
5041 for the convenience of the processor backend. */
5046 /* There is an implicit reference by a regular object file
5047 via the weak symbol. */
5048 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5049 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5054 dynobj
= elf_hash_table (info
)->dynobj
;
5055 bed
= get_elf_backend_data (dynobj
);
5056 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5058 /* FIXME: No way to return error. */
5065 /* Final phase of ELF linker. */
5067 /* A structure we use to avoid passing large numbers of arguments. */
5069 struct elf_final_link_info
5071 /* General link information. */
5072 struct bfd_link_info
*info
;
5075 /* Symbol string table. */
5076 struct strtab
*symstrtab
;
5077 /* .dynsym section. */
5078 asection
*dynsym_sec
;
5079 /* .hash section. */
5081 /* Buffer large enough to hold contents of any section. */
5083 /* Buffer large enough to hold external relocs of any section. */
5084 PTR external_relocs
;
5085 /* Buffer large enough to hold internal relocs of any section. */
5086 Elf_Internal_Rela
*internal_relocs
;
5087 /* Buffer large enough to hold external local symbols of any input
5089 Elf_External_Sym
*external_syms
;
5090 /* Buffer large enough to hold internal local symbols of any input
5092 Elf_Internal_Sym
*internal_syms
;
5093 /* Array large enough to hold a symbol index for each local symbol
5094 of any input BFD. */
5096 /* Array large enough to hold a section pointer for each local
5097 symbol of any input BFD. */
5098 asection
**sections
;
5099 /* Buffer to hold swapped out symbols. */
5100 Elf_External_Sym
*symbuf
;
5101 /* Number of swapped out symbols in buffer. */
5102 size_t symbuf_count
;
5103 /* Number of symbols which fit in symbuf. */
5107 static boolean elf_link_output_sym
5108 PARAMS ((struct elf_final_link_info
*, const char *,
5109 Elf_Internal_Sym
*, asection
*));
5110 static boolean elf_link_flush_output_syms
5111 PARAMS ((struct elf_final_link_info
*));
5112 static boolean elf_link_output_extsym
5113 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5114 static boolean elf_link_input_bfd
5115 PARAMS ((struct elf_final_link_info
*, bfd
*));
5116 static boolean elf_reloc_link_order
5117 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5118 struct bfd_link_order
*));
5120 /* Do the final step of an ELF link. */
5123 elf_bfd_final_link (abfd
, info
)
5125 struct bfd_link_info
*info
;
5128 struct elf_final_link_info finfo
;
5129 register asection
*o
;
5130 register struct bfd_link_order
*p
;
5132 size_t max_contents_size
;
5133 size_t max_external_reloc_size
;
5134 size_t max_internal_reloc_count
;
5135 size_t max_sym_count
;
5137 Elf_Internal_Sym elfsym
;
5139 Elf_Internal_Shdr
*symtab_hdr
;
5140 Elf_Internal_Shdr
*symstrtab_hdr
;
5141 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5144 abfd
->flags
|= DYNAMIC
;
5146 dynobj
= elf_hash_table (info
)->dynobj
;
5149 finfo
.output_bfd
= abfd
;
5150 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5151 if (finfo
.symstrtab
== NULL
)
5155 finfo
.dynsym_sec
= NULL
;
5156 finfo
.hash_sec
= NULL
;
5160 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5161 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5162 if (finfo
.dynsym_sec
== NULL
5163 || finfo
.hash_sec
== NULL
)
5166 finfo
.contents
= NULL
;
5167 finfo
.external_relocs
= NULL
;
5168 finfo
.internal_relocs
= NULL
;
5169 finfo
.external_syms
= NULL
;
5170 finfo
.internal_syms
= NULL
;
5171 finfo
.indices
= NULL
;
5172 finfo
.sections
= NULL
;
5173 finfo
.symbuf
= NULL
;
5174 finfo
.symbuf_count
= 0;
5176 /* Count up the number of relocations we will output for each output
5177 section, so that we know the sizes of the reloc sections. We
5178 also figure out some maximum sizes. */
5179 max_contents_size
= 0;
5180 max_external_reloc_size
= 0;
5181 max_internal_reloc_count
= 0;
5183 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5187 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5189 if (p
->type
== bfd_section_reloc_link_order
5190 || p
->type
== bfd_symbol_reloc_link_order
)
5192 else if (p
->type
== bfd_indirect_link_order
)
5196 sec
= p
->u
.indirect
.section
;
5198 if (info
->relocateable
)
5199 o
->reloc_count
+= sec
->reloc_count
;
5201 if (sec
->_raw_size
> max_contents_size
)
5202 max_contents_size
= sec
->_raw_size
;
5203 if (sec
->_cooked_size
> max_contents_size
)
5204 max_contents_size
= sec
->_cooked_size
;
5206 /* We are interested in just local symbols, not all
5208 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5212 if (elf_bad_symtab (sec
->owner
))
5213 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5214 / sizeof (Elf_External_Sym
));
5216 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5218 if (sym_count
> max_sym_count
)
5219 max_sym_count
= sym_count
;
5221 if ((sec
->flags
& SEC_RELOC
) != 0)
5225 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5226 if (ext_size
> max_external_reloc_size
)
5227 max_external_reloc_size
= ext_size
;
5228 if (sec
->reloc_count
> max_internal_reloc_count
)
5229 max_internal_reloc_count
= sec
->reloc_count
;
5235 if (o
->reloc_count
> 0)
5236 o
->flags
|= SEC_RELOC
;
5239 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5240 set it (this is probably a bug) and if it is set
5241 assign_section_numbers will create a reloc section. */
5242 o
->flags
&=~ SEC_RELOC
;
5246 /* Figure out the file positions for everything but the symbol table
5247 and the relocs. We set symcount to force assign_section_numbers
5248 to create a symbol table. */
5249 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5250 BFD_ASSERT (! abfd
->output_has_begun
);
5251 if (! elf_compute_section_file_positions (abfd
, info
))
5254 /* That created the reloc sections. Set their sizes, and assign
5255 them file positions, and allocate some buffers. */
5256 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5258 if ((o
->flags
& SEC_RELOC
) != 0)
5260 Elf_Internal_Shdr
*rel_hdr
;
5261 register struct elf_link_hash_entry
**p
, **pend
;
5263 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5265 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5267 /* The contents field must last into write_object_contents,
5268 so we allocate it with bfd_alloc rather than malloc. */
5269 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5270 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5272 bfd_set_error (bfd_error_no_memory
);
5276 p
= ((struct elf_link_hash_entry
**)
5277 malloc (o
->reloc_count
5278 * sizeof (struct elf_link_hash_entry
*)));
5279 if (p
== NULL
&& o
->reloc_count
!= 0)
5281 bfd_set_error (bfd_error_no_memory
);
5284 elf_section_data (o
)->rel_hashes
= p
;
5285 pend
= p
+ o
->reloc_count
;
5286 for (; p
< pend
; p
++)
5289 /* Use the reloc_count field as an index when outputting the
5295 assign_file_positions_for_relocs (abfd
);
5297 /* We have now assigned file positions for all the sections except
5298 .symtab and .strtab. We start the .symtab section at the current
5299 file position, and write directly to it. We build the .strtab
5300 section in memory. When we add .dynsym support, we will build
5301 that in memory as well (.dynsym is smaller than .symtab). */
5303 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5304 /* sh_name is set in prep_headers. */
5305 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5306 symtab_hdr
->sh_flags
= 0;
5307 symtab_hdr
->sh_addr
= 0;
5308 symtab_hdr
->sh_size
= 0;
5309 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5310 /* sh_link is set in assign_section_numbers. */
5311 /* sh_info is set below. */
5312 /* sh_offset is set just below. */
5313 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5315 off
= elf_tdata (abfd
)->next_file_pos
;
5316 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5318 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5319 incorrect. We do not yet know the size of the .symtab section.
5320 We correct next_file_pos below, after we do know the size. */
5322 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5323 continuously seeking to the right position in the file. */
5324 if (! info
->keep_memory
|| max_sym_count
< 20)
5325 finfo
.symbuf_size
= 20;
5327 finfo
.symbuf_size
= max_sym_count
;
5328 finfo
.symbuf
= ((Elf_External_Sym
*)
5329 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5330 if (finfo
.symbuf
== NULL
)
5332 bfd_set_error (bfd_error_no_memory
);
5336 /* Start writing out the symbol table. The first symbol is always a
5338 elfsym
.st_value
= 0;
5341 elfsym
.st_other
= 0;
5342 elfsym
.st_shndx
= SHN_UNDEF
;
5343 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5344 &elfsym
, bfd_und_section_ptr
))
5348 /* Some standard ELF linkers do this, but we don't because it causes
5349 bootstrap comparison failures. */
5350 /* Output a file symbol for the output file as the second symbol.
5351 We output this even if we are discarding local symbols, although
5352 I'm not sure if this is correct. */
5353 elfsym
.st_value
= 0;
5355 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5356 elfsym
.st_other
= 0;
5357 elfsym
.st_shndx
= SHN_ABS
;
5358 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5359 &elfsym
, bfd_abs_section_ptr
))
5363 /* Output a symbol for each section. We output these even if we are
5364 discarding local symbols, since they are used for relocs. These
5365 symbols have no names. We store the index of each one in the
5366 index field of the section, so that we can find it again when
5367 outputting relocs. */
5368 elfsym
.st_value
= 0;
5370 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5371 elfsym
.st_other
= 0;
5372 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5374 o
= section_from_elf_index (abfd
, i
);
5375 if (! bfd_is_abs_section (o
))
5376 o
->target_index
= abfd
->symcount
;
5377 elfsym
.st_shndx
= i
;
5378 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5383 /* Allocate some memory to hold information read in from the input
5385 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5386 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5387 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5388 malloc (max_internal_reloc_count
5389 * sizeof (Elf_Internal_Rela
)));
5390 finfo
.external_syms
= ((Elf_External_Sym
*)
5391 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5392 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5393 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5394 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5395 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5396 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5397 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5398 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5399 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5400 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5401 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5402 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5404 bfd_set_error (bfd_error_no_memory
);
5408 /* Since ELF permits relocations to be against local symbols, we
5409 must have the local symbols available when we do the relocations.
5410 Since we would rather only read the local symbols once, and we
5411 would rather not keep them in memory, we handle all the
5412 relocations for a single input file at the same time.
5414 Unfortunately, there is no way to know the total number of local
5415 symbols until we have seen all of them, and the local symbol
5416 indices precede the global symbol indices. This means that when
5417 we are generating relocateable output, and we see a reloc against
5418 a global symbol, we can not know the symbol index until we have
5419 finished examining all the local symbols to see which ones we are
5420 going to output. To deal with this, we keep the relocations in
5421 memory, and don't output them until the end of the link. This is
5422 an unfortunate waste of memory, but I don't see a good way around
5423 it. Fortunately, it only happens when performing a relocateable
5424 link, which is not the common case. FIXME: If keep_memory is set
5425 we could write the relocs out and then read them again; I don't
5426 know how bad the memory loss will be. */
5428 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5429 sub
->output_has_begun
= false;
5430 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5432 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5434 if (p
->type
== bfd_indirect_link_order
5435 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5436 == bfd_target_elf_flavour
))
5438 sub
= p
->u
.indirect
.section
->owner
;
5439 if (! sub
->output_has_begun
)
5441 if (! elf_link_input_bfd (&finfo
, sub
))
5443 sub
->output_has_begun
= true;
5446 else if (p
->type
== bfd_section_reloc_link_order
5447 || p
->type
== bfd_symbol_reloc_link_order
)
5449 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5454 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5460 /* That wrote out all the local symbols. Finish up the symbol table
5461 with the global symbols. */
5463 /* The sh_info field records the index of the first non local
5465 symtab_hdr
->sh_info
= abfd
->symcount
;
5467 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5469 /* We get the global symbols from the hash table. */
5470 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5473 /* Flush all symbols to the file. */
5474 if (! elf_link_flush_output_syms (&finfo
))
5477 /* Now we know the size of the symtab section. */
5478 off
+= symtab_hdr
->sh_size
;
5480 /* Finish up the symbol string table (.strtab) section. */
5481 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5482 /* sh_name was set in prep_headers. */
5483 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5484 symstrtab_hdr
->sh_flags
= 0;
5485 symstrtab_hdr
->sh_addr
= 0;
5486 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5487 symstrtab_hdr
->sh_entsize
= 0;
5488 symstrtab_hdr
->sh_link
= 0;
5489 symstrtab_hdr
->sh_info
= 0;
5490 /* sh_offset is set just below. */
5491 symstrtab_hdr
->sh_addralign
= 1;
5492 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5494 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5495 elf_tdata (abfd
)->next_file_pos
= off
;
5497 /* Adjust the relocs to have the correct symbol indices. */
5498 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5500 struct elf_link_hash_entry
**rel_hash
;
5501 Elf_Internal_Shdr
*rel_hdr
;
5503 if ((o
->flags
& SEC_RELOC
) == 0)
5506 rel_hash
= elf_section_data (o
)->rel_hashes
;
5507 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5508 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5510 if (*rel_hash
== NULL
)
5513 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5515 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5517 Elf_External_Rel
*erel
;
5518 Elf_Internal_Rel irel
;
5520 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5521 elf_swap_reloc_in (abfd
, erel
, &irel
);
5522 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5523 ELF_R_TYPE (irel
.r_info
));
5524 elf_swap_reloc_out (abfd
, &irel
, erel
);
5528 Elf_External_Rela
*erela
;
5529 Elf_Internal_Rela irela
;
5531 BFD_ASSERT (rel_hdr
->sh_entsize
5532 == sizeof (Elf_External_Rela
));
5534 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5535 elf_swap_reloca_in (abfd
, erela
, &irela
);
5536 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5537 ELF_R_TYPE (irela
.r_info
));
5538 elf_swap_reloca_out (abfd
, &irela
, erela
);
5542 /* Set the reloc_count field to 0 to prevent write_relocs from
5543 trying to swap the relocs out itself. */
5547 /* If we are linking against a dynamic object, finish up the dynamic
5548 linking information. */
5551 Elf_External_Dyn
*dyncon
, *dynconend
;
5553 /* Fix up .dynamic entries. */
5554 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5555 BFD_ASSERT (o
!= NULL
);
5557 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5558 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5559 for (; dyncon
< dynconend
; dyncon
++)
5561 Elf_Internal_Dyn dyn
;
5565 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5587 o
= bfd_get_section_by_name (abfd
, name
);
5588 BFD_ASSERT (o
!= NULL
);
5589 dyn
.d_un
.d_ptr
= o
->vma
;
5590 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5597 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5602 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5604 Elf_Internal_Shdr
*hdr
;
5606 hdr
= elf_elfsections (abfd
)[i
];
5607 if (hdr
->sh_type
== type
5608 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5610 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5611 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5614 if (dyn
.d_un
.d_val
== 0
5615 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5616 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5620 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5625 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5628 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5630 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5632 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5634 BFD_ASSERT (info
->shared
);
5637 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5638 o
->contents
, o
->output_offset
,
5644 /* Now backend stuff. */
5645 if (bed
->elf_backend_final_write_processing
)
5646 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5648 if (finfo
.contents
!= NULL
)
5649 free (finfo
.contents
);
5650 if (finfo
.external_relocs
!= NULL
)
5651 free (finfo
.external_relocs
);
5652 if (finfo
.internal_relocs
!= NULL
)
5653 free (finfo
.internal_relocs
);
5654 if (finfo
.external_syms
!= NULL
)
5655 free (finfo
.external_syms
);
5656 if (finfo
.internal_syms
!= NULL
)
5657 free (finfo
.internal_syms
);
5658 if (finfo
.indices
!= NULL
)
5659 free (finfo
.indices
);
5660 if (finfo
.sections
!= NULL
)
5661 free (finfo
.sections
);
5662 if (finfo
.symbuf
!= NULL
)
5663 free (finfo
.symbuf
);
5664 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5666 if ((o
->flags
& SEC_RELOC
) != 0
5667 && elf_section_data (o
)->rel_hashes
!= NULL
)
5668 free (elf_section_data (o
)->rel_hashes
);
5674 if (finfo
.contents
!= NULL
)
5675 free (finfo
.contents
);
5676 if (finfo
.external_relocs
!= NULL
)
5677 free (finfo
.external_relocs
);
5678 if (finfo
.internal_relocs
!= NULL
)
5679 free (finfo
.internal_relocs
);
5680 if (finfo
.external_syms
!= NULL
)
5681 free (finfo
.external_syms
);
5682 if (finfo
.internal_syms
!= NULL
)
5683 free (finfo
.internal_syms
);
5684 if (finfo
.indices
!= NULL
)
5685 free (finfo
.indices
);
5686 if (finfo
.sections
!= NULL
)
5687 free (finfo
.sections
);
5688 if (finfo
.symbuf
!= NULL
)
5689 free (finfo
.symbuf
);
5690 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5692 if ((o
->flags
& SEC_RELOC
) != 0
5693 && elf_section_data (o
)->rel_hashes
!= NULL
)
5694 free (elf_section_data (o
)->rel_hashes
);
5700 /* Add a symbol to the output symbol table. */
5703 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5704 struct elf_final_link_info
*finfo
;
5706 Elf_Internal_Sym
*elfsym
;
5707 asection
*input_sec
;
5709 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5710 struct bfd_link_info
*info
,
5715 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5716 elf_backend_link_output_symbol_hook
;
5717 if (output_symbol_hook
!= NULL
)
5719 if (! ((*output_symbol_hook
)
5720 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5724 if (name
== (const char *) NULL
|| *name
== '\0')
5725 elfsym
->st_name
= 0;
5728 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5729 finfo
->symstrtab
, name
);
5730 if (elfsym
->st_name
== (unsigned long) -1)
5734 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5736 if (! elf_link_flush_output_syms (finfo
))
5740 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5741 finfo
->symbuf
+ finfo
->symbuf_count
);
5742 ++finfo
->symbuf_count
;
5744 ++finfo
->output_bfd
->symcount
;
5749 /* Flush the output symbols to the file. */
5752 elf_link_flush_output_syms (finfo
)
5753 struct elf_final_link_info
*finfo
;
5755 Elf_Internal_Shdr
*symtab
;
5757 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5759 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5761 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5762 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5763 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5766 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5768 finfo
->symbuf_count
= 0;
5773 /* Add an external symbol to the symbol table. This is called from
5774 the hash table traversal routine. */
5777 elf_link_output_extsym (h
, data
)
5778 struct elf_link_hash_entry
*h
;
5781 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5783 Elf_Internal_Sym sym
;
5784 asection
*input_sec
;
5786 /* We don't want to output symbols that have never been mentioned by
5787 a regular file, or that we have been told to strip. However, if
5788 h->indx is set to -2, the symbol is used by a reloc and we must
5792 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5793 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5794 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5795 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5797 else if (finfo
->info
->strip
== strip_all
5798 || (finfo
->info
->strip
== strip_some
5799 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5800 h
->root
.root
.string
,
5801 false, false) == NULL
))
5806 /* If we're stripping it, and it's not a dynamic symbol, there's
5807 nothing else to do. */
5808 if (strip
&& h
->dynindx
== -1)
5812 sym
.st_size
= h
->size
;
5814 if (h
->root
.type
== bfd_link_hash_weak
5815 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5816 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5818 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5820 switch (h
->root
.type
)
5823 case bfd_link_hash_new
:
5827 case bfd_link_hash_undefined
:
5828 input_sec
= bfd_und_section_ptr
;
5829 sym
.st_shndx
= SHN_UNDEF
;
5832 case bfd_link_hash_weak
:
5833 input_sec
= bfd_und_section_ptr
;
5834 sym
.st_shndx
= SHN_UNDEF
;
5837 case bfd_link_hash_defined
:
5840 input_sec
= h
->root
.u
.def
.section
;
5841 if (input_sec
->output_section
!= NULL
)
5843 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5844 input_sec
->output_section
);
5845 if (sym
.st_shndx
== (unsigned short) -1)
5847 /* FIXME: No way to handle errors. */
5851 /* ELF symbols in relocateable files are section relative,
5852 but in nonrelocateable files they are virtual
5854 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5855 if (! finfo
->info
->relocateable
)
5856 sym
.st_value
+= input_sec
->output_section
->vma
;
5860 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5861 == bfd_target_elf_flavour
5862 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5863 sym
.st_shndx
= SHN_UNDEF
;
5864 input_sec
= bfd_und_section_ptr
;
5869 case bfd_link_hash_common
:
5870 input_sec
= bfd_com_section_ptr
;
5871 sym
.st_shndx
= SHN_COMMON
;
5872 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
5875 case bfd_link_hash_indirect
:
5876 case bfd_link_hash_warning
:
5877 /* I have no idea how these should be handled. */
5881 /* If this symbol should be put in the .dynsym section, then put it
5882 there now. We have already know the symbol index. We also fill
5883 in the entry in the .hash section. */
5884 if (h
->dynindx
!= -1)
5886 struct elf_backend_data
*bed
;
5889 bfd_byte
*bucketpos
;
5892 sym
.st_name
= h
->dynstr_index
;
5894 /* Give the processor backend a chance to tweak the symbol
5895 value, and also to finish up anything that needs to be done
5897 bed
= get_elf_backend_data (finfo
->output_bfd
);
5898 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5899 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5901 /* FIXME: No way to return error. */
5905 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5906 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5909 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5910 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5911 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5912 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5913 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5914 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5915 put_word (finfo
->output_bfd
, chain
,
5916 ((bfd_byte
*) finfo
->hash_sec
->contents
5917 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5920 /* If we're stripping it, then it was just a dynamic symbol, and
5921 there's nothing else to do. */
5925 h
->indx
= finfo
->output_bfd
->symcount
;
5927 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5929 /* FIXME: No way to return error. */
5936 /* Link an input file into the linker output file. This function
5937 handles all the sections and relocations of the input file at once.
5938 This is so that we only have to read the local symbols once, and
5939 don't have to keep them in memory. */
5942 elf_link_input_bfd (finfo
, input_bfd
)
5943 struct elf_final_link_info
*finfo
;
5946 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5947 bfd
*, asection
*, bfd_byte
*,
5948 Elf_Internal_Rela
*,
5950 asection
**, char *));
5952 Elf_Internal_Shdr
*symtab_hdr
;
5955 Elf_External_Sym
*esym
;
5956 Elf_External_Sym
*esymend
;
5957 Elf_Internal_Sym
*isym
;
5959 asection
**ppsection
;
5962 output_bfd
= finfo
->output_bfd
;
5964 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5966 /* If this is a dynamic object, we don't want to do anything here:
5967 we don't want the local symbols, and we don't want the section
5969 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5972 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5973 if (elf_bad_symtab (input_bfd
))
5975 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5980 locsymcount
= symtab_hdr
->sh_info
;
5981 extsymoff
= symtab_hdr
->sh_info
;
5984 /* Read the local symbols. */
5986 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5987 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5988 locsymcount
, input_bfd
)
5989 != locsymcount
* sizeof (Elf_External_Sym
))))
5992 /* Swap in the local symbols and write out the ones which we know
5993 are going into the output file. */
5994 esym
= finfo
->external_syms
;
5995 esymend
= esym
+ locsymcount
;
5996 isym
= finfo
->internal_syms
;
5997 pindex
= finfo
->indices
;
5998 ppsection
= finfo
->sections
;
5999 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
6005 elf_swap_symbol_in (input_bfd
, esym
, isym
);
6008 if (elf_bad_symtab (input_bfd
))
6010 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6017 if (isym
->st_shndx
== SHN_UNDEF
)
6018 isec
= bfd_und_section_ptr
;
6019 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
6021 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6025 else if (isym
->st_shndx
== SHN_ABS
)
6026 isec
= bfd_abs_section_ptr
;
6027 else if (isym
->st_shndx
== SHN_COMMON
)
6028 isec
= bfd_com_section_ptr
;
6037 /* Don't output the first, undefined, symbol. */
6038 if (esym
== finfo
->external_syms
)
6041 /* If we are stripping all symbols, we don't want to output this
6043 if (finfo
->info
->strip
== strip_all
)
6046 /* We never output section symbols. Instead, we use the section
6047 symbol of the corresponding section in the output file. */
6048 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6051 /* If we are discarding all local symbols, we don't want to
6052 output this one. If we are generating a relocateable output
6053 file, then some of the local symbols may be required by
6054 relocs; we output them below as we discover that they are
6056 if (finfo
->info
->discard
== discard_all
)
6059 /* Get the name of the symbol. */
6060 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6065 /* See if we are discarding symbols with this name. */
6066 if ((finfo
->info
->strip
== strip_some
6067 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6069 || (finfo
->info
->discard
== discard_l
6070 && strncmp (name
, finfo
->info
->lprefix
,
6071 finfo
->info
->lprefix_len
) == 0))
6074 /* If we get here, we are going to output this symbol. */
6076 /* Adjust the section index for the output file. */
6077 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
6078 isec
->output_section
);
6079 if (isym
->st_shndx
== (unsigned short) -1)
6082 *pindex
= output_bfd
->symcount
;
6084 /* ELF symbols in relocateable files are section relative, but
6085 in executable files they are virtual addresses. Note that
6086 this code assumes that all ELF sections have an associated
6087 BFD section with a reasonable value for output_offset; below
6088 we assume that they also have a reasonable value for
6089 output_section. Any special sections must be set up to meet
6090 these requirements. */
6091 oldval
= isym
->st_value
;
6092 isym
->st_value
+= isec
->output_offset
;
6093 if (! finfo
->info
->relocateable
)
6094 isym
->st_value
+= isec
->output_section
->vma
;
6096 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
6099 /* Restore the old value for reloc handling. */
6100 isym
->st_value
= oldval
;
6103 /* Relocate the contents of each section. */
6104 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6106 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6109 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6110 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6112 /* Section was created by elf_link_create_dynamic_sections.
6113 FIXME: This test is fragile. */
6117 /* Read the contents of the section. */
6118 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6119 (file_ptr
) 0, o
->_raw_size
))
6122 if ((o
->flags
& SEC_RELOC
) != 0)
6124 Elf_Internal_Rela
*internal_relocs
;
6126 /* Get the swapped relocs. */
6127 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6128 finfo
->external_relocs
,
6129 finfo
->internal_relocs
,
6131 if (internal_relocs
== NULL
6132 && o
->reloc_count
> 0)
6135 /* Relocate the section by invoking a back end routine.
6137 The back end routine is responsible for adjusting the
6138 section contents as necessary, and (if using Rela relocs
6139 and generating a relocateable output file) adjusting the
6140 reloc addend as necessary.
6142 The back end routine does not have to worry about setting
6143 the reloc address or the reloc symbol index.
6145 The back end routine is given a pointer to the swapped in
6146 internal symbols, and can access the hash table entries
6147 for the external symbols via elf_sym_hashes (input_bfd).
6149 When generating relocateable output, the back end routine
6150 must handle STB_LOCAL/STT_SECTION symbols specially. The
6151 output symbol is going to be a section symbol
6152 corresponding to the output section, which will require
6153 the addend to be adjusted. */
6155 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6159 finfo
->internal_syms
,
6161 finfo
->symstrtab
->tab
))
6164 if (finfo
->info
->relocateable
)
6166 Elf_Internal_Rela
*irela
;
6167 Elf_Internal_Rela
*irelaend
;
6168 struct elf_link_hash_entry
**rel_hash
;
6169 Elf_Internal_Shdr
*input_rel_hdr
;
6170 Elf_Internal_Shdr
*output_rel_hdr
;
6172 /* Adjust the reloc addresses and symbol indices. */
6174 irela
= internal_relocs
;
6175 irelaend
= irela
+ o
->reloc_count
;
6176 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6177 + o
->output_section
->reloc_count
);
6178 for (; irela
< irelaend
; irela
++, rel_hash
++)
6181 Elf_Internal_Sym
*isym
;
6184 irela
->r_offset
+= o
->output_offset
;
6186 r_symndx
= ELF_R_SYM (irela
->r_info
);
6191 if (r_symndx
>= locsymcount
6192 || (elf_bad_symtab (input_bfd
)
6193 && finfo
->sections
[r_symndx
] == NULL
))
6197 /* This is a reloc against a global symbol. We
6198 have not yet output all the local symbols, so
6199 we do not know the symbol index of any global
6200 symbol. We set the rel_hash entry for this
6201 reloc to point to the global hash table entry
6202 for this symbol. The symbol index is then
6203 set at the end of elf_bfd_final_link. */
6204 indx
= r_symndx
- extsymoff
;
6205 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6207 /* Setting the index to -2 tells
6208 elf_link_output_extsym that this symbol is
6210 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6211 (*rel_hash
)->indx
= -2;
6216 /* This is a reloc against a local symbol. */
6219 isym
= finfo
->internal_syms
+ r_symndx
;
6220 sec
= finfo
->sections
[r_symndx
];
6221 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6223 /* I suppose the backend ought to fill in the
6224 section of any STT_SECTION symbol against a
6225 processor specific section. */
6226 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6228 else if (sec
== NULL
|| sec
->owner
== NULL
)
6230 bfd_set_error (bfd_error_bad_value
);
6235 r_symndx
= sec
->output_section
->target_index
;
6242 if (finfo
->indices
[r_symndx
] == -1)
6248 if (finfo
->info
->strip
== strip_all
)
6250 /* You can't do ld -r -s. */
6251 bfd_set_error (bfd_error_invalid_operation
);
6255 /* This symbol was skipped earlier, but
6256 since it is needed by a reloc, we
6257 must output it now. */
6258 link
= symtab_hdr
->sh_link
;
6259 name
= elf_string_from_elf_section (input_bfd
,
6265 osec
= sec
->output_section
;
6267 elf_section_from_bfd_section (output_bfd
,
6269 if (isym
->st_shndx
== (unsigned short) -1)
6272 isym
->st_value
+= sec
->output_offset
;
6273 if (! finfo
->info
->relocateable
)
6274 isym
->st_value
+= osec
->vma
;
6276 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6278 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6282 r_symndx
= finfo
->indices
[r_symndx
];
6285 irela
->r_info
= ELF_R_INFO (r_symndx
,
6286 ELF_R_TYPE (irela
->r_info
));
6289 /* Swap out the relocs. */
6290 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6291 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6292 BFD_ASSERT (output_rel_hdr
->sh_entsize
6293 == input_rel_hdr
->sh_entsize
);
6294 irela
= internal_relocs
;
6295 irelaend
= irela
+ o
->reloc_count
;
6296 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6298 Elf_External_Rel
*erel
;
6300 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6301 + o
->output_section
->reloc_count
);
6302 for (; irela
< irelaend
; irela
++, erel
++)
6304 Elf_Internal_Rel irel
;
6306 irel
.r_offset
= irela
->r_offset
;
6307 irel
.r_info
= irela
->r_info
;
6308 BFD_ASSERT (irela
->r_addend
== 0);
6309 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6314 Elf_External_Rela
*erela
;
6316 BFD_ASSERT (input_rel_hdr
->sh_entsize
6317 == sizeof (Elf_External_Rela
));
6318 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6319 + o
->output_section
->reloc_count
);
6320 for (; irela
< irelaend
; irela
++, erela
++)
6321 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6324 o
->output_section
->reloc_count
+= o
->reloc_count
;
6328 /* Write out the modified section contents. */
6329 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6330 finfo
->contents
, o
->output_offset
,
6331 (o
->_cooked_size
!= 0
6340 /* Generate a reloc when linking an ELF file. This is a reloc
6341 requested by the linker, and does come from any input file. This
6342 is used to build constructor and destructor tables when linking
6346 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6348 struct bfd_link_info
*info
;
6349 asection
*output_section
;
6350 struct bfd_link_order
*link_order
;
6352 const reloc_howto_type
*howto
;
6355 struct elf_link_hash_entry
**rel_hash_ptr
;
6356 Elf_Internal_Shdr
*rel_hdr
;
6358 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6361 bfd_set_error (bfd_error_bad_value
);
6365 /* If this is an inplace reloc, we must write the addend into the
6367 if (howto
->partial_inplace
6368 && link_order
->u
.reloc
.p
->addend
!= 0)
6371 bfd_reloc_status_type rstat
;
6375 size
= bfd_get_reloc_size (howto
);
6376 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6377 if (buf
== (bfd_byte
*) NULL
)
6379 bfd_set_error (bfd_error_no_memory
);
6382 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6383 link_order
->u
.reloc
.p
->addend
, buf
);
6389 case bfd_reloc_outofrange
:
6391 case bfd_reloc_overflow
:
6392 if (! ((*info
->callbacks
->reloc_overflow
)
6394 (link_order
->type
== bfd_section_reloc_link_order
6395 ? bfd_section_name (output_bfd
,
6396 link_order
->u
.reloc
.p
->u
.section
)
6397 : link_order
->u
.reloc
.p
->u
.name
),
6398 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6399 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6406 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6407 (file_ptr
) link_order
->offset
, size
);
6413 /* Figure out the symbol index. */
6414 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6415 + output_section
->reloc_count
);
6416 if (link_order
->type
== bfd_section_reloc_link_order
)
6418 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6421 *rel_hash_ptr
= NULL
;
6425 struct elf_link_hash_entry
*h
;
6427 h
= elf_link_hash_lookup (elf_hash_table (info
),
6428 link_order
->u
.reloc
.p
->u
.name
,
6429 false, false, true);
6432 /* Setting the index to -2 tells elf_link_output_extsym that
6433 this symbol is used by a reloc. */
6440 if (! ((*info
->callbacks
->unattached_reloc
)
6441 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6442 (asection
*) NULL
, (bfd_vma
) 0)))
6448 /* The address of a reloc is relative to the section in a
6449 relocateable file, and is a virtual address in an executable
6451 offset
= link_order
->offset
;
6452 if (! info
->relocateable
)
6453 offset
+= output_section
->vma
;
6455 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6457 if (rel_hdr
->sh_type
== SHT_REL
)
6459 Elf_Internal_Rel irel
;
6460 Elf_External_Rel
*erel
;
6462 irel
.r_offset
= offset
;
6463 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6464 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6465 + output_section
->reloc_count
);
6466 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6470 Elf_Internal_Rela irela
;
6471 Elf_External_Rela
*erela
;
6473 irela
.r_offset
= offset
;
6474 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6475 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6476 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6477 + output_section
->reloc_count
);
6478 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6481 ++output_section
->reloc_count
;