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_get_lineno NAME(bfd_elf,get_lineno)
107 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
108 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
109 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
110 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
111 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
112 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
113 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
114 #define write_relocs NAME(bfd_elf,_write_relocs)
115 #define elf_find_section NAME(bfd_elf,find_section)
116 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
117 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
118 #define elf_link_create_dynamic_sections \
119 NAME(bfd_elf,link_create_dynamic_sections)
120 #define elf_link_record_dynamic_symbol \
121 NAME(bfd_elf,link_record_dynamic_symbol)
122 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
125 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
126 #define ELF_R_SYM(X) ELF64_R_SYM(X)
127 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
128 #define ELFCLASS ELFCLASS64
130 #define LOG_FILE_ALIGN 3
133 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
134 #define ELF_R_SYM(X) ELF32_R_SYM(X)
135 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
136 #define ELFCLASS ELFCLASS32
138 #define LOG_FILE_ALIGN 2
141 /* Forward declarations of static functions */
143 static unsigned long bfd_add_to_strtab
144 PARAMS ((bfd
*, struct strtab
*, const char *));
145 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
147 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
149 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
151 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
153 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
154 struct symbol_cache_entry
**));
156 static boolean elf_compute_section_file_positions
157 PARAMS ((bfd
*, struct bfd_link_info
*));
158 static boolean prep_headers
PARAMS ((bfd
*));
159 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
160 static boolean assign_section_numbers
PARAMS ((bfd
*));
161 static file_ptr align_file_position
PARAMS ((file_ptr
));
162 static file_ptr assign_file_position_for_section
163 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
164 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
165 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
166 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
167 static file_ptr map_program_segments
168 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
170 static boolean elf_map_symbols
PARAMS ((bfd
*));
171 static boolean swap_out_syms
PARAMS ((bfd
*));
173 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
176 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
177 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
180 #define elf_string_from_elf_strtab(abfd,strindex) \
181 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
184 /* Structure swapping routines */
186 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
187 can be handled by explicitly specifying 32 bits or "the long type". */
189 #define put_word bfd_h_put_64
190 #define get_word bfd_h_get_64
193 #define put_word bfd_h_put_32
194 #define get_word bfd_h_get_32
197 /* Translate an ELF symbol in external format into an ELF symbol in internal
201 elf_swap_symbol_in (abfd
, src
, dst
)
203 Elf_External_Sym
*src
;
204 Elf_Internal_Sym
*dst
;
206 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
207 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
208 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
209 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
210 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
211 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
214 /* Translate an ELF symbol in internal format into an ELF symbol in external
218 elf_swap_symbol_out (abfd
, src
, dst
)
220 Elf_Internal_Sym
*src
;
221 Elf_External_Sym
*dst
;
223 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
224 put_word (abfd
, src
->st_value
, dst
->st_value
);
225 put_word (abfd
, src
->st_size
, dst
->st_size
);
226 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
227 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
228 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
232 /* Translate an ELF file header in external format into an ELF file header in
236 elf_swap_ehdr_in (abfd
, src
, dst
)
238 Elf_External_Ehdr
*src
;
239 Elf_Internal_Ehdr
*dst
;
241 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
242 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
243 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
244 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
245 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
246 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
247 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
248 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
249 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
250 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
251 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
252 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
253 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
254 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
257 /* Translate an ELF file header in internal format into an ELF file header in
261 elf_swap_ehdr_out (abfd
, src
, dst
)
263 Elf_Internal_Ehdr
*src
;
264 Elf_External_Ehdr
*dst
;
266 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
267 /* note that all elements of dst are *arrays of unsigned char* already... */
268 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
269 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
270 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
271 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
272 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
273 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
274 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
275 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
276 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
277 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
278 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
279 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
280 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
284 /* Translate an ELF section header table entry in external format into an
285 ELF section header table entry in internal format. */
288 elf_swap_shdr_in (abfd
, src
, dst
)
290 Elf_External_Shdr
*src
;
291 Elf_Internal_Shdr
*dst
;
293 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
294 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
295 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
296 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
297 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
298 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
299 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
300 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
301 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
302 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
303 dst
->bfd_section
= NULL
;
304 dst
->contents
= NULL
;
307 /* Translate an ELF section header table entry in internal format into an
308 ELF section header table entry in external format. */
311 elf_swap_shdr_out (abfd
, src
, dst
)
313 Elf_Internal_Shdr
*src
;
314 Elf_External_Shdr
*dst
;
316 /* note that all elements of dst are *arrays of unsigned char* already... */
317 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
318 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
319 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
320 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
321 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
322 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
323 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
324 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
325 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
326 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
330 /* Translate an ELF program header table entry in external format into an
331 ELF program header table entry in internal format. */
334 elf_swap_phdr_in (abfd
, src
, dst
)
336 Elf_External_Phdr
*src
;
337 Elf_Internal_Phdr
*dst
;
339 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
340 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
341 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
342 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
343 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
344 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
345 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
346 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
350 elf_swap_phdr_out (abfd
, src
, dst
)
352 Elf_Internal_Phdr
*src
;
353 Elf_External_Phdr
*dst
;
355 /* note that all elements of dst are *arrays of unsigned char* already... */
356 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
357 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
358 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
359 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
360 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
361 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
362 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
363 put_word (abfd
, src
->p_align
, dst
->p_align
);
366 /* Translate an ELF reloc from external format to internal format. */
368 elf_swap_reloc_in (abfd
, src
, dst
)
370 Elf_External_Rel
*src
;
371 Elf_Internal_Rel
*dst
;
373 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
374 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
378 elf_swap_reloca_in (abfd
, src
, dst
)
380 Elf_External_Rela
*src
;
381 Elf_Internal_Rela
*dst
;
383 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
384 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
385 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
388 /* Translate an ELF reloc from internal format to external format. */
390 elf_swap_reloc_out (abfd
, src
, dst
)
392 Elf_Internal_Rel
*src
;
393 Elf_External_Rel
*dst
;
395 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
396 put_word (abfd
, src
->r_info
, dst
->r_info
);
400 elf_swap_reloca_out (abfd
, src
, dst
)
402 Elf_Internal_Rela
*src
;
403 Elf_External_Rela
*dst
;
405 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
406 put_word (abfd
, src
->r_info
, dst
->r_info
);
407 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
411 elf_swap_dyn_in (abfd
, src
, dst
)
413 const Elf_External_Dyn
*src
;
414 Elf_Internal_Dyn
*dst
;
416 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
417 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
421 elf_swap_dyn_out (abfd
, src
, dst
)
423 const Elf_Internal_Dyn
*src
;
424 Elf_External_Dyn
*dst
;
426 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
427 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
430 /* String table creation/manipulation routines */
432 static struct strtab
*
433 bfd_new_strtab (abfd
)
438 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
441 bfd_set_error (bfd_error_no_memory
);
444 ss
->tab
= malloc (1);
447 bfd_set_error (bfd_error_no_memory
);
458 bfd_add_to_strtab (abfd
, ss
, str
)
463 /* should search first, but for now: */
464 /* include the trailing NUL */
465 int ln
= strlen (str
) + 1;
467 /* FIXME: This is slow. Also, we could combine this with the a.out
468 string table building and use a hash table, although it might not
469 be worth it since ELF symbols don't include debugging information
470 and thus have much less overlap. */
471 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
474 bfd_set_error (bfd_error_no_memory
);
475 return (unsigned long) -1;
478 strcpy (ss
->tab
+ ss
->length
, str
);
482 return ss
->length
- ln
;
486 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
492 /* should search first, but for now: */
493 /* include the trailing NUL */
494 int ln
= strlen (str
) + strlen (str2
) + 1;
496 /* should this be using obstacks? */
498 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
500 ss
->tab
= malloc (ln
);
502 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
503 strcpy (ss
->tab
+ ss
->length
, str
);
504 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
508 return ss
->length
- ln
;
511 /* ELF .o/exec file reading */
513 /* Create a new bfd section from an ELF section header. */
516 bfd_section_from_shdr (abfd
, shindex
)
518 unsigned int shindex
;
520 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
521 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
524 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
526 switch (hdr
->sh_type
)
529 /* Inactive section. Throw it away. */
532 case SHT_PROGBITS
: /* Normal section with contents. */
533 case SHT_DYNAMIC
: /* Dynamic linking information. */
534 case SHT_NOBITS
: /* .bss section. */
535 case SHT_HASH
: /* .hash section. */
536 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
538 case SHT_SYMTAB
: /* A symbol table */
539 if (elf_onesymtab (abfd
) == shindex
)
542 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
543 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
544 elf_onesymtab (abfd
) = shindex
;
545 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
546 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
547 abfd
->flags
|= HAS_SYMS
;
549 /* Sometimes a shared object will map in the symbol table. If
550 SHF_ALLOC is set, and this is a shared object, then we also
551 treat this section as a BFD section. We can not base the
552 decision purely on SHF_ALLOC, because that flag is sometimes
553 set in a relocateable object file, which would confuse the
555 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
556 && (abfd
->flags
& DYNAMIC
) != 0
557 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
562 case SHT_DYNSYM
: /* A dynamic symbol table */
563 if (elf_dynsymtab (abfd
) == shindex
)
566 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
567 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
568 elf_dynsymtab (abfd
) = shindex
;
569 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
570 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
571 abfd
->flags
|= HAS_SYMS
;
573 /* Besides being a symbol table, we also treat this as a regular
574 section, so that objcopy can handle it. */
575 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
577 case SHT_STRTAB
: /* A string table */
578 if (hdr
->bfd_section
!= NULL
)
580 if (ehdr
->e_shstrndx
== shindex
)
582 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
583 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
589 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
591 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
592 if (hdr2
->sh_link
== shindex
)
594 if (! bfd_section_from_shdr (abfd
, i
))
596 if (elf_onesymtab (abfd
) == i
)
598 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
599 elf_elfsections (abfd
)[shindex
] =
600 &elf_tdata (abfd
)->strtab_hdr
;
603 if (elf_dynsymtab (abfd
) == i
)
605 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
606 elf_elfsections (abfd
)[shindex
] =
607 &elf_tdata (abfd
)->dynstrtab_hdr
;
608 /* We also treat this as a regular section, so
609 that objcopy can handle it. */
612 #if 0 /* Not handling other string tables specially right now. */
613 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
614 /* We have a strtab for some random other section. */
615 newsect
= (asection
*) hdr2
->bfd_section
;
618 hdr
->bfd_section
= newsect
;
619 hdr2
= &elf_section_data (newsect
)->str_hdr
;
621 elf_elfsections (abfd
)[shindex
] = hdr2
;
627 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
631 /* *These* do a lot of work -- but build no sections! */
633 asection
*target_sect
;
634 Elf_Internal_Shdr
*hdr2
;
635 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
637 /* Get the symbol table. */
638 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
641 /* If this reloc section does not use the main symbol table we
642 don't treat it as a reloc section. BFD can't adequately
643 represent such a section, so at least for now, we don't
644 try. We just present it as a normal section. */
645 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
646 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
648 /* Don't allow REL relocations on a machine that uses RELA and
650 /* @@ Actually, the generic ABI does suggest that both might be
651 used in one file. But the four ABI Processor Supplements I
652 have access to right now all specify that only one is used on
653 each of those architectures. It's conceivable that, e.g., a
654 bunch of absolute 32-bit relocs might be more compact in REL
655 form even on a RELA machine... */
656 BFD_ASSERT (use_rela_p
657 ? (hdr
->sh_type
== SHT_RELA
658 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
659 : (hdr
->sh_type
== SHT_REL
660 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
662 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
664 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
665 if (target_sect
== NULL
)
668 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
670 elf_elfsections (abfd
)[shindex
] = hdr2
;
671 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
672 target_sect
->flags
|= SEC_RELOC
;
673 target_sect
->relocation
= NULL
;
674 target_sect
->rel_filepos
= hdr
->sh_offset
;
675 abfd
->flags
|= HAS_RELOC
;
682 fprintf (stderr
, "Note Sections not yet supported.\n");
689 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
694 /* Check for any processor-specific section types. */
696 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
698 if (bed
->elf_backend_section_from_shdr
)
699 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
708 elf_new_section_hook (abfd
, sec
)
713 struct bfd_elf_section_data
*sdata
;
715 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
718 bfd_set_error (bfd_error_no_memory
);
721 sec
->used_by_bfd
= (PTR
) sdata
;
722 memset (sdata
, 0, sizeof (*sdata
));
726 /* Create a new bfd section from an ELF program header.
728 Since program segments have no names, we generate a synthetic name
729 of the form segment<NUM>, where NUM is generally the index in the
730 program header table. For segments that are split (see below) we
731 generate the names segment<NUM>a and segment<NUM>b.
733 Note that some program segments may have a file size that is different than
734 (less than) the memory size. All this means is that at execution the
735 system must allocate the amount of memory specified by the memory size,
736 but only initialize it with the first "file size" bytes read from the
737 file. This would occur for example, with program segments consisting
738 of combined data+bss.
740 To handle the above situation, this routine generates TWO bfd sections
741 for the single program segment. The first has the length specified by
742 the file size of the segment, and the second has the length specified
743 by the difference between the two sizes. In effect, the segment is split
744 into it's initialized and uninitialized parts.
749 bfd_section_from_phdr (abfd
, hdr
, index
)
751 Elf_Internal_Phdr
*hdr
;
759 split
= ((hdr
->p_memsz
> 0) &&
760 (hdr
->p_filesz
> 0) &&
761 (hdr
->p_memsz
> hdr
->p_filesz
));
762 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
763 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
766 bfd_set_error (bfd_error_no_memory
);
769 strcpy (name
, namebuf
);
770 newsect
= bfd_make_section (abfd
, name
);
773 newsect
->vma
= hdr
->p_vaddr
;
774 newsect
->_raw_size
= hdr
->p_filesz
;
775 newsect
->filepos
= hdr
->p_offset
;
776 newsect
->flags
|= SEC_HAS_CONTENTS
;
777 if (hdr
->p_type
== PT_LOAD
)
779 newsect
->flags
|= SEC_ALLOC
;
780 newsect
->flags
|= SEC_LOAD
;
781 if (hdr
->p_flags
& PF_X
)
783 /* FIXME: all we known is that it has execute PERMISSION,
785 newsect
->flags
|= SEC_CODE
;
788 if (!(hdr
->p_flags
& PF_W
))
790 newsect
->flags
|= SEC_READONLY
;
795 sprintf (namebuf
, "segment%db", index
);
796 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
799 bfd_set_error (bfd_error_no_memory
);
802 strcpy (name
, namebuf
);
803 newsect
= bfd_make_section (abfd
, name
);
806 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
807 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
808 if (hdr
->p_type
== PT_LOAD
)
810 newsect
->flags
|= SEC_ALLOC
;
811 if (hdr
->p_flags
& PF_X
)
812 newsect
->flags
|= SEC_CODE
;
814 if (!(hdr
->p_flags
& PF_W
))
815 newsect
->flags
|= SEC_READONLY
;
821 /* Begin processing a given object.
823 First we validate the file by reading in the ELF header and checking
826 static INLINE boolean
828 Elf_External_Ehdr
*x_ehdrp
;
830 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
831 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
832 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
833 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
836 /* Check to see if the file associated with ABFD matches the target vector
839 Note that we may be called several times with the same ABFD, but different
840 target vectors, most of which will not match. We have to avoid leaving
841 any side effects in ABFD, or any data it points to (like tdata), if the
842 file does not match the target vector. */
848 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
849 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
850 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
851 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
852 unsigned int shindex
;
853 char *shstrtab
; /* Internal copy of section header stringtab */
854 struct elf_backend_data
*ebd
;
855 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
856 struct elf_obj_tdata
*new_tdata
= NULL
;
858 /* Read in the ELF header in external format. */
860 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
862 if (bfd_get_error () != bfd_error_system_call
)
863 goto got_wrong_format_error
;
868 /* Now check to see if we have a valid ELF file, and one that BFD can
869 make use of. The magic number must match, the address size ('class')
870 and byte-swapping must match our XVEC entry, and it must have a
871 section header table (FIXME: See comments re sections at top of this
874 if ((elf_file_p (&x_ehdr
) == false) ||
875 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
876 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
877 goto got_wrong_format_error
;
879 /* Check that file's byte order matches xvec's */
880 switch (x_ehdr
.e_ident
[EI_DATA
])
882 case ELFDATA2MSB
: /* Big-endian */
883 if (!abfd
->xvec
->header_byteorder_big_p
)
884 goto got_wrong_format_error
;
886 case ELFDATA2LSB
: /* Little-endian */
887 if (abfd
->xvec
->header_byteorder_big_p
)
888 goto got_wrong_format_error
;
890 case ELFDATANONE
: /* No data encoding specified */
891 default: /* Unknown data encoding specified */
892 goto got_wrong_format_error
;
895 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
896 the tdata pointer in the bfd. */
898 new_tdata
= ((struct elf_obj_tdata
*)
899 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
900 if (new_tdata
== NULL
)
901 goto got_no_memory_error
;
902 elf_tdata (abfd
) = new_tdata
;
904 /* Now that we know the byte order, swap in the rest of the header */
905 i_ehdrp
= elf_elfheader (abfd
);
906 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
908 elf_debug_file (i_ehdrp
);
911 /* If there is no section header table, we're hosed. */
912 if (i_ehdrp
->e_shoff
== 0)
913 goto got_wrong_format_error
;
915 /* As a simple sanity check, verify that the what BFD thinks is the
916 size of each section header table entry actually matches the size
917 recorded in the file. */
918 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
919 goto got_wrong_format_error
;
921 ebd
= get_elf_backend_data (abfd
);
923 /* Check that the ELF e_machine field matches what this particular
924 BFD format expects. */
925 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
927 const bfd_target
* const *target_ptr
;
929 if (ebd
->elf_machine_code
!= EM_NONE
)
930 goto got_wrong_format_error
;
932 /* This is the generic ELF target. Let it match any ELF target
933 for which we do not have a specific backend. */
934 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
936 struct elf_backend_data
*back
;
938 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
940 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
941 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
943 /* target_ptr is an ELF backend which matches this
944 object file, so reject the generic ELF target. */
945 goto got_wrong_format_error
;
950 if (i_ehdrp
->e_type
== ET_EXEC
)
951 abfd
->flags
|= EXEC_P
;
952 else if (i_ehdrp
->e_type
== ET_DYN
)
953 abfd
->flags
|= DYNAMIC
;
955 if (i_ehdrp
->e_phnum
> 0)
956 abfd
->flags
|= D_PAGED
;
958 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
961 /* Remember the entry point specified in the ELF file header. */
962 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
964 /* Allocate space for a copy of the section header table in
965 internal form, seek to the section header table in the file,
966 read it in, and convert it to internal form. */
967 i_shdrp
= ((Elf_Internal_Shdr
*)
968 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
969 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
971 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
972 if (!i_shdrp
|| !elf_elfsections (abfd
))
973 goto got_no_memory_error
;
974 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
976 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
978 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
980 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
981 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
983 if (i_ehdrp
->e_shstrndx
)
985 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
989 /* Read in the string table containing the names of the sections. We
990 will need the base pointer to this table later. */
991 /* We read this inline now, so that we don't have to go through
992 bfd_section_from_shdr with it (since this particular strtab is
993 used to find all of the ELF section names.) */
995 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
999 /* Once all of the section headers have been read and converted, we
1000 can start processing them. Note that the first section header is
1001 a dummy placeholder entry, so we ignore it. */
1003 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1005 if (! bfd_section_from_shdr (abfd
, shindex
))
1009 /* Let the backend double check the format and override global
1011 if (ebd
->elf_backend_object_p
)
1013 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
1014 goto got_wrong_format_error
;
1017 return (abfd
->xvec
);
1019 got_wrong_format_error
:
1020 bfd_set_error (bfd_error_wrong_format
);
1022 got_no_memory_error
:
1023 bfd_set_error (bfd_error_no_memory
);
1026 if (new_tdata
!= NULL
1027 && new_tdata
->elf_sect_ptr
!= NULL
)
1028 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1029 if (i_shdrp
!= NULL
)
1030 bfd_release (abfd
, i_shdrp
);
1031 if (new_tdata
!= NULL
)
1032 bfd_release (abfd
, new_tdata
);
1033 elf_tdata (abfd
) = preserved_tdata
;
1038 /* ELF .o/exec file writing */
1040 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1041 of the symbol if there is one. */
1042 static INLINE elf_symbol_type
*
1043 elf_symbol_from (ignore_abfd
, symbol
)
1047 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1050 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1053 return (elf_symbol_type
*) symbol
;
1057 write_relocs (abfd
, sec
, xxx
)
1062 Elf_Internal_Shdr
*rela_hdr
;
1063 Elf_External_Rela
*outbound_relocas
;
1064 Elf_External_Rel
*outbound_relocs
;
1066 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1067 asymbol
*last_sym
= 0;
1068 int last_sym_idx
= 9999999; /* should always be written before use */
1070 if ((sec
->flags
& SEC_RELOC
) == 0)
1073 /* The linker backend writes the relocs out itself, and sets the
1074 reloc_count field to zero to inhibit writing them here. Also,
1075 sometimes the SEC_RELOC flag gets set even when there aren't any
1077 if (sec
->reloc_count
== 0)
1080 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1082 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1083 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1084 if (!rela_hdr
->contents
)
1086 bfd_set_error (bfd_error_no_memory
);
1087 abort (); /* FIXME */
1090 /* orelocation has the data, reloc_count has the count... */
1093 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1095 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1097 Elf_Internal_Rela dst_rela
;
1098 Elf_External_Rela
*src_rela
;
1103 ptr
= sec
->orelocation
[idx
];
1104 src_rela
= outbound_relocas
+ idx
;
1105 if (!(abfd
->flags
& EXEC_P
))
1106 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1108 dst_rela
.r_offset
= ptr
->address
;
1110 sym
= *ptr
->sym_ptr_ptr
;
1111 if (sym
== last_sym
)
1116 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1118 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1120 dst_rela
.r_addend
= ptr
->addend
;
1121 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1125 /* REL relocations */
1127 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1129 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1131 Elf_Internal_Rel dst_rel
;
1132 Elf_External_Rel
*src_rel
;
1137 ptr
= sec
->orelocation
[idx
];
1138 sym
= *ptr
->sym_ptr_ptr
;
1139 src_rel
= outbound_relocs
+ idx
;
1140 if (!(abfd
->flags
& EXEC_P
))
1141 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1143 dst_rel
.r_offset
= ptr
->address
;
1145 if (sym
== last_sym
)
1150 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1152 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1154 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1159 /* Set up an ELF internal section header for a section. */
1163 elf_fake_sections (abfd
, asect
, ignore
)
1168 Elf_Internal_Shdr
*this_hdr
;
1170 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1172 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1174 if (this_hdr
->sh_name
== (unsigned long) -1)
1175 abort (); /* FIXME */
1177 this_hdr
->sh_flags
= 0;
1178 if ((asect
->flags
& SEC_ALLOC
) != 0)
1179 this_hdr
->sh_addr
= asect
->vma
;
1181 this_hdr
->sh_addr
= 0;
1182 this_hdr
->sh_offset
= 0;
1183 this_hdr
->sh_size
= asect
->_raw_size
;
1184 this_hdr
->sh_link
= 0;
1185 this_hdr
->sh_info
= 0;
1186 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1187 this_hdr
->sh_entsize
= 0;
1189 this_hdr
->bfd_section
= asect
;
1190 this_hdr
->contents
= NULL
;
1192 /* FIXME: This should not be based on section names. */
1193 if (strcmp (asect
->name
, ".dynstr") == 0)
1194 this_hdr
->sh_type
= SHT_STRTAB
;
1195 else if (strcmp (asect
->name
, ".hash") == 0)
1197 this_hdr
->sh_type
= SHT_HASH
;
1198 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1200 else if (strcmp (asect
->name
, ".dynsym") == 0)
1202 this_hdr
->sh_type
= SHT_DYNSYM
;
1203 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1205 else if (strcmp (asect
->name
, ".dynamic") == 0)
1207 this_hdr
->sh_type
= SHT_DYNAMIC
;
1208 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1210 else if (strncmp (asect
->name
, ".rela", 5) == 0
1211 && get_elf_backend_data (abfd
)->use_rela_p
)
1213 this_hdr
->sh_type
= SHT_RELA
;
1214 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1216 else if (strncmp (asect
->name
, ".rel", 4) == 0
1217 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1219 this_hdr
->sh_type
= SHT_REL
;
1220 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1222 else if (strcmp (asect
->name
, ".note") == 0)
1223 this_hdr
->sh_type
= SHT_NOTE
;
1224 else if (strncmp (asect
->name
, ".stab", 5) == 0
1225 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1226 this_hdr
->sh_type
= SHT_STRTAB
;
1227 else if ((asect
->flags
& SEC_ALLOC
) != 0
1228 && (asect
->flags
& SEC_LOAD
) != 0)
1229 this_hdr
->sh_type
= SHT_PROGBITS
;
1230 else if ((asect
->flags
& SEC_ALLOC
) != 0
1231 && ((asect
->flags
& SEC_LOAD
) == 0))
1233 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1234 || strcmp (asect
->name
, ".sbss") == 0);
1235 this_hdr
->sh_type
= SHT_NOBITS
;
1240 this_hdr
->sh_type
= SHT_PROGBITS
;
1243 if ((asect
->flags
& SEC_ALLOC
) != 0)
1244 this_hdr
->sh_flags
|= SHF_ALLOC
;
1245 if ((asect
->flags
& SEC_READONLY
) == 0)
1246 this_hdr
->sh_flags
|= SHF_WRITE
;
1247 if ((asect
->flags
& SEC_CODE
) != 0)
1248 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1250 /* Check for processor-specific section types. */
1252 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1254 if (bed
->elf_backend_fake_sections
)
1255 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1258 /* If the section has relocs, set up a section header for the
1259 SHT_REL[A] section. */
1260 if ((asect
->flags
& SEC_RELOC
) != 0)
1262 Elf_Internal_Shdr
*rela_hdr
;
1263 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1265 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1267 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1268 use_rela_p
? ".rela" : ".rel",
1270 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1271 rela_hdr
->sh_entsize
= (use_rela_p
1272 ? sizeof (Elf_External_Rela
)
1273 : sizeof (Elf_External_Rel
));
1274 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1275 rela_hdr
->sh_flags
= 0;
1276 rela_hdr
->sh_addr
= 0;
1277 rela_hdr
->sh_size
= 0;
1278 rela_hdr
->sh_offset
= 0;
1282 /* Assign all ELF section numbers. The dummy first section is handled here
1283 too. The link/info pointers for the standard section types are filled
1284 in here too, while we're at it. */
1287 assign_section_numbers (abfd
)
1290 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1292 unsigned int section_number
;
1293 Elf_Internal_Shdr
**i_shdrp
;
1297 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1299 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1301 d
->this_idx
= section_number
++;
1302 if ((sec
->flags
& SEC_RELOC
) == 0)
1305 d
->rel_idx
= section_number
++;
1308 t
->shstrtab_section
= section_number
++;
1309 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1310 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1311 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1313 if (abfd
->symcount
> 0)
1315 t
->symtab_section
= section_number
++;
1316 t
->strtab_section
= section_number
++;
1319 elf_elfheader (abfd
)->e_shnum
= section_number
;
1321 /* Set up the list of section header pointers, in agreement with the
1323 i_shdrp
= ((Elf_Internal_Shdr
**)
1324 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1325 if (i_shdrp
== NULL
)
1327 bfd_set_error (bfd_error_no_memory
);
1331 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1332 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1333 if (i_shdrp
[0] == NULL
)
1335 bfd_release (abfd
, i_shdrp
);
1336 bfd_set_error (bfd_error_no_memory
);
1339 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1341 elf_elfsections (abfd
) = i_shdrp
;
1343 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1344 if (abfd
->symcount
> 0)
1346 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1347 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1348 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1350 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1352 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1356 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1357 if (d
->rel_idx
!= 0)
1358 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1360 /* Fill in the sh_link and sh_info fields while we're at it. */
1362 /* sh_link of a reloc section is the section index of the symbol
1363 table. sh_info is the section index of the section to which
1364 the relocation entries apply. */
1365 if (d
->rel_idx
!= 0)
1367 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1368 d
->rel_hdr
.sh_info
= d
->this_idx
;
1371 switch (d
->this_hdr
.sh_type
)
1375 /* A reloc section which we are treating as a normal BFD
1376 section. sh_link is the section index of the symbol
1377 table. sh_info is the section index of the section to
1378 which the relocation entries apply. We assume that an
1379 allocated reloc section uses the dynamic symbol table.
1380 FIXME: How can we be sure? */
1381 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1383 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1385 /* We look up the section the relocs apply to by name. */
1387 if (d
->this_hdr
.sh_type
== SHT_REL
)
1391 s
= bfd_get_section_by_name (abfd
, name
);
1393 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1397 /* We assume that a section named .stab*str is a stabs
1398 string section. We look for a section with the same name
1399 but without the trailing ``str'', and set its sh_link
1400 field to point to this section. */
1401 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1402 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1407 len
= strlen (sec
->name
);
1408 alc
= (char *) malloc (len
- 2);
1411 bfd_set_error (bfd_error_no_memory
);
1414 strncpy (alc
, sec
->name
, len
- 3);
1415 alc
[len
- 3] = '\0';
1416 s
= bfd_get_section_by_name (abfd
, alc
);
1420 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1422 /* This is a .stab section. */
1423 elf_section_data (s
)->this_hdr
.sh_entsize
=
1424 4 + 2 * (ARCH_SIZE
/ 8);
1431 /* sh_link is the section header index of the string table
1432 used for the dynamic entries or symbol table. */
1433 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1435 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1439 /* sh_link is the section header index of the symbol table
1440 this hash table is for. */
1441 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1443 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1451 /* Map symbol from it's internal number to the external number, moving
1452 all local symbols to be at the head of the list. */
1455 sym_is_global (abfd
, sym
)
1459 /* If the backend has a special mapping, use it. */
1460 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1461 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1464 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1466 if (sym
->flags
& BSF_LOCAL
)
1470 if (sym
->section
== 0)
1472 /* Is this valid? */
1477 if (bfd_is_und_section (sym
->section
))
1479 if (bfd_is_com_section (sym
->section
))
1481 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1487 elf_map_symbols (abfd
)
1490 int symcount
= bfd_get_symcount (abfd
);
1491 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1492 asymbol
**sect_syms
;
1494 int num_globals
= 0;
1495 int num_locals2
= 0;
1496 int num_globals2
= 0;
1498 int num_sections
= 0;
1499 Elf_Sym_Extra
*sym_extra
;
1504 fprintf (stderr
, "elf_map_symbols\n");
1508 /* Add local symbols for each section for which there are relocs.
1509 FIXME: How can we tell which sections have relocs at this point?
1510 Will reloc_count always be accurate? Actually, I think most ELF
1511 targets create section symbols for all sections anyhow. */
1512 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1514 if (max_index
< asect
->index
)
1515 max_index
= asect
->index
;
1519 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1520 elf_section_syms (abfd
) = sect_syms
;
1524 bfd_set_error (bfd_error_no_memory
);
1528 for (idx
= 0; idx
< symcount
; idx
++)
1530 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0)
1534 sec
= syms
[idx
]->section
;
1535 if (! bfd_is_abs_section (sec
))
1537 if (sec
->owner
!= abfd
)
1539 sec
= sec
->output_section
;
1540 BFD_ASSERT (sec
->owner
== abfd
);
1542 sect_syms
[sec
->index
] = syms
[idx
];
1547 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1551 if (sect_syms
[asect
->index
] != NULL
)
1554 sym
= bfd_make_empty_symbol (abfd
);
1557 sym
->the_bfd
= abfd
;
1558 sym
->name
= asect
->name
;
1559 sym
->value
= asect
->vma
;
1560 /* Set the flags to 0 to indicate that this one was newly added. */
1562 sym
->section
= asect
;
1563 sect_syms
[asect
->index
] = sym
;
1567 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1568 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1576 asymbol
**osyms
= syms
;
1577 syms
= (asymbol
**) bfd_alloc (abfd
,
1578 ((symcount
+ num_sections
+ 1)
1579 * sizeof (asymbol
*)));
1580 memcpy (syms
, osyms
, symcount
* sizeof (asymbol
*));
1583 syms
= (asymbol
**) bfd_alloc (abfd
,
1584 (num_sections
+ 1) * sizeof (asymbol
*));
1587 bfd_set_error (bfd_error_no_memory
);
1591 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1593 if (sect_syms
[asect
->index
] != NULL
1594 && sect_syms
[asect
->index
]->flags
== 0)
1596 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1597 syms
[symcount
++] = sect_syms
[asect
->index
];
1601 syms
[symcount
] = (asymbol
*) 0;
1602 bfd_set_symtab (abfd
, syms
, symcount
);
1605 elf_sym_extra (abfd
) = sym_extra
1606 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1609 bfd_set_error (bfd_error_no_memory
);
1613 /* Identify and classify all of the symbols. */
1614 for (idx
= 0; idx
< symcount
; idx
++)
1616 if (!sym_is_global (abfd
, syms
[idx
]))
1622 /* Now provide mapping information. Add +1 for skipping over the
1624 for (idx
= 0; idx
< symcount
; idx
++)
1626 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1627 if (!sym_is_global (abfd
, syms
[idx
]))
1628 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1630 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1633 elf_num_locals (abfd
) = num_locals
;
1634 elf_num_globals (abfd
) = num_globals
;
1638 /* Compute the file positions we are going to put the sections at, and
1639 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1640 is not NULL, this is being called by the ELF backend linker. */
1643 elf_compute_section_file_positions (abfd
, link_info
)
1645 struct bfd_link_info
*link_info
;
1647 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1648 Elf_Internal_Shdr
*shstrtab_hdr
;
1650 if (abfd
->output_has_begun
)
1653 /* Do any elf backend specific processing first. */
1654 if (bed
->elf_backend_begin_write_processing
)
1655 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1657 if (! prep_headers (abfd
))
1660 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1662 if (!assign_section_numbers (abfd
))
1665 /* The backend linker builds symbol table information itself. */
1666 if (link_info
== NULL
)
1668 if (! swap_out_syms (abfd
))
1672 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1673 /* sh_name was set in prep_headers. */
1674 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1675 shstrtab_hdr
->sh_flags
= 0;
1676 shstrtab_hdr
->sh_addr
= 0;
1677 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1678 shstrtab_hdr
->sh_entsize
= 0;
1679 shstrtab_hdr
->sh_link
= 0;
1680 shstrtab_hdr
->sh_info
= 0;
1681 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1682 shstrtab_hdr
->sh_addralign
= 1;
1683 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1685 if (!assign_file_positions_except_relocs (abfd
,
1686 link_info
== NULL
? true : false))
1689 abfd
->output_has_begun
= true;
1695 /* Align to the maximum file alignment that could be required for any
1696 ELF data structure. */
1698 static INLINE file_ptr
1699 align_file_position (off
)
1702 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1705 /* Assign a file position to a section, optionally aligning to the
1706 required section alignment. */
1708 static INLINE file_ptr
1709 assign_file_position_for_section (i_shdrp
, offset
, align
)
1710 Elf_Internal_Shdr
*i_shdrp
;
1718 al
= i_shdrp
->sh_addralign
;
1720 offset
= BFD_ALIGN (offset
, al
);
1722 i_shdrp
->sh_offset
= offset
;
1723 if (i_shdrp
->bfd_section
!= NULL
)
1724 i_shdrp
->bfd_section
->filepos
= offset
;
1725 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1726 offset
+= i_shdrp
->sh_size
;
1730 /* Get the size of the program header. This is called by the linker
1731 before any of the section VMA's are set, so it can't calculate the
1732 correct value for a strange memory layout. */
1734 static bfd_size_type
1735 get_program_header_size (abfd
)
1741 /* Assume we will need exactly two PT_LOAD segments: one for text
1742 and one for data. */
1745 s
= bfd_get_section_by_name (abfd
, ".interp");
1746 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1748 /* If we have a loadable interpreter section, we need a
1749 PT_INTERP segment. In this case, assume we also need a
1750 PT_PHDR segment, although that may not be true for all
1755 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1757 /* We need a PT_DYNAMIC segment. */
1761 return segs
* sizeof (Elf_External_Phdr
);
1764 /* Create the program header. OFF is the file offset where the
1765 program header should be written. FIRST is the first loadable ELF
1766 section. PHDR_SIZE is the size of the program header as returned
1767 by get_program_header_size. */
1770 map_program_segments (abfd
, off
, first
, phdr_size
)
1773 Elf_Internal_Shdr
*first
;
1774 bfd_size_type phdr_size
;
1776 Elf_Internal_Phdr phdrs
[10];
1777 unsigned int phdr_count
;
1778 Elf_Internal_Phdr
*phdr
;
1779 int phdr_size_adjust
;
1781 Elf_Internal_Shdr
**hdrpp
;
1782 asection
*sinterp
, *sdyn
;
1783 unsigned int last_type
;
1784 Elf_Internal_Ehdr
*i_ehdrp
;
1786 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1787 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1788 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1793 phdr_size_adjust
= 0;
1795 /* If we have a loadable .interp section, we must create a PT_INTERP
1796 segment which must precede all PT_LOAD segments. We assume that
1797 we must also create a PT_PHDR segment, although that may not be
1798 true for all targets. */
1799 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1800 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1802 BFD_ASSERT (first
!= NULL
);
1804 phdr
->p_type
= PT_PHDR
;
1806 phdr
->p_offset
= off
;
1808 /* Account for any adjustment made because of the alignment of
1809 the first loadable section. */
1810 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1811 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1813 /* The program header precedes all loadable sections. This lets
1814 us compute its loadable address. This depends on the linker
1816 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1819 phdr
->p_filesz
= phdr_size
;
1820 phdr
->p_memsz
= phdr_size
;
1822 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1823 phdr
->p_flags
= PF_R
| PF_X
;
1825 phdr
->p_align
= FILE_ALIGN
;
1826 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1828 /* Include the ELF header in the first loadable segment. */
1829 phdr_size_adjust
+= off
;
1834 phdr
->p_type
= PT_INTERP
;
1835 phdr
->p_offset
= sinterp
->filepos
;
1836 phdr
->p_vaddr
= sinterp
->vma
;
1838 phdr
->p_filesz
= sinterp
->_raw_size
;
1839 phdr
->p_memsz
= sinterp
->_raw_size
;
1840 phdr
->p_flags
= PF_R
;
1841 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1847 /* Look through the sections to see how they will be divided into
1848 program segments. The sections must be arranged in order by
1849 sh_addr for this to work correctly. */
1850 phdr
->p_type
= PT_NULL
;
1851 last_type
= SHT_PROGBITS
;
1852 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1853 i
< elf_elfheader (abfd
)->e_shnum
;
1856 Elf_Internal_Shdr
*hdr
;
1860 /* Ignore any section which will not be part of the process
1862 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1865 /* If this section fits in the segment we are constructing, add
1867 if (phdr
->p_type
!= PT_NULL
1868 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1869 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1870 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1872 bfd_size_type adjust
;
1874 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1875 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1876 if (hdr
->sh_type
!= SHT_NOBITS
)
1877 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1878 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1879 phdr
->p_flags
|= PF_W
;
1880 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1881 phdr
->p_flags
|= PF_X
;
1882 last_type
= hdr
->sh_type
;
1886 /* If we have a segment, move to the next one. */
1887 if (phdr
->p_type
!= PT_NULL
)
1893 /* Start a new segment. */
1894 phdr
->p_type
= PT_LOAD
;
1895 phdr
->p_offset
= hdr
->sh_offset
;
1896 phdr
->p_vaddr
= hdr
->sh_addr
;
1898 if (hdr
->sh_type
== SHT_NOBITS
)
1901 phdr
->p_filesz
= hdr
->sh_size
;
1902 phdr
->p_memsz
= hdr
->sh_size
;
1903 phdr
->p_flags
= PF_R
;
1904 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1905 phdr
->p_flags
|= PF_W
;
1906 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1907 phdr
->p_flags
|= PF_X
;
1908 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1912 && (sinterp
->flags
& SEC_LOAD
) != 0)
1914 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1915 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1916 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1917 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1920 last_type
= hdr
->sh_type
;
1923 if (phdr
->p_type
!= PT_NULL
)
1929 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1930 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1931 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1933 phdr
->p_type
= PT_DYNAMIC
;
1934 phdr
->p_offset
= sdyn
->filepos
;
1935 phdr
->p_vaddr
= sdyn
->vma
;
1937 phdr
->p_filesz
= sdyn
->_raw_size
;
1938 phdr
->p_memsz
= sdyn
->_raw_size
;
1939 phdr
->p_flags
= PF_R
;
1940 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1941 phdr
->p_flags
|= PF_W
;
1942 if ((sdyn
->flags
& SEC_CODE
) != 0)
1943 phdr
->p_flags
|= PF_X
;
1944 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1950 /* Make sure the return value from get_program_header_size matches
1951 what we computed here. Actually, it's OK if we allocated too
1952 much space in the program header. */
1953 if (phdr_count
> phdr_size
/ sizeof (Elf_External_Phdr
))
1956 /* Set up program header information. */
1957 i_ehdrp
= elf_elfheader (abfd
);
1958 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1959 i_ehdrp
->e_phoff
= off
;
1960 i_ehdrp
->e_phnum
= phdr_count
;
1962 /* Save the program headers away. I don't think anybody uses this
1963 information right now. */
1964 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1967 * sizeof (Elf_Internal_Phdr
))));
1968 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1970 bfd_set_error (bfd_error_no_memory
);
1971 return (file_ptr
) -1;
1973 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1974 phdr_count
* sizeof (Elf_Internal_Phdr
));
1976 /* Write out the program headers. */
1977 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1978 return (file_ptr
) -1;
1980 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1982 Elf_External_Phdr extphdr
;
1984 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1985 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1986 != sizeof (Elf_External_Phdr
))
1987 return (file_ptr
) -1;
1990 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1993 /* Work out the file positions of all the sections. This is called by
1994 elf_compute_section_file_positions. All the section sizes and VMAs
1995 must be known before this is called.
1997 We do not consider reloc sections at this point, unless they form
1998 part of the loadable image. Reloc sections are assigned file
1999 positions in assign_file_positions_for_relocs, which is called by
2000 write_object_contents and final_link.
2002 If DOSYMS is false, we do not assign file positions for the symbol
2003 table or the string table. */
2006 assign_file_positions_except_relocs (abfd
, dosyms
)
2010 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2011 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2012 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2015 /* Start after the ELF header. */
2016 off
= i_ehdrp
->e_ehsize
;
2018 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2020 Elf_Internal_Shdr
**hdrpp
;
2023 /* We are not creating an executable, which means that we are
2024 not creating a program header, and that the actual order of
2025 the sections in the file is unimportant. */
2026 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2028 Elf_Internal_Shdr
*hdr
;
2031 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2033 hdr
->sh_offset
= -1;
2037 && (i
== tdata
->symtab_section
2038 || i
== tdata
->strtab_section
))
2040 hdr
->sh_offset
= -1;
2044 off
= assign_file_position_for_section (hdr
, off
, true);
2050 bfd_size_type phdr_size
;
2051 bfd_vma maxpagesize
;
2052 Elf_Internal_Shdr
**hdrpp
;
2054 Elf_Internal_Shdr
*first
;
2057 /* We are creating an executable. We must create a program
2058 header. We can't actually create the program header until we
2059 have set the file positions for the sections, but we can
2060 figure out how big it is going to be. */
2061 off
= align_file_position (off
);
2062 phdr_size
= get_program_header_size (abfd
);
2063 if (phdr_size
== (file_ptr
) -1)
2068 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2069 if (maxpagesize
== 0)
2072 /* FIXME: We might want to sort the sections on the sh_addr
2073 field here. For now, we just assume that the linker will
2074 create the sections in an appropriate order. */
2076 /* Assign file positions in two passes. In the first pass, we
2077 assign a file position to every section which forms part of
2078 the executable image. */
2080 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2082 Elf_Internal_Shdr
*hdr
;
2085 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2091 /* The section VMA must equal the file position modulo the
2092 page size. This is required by the program header. */
2093 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2095 off
= assign_file_position_for_section (hdr
, off
, false);
2098 /* Assign file positions to all the sections which do not form
2099 part of the loadable image, except for the relocs. */
2100 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2102 Elf_Internal_Shdr
*hdr
;
2105 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2107 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2109 hdr
->sh_offset
= -1;
2113 && (i
== tdata
->symtab_section
2114 || i
== tdata
->strtab_section
))
2116 hdr
->sh_offset
= -1;
2120 off
= assign_file_position_for_section (hdr
, off
, true);
2123 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2124 if (phdr_map
== (file_ptr
) -1)
2126 BFD_ASSERT (phdr_map
<= phdr_off
+ phdr_size
);
2129 /* Place the section headers. */
2130 off
= align_file_position (off
);
2131 i_ehdrp
->e_shoff
= off
;
2132 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2134 elf_tdata (abfd
)->next_file_pos
= off
;
2143 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2144 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2145 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2147 struct strtab
*shstrtab
;
2149 i_ehdrp
= elf_elfheader (abfd
);
2150 i_shdrp
= elf_elfsections (abfd
);
2152 shstrtab
= bfd_new_strtab (abfd
);
2156 elf_shstrtab (abfd
) = shstrtab
;
2158 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2159 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2160 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2161 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2163 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2164 i_ehdrp
->e_ident
[EI_DATA
] =
2165 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2166 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2168 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2169 i_ehdrp
->e_ident
[count
] = 0;
2171 if ((abfd
->flags
& DYNAMIC
) != 0)
2172 i_ehdrp
->e_type
= ET_DYN
;
2173 else if ((abfd
->flags
& EXEC_P
) != 0)
2174 i_ehdrp
->e_type
= ET_EXEC
;
2176 i_ehdrp
->e_type
= ET_REL
;
2178 switch (bfd_get_arch (abfd
))
2180 case bfd_arch_unknown
:
2181 i_ehdrp
->e_machine
= EM_NONE
;
2183 case bfd_arch_sparc
:
2185 i_ehdrp
->e_machine
= EM_SPARC64
;
2187 i_ehdrp
->e_machine
= EM_SPARC
;
2191 i_ehdrp
->e_machine
= EM_386
;
2194 i_ehdrp
->e_machine
= EM_68K
;
2197 i_ehdrp
->e_machine
= EM_88K
;
2200 i_ehdrp
->e_machine
= EM_860
;
2202 case bfd_arch_mips
: /* MIPS Rxxxx */
2203 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2206 i_ehdrp
->e_machine
= EM_PARISC
;
2208 case bfd_arch_powerpc
:
2209 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2211 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2213 i_ehdrp
->e_machine
= EM_NONE
;
2215 i_ehdrp
->e_version
= EV_CURRENT
;
2216 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2218 /* no program header, for now. */
2219 i_ehdrp
->e_phoff
= 0;
2220 i_ehdrp
->e_phentsize
= 0;
2221 i_ehdrp
->e_phnum
= 0;
2223 /* each bfd section is section header entry */
2224 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2225 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2227 /* if we're building an executable, we'll need a program header table */
2228 if (abfd
->flags
& EXEC_P
)
2230 /* it all happens later */
2232 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2234 /* elf_build_phdrs() returns a (NULL-terminated) array of
2235 Elf_Internal_Phdrs */
2236 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2237 i_ehdrp
->e_phoff
= outbase
;
2238 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2243 i_ehdrp
->e_phentsize
= 0;
2245 i_ehdrp
->e_phoff
= 0;
2248 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2250 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2252 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2254 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2255 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2256 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2263 swap_out_syms (abfd
)
2266 if (!elf_map_symbols (abfd
))
2269 /* Dump out the symtabs. */
2271 int symcount
= bfd_get_symcount (abfd
);
2272 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2273 struct strtab
*stt
= bfd_new_strtab (abfd
);
2274 Elf_Internal_Shdr
*symtab_hdr
;
2275 Elf_Internal_Shdr
*symstrtab_hdr
;
2276 Elf_External_Sym
*outbound_syms
;
2281 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2282 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2283 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2284 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2285 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2286 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2288 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2289 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2291 outbound_syms
= (Elf_External_Sym
*)
2292 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2295 bfd_set_error (bfd_error_no_memory
);
2298 /* now generate the data (for "contents") */
2300 /* Fill in zeroth symbol and swap it out. */
2301 Elf_Internal_Sym sym
;
2307 sym
.st_shndx
= SHN_UNDEF
;
2308 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2310 for (idx
= 0; idx
< symcount
; idx
++)
2312 Elf_Internal_Sym sym
;
2313 bfd_vma value
= syms
[idx
]->value
;
2314 elf_symbol_type
*type_ptr
;
2316 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2317 /* Section symbols have no names. */
2321 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2322 if (sym
.st_name
== (unsigned long) -1)
2326 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2328 if (bfd_is_com_section (syms
[idx
]->section
))
2330 /* ELF common symbols put the alignment into the `value' field,
2331 and the size into the `size' field. This is backwards from
2332 how BFD handles it, so reverse it here. */
2333 sym
.st_size
= value
;
2334 if (type_ptr
== NULL
2335 || type_ptr
->internal_elf_sym
.st_value
== 0)
2336 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2338 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2339 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2340 syms
[idx
]->section
);
2344 asection
*sec
= syms
[idx
]->section
;
2347 if (sec
->output_section
)
2349 value
+= sec
->output_offset
;
2350 sec
= sec
->output_section
;
2353 sym
.st_value
= value
;
2354 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2355 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2359 /* Writing this would be a hell of a lot easier if we had
2360 some decent documentation on bfd, and knew what to expect
2361 of the library, and what to demand of applications. For
2362 example, it appears that `objcopy' might not set the
2363 section of a symbol to be a section that is actually in
2365 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2366 BFD_ASSERT (sec2
!= 0);
2367 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2368 BFD_ASSERT (shndx
!= -1);
2372 if (bfd_is_com_section (syms
[idx
]->section
))
2373 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2374 else if (bfd_is_und_section (syms
[idx
]->section
))
2375 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
2376 ((syms
[idx
]->flags
& BSF_FUNCTION
)
2379 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2380 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2381 else if (syms
[idx
]->flags
& BSF_FILE
)
2382 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2385 int bind
= STB_LOCAL
;
2386 int type
= STT_OBJECT
;
2387 unsigned int flags
= syms
[idx
]->flags
;
2389 if (flags
& BSF_LOCAL
)
2391 else if (flags
& BSF_WEAK
)
2393 else if (flags
& BSF_GLOBAL
)
2396 if (flags
& BSF_FUNCTION
)
2399 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2403 elf_swap_symbol_out (abfd
, &sym
,
2405 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2408 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2409 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2410 symstrtab_hdr
->sh_size
= stt
->length
;
2411 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2413 symstrtab_hdr
->sh_flags
= 0;
2414 symstrtab_hdr
->sh_addr
= 0;
2415 symstrtab_hdr
->sh_entsize
= 0;
2416 symstrtab_hdr
->sh_link
= 0;
2417 symstrtab_hdr
->sh_info
= 0;
2418 symstrtab_hdr
->sh_addralign
= 1;
2425 write_shdrs_and_ehdr (abfd
)
2428 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2429 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2430 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2431 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2433 struct strtab
*shstrtab
;
2435 i_ehdrp
= elf_elfheader (abfd
);
2436 i_shdrp
= elf_elfsections (abfd
);
2437 shstrtab
= elf_shstrtab (abfd
);
2439 /* swap the header before spitting it out... */
2442 elf_debug_file (i_ehdrp
);
2444 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2445 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2446 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2447 != sizeof (x_ehdr
)))
2450 /* at this point we've concocted all the ELF sections... */
2451 x_shdrp
= (Elf_External_Shdr
*)
2452 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2455 bfd_set_error (bfd_error_no_memory
);
2459 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2462 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2465 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2467 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2468 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2469 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2472 /* need to dump the string table too... */
2477 /* Assign file positions for all the reloc sections which are not part
2478 of the loadable file image. */
2481 assign_file_positions_for_relocs (abfd
)
2486 Elf_Internal_Shdr
**shdrpp
;
2488 off
= elf_tdata (abfd
)->next_file_pos
;
2490 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2491 i
< elf_elfheader (abfd
)->e_shnum
;
2494 Elf_Internal_Shdr
*shdrp
;
2497 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2498 && shdrp
->sh_offset
== -1)
2499 off
= assign_file_position_for_section (shdrp
, off
, true);
2502 elf_tdata (abfd
)->next_file_pos
= off
;
2506 NAME(bfd_elf
,write_object_contents
) (abfd
)
2509 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2510 Elf_Internal_Ehdr
*i_ehdrp
;
2511 Elf_Internal_Shdr
**i_shdrp
;
2514 if (! abfd
->output_has_begun
2515 && ! elf_compute_section_file_positions (abfd
,
2516 (struct bfd_link_info
*) NULL
))
2519 i_shdrp
= elf_elfsections (abfd
);
2520 i_ehdrp
= elf_elfheader (abfd
);
2522 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2523 assign_file_positions_for_relocs (abfd
);
2525 /* After writing the headers, we need to write the sections too... */
2526 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2528 if (bed
->elf_backend_section_processing
)
2529 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2530 if (i_shdrp
[count
]->contents
)
2532 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2533 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2535 != i_shdrp
[count
]->sh_size
))
2540 if (bed
->elf_backend_final_write_processing
)
2541 (*bed
->elf_backend_final_write_processing
) (abfd
,
2542 elf_tdata (abfd
)->linker
);
2544 return write_shdrs_and_ehdr (abfd
);
2547 /* Given an ELF section number, retrieve the corresponding BFD
2551 section_from_elf_index (abfd
, index
)
2555 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
2556 if (index
>= elf_elfheader (abfd
)->e_shnum
)
2558 return elf_elfsections (abfd
)[index
]->bfd_section
;
2561 /* given a section, search the header to find them... */
2563 elf_section_from_bfd_section (abfd
, asect
)
2567 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2568 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2570 Elf_Internal_Shdr
*hdr
;
2571 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2573 if (asect
->owner
== NULL
)
2575 if (bfd_is_abs_section (asect
))
2577 if (bfd_is_com_section (asect
))
2579 if (bfd_is_und_section (asect
))
2584 BFD_ASSERT (asect
->owner
== abfd
);
2586 for (index
= 0; index
< maxindex
; index
++)
2588 hdr
= i_shdrp
[index
];
2589 if (hdr
->bfd_section
== asect
)
2592 if (bed
->elf_backend_section_from_bfd_section
)
2597 if ((*bed
->elf_backend_section_from_bfd_section
)
2598 (abfd
, hdr
, asect
, &retval
))
2606 /* given a symbol, return the bfd index for that symbol. */
2608 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2610 struct symbol_cache_entry
**asym_ptr_ptr
;
2612 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2614 flagword flags
= asym_ptr
->flags
;
2616 /* When gas creates relocations against local labels, it creates its
2617 own symbol for the section, but does put the symbol into the
2618 symbol chain, so udata is 0. When the linker is generating
2619 relocatable output, this section symbol may be for one of the
2620 input sections rather than the output section. */
2621 if (asym_ptr
->udata
== (PTR
) 0
2622 && (flags
& BSF_SECTION_SYM
)
2623 && asym_ptr
->section
)
2627 if (asym_ptr
->section
->output_section
!= NULL
)
2628 indx
= asym_ptr
->section
->output_section
->index
;
2630 indx
= asym_ptr
->section
->index
;
2631 if (elf_section_syms (abfd
)[indx
])
2632 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2635 if (asym_ptr
->udata
)
2636 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2646 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2647 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2656 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2658 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2661 Elf_Internal_Shdr
*hdr
;
2662 long symcount
; /* Number of external ELF symbols */
2663 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2664 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2665 Elf_Internal_Sym i_sym
;
2666 Elf_External_Sym
*x_symp
= NULL
;
2668 /* Read each raw ELF symbol, converting from external ELF form to
2669 internal ELF form, and then using the information to create a
2670 canonical bfd symbol table entry.
2672 Note that we allocate the initial bfd canonical symbol buffer
2673 based on a one-to-one mapping of the ELF symbols to canonical
2674 symbols. We actually use all the ELF symbols, so there will be no
2675 space left over at the end. When we have all the symbols, we
2676 build the caller's pointer vector. */
2679 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2681 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2682 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2685 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2688 sym
= symbase
= NULL
;
2693 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2696 symbase
= ((elf_symbol_type
*)
2697 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2698 if (symbase
== (elf_symbol_type
*) NULL
)
2700 bfd_set_error (bfd_error_no_memory
);
2705 /* Temporarily allocate room for the raw ELF symbols. */
2706 x_symp
= ((Elf_External_Sym
*)
2707 malloc (symcount
* sizeof (Elf_External_Sym
)));
2708 if (x_symp
== NULL
&& symcount
!= 0)
2710 bfd_set_error (bfd_error_no_memory
);
2714 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2715 != symcount
* sizeof (Elf_External_Sym
))
2717 /* Skip first symbol, which is a null dummy. */
2718 for (i
= 1; i
< symcount
; i
++)
2720 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2721 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2722 #ifdef ELF_KEEP_EXTSYM
2723 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2725 sym
->symbol
.the_bfd
= abfd
;
2727 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2730 sym
->symbol
.value
= i_sym
.st_value
;
2732 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2734 sym
->symbol
.section
= section_from_elf_index (abfd
,
2736 if (sym
->symbol
.section
== NULL
)
2738 /* This symbol is in a section for which we did not
2739 create a BFD section. Just use bfd_abs_section,
2740 although it is wrong. FIXME. */
2741 sym
->symbol
.section
= bfd_abs_section_ptr
;
2744 else if (i_sym
.st_shndx
== SHN_ABS
)
2746 sym
->symbol
.section
= bfd_abs_section_ptr
;
2748 else if (i_sym
.st_shndx
== SHN_COMMON
)
2750 sym
->symbol
.section
= bfd_com_section_ptr
;
2751 /* Elf puts the alignment into the `value' field, and
2752 the size into the `size' field. BFD wants to see the
2753 size in the value field, and doesn't care (at the
2754 moment) about the alignment. */
2755 sym
->symbol
.value
= i_sym
.st_size
;
2757 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2759 sym
->symbol
.section
= bfd_und_section_ptr
;
2762 sym
->symbol
.section
= bfd_abs_section_ptr
;
2764 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2766 switch (ELF_ST_BIND (i_sym
.st_info
))
2769 sym
->symbol
.flags
|= BSF_LOCAL
;
2772 sym
->symbol
.flags
|= BSF_GLOBAL
;
2775 sym
->symbol
.flags
|= BSF_WEAK
;
2779 switch (ELF_ST_TYPE (i_sym
.st_info
))
2782 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2785 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2788 sym
->symbol
.flags
|= BSF_FUNCTION
;
2793 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2795 /* Do some backend-specific processing on this symbol. */
2797 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2798 if (ebd
->elf_backend_symbol_processing
)
2799 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2806 /* Do some backend-specific processing on this symbol table. */
2808 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2809 if (ebd
->elf_backend_symbol_table_processing
)
2810 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2813 /* We rely on the zalloc to clear out the final symbol entry. */
2815 symcount
= sym
- symbase
;
2817 /* Fill in the user's symbol pointer vector if needed. */
2825 *symptrs
++ = &sym
->symbol
;
2828 *symptrs
= 0; /* Final null pointer */
2840 /* Return the number of bytes required to hold the symtab vector.
2842 Note that we base it on the count plus 1, since we will null terminate
2843 the vector allocated based on this size. However, the ELF symbol table
2844 always has a dummy entry as symbol #0, so it ends up even. */
2847 elf_get_symtab_upper_bound (abfd
)
2852 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2854 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2855 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2861 elf_get_dynamic_symtab_upper_bound (abfd
)
2866 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2868 if (elf_dynsymtab (abfd
) == 0)
2870 bfd_set_error (bfd_error_invalid_operation
);
2874 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2875 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2881 elf_get_reloc_upper_bound (abfd
, asect
)
2885 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2888 /* Read in and swap the external relocs. */
2891 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2896 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2897 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2898 PTR allocated
= NULL
;
2899 bfd_byte
*native_relocs
;
2905 if (asect
->relocation
!= NULL
2906 || (asect
->flags
& SEC_RELOC
) == 0
2907 || asect
->reloc_count
== 0)
2910 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2911 && (asect
->reloc_count
2912 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2914 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2915 if (allocated
== NULL
)
2917 bfd_set_error (bfd_error_no_memory
);
2921 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2922 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2923 != d
->rel_hdr
.sh_size
))
2926 native_relocs
= (bfd_byte
*) allocated
;
2928 relents
= ((arelent
*)
2929 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2930 if (relents
== NULL
)
2932 bfd_set_error (bfd_error_no_memory
);
2936 entsize
= d
->rel_hdr
.sh_entsize
;
2937 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2938 || entsize
== sizeof (Elf_External_Rela
));
2940 for (i
= 0, relent
= relents
;
2941 i
< asect
->reloc_count
;
2942 i
++, relent
++, native_relocs
+= entsize
)
2944 Elf_Internal_Rela rela
;
2945 Elf_Internal_Rel rel
;
2947 if (entsize
== sizeof (Elf_External_Rela
))
2948 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2951 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2952 rela
.r_offset
= rel
.r_offset
;
2953 rela
.r_info
= rel
.r_info
;
2957 /* The address of an ELF reloc is section relative for an object
2958 file, and absolute for an executable file or shared library.
2959 The address of a BFD reloc is always section relative. */
2960 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2961 relent
->address
= rela
.r_offset
;
2963 relent
->address
= rela
.r_offset
- asect
->vma
;
2965 if (ELF_R_SYM (rela
.r_info
) == 0)
2966 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2971 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
2974 /* Canonicalize ELF section symbols. FIXME: Why? */
2975 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
2976 relent
->sym_ptr_ptr
= ps
;
2978 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2981 relent
->addend
= rela
.r_addend
;
2983 if (entsize
== sizeof (Elf_External_Rela
))
2984 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
2986 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
2989 asect
->relocation
= relents
;
2991 if (allocated
!= NULL
)
2997 if (allocated
!= NULL
)
3004 elf_debug_section (str
, num
, hdr
)
3007 Elf_Internal_Shdr
*hdr
;
3009 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3011 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3012 (long) hdr
->sh_name
,
3013 (long) hdr
->sh_type
,
3014 (long) hdr
->sh_flags
);
3016 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3017 (long) hdr
->sh_addr
,
3018 (long) hdr
->sh_offset
,
3019 (long) hdr
->sh_size
);
3021 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3022 (long) hdr
->sh_link
,
3023 (long) hdr
->sh_info
,
3024 (long) hdr
->sh_addralign
);
3025 fprintf (stderr
, "sh_entsize = %ld\n",
3026 (long) hdr
->sh_entsize
);
3031 elf_debug_file (ehdrp
)
3032 Elf_Internal_Ehdr
*ehdrp
;
3034 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3035 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3036 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3037 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3038 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3039 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3040 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3044 /* Canonicalize the relocs. */
3047 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3056 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3059 tblptr
= section
->relocation
;
3060 for (i
= 0; i
< section
->reloc_count
; i
++)
3061 *relptr
++ = tblptr
++;
3065 return section
->reloc_count
;
3069 elf_get_symtab (abfd
, alocation
)
3071 asymbol
**alocation
;
3073 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3076 bfd_get_symcount (abfd
) = symcount
;
3081 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3083 asymbol
**alocation
;
3085 return elf_slurp_symbol_table (abfd
, alocation
, true);
3089 elf_make_empty_symbol (abfd
)
3092 elf_symbol_type
*newsym
;
3094 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3097 bfd_set_error (bfd_error_no_memory
);
3102 newsym
->symbol
.the_bfd
= abfd
;
3103 return &newsym
->symbol
;
3108 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3113 bfd_symbol_info (symbol
, ret
);
3117 elf_get_lineno (ignore_abfd
, symbol
)
3121 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3128 elf_set_arch_mach (abfd
, arch
, machine
)
3130 enum bfd_architecture arch
;
3131 unsigned long machine
;
3133 /* If this isn't the right architecture for this backend, and this
3134 isn't the generic backend, fail. */
3135 if (arch
!= get_elf_backend_data (abfd
)->arch
3136 && arch
!= bfd_arch_unknown
3137 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3140 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3144 elf_find_nearest_line (abfd
,
3155 CONST
char **filename_ptr
;
3156 CONST
char **functionname_ptr
;
3157 unsigned int *line_ptr
;
3163 elf_sizeof_headers (abfd
, reloc
)
3169 ret
= sizeof (Elf_External_Ehdr
);
3171 ret
+= get_program_header_size (abfd
);
3176 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3181 bfd_size_type count
;
3183 Elf_Internal_Shdr
*hdr
;
3185 if (! abfd
->output_has_begun
3186 && ! elf_compute_section_file_positions (abfd
,
3187 (struct bfd_link_info
*) NULL
))
3190 hdr
= &elf_section_data (section
)->this_hdr
;
3192 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3194 if (bfd_write (location
, 1, count
, abfd
) != count
)
3201 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3204 Elf_Internal_Rela
*dst
;
3206 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3212 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3215 Elf_Internal_Rel
*dst
;
3217 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3223 /* Core file support */
3225 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3226 #include <sys/procfs.h>
3228 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3229 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3230 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3236 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3243 prstatus_t
*status
= (prstatus_t
*) 0;
3245 if (descsz
== sizeof (prstatus_t
))
3247 newsect
= bfd_make_section (abfd
, ".reg");
3248 if (newsect
== NULL
)
3250 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3251 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3252 newsect
->flags
= SEC_HAS_CONTENTS
;
3253 newsect
->alignment_power
= 2;
3254 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3256 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3262 /* Stash a copy of the prpsinfo structure away for future use. */
3265 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3271 if (descsz
== sizeof (prpsinfo_t
))
3273 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3275 bfd_set_error (bfd_error_no_memory
);
3278 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3284 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3292 newsect
= bfd_make_section (abfd
, ".reg2");
3293 if (newsect
== NULL
)
3295 newsect
->_raw_size
= descsz
;
3296 newsect
->filepos
= filepos
;
3297 newsect
->flags
= SEC_HAS_CONTENTS
;
3298 newsect
->alignment_power
= 2;
3302 #endif /* HAVE_PROCFS */
3304 /* Return a pointer to the args (including the command name) that were
3305 seen by the program that generated the core dump. Note that for
3306 some reason, a spurious space is tacked onto the end of the args
3307 in some (at least one anyway) implementations, so strip it off if
3311 elf_core_file_failing_command (abfd
)
3315 if (core_prpsinfo (abfd
))
3317 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3318 char *scan
= p
->pr_psargs
;
3323 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3327 return p
->pr_psargs
;
3333 /* Return the number of the signal that caused the core dump. Presumably,
3334 since we have a core file, we got a signal of some kind, so don't bother
3335 checking the other process status fields, just return the signal number.
3339 elf_core_file_failing_signal (abfd
)
3343 if (core_prstatus (abfd
))
3345 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3351 /* Check to see if the core file could reasonably be expected to have
3352 come for the current executable file. Note that by default we return
3353 true unless we find something that indicates that there might be a
3358 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3367 /* First, xvecs must match since both are ELF files for the same target. */
3369 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3371 bfd_set_error (bfd_error_system_call
);
3377 /* If no prpsinfo, just return true. Otherwise, grab the last component
3378 of the exec'd pathname from the prpsinfo. */
3380 if (core_prpsinfo (core_bfd
))
3382 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3389 /* Find the last component of the executable pathname. */
3391 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3397 execname
= (char *) exec_bfd
->filename
;
3400 /* See if they match */
3402 return strcmp (execname
, corename
) ? false : true;
3408 #endif /* HAVE_PROCFS */
3411 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3412 the information that would normally be available from the /proc interface
3413 for the process, at the time the process dumped core. Currently this
3414 includes copies of the prstatus, prpsinfo, and fpregset structures.
3416 Since these structures are potentially machine dependent in size and
3417 ordering, bfd provides two levels of support for them. The first level,
3418 available on all machines since it does not require that the host
3419 have /proc support or the relevant include files, is to create a bfd
3420 section for each of the prstatus, prpsinfo, and fpregset structures,
3421 without any interpretation of their contents. With just this support,
3422 the bfd client will have to interpret the structures itself. Even with
3423 /proc support, it might want these full structures for it's own reasons.
3425 In the second level of support, where HAVE_PROCFS is defined, bfd will
3426 pick apart the structures to gather some additional information that
3427 clients may want, such as the general register set, the name of the
3428 exec'ed file and its arguments, the signal (if any) that caused the
3434 elf_corefile_note (abfd
, hdr
)
3436 Elf_Internal_Phdr
*hdr
;
3438 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3439 Elf_Internal_Note i_note
; /* Elf note, internal form */
3440 char *buf
= NULL
; /* Entire note segment contents */
3441 char *namedata
; /* Name portion of the note */
3442 char *descdata
; /* Descriptor portion of the note */
3443 char *sectname
; /* Name to use for new section */
3444 long filepos
; /* File offset to descriptor data */
3447 if (hdr
->p_filesz
> 0
3448 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3449 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3450 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3452 x_note_p
= (Elf_External_Note
*) buf
;
3453 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3455 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3456 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3457 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3458 namedata
= x_note_p
->name
;
3459 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3460 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3461 switch (i_note
.type
)
3464 /* process descdata as prstatus info */
3465 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3467 sectname
= ".prstatus";
3470 /* process descdata as fpregset info */
3471 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3473 sectname
= ".fpregset";
3476 /* process descdata as prpsinfo */
3477 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3479 sectname
= ".prpsinfo";
3482 /* Unknown descriptor, just ignore it. */
3486 if (sectname
!= NULL
)
3488 newsect
= bfd_make_section (abfd
, sectname
);
3489 if (newsect
== NULL
)
3491 newsect
->_raw_size
= i_note
.descsz
;
3492 newsect
->filepos
= filepos
;
3493 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3494 newsect
->alignment_power
= 2;
3496 x_note_p
= (Elf_External_Note
*)
3497 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3504 else if (hdr
->p_filesz
> 0)
3506 bfd_set_error (bfd_error_no_memory
);
3513 /* Core files are simply standard ELF formatted files that partition
3514 the file using the execution view of the file (program header table)
3515 rather than the linking view. In fact, there is no section header
3516 table in a core file.
3518 The process status information (including the contents of the general
3519 register set) and the floating point register set are stored in a
3520 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3521 that allow standard bfd access to the general registers (.reg) and the
3522 floating point registers (.reg2).
3527 elf_core_file_p (abfd
)
3530 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3531 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3532 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3533 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3534 unsigned int phindex
;
3535 struct elf_backend_data
*ebd
;
3537 /* Read in the ELF header in external format. */
3539 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3541 if (bfd_get_error () != bfd_error_system_call
)
3542 bfd_set_error (bfd_error_wrong_format
);
3546 /* Now check to see if we have a valid ELF file, and one that BFD can
3547 make use of. The magic number must match, the address size ('class')
3548 and byte-swapping must match our XVEC entry, and it must have a
3549 program header table (FIXME: See comments re segments at top of this
3552 if (elf_file_p (&x_ehdr
) == false)
3555 bfd_set_error (bfd_error_wrong_format
);
3559 /* FIXME, Check EI_VERSION here ! */
3563 int desired_address_size
= ELFCLASS32
;
3566 int desired_address_size
= ELFCLASS64
;
3569 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3573 /* Switch xvec to match the specified byte order. */
3574 switch (x_ehdr
.e_ident
[EI_DATA
])
3576 case ELFDATA2MSB
: /* Big-endian */
3577 if (abfd
->xvec
->byteorder_big_p
== false)
3580 case ELFDATA2LSB
: /* Little-endian */
3581 if (abfd
->xvec
->byteorder_big_p
== true)
3584 case ELFDATANONE
: /* No data encoding specified */
3585 default: /* Unknown data encoding specified */
3589 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3590 the tdata pointer in the bfd. */
3593 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3594 if (elf_tdata (abfd
) == NULL
)
3596 bfd_set_error (bfd_error_no_memory
);
3600 /* FIXME, `wrong' returns from this point onward, leak memory. */
3602 /* Now that we know the byte order, swap in the rest of the header */
3603 i_ehdrp
= elf_elfheader (abfd
);
3604 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3606 elf_debug_file (i_ehdrp
);
3609 ebd
= get_elf_backend_data (abfd
);
3611 /* Check that the ELF e_machine field matches what this particular
3612 BFD format expects. */
3613 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3615 const bfd_target
* const *target_ptr
;
3617 if (ebd
->elf_machine_code
!= EM_NONE
)
3620 /* This is the generic ELF target. Let it match any ELF target
3621 for which we do not have a specific backend. */
3622 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3624 struct elf_backend_data
*back
;
3626 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3628 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3629 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3631 /* target_ptr is an ELF backend which matches this
3632 object file, so reject the generic ELF target. */
3638 /* If there is no program header, or the type is not a core file, then
3640 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3643 /* Allocate space for a copy of the program header table in
3644 internal form, seek to the program header table in the file,
3645 read it in, and convert it to internal form. As a simple sanity
3646 check, verify that the what BFD thinks is the size of each program
3647 header table entry actually matches the size recorded in the file. */
3649 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3651 i_phdrp
= (Elf_Internal_Phdr
*)
3652 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3655 bfd_set_error (bfd_error_no_memory
);
3658 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3660 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3662 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3665 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3668 /* Once all of the program headers have been read and converted, we
3669 can start processing them. */
3671 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3673 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3674 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3676 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3681 /* Remember the entry point specified in the ELF file header. */
3683 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3688 /* ELF linker code. */
3690 static boolean elf_link_add_object_symbols
3691 PARAMS ((bfd
*, struct bfd_link_info
*));
3692 static boolean elf_link_add_archive_symbols
3693 PARAMS ((bfd
*, struct bfd_link_info
*));
3694 static Elf_Internal_Rela
*elf_link_read_relocs
3695 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
3696 static boolean elf_adjust_dynamic_symbol
3697 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3699 /* Given an ELF BFD, add symbols to the global hash table as
3703 elf_bfd_link_add_symbols (abfd
, info
)
3705 struct bfd_link_info
*info
;
3707 switch (bfd_get_format (abfd
))
3710 return elf_link_add_object_symbols (abfd
, info
);
3712 return elf_link_add_archive_symbols (abfd
, info
);
3714 bfd_set_error (bfd_error_wrong_format
);
3719 /* Add symbols from an ELF archive file to the linker hash table. We
3720 don't use _bfd_generic_link_add_archive_symbols because of a
3721 problem which arises on UnixWare. The UnixWare libc.so is an
3722 archive which includes an entry libc.so.1 which defines a bunch of
3723 symbols. The libc.so archive also includes a number of other
3724 object files, which also define symbols, some of which are the same
3725 as those defined in libc.so.1. Correct linking requires that we
3726 consider each object file in turn, and include it if it defines any
3727 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3728 this; it looks through the list of undefined symbols, and includes
3729 any object file which defines them. When this algorithm is used on
3730 UnixWare, it winds up pulling in libc.so.1 early and defining a
3731 bunch of symbols. This means that some of the other objects in the
3732 archive are not included in the link, which is incorrect since they
3733 precede libc.so.1 in the archive.
3735 Fortunately, ELF archive handling is simpler than that done by
3736 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3737 oddities. In ELF, if we find a symbol in the archive map, and the
3738 symbol is currently undefined, we know that we must pull in that
3741 Unfortunately, we do have to make multiple passes over the symbol
3742 table until nothing further is resolved. */
3745 elf_link_add_archive_symbols (abfd
, info
)
3747 struct bfd_link_info
*info
;
3750 boolean
*defined
= NULL
;
3751 boolean
*included
= NULL
;
3755 if (! bfd_has_map (abfd
))
3757 bfd_set_error (bfd_error_no_symbols
);
3761 /* Keep track of all symbols we know to be already defined, and all
3762 files we know to be already included. This is to speed up the
3763 second and subsequent passes. */
3764 c
= bfd_ardata (abfd
)->symdef_count
;
3767 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3768 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3769 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3771 bfd_set_error (bfd_error_no_memory
);
3774 memset (defined
, 0, c
* sizeof (boolean
));
3775 memset (included
, 0, c
* sizeof (boolean
));
3777 symdefs
= bfd_ardata (abfd
)->symdefs
;
3790 symdefend
= symdef
+ c
;
3791 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3793 struct elf_link_hash_entry
*h
;
3795 struct bfd_link_hash_entry
*undefs_tail
;
3798 if (defined
[i
] || included
[i
])
3800 if (symdef
->file_offset
== last
)
3806 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3807 false, false, false);
3808 if (h
== (struct elf_link_hash_entry
*) NULL
)
3810 if (h
->root
.type
!= bfd_link_hash_undefined
)
3816 /* We need to include this archive member. */
3818 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3819 if (element
== (bfd
*) NULL
)
3822 if (! bfd_check_format (element
, bfd_object
))
3825 /* Doublecheck that we have not included this object
3826 already--it should be impossible, but there may be
3827 something wrong with the archive. */
3828 if (element
->archive_pass
!= 0)
3830 bfd_set_error (bfd_error_bad_value
);
3833 element
->archive_pass
= 1;
3835 undefs_tail
= info
->hash
->undefs_tail
;
3837 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3840 if (! elf_link_add_object_symbols (element
, info
))
3843 /* If there are any new undefined symbols, we need to make
3844 another pass through the archive in order to see whether
3845 they can be defined. FIXME: This isn't perfect, because
3846 common symbols wind up on undefs_tail and because an
3847 undefined symbol which is defined later on in this pass
3848 does not require another pass. This isn't a bug, but it
3849 does make the code less efficient than it could be. */
3850 if (undefs_tail
!= info
->hash
->undefs_tail
)
3853 /* Look backward to mark all symbols from this object file
3854 which we have already seen in this pass. */
3858 included
[mark
] = true;
3863 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3865 /* We mark subsequent symbols from this object file as we go
3866 on through the loop. */
3867 last
= symdef
->file_offset
;
3878 if (defined
!= (boolean
*) NULL
)
3880 if (included
!= (boolean
*) NULL
)
3885 /* Record a new dynamic symbol. We record the dynamic symbols as we
3886 read the input files, since we need to have a list of all of them
3887 before we can determine the final sizes of the output sections. */
3890 elf_link_record_dynamic_symbol (info
, h
)
3891 struct bfd_link_info
*info
;
3892 struct elf_link_hash_entry
*h
;
3894 if (h
->dynindx
== -1)
3896 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3897 ++elf_hash_table (info
)->dynsymcount
;
3898 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3899 elf_hash_table (info
)->dynstr
,
3900 h
->root
.root
.string
);
3901 if (h
->dynstr_index
== (unsigned long) -1)
3908 /* Add symbols from an ELF object file to the linker hash table. */
3911 elf_link_add_object_symbols (abfd
, info
)
3913 struct bfd_link_info
*info
;
3915 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3916 const Elf_Internal_Sym
*,
3917 const char **, flagword
*,
3918 asection
**, bfd_vma
*));
3919 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
3920 asection
*, const Elf_Internal_Rela
*));
3922 Elf_Internal_Shdr
*hdr
;
3926 Elf_External_Sym
*buf
= NULL
;
3927 struct elf_link_hash_entry
**sym_hash
;
3929 Elf_External_Dyn
*dynbuf
= NULL
;
3930 struct elf_link_hash_entry
*weaks
;
3931 Elf_External_Sym
*esym
;
3932 Elf_External_Sym
*esymend
;
3934 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
3935 collect
= get_elf_backend_data (abfd
)->collect
;
3937 /* A stripped shared library might only have a dynamic symbol table,
3938 not a regular symbol table. In that case we can still go ahead
3939 and link using the dynamic symbol table. */
3940 if (elf_onesymtab (abfd
) == 0
3941 && elf_dynsymtab (abfd
) != 0)
3943 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
3944 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
3947 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3948 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3950 /* The sh_info field of the symtab header tells us where the
3951 external symbols start. We don't care about the local symbols at
3953 if (elf_bad_symtab (abfd
))
3955 extsymcount
= symcount
;
3960 extsymcount
= symcount
- hdr
->sh_info
;
3961 extsymoff
= hdr
->sh_info
;
3964 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
3965 if (buf
== NULL
&& extsymcount
!= 0)
3967 bfd_set_error (bfd_error_no_memory
);
3971 /* We store a pointer to the hash table entry for each external
3973 sym_hash
= ((struct elf_link_hash_entry
**)
3975 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
3976 if (sym_hash
== NULL
)
3978 bfd_set_error (bfd_error_no_memory
);
3981 elf_sym_hashes (abfd
) = sym_hash
;
3983 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
3987 /* If we are creating a shared library, create all the dynamic
3988 sections immediately. We need to attach them to something,
3989 so we attach them to this BFD, provided it is the right
3990 format. FIXME: If there are no input BFD's of the same
3991 format as the output, we can't make a shared library. */
3993 && elf_hash_table (info
)->dynobj
== NULL
3994 && abfd
->xvec
== info
->hash
->creator
)
3996 if (! elf_link_create_dynamic_sections (abfd
, info
))
3998 elf_hash_table (info
)->dynobj
= abfd
;
4005 unsigned long strindex
;
4009 /* You can't use -r against a dynamic object. Also, there's no
4010 hope of using a dynamic object which does not exactly match
4011 the format of the output file. */
4012 if (info
->relocateable
4013 || info
->hash
->creator
!= abfd
->xvec
)
4015 bfd_set_error (bfd_error_invalid_operation
);
4019 /* Find the name to use in a DT_NEEDED entry that refers to this
4020 object. If the object has a DT_SONAME entry, we use it.
4021 Otherwise, if the generic linker stuck something in
4022 elf_dt_needed_name, we use that. Otherwise, we just use the
4024 name
= bfd_get_filename (abfd
);
4025 if (elf_dt_needed_name (abfd
) != NULL
)
4026 name
= elf_dt_needed_name (abfd
);
4027 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4030 Elf_External_Dyn
*extdyn
;
4031 Elf_External_Dyn
*extdynend
;
4033 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4036 bfd_set_error (bfd_error_no_memory
);
4040 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4041 (file_ptr
) 0, s
->_raw_size
))
4045 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4046 for (; extdyn
< extdynend
; extdyn
++)
4048 Elf_Internal_Dyn dyn
;
4050 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4051 if (dyn
.d_tag
== DT_SONAME
)
4056 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4059 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4060 name
= elf_string_from_elf_section (abfd
, link
,
4073 /* We do not want to include any of the sections in a dynamic
4074 object in the output file. We hack by simply clobbering the
4075 list of sections in the BFD. This could be handled more
4076 cleanly by, say, a new section flag; the existing
4077 SEC_NEVER_LOAD flag is not the one we want, because that one
4078 still implies that the section takes up space in the output
4080 abfd
->sections
= NULL
;
4082 /* If this is the first dynamic object found in the link, create
4083 the special sections required for dynamic linking. We need
4084 to put them somewhere, and attaching them to the first
4085 dynamic object is as good place as any. */
4086 if (elf_hash_table (info
)->dynobj
== NULL
)
4088 if (! elf_link_create_dynamic_sections (abfd
, info
))
4090 elf_hash_table (info
)->dynobj
= abfd
;
4093 /* Add a DT_NEEDED entry for this dynamic object. */
4094 strindex
= bfd_add_to_strtab (abfd
,
4095 elf_hash_table (info
)->dynstr
,
4097 if (strindex
== (unsigned long) -1)
4099 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4104 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4106 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4107 != extsymcount
* sizeof (Elf_External_Sym
)))
4112 esymend
= buf
+ extsymcount
;
4113 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4115 Elf_Internal_Sym sym
;
4121 struct elf_link_hash_entry
*h
= NULL
;
4124 elf_swap_symbol_in (abfd
, esym
, &sym
);
4126 flags
= BSF_NO_FLAGS
;
4128 value
= sym
.st_value
;
4131 bind
= ELF_ST_BIND (sym
.st_info
);
4132 if (bind
== STB_LOCAL
)
4134 /* This should be impossible, since ELF requires that all
4135 global symbols follow all local symbols, and that sh_info
4136 point to the first global symbol. Unfortunatealy, Irix 5
4140 else if (bind
== STB_GLOBAL
)
4142 else if (bind
== STB_WEAK
)
4146 /* Leave it up to the processor backend. */
4149 if (sym
.st_shndx
== SHN_UNDEF
)
4150 sec
= bfd_und_section_ptr
;
4151 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4153 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4157 sec
= bfd_abs_section_ptr
;
4159 else if (sym
.st_shndx
== SHN_ABS
)
4160 sec
= bfd_abs_section_ptr
;
4161 else if (sym
.st_shndx
== SHN_COMMON
)
4163 sec
= bfd_com_section_ptr
;
4164 /* What ELF calls the size we call the value. What ELF
4165 calls the value we call the alignment. */
4166 value
= sym
.st_size
;
4170 /* Leave it up to the processor backend. */
4173 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4174 if (name
== (const char *) NULL
)
4177 if (add_symbol_hook
)
4179 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4183 /* The hook function sets the name to NULL if this symbol
4184 should be skipped for some reason. */
4185 if (name
== (const char *) NULL
)
4189 /* Sanity check that all possibilities were handled. */
4190 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4192 bfd_set_error (bfd_error_bad_value
);
4196 if (bfd_is_und_section (sec
)
4197 || bfd_is_com_section (sec
))
4202 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4204 /* We need to look up the symbol now in order to get some of
4205 the dynamic object handling right. We pass the hash
4206 table entry in to _bfd_generic_link_add_one_symbol so
4207 that it does not have to look it up again. */
4208 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4209 true, false, false);
4214 /* If we are looking at a dynamic object, and this is a
4215 definition, we need to see if it has already been defined
4216 by some other object. If it has, we want to use the
4217 existing definition, and we do not want to report a
4218 multiple symbol definition error; we do this by
4219 clobbering sec to be bfd_und_section_ptr. */
4220 if (dynamic
&& definition
)
4222 if (h
->root
.type
== bfd_link_hash_defined
)
4223 sec
= bfd_und_section_ptr
;
4226 /* Similarly, if we are not looking at a dynamic object, and
4227 we have a definition, we want to override any definition
4228 we may have from a dynamic object. Symbols from regular
4229 files always take precedence over symbols from dynamic
4230 objects, even if they are defined after the dynamic
4231 object in the link. */
4234 && h
->root
.type
== bfd_link_hash_defined
4235 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4236 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4237 == bfd_target_elf_flavour
)
4238 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4241 /* Change the hash table entry to undefined, and let
4242 _bfd_generic_link_add_one_symbol do the right thing
4243 with the new definition. */
4244 h
->root
.type
= bfd_link_hash_undefined
;
4245 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4246 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4249 /* If this is a weak definition which we are going to use,
4250 and the symbol is currently undefined, record that the
4251 definition is weak. */
4253 && (flags
& BSF_WEAK
) != 0
4254 && ! bfd_is_und_section (sec
)
4255 && (h
->root
.type
== bfd_link_hash_new
4256 || h
->root
.type
== bfd_link_hash_undefined
4257 || h
->root
.type
== bfd_link_hash_weak
))
4258 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4261 if (! (_bfd_generic_link_add_one_symbol
4262 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4263 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4268 && (flags
& BSF_WEAK
) != 0
4269 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4270 && (*sym_hash
)->weakdef
== NULL
)
4272 /* Keep a list of all weak defined non function symbols from
4273 a dynamic object, using the weakdef field. Later in this
4274 function we will set the weakdef field to the correct
4275 value. We only put non-function symbols from dynamic
4276 objects on this list, because that happens to be the only
4277 time we need to know the normal symbol corresponding to a
4278 weak symbol, and the information is time consuming to
4279 figure out. If the weakdef field is not already NULL,
4280 then this symbol was already defined by some previous
4281 dynamic object, and we will be using that previous
4282 definition anyhow. */
4284 (*sym_hash
)->weakdef
= weaks
;
4288 /* Get the alignment of a common symbol. */
4289 if (sym
.st_shndx
== SHN_COMMON
4290 && h
->root
.type
== bfd_link_hash_common
)
4291 h
->root
.u
.c
.alignment_power
= bfd_log2 (sym
.st_value
);
4293 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4299 /* Remember the symbol size and type. */
4300 if (sym
.st_size
!= 0)
4302 /* FIXME: We should probably somehow give a warning if
4303 the symbol size changes. */
4304 h
->size
= sym
.st_size
;
4306 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4308 /* FIXME: We should probably somehow give a warning if
4309 the symbol type changes. */
4310 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4313 /* Set a flag in the hash table entry indicating the type of
4314 reference or definition we just found. Keep a count of
4315 the number of dynamic symbols we find. A dynamic symbol
4316 is one which is referenced or defined by both a regular
4317 object and a shared object, or one which is referenced or
4318 defined by more than one shared object. */
4319 old_flags
= h
->elf_link_hash_flags
;
4324 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4326 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4328 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4329 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4335 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4337 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4338 if ((old_flags
& new_flag
) != 0
4339 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4340 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4344 h
->elf_link_hash_flags
|= new_flag
;
4345 if (dynsym
&& h
->dynindx
== -1)
4347 if (! elf_link_record_dynamic_symbol (info
, h
))
4353 /* Now set the weakdefs field correctly for all the weak defined
4354 symbols we found. The only way to do this is to search all the
4355 symbols. Since we only need the information for non functions in
4356 dynamic objects, that's the only time we actually put anything on
4357 the list WEAKS. We need this information so that if a regular
4358 object refers to a symbol defined weakly in a dynamic object, the
4359 real symbol in the dynamic object is also put in the dynamic
4360 symbols; we also must arrange for both symbols to point to the
4361 same memory location. We could handle the general case of symbol
4362 aliasing, but a general symbol alias can only be generated in
4363 assembler code, handling it correctly would be very time
4364 consuming, and other ELF linkers don't handle general aliasing
4366 while (weaks
!= NULL
)
4368 struct elf_link_hash_entry
*hlook
;
4371 struct elf_link_hash_entry
**hpp
;
4372 struct elf_link_hash_entry
**hppend
;
4375 weaks
= hlook
->weakdef
;
4376 hlook
->weakdef
= NULL
;
4378 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4379 slook
= hlook
->root
.u
.def
.section
;
4380 vlook
= hlook
->root
.u
.def
.value
;
4382 hpp
= elf_sym_hashes (abfd
);
4383 hppend
= hpp
+ extsymcount
;
4384 for (; hpp
< hppend
; hpp
++)
4386 struct elf_link_hash_entry
*h
;
4390 && h
->root
.type
== bfd_link_hash_defined
4391 && h
->root
.u
.def
.section
== slook
4392 && h
->root
.u
.def
.value
== vlook
)
4396 /* If the weak definition is in the list of dynamic
4397 symbols, make sure the real definition is put there
4399 if (hlook
->dynindx
!= -1
4400 && h
->dynindx
== -1)
4402 if (! elf_link_record_dynamic_symbol (info
, h
))
4417 /* If this object is the same format as the output object, and it is
4418 not a shared library, then let the backend look through the
4421 This is required to build global offset table entries and to
4422 arrange for dynamic relocs. It is not required for the
4423 particular common case of linking non PIC code, even when linking
4424 against shared libraries, but unfortunately there is no way of
4425 knowing whether an object file has been compiled PIC or not.
4426 Looking through the relocs is not particularly time consuming.
4427 The problem is that we must either (1) keep the relocs in memory,
4428 which causes the linker to require additional runtime memory or
4429 (2) read the relocs twice from the input file, which wastes time.
4430 This would be a good case for using mmap.
4432 I have no idea how to handle linking PIC code into a file of a
4433 different format. It probably can't be done. */
4434 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
4436 && abfd
->xvec
== info
->hash
->creator
4437 && check_relocs
!= NULL
)
4441 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4443 Elf_Internal_Rela
*internal_relocs
;
4446 if ((o
->flags
& SEC_RELOC
) == 0
4447 || o
->reloc_count
== 0)
4450 /* I believe we can ignore the relocs for any section which
4451 does not form part of the final process image, such as a
4452 debugging section. */
4453 if ((o
->flags
& SEC_ALLOC
) == 0)
4456 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
4457 (Elf_Internal_Rela
*) NULL
,
4459 if (internal_relocs
== NULL
)
4462 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
4464 if (! info
->keep_memory
)
4465 free (internal_relocs
);
4482 /* Create some sections which will be filled in with dynamic linking
4483 information. The ABFD argument is an input file which is a dynamic
4484 object. The dynamic sections take up virtual memory space when the
4485 final executable is run, so we need to create them before addresses
4486 are assigned to the output sections. We work out the actual
4487 contents and size of these sections later. */
4490 elf_link_create_dynamic_sections (abfd
, info
)
4492 struct bfd_link_info
*info
;
4495 register asection
*s
;
4496 struct elf_link_hash_entry
*h
;
4497 struct elf_backend_data
*bed
;
4499 /* Note that we set the SEC_IN_MEMORY flag for all of these
4501 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4503 /* A dynamically linked executable has a .interp section, but a
4504 shared library does not. */
4507 s
= bfd_make_section (abfd
, ".interp");
4509 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4513 s
= bfd_make_section (abfd
, ".dynsym");
4515 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4516 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4519 /* The first .dynsym symbol is a dummy. */
4520 elf_hash_table (info
)->dynsymcount
= 1;
4522 s
= bfd_make_section (abfd
, ".dynstr");
4524 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4527 /* Create a strtab to hold the dynamic symbol names. */
4528 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4529 if (elf_hash_table (info
)->dynstr
== NULL
)
4532 s
= bfd_make_section (abfd
, ".dynamic");
4534 || ! bfd_set_section_flags (abfd
, s
, flags
)
4535 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4538 /* The special symbol _DYNAMIC is always set to the start of the
4539 .dynamic section. This call occurs before we have processed the
4540 symbols for any dynamic object, so we don't have to worry about
4541 overriding a dynamic definition. We could set _DYNAMIC in a
4542 linker script, but we only want to define it if we are, in fact,
4543 creating a .dynamic section. We don't want to define it if there
4544 is no .dynamic section, since on some ELF platforms the start up
4545 code examines it to decide how to initialize the process. */
4547 if (! (_bfd_generic_link_add_one_symbol
4548 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4549 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4550 (struct bfd_link_hash_entry
**) &h
)))
4552 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4553 h
->type
= STT_OBJECT
;
4556 && ! elf_link_record_dynamic_symbol (info
, h
))
4559 s
= bfd_make_section (abfd
, ".hash");
4561 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4562 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4565 /* Let the backend create the rest of the sections. This lets the
4566 backend set the right flags. The backend will normally create
4567 the .got and .plt sections. */
4568 bed
= get_elf_backend_data (abfd
);
4569 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4572 /* Add an entry to the .dynamic table. */
4575 elf_add_dynamic_entry (info
, tag
, val
)
4576 struct bfd_link_info
*info
;
4580 Elf_Internal_Dyn dyn
;
4584 bfd_byte
*newcontents
;
4586 dynobj
= elf_hash_table (info
)->dynobj
;
4588 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4589 BFD_ASSERT (s
!= NULL
);
4591 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4592 if (s
->contents
== NULL
)
4593 newcontents
= (bfd_byte
*) malloc (newsize
);
4595 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4596 if (newcontents
== NULL
)
4598 bfd_set_error (bfd_error_no_memory
);
4603 dyn
.d_un
.d_val
= val
;
4604 elf_swap_dyn_out (dynobj
, &dyn
,
4605 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4607 s
->_raw_size
= newsize
;
4608 s
->contents
= newcontents
;
4613 /* Read and swap the relocs for a section. They may have been cached.
4614 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4615 they are used as buffers to read into. They are known to be large
4616 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
4617 value is allocated using either malloc or bfd_alloc, according to
4618 the KEEP_MEMORY argument. */
4620 static Elf_Internal_Rela
*
4621 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
4624 PTR external_relocs
;
4625 Elf_Internal_Rela
*internal_relocs
;
4626 boolean keep_memory
;
4628 Elf_Internal_Shdr
*rel_hdr
;
4630 Elf_Internal_Rela
*alloc2
= NULL
;
4632 if (elf_section_data (o
)->relocs
!= NULL
)
4633 return elf_section_data (o
)->relocs
;
4635 if (o
->reloc_count
== 0)
4638 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4640 if (internal_relocs
== NULL
)
4644 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
4646 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
4648 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
4649 if (internal_relocs
== NULL
)
4651 bfd_set_error (bfd_error_no_memory
);
4656 if (external_relocs
== NULL
)
4658 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
4661 bfd_set_error (bfd_error_no_memory
);
4664 external_relocs
= alloc1
;
4667 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
4668 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
4669 != rel_hdr
->sh_size
))
4672 /* Swap in the relocs. For convenience, we always produce an
4673 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4675 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4677 Elf_External_Rel
*erel
;
4678 Elf_External_Rel
*erelend
;
4679 Elf_Internal_Rela
*irela
;
4681 erel
= (Elf_External_Rel
*) external_relocs
;
4682 erelend
= erel
+ o
->reloc_count
;
4683 irela
= internal_relocs
;
4684 for (; erel
< erelend
; erel
++, irela
++)
4686 Elf_Internal_Rel irel
;
4688 elf_swap_reloc_in (abfd
, erel
, &irel
);
4689 irela
->r_offset
= irel
.r_offset
;
4690 irela
->r_info
= irel
.r_info
;
4691 irela
->r_addend
= 0;
4696 Elf_External_Rela
*erela
;
4697 Elf_External_Rela
*erelaend
;
4698 Elf_Internal_Rela
*irela
;
4700 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
4702 erela
= (Elf_External_Rela
*) external_relocs
;
4703 erelaend
= erela
+ o
->reloc_count
;
4704 irela
= internal_relocs
;
4705 for (; erela
< erelaend
; erela
++, irela
++)
4706 elf_swap_reloca_in (abfd
, erela
, irela
);
4709 /* Cache the results for next time, if we can. */
4711 elf_section_data (o
)->relocs
= internal_relocs
;
4716 /* Don't free alloc2, since if it was allocated we are passing it
4717 back (under the name of internal_relocs). */
4719 return internal_relocs
;
4729 /* Record an assignment to a symbol made by a linker script. We need
4730 this in case some dynamic object refers to this symbol. */
4734 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4736 struct bfd_link_info
*info
;
4739 struct elf_link_hash_entry
*h
;
4741 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
4745 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4746 h
->type
= STT_OBJECT
;
4748 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4749 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4751 && h
->dynindx
== -1)
4753 if (! elf_link_record_dynamic_symbol (info
, h
))
4756 /* If this is a weak defined symbol, and we know a corresponding
4757 real symbol from the same dynamic object, make sure the real
4758 symbol is also made into a dynamic symbol. */
4759 if (h
->weakdef
!= NULL
4760 && h
->weakdef
->dynindx
== -1)
4762 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4770 /* Array used to determine the number of hash table buckets to use
4771 based on the number of symbols there are. If there are fewer than
4772 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4773 fewer than 37 we use 17 buckets, and so forth. We never use more
4774 than 521 buckets. */
4776 static const size_t elf_buckets
[] =
4778 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4781 /* Set up the sizes and contents of the ELF dynamic sections. This is
4782 called by the ELF linker emulation before_allocation routine. We
4783 must set the sizes of the sections before the linker sets the
4784 addresses of the various sections. */
4787 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
, info
,
4792 struct bfd_link_info
*info
;
4793 asection
**sinterpptr
;
4798 Elf_Internal_Sym isym
;
4801 struct elf_backend_data
*bed
;
4805 dynobj
= elf_hash_table (info
)->dynobj
;
4806 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4808 /* If there were no dynamic objects in the link, there is nothing to
4813 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4814 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4816 /* Set the size of the .dynsym and .hash sections. We counted the
4817 number of dynamic symbols in elf_link_add_object_symbols. We
4818 will build the contents of .dynsym and .hash when we build the
4819 final symbol table, because until then we do not know the correct
4820 value to give the symbols. We built the .dynstr section as we
4821 went along in elf_link_add_object_symbols. */
4822 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4823 BFD_ASSERT (s
!= NULL
);
4824 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4825 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4826 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4828 bfd_set_error (bfd_error_no_memory
);
4832 /* The first entry in .dynsym is a dummy symbol. */
4839 elf_swap_symbol_out (output_bfd
, &isym
,
4840 (Elf_External_Sym
*) s
->contents
);
4842 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4844 bucketcount
= elf_buckets
[i
];
4845 if (dynsymcount
< elf_buckets
[i
+ 1])
4849 s
= bfd_get_section_by_name (dynobj
, ".hash");
4850 BFD_ASSERT (s
!= NULL
);
4851 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4852 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4853 if (s
->contents
== NULL
)
4855 bfd_set_error (bfd_error_no_memory
);
4858 memset (s
->contents
, 0, s
->_raw_size
);
4860 put_word (output_bfd
, bucketcount
, s
->contents
);
4861 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4863 elf_hash_table (info
)->bucketcount
= bucketcount
;
4869 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, soname
);
4870 if (indx
== (unsigned long) -1
4871 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
4879 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4880 if (indx
== (unsigned long) -1
4881 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4885 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4886 BFD_ASSERT (s
!= NULL
);
4887 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4888 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4890 /* Find all symbols which were defined in a dynamic object and make
4891 the backend pick a reasonable value for them. */
4892 elf_link_hash_traverse (elf_hash_table (info
),
4893 elf_adjust_dynamic_symbol
,
4896 /* Add some entries to the .dynamic section. We fill in some of the
4897 values later, in elf_bfd_final_link, but we must add the entries
4898 now so that we know the final size of the .dynamic section. */
4899 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4901 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4904 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4906 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4909 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4910 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4911 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4912 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4913 elf_hash_table (info
)->dynstr
->length
)
4914 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4915 sizeof (Elf_External_Sym
)))
4918 /* The backend must work out the sizes of all the other dynamic
4920 bed
= get_elf_backend_data (output_bfd
);
4921 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4924 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4927 /* Make the backend pick a good value for a dynamic symbol. This is
4928 called via elf_link_hash_traverse, and also calls itself
4932 elf_adjust_dynamic_symbol (h
, data
)
4933 struct elf_link_hash_entry
*h
;
4936 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4938 struct elf_backend_data
*bed
;
4940 /* If this symbol is not defined by a dynamic object, or is not
4941 referenced by a regular object, ignore it. FIXME: Do we need to
4942 worry about symbols which are defined by one dynamic object and
4943 referenced by another one? */
4944 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4945 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4946 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4949 /* If we've already adjusted this symbol, don't do it again. This
4950 can happen via a recursive call. */
4951 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4954 /* Don't look at this symbol again. Note that we must set this
4955 after checking the above conditions, because we may look at a
4956 symbol once, decide not to do anything, and then get called
4957 recursively later after REF_REGULAR is set below. */
4958 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4960 /* If this is a weak definition, and we know a real definition, and
4961 the real symbol is not itself defined by a regular object file,
4962 then get a good value for the real definition. We handle the
4963 real symbol first, for the convenience of the backend routine.
4965 Note that there is a confusing case here. If the real definition
4966 is defined by a regular object file, we don't get the real symbol
4967 from the dynamic object, but we do get the weak symbol. If the
4968 processor backend uses a COPY reloc, then if some routine in the
4969 dynamic object changes the real symbol, we will not see that
4970 change in the corresponding weak symbol. This is the way other
4971 ELF linkers work as well, and seems to be a result of the shared
4974 I will clarify this issue. Most SVR4 shared libraries define the
4975 variable _timezone and define timezone as a weak synonym. The
4976 tzset call changes _timezone. If you write
4977 extern int timezone;
4979 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4980 you might expect that, since timezone is a synonym for _timezone,
4981 the same number will print both times. However, if the processor
4982 backend uses a COPY reloc, then actually timezone will be copied
4983 into your process image, and, since you define _timezone
4984 yourself, _timezone will not. Thus timezone and _timezone will
4985 wind up at different memory locations. The tzset call will set
4986 _timezone, leaving timezone unchanged. */
4988 if (h
->weakdef
!= NULL
)
4990 struct elf_link_hash_entry
*weakdef
;
4992 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4993 weakdef
= h
->weakdef
;
4994 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4995 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4996 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
4998 /* This symbol is defined by a regular object file, so we
4999 will not do anything special. Clear weakdef for the
5000 convenience of the processor backend. */
5005 /* There is an implicit reference by a regular object file
5006 via the weak symbol. */
5007 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
5008 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
5013 dynobj
= elf_hash_table (info
)->dynobj
;
5014 bed
= get_elf_backend_data (dynobj
);
5015 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
5017 /* FIXME: No way to return error. */
5024 /* Final phase of ELF linker. */
5026 /* A structure we use to avoid passing large numbers of arguments. */
5028 struct elf_final_link_info
5030 /* General link information. */
5031 struct bfd_link_info
*info
;
5034 /* Symbol string table. */
5035 struct strtab
*symstrtab
;
5036 /* .dynsym section. */
5037 asection
*dynsym_sec
;
5038 /* .hash section. */
5040 /* Buffer large enough to hold contents of any section. */
5042 /* Buffer large enough to hold external relocs of any section. */
5043 PTR external_relocs
;
5044 /* Buffer large enough to hold internal relocs of any section. */
5045 Elf_Internal_Rela
*internal_relocs
;
5046 /* Buffer large enough to hold external local symbols of any input
5048 Elf_External_Sym
*external_syms
;
5049 /* Buffer large enough to hold internal local symbols of any input
5051 Elf_Internal_Sym
*internal_syms
;
5052 /* Array large enough to hold a symbol index for each local symbol
5053 of any input BFD. */
5055 /* Array large enough to hold a section pointer for each local
5056 symbol of any input BFD. */
5057 asection
**sections
;
5058 /* Buffer to hold swapped out symbols. */
5059 Elf_External_Sym
*symbuf
;
5060 /* Number of swapped out symbols in buffer. */
5061 size_t symbuf_count
;
5062 /* Number of symbols which fit in symbuf. */
5066 static boolean elf_link_output_sym
5067 PARAMS ((struct elf_final_link_info
*, const char *,
5068 Elf_Internal_Sym
*, asection
*));
5069 static boolean elf_link_flush_output_syms
5070 PARAMS ((struct elf_final_link_info
*));
5071 static boolean elf_link_output_extsym
5072 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5073 static boolean elf_link_input_bfd
5074 PARAMS ((struct elf_final_link_info
*, bfd
*));
5075 static boolean elf_reloc_link_order
5076 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5077 struct bfd_link_order
*));
5079 /* Do the final step of an ELF link. */
5082 elf_bfd_final_link (abfd
, info
)
5084 struct bfd_link_info
*info
;
5087 struct elf_final_link_info finfo
;
5088 register asection
*o
;
5089 register struct bfd_link_order
*p
;
5091 size_t max_contents_size
;
5092 size_t max_external_reloc_size
;
5093 size_t max_internal_reloc_count
;
5094 size_t max_sym_count
;
5096 Elf_Internal_Sym elfsym
;
5098 Elf_Internal_Shdr
*symtab_hdr
;
5099 Elf_Internal_Shdr
*symstrtab_hdr
;
5100 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5103 abfd
->flags
|= DYNAMIC
;
5105 dynobj
= elf_hash_table (info
)->dynobj
;
5108 finfo
.output_bfd
= abfd
;
5109 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5110 if (finfo
.symstrtab
== NULL
)
5114 finfo
.dynsym_sec
= NULL
;
5115 finfo
.hash_sec
= NULL
;
5119 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5120 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5121 if (finfo
.dynsym_sec
== NULL
5122 || finfo
.hash_sec
== NULL
)
5125 finfo
.contents
= NULL
;
5126 finfo
.external_relocs
= NULL
;
5127 finfo
.internal_relocs
= NULL
;
5128 finfo
.external_syms
= NULL
;
5129 finfo
.internal_syms
= NULL
;
5130 finfo
.indices
= NULL
;
5131 finfo
.sections
= NULL
;
5132 finfo
.symbuf
= NULL
;
5133 finfo
.symbuf_count
= 0;
5135 /* Count up the number of relocations we will output for each output
5136 section, so that we know the sizes of the reloc sections. We
5137 also figure out some maximum sizes. */
5138 max_contents_size
= 0;
5139 max_external_reloc_size
= 0;
5140 max_internal_reloc_count
= 0;
5142 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5146 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5148 if (p
->type
== bfd_section_reloc_link_order
5149 || p
->type
== bfd_symbol_reloc_link_order
)
5151 else if (p
->type
== bfd_indirect_link_order
)
5155 sec
= p
->u
.indirect
.section
;
5157 if (info
->relocateable
)
5158 o
->reloc_count
+= sec
->reloc_count
;
5160 if (sec
->_raw_size
> max_contents_size
)
5161 max_contents_size
= sec
->_raw_size
;
5162 if (sec
->_cooked_size
> max_contents_size
)
5163 max_contents_size
= sec
->_cooked_size
;
5165 /* We are interested in just local symbols, not all
5167 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5171 if (elf_bad_symtab (sec
->owner
))
5172 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5173 / sizeof (Elf_External_Sym
));
5175 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5177 if (sym_count
> max_sym_count
)
5178 max_sym_count
= sym_count
;
5180 if ((sec
->flags
& SEC_RELOC
) != 0)
5184 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5185 if (ext_size
> max_external_reloc_size
)
5186 max_external_reloc_size
= ext_size
;
5187 if (sec
->reloc_count
> max_internal_reloc_count
)
5188 max_internal_reloc_count
= sec
->reloc_count
;
5194 if (o
->reloc_count
> 0)
5195 o
->flags
|= SEC_RELOC
;
5198 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5199 set it (this is probably a bug) and if it is set
5200 assign_section_numbers will create a reloc section. */
5201 o
->flags
&=~ SEC_RELOC
;
5204 /* If the SEC_ALLOC flag is not set, force the section VMA to
5205 zero. This is done in elf_fake_sections as well, but forcing
5206 the VMA to 0 here will ensure that relocs against these
5207 sections are handled correctly. */
5208 if ((o
->flags
& SEC_ALLOC
) == 0)
5212 /* Figure out the file positions for everything but the symbol table
5213 and the relocs. We set symcount to force assign_section_numbers
5214 to create a symbol table. */
5215 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5216 BFD_ASSERT (! abfd
->output_has_begun
);
5217 if (! elf_compute_section_file_positions (abfd
, info
))
5220 /* That created the reloc sections. Set their sizes, and assign
5221 them file positions, and allocate some buffers. */
5222 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5224 if ((o
->flags
& SEC_RELOC
) != 0)
5226 Elf_Internal_Shdr
*rel_hdr
;
5227 register struct elf_link_hash_entry
**p
, **pend
;
5229 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5231 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5233 /* The contents field must last into write_object_contents,
5234 so we allocate it with bfd_alloc rather than malloc. */
5235 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5236 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5238 bfd_set_error (bfd_error_no_memory
);
5242 p
= ((struct elf_link_hash_entry
**)
5243 malloc (o
->reloc_count
5244 * sizeof (struct elf_link_hash_entry
*)));
5245 if (p
== NULL
&& o
->reloc_count
!= 0)
5247 bfd_set_error (bfd_error_no_memory
);
5250 elf_section_data (o
)->rel_hashes
= p
;
5251 pend
= p
+ o
->reloc_count
;
5252 for (; p
< pend
; p
++)
5255 /* Use the reloc_count field as an index when outputting the
5261 assign_file_positions_for_relocs (abfd
);
5263 /* We have now assigned file positions for all the sections except
5264 .symtab and .strtab. We start the .symtab section at the current
5265 file position, and write directly to it. We build the .strtab
5266 section in memory. When we add .dynsym support, we will build
5267 that in memory as well (.dynsym is smaller than .symtab). */
5269 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5270 /* sh_name is set in prep_headers. */
5271 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5272 symtab_hdr
->sh_flags
= 0;
5273 symtab_hdr
->sh_addr
= 0;
5274 symtab_hdr
->sh_size
= 0;
5275 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5276 /* sh_link is set in assign_section_numbers. */
5277 /* sh_info is set below. */
5278 /* sh_offset is set just below. */
5279 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5281 off
= elf_tdata (abfd
)->next_file_pos
;
5282 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5284 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5285 incorrect. We do not yet know the size of the .symtab section.
5286 We correct next_file_pos below, after we do know the size. */
5288 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5289 continuously seeking to the right position in the file. */
5290 if (! info
->keep_memory
|| max_sym_count
< 20)
5291 finfo
.symbuf_size
= 20;
5293 finfo
.symbuf_size
= max_sym_count
;
5294 finfo
.symbuf
= ((Elf_External_Sym
*)
5295 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5296 if (finfo
.symbuf
== NULL
)
5298 bfd_set_error (bfd_error_no_memory
);
5302 /* Start writing out the symbol table. The first symbol is always a
5304 elfsym
.st_value
= 0;
5307 elfsym
.st_other
= 0;
5308 elfsym
.st_shndx
= SHN_UNDEF
;
5309 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5310 &elfsym
, bfd_und_section_ptr
))
5314 /* Some standard ELF linkers do this, but we don't because it causes
5315 bootstrap comparison failures. */
5316 /* Output a file symbol for the output file as the second symbol.
5317 We output this even if we are discarding local symbols, although
5318 I'm not sure if this is correct. */
5319 elfsym
.st_value
= 0;
5321 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5322 elfsym
.st_other
= 0;
5323 elfsym
.st_shndx
= SHN_ABS
;
5324 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5325 &elfsym
, bfd_abs_section_ptr
))
5329 /* Output a symbol for each section. We output these even if we are
5330 discarding local symbols, since they are used for relocs. These
5331 symbols have no names. We store the index of each one in the
5332 index field of the section, so that we can find it again when
5333 outputting relocs. */
5334 elfsym
.st_value
= 0;
5336 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5337 elfsym
.st_other
= 0;
5338 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5340 o
= section_from_elf_index (abfd
, i
);
5342 o
->target_index
= abfd
->symcount
;
5343 elfsym
.st_shndx
= i
;
5344 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5349 /* Allocate some memory to hold information read in from the input
5351 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5352 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5353 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5354 malloc (max_internal_reloc_count
5355 * sizeof (Elf_Internal_Rela
)));
5356 finfo
.external_syms
= ((Elf_External_Sym
*)
5357 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5358 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5359 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5360 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5361 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5362 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5363 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5364 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5365 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5366 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5367 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5368 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5370 bfd_set_error (bfd_error_no_memory
);
5374 /* Since ELF permits relocations to be against local symbols, we
5375 must have the local symbols available when we do the relocations.
5376 Since we would rather only read the local symbols once, and we
5377 would rather not keep them in memory, we handle all the
5378 relocations for a single input file at the same time.
5380 Unfortunately, there is no way to know the total number of local
5381 symbols until we have seen all of them, and the local symbol
5382 indices precede the global symbol indices. This means that when
5383 we are generating relocateable output, and we see a reloc against
5384 a global symbol, we can not know the symbol index until we have
5385 finished examining all the local symbols to see which ones we are
5386 going to output. To deal with this, we keep the relocations in
5387 memory, and don't output them until the end of the link. This is
5388 an unfortunate waste of memory, but I don't see a good way around
5389 it. Fortunately, it only happens when performing a relocateable
5390 link, which is not the common case. FIXME: If keep_memory is set
5391 we could write the relocs out and then read them again; I don't
5392 know how bad the memory loss will be. */
5394 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5395 sub
->output_has_begun
= false;
5396 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5398 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5400 if (p
->type
== bfd_indirect_link_order
5401 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5402 == bfd_target_elf_flavour
))
5404 sub
= p
->u
.indirect
.section
->owner
;
5405 if (! sub
->output_has_begun
)
5407 if (! elf_link_input_bfd (&finfo
, sub
))
5409 sub
->output_has_begun
= true;
5412 else if (p
->type
== bfd_section_reloc_link_order
5413 || p
->type
== bfd_symbol_reloc_link_order
)
5415 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5420 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5426 /* That wrote out all the local symbols. Finish up the symbol table
5427 with the global symbols. */
5429 /* The sh_info field records the index of the first non local
5431 symtab_hdr
->sh_info
= abfd
->symcount
;
5433 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5435 /* We get the global symbols from the hash table. */
5436 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5439 /* Flush all symbols to the file. */
5440 if (! elf_link_flush_output_syms (&finfo
))
5443 /* Now we know the size of the symtab section. */
5444 off
+= symtab_hdr
->sh_size
;
5446 /* Finish up the symbol string table (.strtab) section. */
5447 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5448 /* sh_name was set in prep_headers. */
5449 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5450 symstrtab_hdr
->sh_flags
= 0;
5451 symstrtab_hdr
->sh_addr
= 0;
5452 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5453 symstrtab_hdr
->sh_entsize
= 0;
5454 symstrtab_hdr
->sh_link
= 0;
5455 symstrtab_hdr
->sh_info
= 0;
5456 /* sh_offset is set just below. */
5457 symstrtab_hdr
->sh_addralign
= 1;
5458 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5460 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5461 elf_tdata (abfd
)->next_file_pos
= off
;
5463 /* Adjust the relocs to have the correct symbol indices. */
5464 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5466 struct elf_link_hash_entry
**rel_hash
;
5467 Elf_Internal_Shdr
*rel_hdr
;
5469 if ((o
->flags
& SEC_RELOC
) == 0)
5472 rel_hash
= elf_section_data (o
)->rel_hashes
;
5473 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5474 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5476 if (*rel_hash
== NULL
)
5479 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5481 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5483 Elf_External_Rel
*erel
;
5484 Elf_Internal_Rel irel
;
5486 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5487 elf_swap_reloc_in (abfd
, erel
, &irel
);
5488 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5489 ELF_R_TYPE (irel
.r_info
));
5490 elf_swap_reloc_out (abfd
, &irel
, erel
);
5494 Elf_External_Rela
*erela
;
5495 Elf_Internal_Rela irela
;
5497 BFD_ASSERT (rel_hdr
->sh_entsize
5498 == sizeof (Elf_External_Rela
));
5500 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5501 elf_swap_reloca_in (abfd
, erela
, &irela
);
5502 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5503 ELF_R_TYPE (irela
.r_info
));
5504 elf_swap_reloca_out (abfd
, &irela
, erela
);
5508 /* Set the reloc_count field to 0 to prevent write_relocs from
5509 trying to swap the relocs out itself. */
5513 /* If we are linking against a dynamic object, finish up the dynamic
5514 linking information. */
5517 Elf_External_Dyn
*dyncon
, *dynconend
;
5519 /* Fix up .dynamic entries. */
5520 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5521 BFD_ASSERT (o
!= NULL
);
5523 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5524 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5525 for (; dyncon
< dynconend
; dyncon
++)
5527 Elf_Internal_Dyn dyn
;
5531 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5553 o
= bfd_get_section_by_name (abfd
, name
);
5554 BFD_ASSERT (o
!= NULL
);
5555 dyn
.d_un
.d_ptr
= o
->vma
;
5556 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5563 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5568 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5570 Elf_Internal_Shdr
*hdr
;
5572 hdr
= elf_elfsections (abfd
)[i
];
5573 if (hdr
->sh_type
== type
5574 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5576 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5577 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5580 if (dyn
.d_un
.d_val
== 0
5581 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5582 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5586 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5591 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5594 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5596 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5598 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5600 /* At this point, we are only interested in sections
5601 created by elf_link_create_dynamic_sections. FIXME:
5602 This test is fragile. */
5605 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5606 o
->contents
, o
->output_offset
,
5612 if (finfo
.contents
!= NULL
)
5613 free (finfo
.contents
);
5614 if (finfo
.external_relocs
!= NULL
)
5615 free (finfo
.external_relocs
);
5616 if (finfo
.internal_relocs
!= NULL
)
5617 free (finfo
.internal_relocs
);
5618 if (finfo
.external_syms
!= NULL
)
5619 free (finfo
.external_syms
);
5620 if (finfo
.internal_syms
!= NULL
)
5621 free (finfo
.internal_syms
);
5622 if (finfo
.indices
!= NULL
)
5623 free (finfo
.indices
);
5624 if (finfo
.sections
!= NULL
)
5625 free (finfo
.sections
);
5626 if (finfo
.symbuf
!= NULL
)
5627 free (finfo
.symbuf
);
5628 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5630 if ((o
->flags
& SEC_RELOC
) != 0
5631 && elf_section_data (o
)->rel_hashes
!= NULL
)
5632 free (elf_section_data (o
)->rel_hashes
);
5635 elf_tdata (abfd
)->linker
= true;
5640 if (finfo
.contents
!= NULL
)
5641 free (finfo
.contents
);
5642 if (finfo
.external_relocs
!= NULL
)
5643 free (finfo
.external_relocs
);
5644 if (finfo
.internal_relocs
!= NULL
)
5645 free (finfo
.internal_relocs
);
5646 if (finfo
.external_syms
!= NULL
)
5647 free (finfo
.external_syms
);
5648 if (finfo
.internal_syms
!= NULL
)
5649 free (finfo
.internal_syms
);
5650 if (finfo
.indices
!= NULL
)
5651 free (finfo
.indices
);
5652 if (finfo
.sections
!= NULL
)
5653 free (finfo
.sections
);
5654 if (finfo
.symbuf
!= NULL
)
5655 free (finfo
.symbuf
);
5656 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5658 if ((o
->flags
& SEC_RELOC
) != 0
5659 && elf_section_data (o
)->rel_hashes
!= NULL
)
5660 free (elf_section_data (o
)->rel_hashes
);
5666 /* Add a symbol to the output symbol table. */
5669 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5670 struct elf_final_link_info
*finfo
;
5672 Elf_Internal_Sym
*elfsym
;
5673 asection
*input_sec
;
5675 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5676 struct bfd_link_info
*info
,
5681 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5682 elf_backend_link_output_symbol_hook
;
5683 if (output_symbol_hook
!= NULL
)
5685 if (! ((*output_symbol_hook
)
5686 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5690 if (name
== (const char *) NULL
|| *name
== '\0')
5691 elfsym
->st_name
= 0;
5694 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5695 finfo
->symstrtab
, name
);
5696 if (elfsym
->st_name
== (unsigned long) -1)
5700 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5702 if (! elf_link_flush_output_syms (finfo
))
5706 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5707 finfo
->symbuf
+ finfo
->symbuf_count
);
5708 ++finfo
->symbuf_count
;
5710 ++finfo
->output_bfd
->symcount
;
5715 /* Flush the output symbols to the file. */
5718 elf_link_flush_output_syms (finfo
)
5719 struct elf_final_link_info
*finfo
;
5721 Elf_Internal_Shdr
*symtab
;
5723 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5725 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5727 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5728 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5729 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5732 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5734 finfo
->symbuf_count
= 0;
5739 /* Add an external symbol to the symbol table. This is called from
5740 the hash table traversal routine. */
5743 elf_link_output_extsym (h
, data
)
5744 struct elf_link_hash_entry
*h
;
5747 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5749 Elf_Internal_Sym sym
;
5750 asection
*input_sec
;
5752 /* We don't want to output symbols that have never been mentioned by
5753 a regular file, or that we have been told to strip. However, if
5754 h->indx is set to -2, the symbol is used by a reloc and we must
5758 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5759 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5760 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5761 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5763 else if (finfo
->info
->strip
== strip_all
5764 || (finfo
->info
->strip
== strip_some
5765 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5766 h
->root
.root
.string
,
5767 false, false) == NULL
))
5772 /* If we're stripping it, and it's not a dynamic symbol, there's
5773 nothing else to do. */
5774 if (strip
&& h
->dynindx
== -1)
5778 sym
.st_size
= h
->size
;
5780 if (h
->root
.type
== bfd_link_hash_weak
5781 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5782 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5784 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5786 switch (h
->root
.type
)
5789 case bfd_link_hash_new
:
5793 case bfd_link_hash_undefined
:
5794 input_sec
= bfd_und_section_ptr
;
5795 sym
.st_shndx
= SHN_UNDEF
;
5798 case bfd_link_hash_weak
:
5799 input_sec
= bfd_und_section_ptr
;
5800 sym
.st_shndx
= SHN_UNDEF
;
5803 case bfd_link_hash_defined
:
5806 input_sec
= h
->root
.u
.def
.section
;
5807 if (input_sec
->output_section
!= NULL
)
5809 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5810 input_sec
->output_section
);
5811 if (sym
.st_shndx
== (unsigned short) -1)
5813 /* FIXME: No way to handle errors. */
5817 /* ELF symbols in relocateable files are section relative,
5818 but in nonrelocateable files they are virtual
5820 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5821 if (! finfo
->info
->relocateable
)
5822 sym
.st_value
+= input_sec
->output_section
->vma
;
5826 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5827 == bfd_target_elf_flavour
5828 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5829 sym
.st_shndx
= SHN_UNDEF
;
5830 input_sec
= bfd_und_section_ptr
;
5835 case bfd_link_hash_common
:
5836 input_sec
= bfd_com_section_ptr
;
5837 sym
.st_shndx
= SHN_COMMON
;
5838 sym
.st_value
= 1 << h
->root
.u
.c
.alignment_power
;
5841 case bfd_link_hash_indirect
:
5842 case bfd_link_hash_warning
:
5843 /* I have no idea how these should be handled. */
5847 /* If this symbol should be put in the .dynsym section, then put it
5848 there now. We have already know the symbol index. We also fill
5849 in the entry in the .hash section. */
5850 if (h
->dynindx
!= -1)
5852 struct elf_backend_data
*bed
;
5855 bfd_byte
*bucketpos
;
5858 sym
.st_name
= h
->dynstr_index
;
5860 /* Give the processor backend a chance to tweak the symbol
5861 value, and also to finish up anything that needs to be done
5863 bed
= get_elf_backend_data (finfo
->output_bfd
);
5864 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5865 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5867 /* FIXME: No way to return error. */
5871 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5872 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5875 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5876 bucket
= bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
) % bucketcount
;
5877 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5878 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5879 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5880 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5881 put_word (finfo
->output_bfd
, chain
,
5882 ((bfd_byte
*) finfo
->hash_sec
->contents
5883 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5886 /* If we're stripping it, then it was just a dynamic symbol, and
5887 there's nothing else to do. */
5891 h
->indx
= finfo
->output_bfd
->symcount
;
5893 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5895 /* FIXME: No way to return error. */
5902 /* Link an input file into the linker output file. This function
5903 handles all the sections and relocations of the input file at once.
5904 This is so that we only have to read the local symbols once, and
5905 don't have to keep them in memory. */
5908 elf_link_input_bfd (finfo
, input_bfd
)
5909 struct elf_final_link_info
*finfo
;
5912 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5913 bfd
*, asection
*, bfd_byte
*,
5914 Elf_Internal_Rela
*,
5916 asection
**, char *));
5918 Elf_Internal_Shdr
*symtab_hdr
;
5921 Elf_External_Sym
*esym
;
5922 Elf_External_Sym
*esymend
;
5923 Elf_Internal_Sym
*isym
;
5925 asection
**ppsection
;
5928 output_bfd
= finfo
->output_bfd
;
5930 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5932 /* If this is a dynamic object, we don't want to do anything here:
5933 we don't want the local symbols, and we don't want the section
5935 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5938 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5939 if (elf_bad_symtab (input_bfd
))
5941 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5946 locsymcount
= symtab_hdr
->sh_info
;
5947 extsymoff
= symtab_hdr
->sh_info
;
5950 /* Read the local symbols. */
5952 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5953 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5954 locsymcount
, input_bfd
)
5955 != locsymcount
* sizeof (Elf_External_Sym
))))
5958 /* Swap in the local symbols and write out the ones which we know
5959 are going into the output file. */
5960 esym
= finfo
->external_syms
;
5961 esymend
= esym
+ locsymcount
;
5962 isym
= finfo
->internal_syms
;
5963 pindex
= finfo
->indices
;
5964 ppsection
= finfo
->sections
;
5965 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5971 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5974 if (elf_bad_symtab (input_bfd
))
5976 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5983 if (isym
->st_shndx
== SHN_UNDEF
)
5984 isec
= bfd_und_section_ptr
;
5985 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5986 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5987 else if (isym
->st_shndx
== SHN_ABS
)
5988 isec
= bfd_abs_section_ptr
;
5989 else if (isym
->st_shndx
== SHN_COMMON
)
5990 isec
= bfd_com_section_ptr
;
5999 /* Don't output the first, undefined, symbol. */
6000 if (esym
== finfo
->external_syms
)
6003 /* If we are stripping all symbols, we don't want to output this
6005 if (finfo
->info
->strip
== strip_all
)
6008 /* We never output section symbols. Instead, we use the section
6009 symbol of the corresponding section in the output file. */
6010 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6013 /* If we are discarding all local symbols, we don't want to
6014 output this one. If we are generating a relocateable output
6015 file, then some of the local symbols may be required by
6016 relocs; we output them below as we discover that they are
6018 if (finfo
->info
->discard
== discard_all
)
6021 /* Get the name of the symbol. */
6022 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6027 /* See if we are discarding symbols with this name. */
6028 if ((finfo
->info
->strip
== strip_some
6029 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6031 || (finfo
->info
->discard
== discard_l
6032 && strncmp (name
, finfo
->info
->lprefix
,
6033 finfo
->info
->lprefix_len
) == 0))
6036 /* If we get here, we are going to output this symbol. */
6038 /* Adjust the section index for the output file. */
6039 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
6040 isec
->output_section
);
6041 if (isym
->st_shndx
== (unsigned short) -1)
6044 *pindex
= output_bfd
->symcount
;
6046 /* ELF symbols in relocateable files are section relative, but
6047 in executable files they are virtual addresses. Note that
6048 this code assumes that all ELF sections have an associated
6049 BFD section with a reasonable value for output_offset; below
6050 we assume that they also have a reasonable value for
6051 output_section. Any special sections must be set up to meet
6052 these requirements. */
6053 oldval
= isym
->st_value
;
6054 isym
->st_value
+= isec
->output_offset
;
6055 if (! finfo
->info
->relocateable
)
6056 isym
->st_value
+= isec
->output_section
->vma
;
6058 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
6061 /* Restore the old value for reloc handling. */
6062 isym
->st_value
= oldval
;
6065 /* Relocate the contents of each section. */
6066 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6068 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6071 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6072 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6074 /* Section was created by elf_link_create_dynamic_sections.
6075 FIXME: This test is fragile. */
6079 /* Read the contents of the section. */
6080 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6081 (file_ptr
) 0, o
->_raw_size
))
6084 if ((o
->flags
& SEC_RELOC
) != 0)
6086 Elf_Internal_Rela
*internal_relocs
;
6088 /* Get the swapped relocs. */
6089 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
6090 finfo
->external_relocs
,
6091 finfo
->internal_relocs
,
6093 if (internal_relocs
== NULL
6094 && o
->reloc_count
> 0)
6097 /* Relocate the section by invoking a back end routine.
6099 The back end routine is responsible for adjusting the
6100 section contents as necessary, and (if using Rela relocs
6101 and generating a relocateable output file) adjusting the
6102 reloc addend as necessary.
6104 The back end routine does not have to worry about setting
6105 the reloc address or the reloc symbol index.
6107 The back end routine is given a pointer to the swapped in
6108 internal symbols, and can access the hash table entries
6109 for the external symbols via elf_sym_hashes (input_bfd).
6111 When generating relocateable output, the back end routine
6112 must handle STB_LOCAL/STT_SECTION symbols specially. The
6113 output symbol is going to be a section symbol
6114 corresponding to the output section, which will require
6115 the addend to be adjusted. */
6117 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6121 finfo
->internal_syms
,
6123 finfo
->symstrtab
->tab
))
6126 if (finfo
->info
->relocateable
)
6128 Elf_Internal_Rela
*irela
;
6129 Elf_Internal_Rela
*irelaend
;
6130 struct elf_link_hash_entry
**rel_hash
;
6131 Elf_Internal_Shdr
*input_rel_hdr
;
6132 Elf_Internal_Shdr
*output_rel_hdr
;
6134 /* Adjust the reloc addresses and symbol indices. */
6136 irela
= internal_relocs
;
6137 irelaend
= irela
+ o
->reloc_count
;
6138 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6139 + o
->output_section
->reloc_count
);
6140 for (; irela
< irelaend
; irela
++, rel_hash
++)
6143 Elf_Internal_Sym
*isym
;
6146 irela
->r_offset
+= o
->output_offset
;
6148 r_symndx
= ELF_R_SYM (irela
->r_info
);
6153 if (r_symndx
>= locsymcount
6154 || (elf_bad_symtab (input_bfd
)
6155 && finfo
->sections
[r_symndx
] == NULL
))
6159 /* This is a reloc against a global symbol. We
6160 have not yet output all the local symbols, so
6161 we do not know the symbol index of any global
6162 symbol. We set the rel_hash entry for this
6163 reloc to point to the global hash table entry
6164 for this symbol. The symbol index is then
6165 set at the end of elf_bfd_final_link. */
6166 indx
= r_symndx
- extsymoff
;
6167 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6169 /* Setting the index to -2 tells
6170 elf_link_output_extsym that this symbol is
6172 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6173 (*rel_hash
)->indx
= -2;
6178 /* This is a reloc against a local symbol. */
6181 isym
= finfo
->internal_syms
+ r_symndx
;
6182 sec
= finfo
->sections
[r_symndx
];
6183 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6185 /* I suppose the backend ought to fill in the
6186 section of any STT_SECTION symbol against a
6187 processor specific section. */
6188 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6190 else if (sec
== NULL
|| sec
->owner
== NULL
)
6192 bfd_set_error (bfd_error_bad_value
);
6197 r_symndx
= sec
->output_section
->target_index
;
6204 if (finfo
->indices
[r_symndx
] == -1)
6210 if (finfo
->info
->strip
== strip_all
)
6212 /* You can't do ld -r -s. */
6213 bfd_set_error (bfd_error_invalid_operation
);
6217 /* This symbol was skipped earlier, but
6218 since it is needed by a reloc, we
6219 must output it now. */
6220 link
= symtab_hdr
->sh_link
;
6221 name
= elf_string_from_elf_section (input_bfd
,
6227 osec
= sec
->output_section
;
6229 elf_section_from_bfd_section (output_bfd
,
6231 if (isym
->st_shndx
== (unsigned short) -1)
6234 isym
->st_value
+= sec
->output_offset
;
6235 if (! finfo
->info
->relocateable
)
6236 isym
->st_value
+= osec
->vma
;
6238 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6240 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6244 r_symndx
= finfo
->indices
[r_symndx
];
6247 irela
->r_info
= ELF_R_INFO (r_symndx
,
6248 ELF_R_TYPE (irela
->r_info
));
6251 /* Swap out the relocs. */
6252 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6253 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6254 BFD_ASSERT (output_rel_hdr
->sh_entsize
6255 == input_rel_hdr
->sh_entsize
);
6256 irela
= internal_relocs
;
6257 irelaend
= irela
+ o
->reloc_count
;
6258 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6260 Elf_External_Rel
*erel
;
6262 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6263 + o
->output_section
->reloc_count
);
6264 for (; irela
< irelaend
; irela
++, erel
++)
6266 Elf_Internal_Rel irel
;
6268 irel
.r_offset
= irela
->r_offset
;
6269 irel
.r_info
= irela
->r_info
;
6270 BFD_ASSERT (irela
->r_addend
== 0);
6271 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6276 Elf_External_Rela
*erela
;
6278 BFD_ASSERT (input_rel_hdr
->sh_entsize
6279 == sizeof (Elf_External_Rela
));
6280 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6281 + o
->output_section
->reloc_count
);
6282 for (; irela
< irelaend
; irela
++, erela
++)
6283 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6286 o
->output_section
->reloc_count
+= o
->reloc_count
;
6290 /* Write out the modified section contents. */
6291 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6292 finfo
->contents
, o
->output_offset
,
6293 (o
->_cooked_size
!= 0
6302 /* Generate a reloc when linking an ELF file. This is a reloc
6303 requested by the linker, and does come from any input file. This
6304 is used to build constructor and destructor tables when linking
6308 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6310 struct bfd_link_info
*info
;
6311 asection
*output_section
;
6312 struct bfd_link_order
*link_order
;
6314 const reloc_howto_type
*howto
;
6317 struct elf_link_hash_entry
**rel_hash_ptr
;
6318 Elf_Internal_Shdr
*rel_hdr
;
6320 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6323 bfd_set_error (bfd_error_bad_value
);
6327 /* If this is an inplace reloc, we must write the addend into the
6329 if (howto
->partial_inplace
6330 && link_order
->u
.reloc
.p
->addend
!= 0)
6333 bfd_reloc_status_type rstat
;
6337 size
= bfd_get_reloc_size (howto
);
6338 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6339 if (buf
== (bfd_byte
*) NULL
)
6341 bfd_set_error (bfd_error_no_memory
);
6344 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6345 link_order
->u
.reloc
.p
->addend
, buf
);
6351 case bfd_reloc_outofrange
:
6353 case bfd_reloc_overflow
:
6354 if (! ((*info
->callbacks
->reloc_overflow
)
6356 (link_order
->type
== bfd_section_reloc_link_order
6357 ? bfd_section_name (output_bfd
,
6358 link_order
->u
.reloc
.p
->u
.section
)
6359 : link_order
->u
.reloc
.p
->u
.name
),
6360 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6361 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6368 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6369 (file_ptr
) link_order
->offset
, size
);
6375 /* Figure out the symbol index. */
6376 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6377 + output_section
->reloc_count
);
6378 if (link_order
->type
== bfd_section_reloc_link_order
)
6380 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6383 *rel_hash_ptr
= NULL
;
6387 struct elf_link_hash_entry
*h
;
6389 h
= elf_link_hash_lookup (elf_hash_table (info
),
6390 link_order
->u
.reloc
.p
->u
.name
,
6391 false, false, true);
6394 /* Setting the index to -2 tells elf_link_output_extsym that
6395 this symbol is used by a reloc. */
6402 if (! ((*info
->callbacks
->unattached_reloc
)
6403 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6404 (asection
*) NULL
, (bfd_vma
) 0)))
6410 /* The address of a reloc is relative to the section in a
6411 relocateable file, and is a virtual address in an executable
6413 offset
= link_order
->offset
;
6414 if (! info
->relocateable
)
6415 offset
+= output_section
->vma
;
6417 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6419 if (rel_hdr
->sh_type
== SHT_REL
)
6421 Elf_Internal_Rel irel
;
6422 Elf_External_Rel
*erel
;
6424 irel
.r_offset
= offset
;
6425 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6426 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6427 + output_section
->reloc_count
);
6428 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6432 Elf_Internal_Rela irela
;
6433 Elf_External_Rela
*erela
;
6435 irela
.r_offset
= offset
;
6436 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6437 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6438 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6439 + output_section
->reloc_count
);
6440 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6443 ++output_section
->reloc_count
;