1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
98 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
99 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
100 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
101 #define elf_get_symtab NAME(bfd_elf,get_symtab)
102 #define elf_canonicalize_dynamic_symtab \
103 NAME(bfd_elf,canonicalize_dynamic_symtab)
104 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
105 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
106 #define elf_print_symbol NAME(bfd_elf,print_symbol)
107 #define elf_get_lineno NAME(bfd_elf,get_lineno)
108 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
109 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
110 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
111 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
112 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
113 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
114 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
115 #define write_relocs NAME(bfd_elf,_write_relocs)
116 #define elf_find_section NAME(bfd_elf,find_section)
117 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
118 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
119 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
122 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
123 #define ELF_R_SYM(X) ELF64_R_SYM(X)
124 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
125 #define ELFCLASS ELFCLASS64
127 #define LOG_FILE_ALIGN 3
130 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
131 #define ELF_R_SYM(X) ELF32_R_SYM(X)
132 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
133 #define ELFCLASS ELFCLASS32
135 #define LOG_FILE_ALIGN 2
138 /* Forward declarations of static functions */
140 static unsigned long bfd_add_to_strtab
141 PARAMS ((bfd
*, struct strtab
*, const char *));
142 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
144 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
146 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
148 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
150 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
151 struct symbol_cache_entry
**));
153 static boolean elf_compute_section_file_positions
154 PARAMS ((bfd
*, struct bfd_link_info
*));
155 static boolean prep_headers
PARAMS ((bfd
*));
156 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
157 static boolean assign_section_numbers
PARAMS ((bfd
*));
158 static file_ptr align_file_position
PARAMS ((file_ptr
));
159 static file_ptr assign_file_position_for_section
160 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
161 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
162 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
163 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
164 static file_ptr map_program_segments
165 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
167 static boolean elf_map_symbols
PARAMS ((bfd
*));
168 static boolean swap_out_syms
PARAMS ((bfd
*));
170 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
173 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
174 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
177 #define elf_string_from_elf_strtab(abfd,strindex) \
178 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
181 /* Structure swapping routines */
183 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
184 can be handled by explicitly specifying 32 bits or "the long type". */
186 #define put_word bfd_h_put_64
187 #define get_word bfd_h_get_64
190 #define put_word bfd_h_put_32
191 #define get_word bfd_h_get_32
194 /* Translate an ELF symbol in external format into an ELF symbol in internal
198 elf_swap_symbol_in (abfd
, src
, dst
)
200 Elf_External_Sym
*src
;
201 Elf_Internal_Sym
*dst
;
203 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
204 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
205 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
206 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
207 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
208 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
211 /* Translate an ELF symbol in internal format into an ELF symbol in external
215 elf_swap_symbol_out (abfd
, src
, dst
)
217 Elf_Internal_Sym
*src
;
218 Elf_External_Sym
*dst
;
220 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
221 put_word (abfd
, src
->st_value
, dst
->st_value
);
222 put_word (abfd
, src
->st_size
, dst
->st_size
);
223 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
224 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
225 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
229 /* Translate an ELF file header in external format into an ELF file header in
233 elf_swap_ehdr_in (abfd
, src
, dst
)
235 Elf_External_Ehdr
*src
;
236 Elf_Internal_Ehdr
*dst
;
238 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
239 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
240 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
241 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
242 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
243 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
244 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
245 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
246 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
247 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
248 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
249 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
250 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
251 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
254 /* Translate an ELF file header in internal format into an ELF file header in
258 elf_swap_ehdr_out (abfd
, src
, dst
)
260 Elf_Internal_Ehdr
*src
;
261 Elf_External_Ehdr
*dst
;
263 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
264 /* note that all elements of dst are *arrays of unsigned char* already... */
265 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
266 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
267 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
268 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
269 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
270 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
271 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
272 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
273 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
274 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
275 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
276 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
277 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
281 /* Translate an ELF section header table entry in external format into an
282 ELF section header table entry in internal format. */
285 elf_swap_shdr_in (abfd
, src
, dst
)
287 Elf_External_Shdr
*src
;
288 Elf_Internal_Shdr
*dst
;
290 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
291 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
292 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
293 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
294 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
295 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
296 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
297 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
298 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
299 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
300 /* we haven't done any processing on it yet, so... */
301 dst
->rawdata
= (void *) 0;
304 /* Translate an ELF section header table entry in internal format into an
305 ELF section header table entry in external format. */
308 elf_swap_shdr_out (abfd
, src
, dst
)
310 Elf_Internal_Shdr
*src
;
311 Elf_External_Shdr
*dst
;
313 /* note that all elements of dst are *arrays of unsigned char* already... */
314 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
315 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
316 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
317 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
318 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
319 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
320 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
321 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
322 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
323 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
327 /* Translate an ELF program header table entry in external format into an
328 ELF program header table entry in internal format. */
331 elf_swap_phdr_in (abfd
, src
, dst
)
333 Elf_External_Phdr
*src
;
334 Elf_Internal_Phdr
*dst
;
336 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
337 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
338 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
339 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
340 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
341 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
342 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
343 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
347 elf_swap_phdr_out (abfd
, src
, dst
)
349 Elf_Internal_Phdr
*src
;
350 Elf_External_Phdr
*dst
;
352 /* note that all elements of dst are *arrays of unsigned char* already... */
353 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
354 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
355 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
356 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
357 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
358 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
359 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
360 put_word (abfd
, src
->p_align
, dst
->p_align
);
363 /* Translate an ELF reloc from external format to internal format. */
365 elf_swap_reloc_in (abfd
, src
, dst
)
367 Elf_External_Rel
*src
;
368 Elf_Internal_Rel
*dst
;
370 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
371 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
375 elf_swap_reloca_in (abfd
, src
, dst
)
377 Elf_External_Rela
*src
;
378 Elf_Internal_Rela
*dst
;
380 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
381 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
382 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
385 /* Translate an ELF reloc from internal format to external format. */
387 elf_swap_reloc_out (abfd
, src
, dst
)
389 Elf_Internal_Rel
*src
;
390 Elf_External_Rel
*dst
;
392 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
393 put_word (abfd
, src
->r_info
, dst
->r_info
);
397 elf_swap_reloca_out (abfd
, src
, dst
)
399 Elf_Internal_Rela
*src
;
400 Elf_External_Rela
*dst
;
402 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
403 put_word (abfd
, src
->r_info
, dst
->r_info
);
404 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
408 elf_swap_dyn_in (abfd
, src
, dst
)
410 const Elf_External_Dyn
*src
;
411 Elf_Internal_Dyn
*dst
;
413 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
414 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
418 elf_swap_dyn_out (abfd
, src
, dst
)
420 const Elf_Internal_Dyn
*src
;
421 Elf_External_Dyn
*dst
;
423 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
424 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
427 /* String table creation/manipulation routines */
429 static struct strtab
*
430 bfd_new_strtab (abfd
)
435 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
438 bfd_set_error (bfd_error_no_memory
);
441 ss
->tab
= malloc (1);
444 bfd_set_error (bfd_error_no_memory
);
455 bfd_add_to_strtab (abfd
, ss
, str
)
460 /* should search first, but for now: */
461 /* include the trailing NUL */
462 int ln
= strlen (str
) + 1;
464 /* FIXME: This is slow. Also, we could combine this with the a.out
465 string table building and use a hash table, although it might not
466 be worth it since ELF symbols don't include debugging information
467 and thus have much less overlap. */
468 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
471 bfd_set_error (bfd_error_no_memory
);
472 return (unsigned long) -1;
475 strcpy (ss
->tab
+ ss
->length
, str
);
479 return ss
->length
- ln
;
483 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
489 /* should search first, but for now: */
490 /* include the trailing NUL */
491 int ln
= strlen (str
) + strlen (str2
) + 1;
493 /* should this be using obstacks? */
495 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
497 ss
->tab
= malloc (ln
);
499 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
500 strcpy (ss
->tab
+ ss
->length
, str
);
501 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
505 return ss
->length
- ln
;
508 /* ELF .o/exec file reading */
510 /* Create a new bfd section from an ELF section header. */
513 bfd_section_from_shdr (abfd
, shindex
)
515 unsigned int shindex
;
517 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
518 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
521 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
523 switch (hdr
->sh_type
)
526 /* Inactive section. Throw it away. */
529 case SHT_PROGBITS
: /* Normal section with contents. */
530 case SHT_DYNAMIC
: /* Dynamic linking information. */
531 case SHT_NOBITS
: /* .bss section. */
532 case SHT_HASH
: /* .hash section. */
533 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
535 case SHT_SYMTAB
: /* A symbol table */
536 if (elf_onesymtab (abfd
) == shindex
)
539 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
540 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
541 elf_onesymtab (abfd
) = shindex
;
542 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
543 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
544 abfd
->flags
|= HAS_SYMS
;
547 case SHT_DYNSYM
: /* A dynamic symbol table */
548 if (elf_dynsymtab (abfd
) == shindex
)
551 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
552 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
553 elf_dynsymtab (abfd
) = shindex
;
554 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
555 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
556 abfd
->flags
|= HAS_SYMS
;
558 /* Besides being a symbol table, we also treat this as a regular
559 section, so that objcopy can handle it. */
560 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
562 case SHT_STRTAB
: /* A string table */
563 if (hdr
->rawdata
!= NULL
)
565 if (ehdr
->e_shstrndx
== shindex
)
567 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
568 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
569 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
575 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
577 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
578 if (hdr2
->sh_link
== shindex
)
580 if (! bfd_section_from_shdr (abfd
, i
))
582 if (elf_onesymtab (abfd
) == i
)
584 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
585 elf_elfsections (abfd
)[shindex
] =
586 &elf_tdata (abfd
)->strtab_hdr
;
589 if (elf_dynsymtab (abfd
) == i
)
591 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
592 elf_elfsections (abfd
)[shindex
] =
593 &elf_tdata (abfd
)->dynstrtab_hdr
;
594 /* We also treat this as a regular section, so
595 that objcopy can handle it. */
598 #if 0 /* Not handling other string tables specially right now. */
599 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
600 /* We have a strtab for some random other section. */
601 newsect
= (asection
*) hdr2
->rawdata
;
604 hdr
->rawdata
= (PTR
) newsect
;
605 hdr2
= &elf_section_data (newsect
)->str_hdr
;
607 elf_elfsections (abfd
)[shindex
] = hdr2
;
613 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
617 /* *These* do a lot of work -- but build no sections! */
619 asection
*target_sect
;
620 Elf_Internal_Shdr
*hdr2
;
621 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
623 /* Get the symbol table. */
624 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
627 /* If this reloc section does not use the main symbol table we
628 don't treat it as a reloc section. BFD can't adequately
629 represent such a section, so at least for now, we don't
630 try. We just present it as a normal section. */
631 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
632 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
634 /* Don't allow REL relocations on a machine that uses RELA and
636 /* @@ Actually, the generic ABI does suggest that both might be
637 used in one file. But the four ABI Processor Supplements I
638 have access to right now all specify that only one is used on
639 each of those architectures. It's conceivable that, e.g., a
640 bunch of absolute 32-bit relocs might be more compact in REL
641 form even on a RELA machine... */
642 BFD_ASSERT (use_rela_p
643 ? (hdr
->sh_type
== SHT_RELA
644 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
645 : (hdr
->sh_type
== SHT_REL
646 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
648 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
650 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
651 if (target_sect
== NULL
652 || elf_section_data (target_sect
) == NULL
)
655 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
657 elf_elfsections (abfd
)[shindex
] = hdr2
;
658 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
659 target_sect
->flags
|= SEC_RELOC
;
660 target_sect
->relocation
= NULL
;
661 target_sect
->rel_filepos
= hdr
->sh_offset
;
662 abfd
->flags
|= HAS_RELOC
;
669 fprintf (stderr
, "Note Sections not yet supported.\n");
676 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
681 /* Check for any processor-specific section types. */
683 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
685 if (bed
->elf_backend_section_from_shdr
)
686 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
695 elf_new_section_hook (abfd
, sec
)
700 struct bfd_elf_section_data
*sdata
;
702 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
705 bfd_set_error (bfd_error_no_memory
);
708 sec
->used_by_bfd
= (PTR
) sdata
;
709 memset (sdata
, 0, sizeof (*sdata
));
713 /* Create a new bfd section from an ELF program header.
715 Since program segments have no names, we generate a synthetic name
716 of the form segment<NUM>, where NUM is generally the index in the
717 program header table. For segments that are split (see below) we
718 generate the names segment<NUM>a and segment<NUM>b.
720 Note that some program segments may have a file size that is different than
721 (less than) the memory size. All this means is that at execution the
722 system must allocate the amount of memory specified by the memory size,
723 but only initialize it with the first "file size" bytes read from the
724 file. This would occur for example, with program segments consisting
725 of combined data+bss.
727 To handle the above situation, this routine generates TWO bfd sections
728 for the single program segment. The first has the length specified by
729 the file size of the segment, and the second has the length specified
730 by the difference between the two sizes. In effect, the segment is split
731 into it's initialized and uninitialized parts.
736 bfd_section_from_phdr (abfd
, hdr
, index
)
738 Elf_Internal_Phdr
*hdr
;
746 split
= ((hdr
->p_memsz
> 0) &&
747 (hdr
->p_filesz
> 0) &&
748 (hdr
->p_memsz
> hdr
->p_filesz
));
749 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
750 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
753 bfd_set_error (bfd_error_no_memory
);
756 strcpy (name
, namebuf
);
757 newsect
= bfd_make_section (abfd
, name
);
760 newsect
->vma
= hdr
->p_vaddr
;
761 newsect
->_raw_size
= hdr
->p_filesz
;
762 newsect
->filepos
= hdr
->p_offset
;
763 newsect
->flags
|= SEC_HAS_CONTENTS
;
764 if (hdr
->p_type
== PT_LOAD
)
766 newsect
->flags
|= SEC_ALLOC
;
767 newsect
->flags
|= SEC_LOAD
;
768 if (hdr
->p_flags
& PF_X
)
770 /* FIXME: all we known is that it has execute PERMISSION,
772 newsect
->flags
|= SEC_CODE
;
775 if (!(hdr
->p_flags
& PF_W
))
777 newsect
->flags
|= SEC_READONLY
;
782 sprintf (namebuf
, "segment%db", index
);
783 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
786 bfd_set_error (bfd_error_no_memory
);
789 strcpy (name
, namebuf
);
790 newsect
= bfd_make_section (abfd
, name
);
793 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
794 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
795 if (hdr
->p_type
== PT_LOAD
)
797 newsect
->flags
|= SEC_ALLOC
;
798 if (hdr
->p_flags
& PF_X
)
799 newsect
->flags
|= SEC_CODE
;
801 if (!(hdr
->p_flags
& PF_W
))
802 newsect
->flags
|= SEC_READONLY
;
808 /* Begin processing a given object.
810 First we validate the file by reading in the ELF header and checking
813 static INLINE boolean
815 Elf_External_Ehdr
*x_ehdrp
;
817 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
818 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
819 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
820 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
823 /* Check to see if the file associated with ABFD matches the target vector
826 Note that we may be called several times with the same ABFD, but different
827 target vectors, most of which will not match. We have to avoid leaving
828 any side effects in ABFD, or any data it points to (like tdata), if the
829 file does not match the target vector. */
835 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
836 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
837 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
838 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
839 unsigned int shindex
;
840 char *shstrtab
; /* Internal copy of section header stringtab */
841 struct elf_backend_data
*ebd
;
842 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
843 struct elf_obj_tdata
*new_tdata
= NULL
;
845 /* Read in the ELF header in external format. */
847 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
849 if (bfd_get_error () != bfd_error_system_call
)
850 goto got_wrong_format_error
;
855 /* Now check to see if we have a valid ELF file, and one that BFD can
856 make use of. The magic number must match, the address size ('class')
857 and byte-swapping must match our XVEC entry, and it must have a
858 section header table (FIXME: See comments re sections at top of this
861 if ((elf_file_p (&x_ehdr
) == false) ||
862 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
863 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
864 goto got_wrong_format_error
;
866 /* Check that file's byte order matches xvec's */
867 switch (x_ehdr
.e_ident
[EI_DATA
])
869 case ELFDATA2MSB
: /* Big-endian */
870 if (!abfd
->xvec
->header_byteorder_big_p
)
871 goto got_wrong_format_error
;
873 case ELFDATA2LSB
: /* Little-endian */
874 if (abfd
->xvec
->header_byteorder_big_p
)
875 goto got_wrong_format_error
;
877 case ELFDATANONE
: /* No data encoding specified */
878 default: /* Unknown data encoding specified */
879 goto got_wrong_format_error
;
882 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
883 the tdata pointer in the bfd. */
885 new_tdata
= ((struct elf_obj_tdata
*)
886 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
887 if (new_tdata
== NULL
)
888 goto got_no_memory_error
;
889 elf_tdata (abfd
) = new_tdata
;
891 /* Now that we know the byte order, swap in the rest of the header */
892 i_ehdrp
= elf_elfheader (abfd
);
893 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
895 elf_debug_file (i_ehdrp
);
898 /* If there is no section header table, we're hosed. */
899 if (i_ehdrp
->e_shoff
== 0)
900 goto got_wrong_format_error
;
902 /* As a simple sanity check, verify that the what BFD thinks is the
903 size of each section header table entry actually matches the size
904 recorded in the file. */
905 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
906 goto got_wrong_format_error
;
908 ebd
= get_elf_backend_data (abfd
);
910 /* Check that the ELF e_machine field matches what this particular
911 BFD format expects. */
912 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
914 const bfd_target
* const *target_ptr
;
916 if (ebd
->elf_machine_code
!= EM_NONE
)
917 goto got_wrong_format_error
;
919 /* This is the generic ELF target. Let it match any ELF target
920 for which we do not have a specific backend. */
921 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
923 struct elf_backend_data
*back
;
925 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
927 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
928 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
930 /* target_ptr is an ELF backend which matches this
931 object file, so reject the generic ELF target. */
932 goto got_wrong_format_error
;
937 if (i_ehdrp
->e_type
== ET_EXEC
)
938 abfd
->flags
|= EXEC_P
;
939 else if (i_ehdrp
->e_type
== ET_DYN
)
940 abfd
->flags
|= DYNAMIC
;
942 if (i_ehdrp
->e_phnum
> 0)
943 abfd
->flags
|= D_PAGED
;
945 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
948 /* Remember the entry point specified in the ELF file header. */
949 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
951 /* Allocate space for a copy of the section header table in
952 internal form, seek to the section header table in the file,
953 read it in, and convert it to internal form. */
954 i_shdrp
= ((Elf_Internal_Shdr
*)
955 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
956 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
958 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
959 if (!i_shdrp
|| !elf_elfsections (abfd
))
960 goto got_no_memory_error
;
961 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
963 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
965 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
967 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
968 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
970 if (i_ehdrp
->e_shstrndx
)
972 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
976 /* Read in the string table containing the names of the sections. We
977 will need the base pointer to this table later. */
978 /* We read this inline now, so that we don't have to go through
979 bfd_section_from_shdr with it (since this particular strtab is
980 used to find all of the ELF section names.) */
982 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
986 /* Once all of the section headers have been read and converted, we
987 can start processing them. Note that the first section header is
988 a dummy placeholder entry, so we ignore it. */
990 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
992 if (! bfd_section_from_shdr (abfd
, shindex
))
996 /* Let the backend double check the format and override global
998 if (ebd
->elf_backend_object_p
)
1000 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
1001 goto got_wrong_format_error
;
1004 return (abfd
->xvec
);
1006 got_wrong_format_error
:
1007 bfd_set_error (bfd_error_wrong_format
);
1009 got_no_memory_error
:
1010 bfd_set_error (bfd_error_no_memory
);
1013 if (new_tdata
!= NULL
1014 && new_tdata
->elf_sect_ptr
!= NULL
)
1015 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1016 if (i_shdrp
!= NULL
)
1017 bfd_release (abfd
, i_shdrp
);
1018 if (new_tdata
!= NULL
)
1019 bfd_release (abfd
, new_tdata
);
1020 elf_tdata (abfd
) = preserved_tdata
;
1025 /* ELF .o/exec file writing */
1027 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1028 of the symbol if there is one. */
1029 static INLINE elf_symbol_type
*
1030 elf_symbol_from (ignore_abfd
, symbol
)
1034 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1037 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1040 return (elf_symbol_type
*) symbol
;
1044 write_relocs (abfd
, sec
, xxx
)
1049 Elf_Internal_Shdr
*rela_hdr
;
1050 Elf_External_Rela
*outbound_relocas
;
1051 Elf_External_Rel
*outbound_relocs
;
1053 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1054 asymbol
*last_sym
= 0;
1055 int last_sym_idx
= 9999999; /* should always be written before use */
1057 if ((sec
->flags
& SEC_RELOC
) == 0)
1060 /* The linker backend writes the relocs out itself, and sets the
1061 reloc_count field to zero to inhibit writing them here. Also,
1062 sometimes the SEC_RELOC flag gets set even when there aren't any
1064 if (sec
->reloc_count
== 0)
1067 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1069 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1070 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1071 if (!rela_hdr
->contents
)
1073 bfd_set_error (bfd_error_no_memory
);
1074 abort (); /* FIXME */
1077 /* orelocation has the data, reloc_count has the count... */
1080 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1082 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1084 Elf_Internal_Rela dst_rela
;
1085 Elf_External_Rela
*src_rela
;
1090 ptr
= sec
->orelocation
[idx
];
1091 src_rela
= outbound_relocas
+ idx
;
1092 if (!(abfd
->flags
& EXEC_P
))
1093 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1095 dst_rela
.r_offset
= ptr
->address
;
1097 sym
= *ptr
->sym_ptr_ptr
;
1098 if (sym
== last_sym
)
1103 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1105 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1107 dst_rela
.r_addend
= ptr
->addend
;
1108 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1112 /* REL relocations */
1114 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1116 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1118 Elf_Internal_Rel dst_rel
;
1119 Elf_External_Rel
*src_rel
;
1124 ptr
= sec
->orelocation
[idx
];
1125 sym
= *ptr
->sym_ptr_ptr
;
1126 src_rel
= outbound_relocs
+ idx
;
1127 if (!(abfd
->flags
& EXEC_P
))
1128 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1130 dst_rel
.r_offset
= ptr
->address
;
1132 if (sym
== last_sym
)
1137 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1139 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1141 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1146 /* Set up an ELF internal section header for a section. */
1150 elf_fake_sections (abfd
, asect
, ignore
)
1155 Elf_Internal_Shdr
*this_hdr
;
1157 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1159 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1161 if (this_hdr
->sh_name
== (unsigned long) -1)
1162 abort (); /* FIXME */
1164 this_hdr
->sh_flags
= 0;
1165 if ((asect
->flags
& SEC_ALLOC
) != 0)
1166 this_hdr
->sh_addr
= asect
->vma
;
1168 this_hdr
->sh_addr
= 0;
1169 this_hdr
->sh_offset
= 0;
1170 this_hdr
->sh_size
= asect
->_raw_size
;
1171 this_hdr
->sh_link
= 0;
1172 this_hdr
->sh_info
= 0;
1173 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1174 this_hdr
->sh_entsize
= 0;
1176 this_hdr
->rawdata
= (PTR
) asect
;
1177 this_hdr
->contents
= NULL
;
1180 /* FIXME: This should not be based on section names. */
1181 if (strcmp (asect
->name
, ".dynstr") == 0)
1182 this_hdr
->sh_type
= SHT_STRTAB
;
1183 else if (strcmp (asect
->name
, ".hash") == 0)
1185 this_hdr
->sh_type
= SHT_HASH
;
1186 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1188 else if (strcmp (asect
->name
, ".dynsym") == 0)
1190 this_hdr
->sh_type
= SHT_DYNSYM
;
1191 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1193 else if (strcmp (asect
->name
, ".dynamic") == 0)
1195 this_hdr
->sh_type
= SHT_DYNAMIC
;
1196 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1198 else if (strncmp (asect
->name
, ".rel.", 5) == 0)
1200 this_hdr
->sh_type
= SHT_REL
;
1201 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1203 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1205 this_hdr
->sh_type
= SHT_RELA
;
1206 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1208 else if (strcmp (asect
->name
, ".note") == 0)
1209 this_hdr
->sh_type
= SHT_NOTE
;
1210 else if (strncmp (asect
->name
, ".stab", 5) == 0
1211 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1212 this_hdr
->sh_type
= SHT_STRTAB
;
1213 else if ((asect
->flags
& SEC_ALLOC
) != 0
1214 && (asect
->flags
& SEC_LOAD
) != 0)
1215 this_hdr
->sh_type
= SHT_PROGBITS
;
1216 else if ((asect
->flags
& SEC_ALLOC
) != 0
1217 && ((asect
->flags
& SEC_LOAD
) == 0))
1219 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1220 || strcmp (asect
->name
, ".sbss") == 0);
1221 this_hdr
->sh_type
= SHT_NOBITS
;
1226 this_hdr
->sh_type
= SHT_PROGBITS
;
1229 if ((asect
->flags
& SEC_ALLOC
) != 0)
1230 this_hdr
->sh_flags
|= SHF_ALLOC
;
1231 if ((asect
->flags
& SEC_READONLY
) == 0)
1232 this_hdr
->sh_flags
|= SHF_WRITE
;
1233 if ((asect
->flags
& SEC_CODE
) != 0)
1234 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1236 /* Check for processor-specific section types. */
1238 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1240 if (bed
->elf_backend_fake_sections
)
1241 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1244 /* If the section has relocs, set up a section header for the
1245 SHT_REL[A] section. */
1246 if ((asect
->flags
& SEC_RELOC
) != 0)
1248 Elf_Internal_Shdr
*rela_hdr
;
1249 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1251 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1253 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1254 use_rela_p
? ".rela" : ".rel",
1256 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1257 rela_hdr
->sh_entsize
= (use_rela_p
1258 ? sizeof (Elf_External_Rela
)
1259 : sizeof (Elf_External_Rel
));
1260 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1261 rela_hdr
->sh_flags
= 0;
1262 rela_hdr
->sh_addr
= 0;
1263 rela_hdr
->sh_size
= 0;
1264 rela_hdr
->sh_offset
= 0;
1269 /* Assign all ELF section numbers. The dummy first section is handled here
1270 too. The link/info pointers for the standard section types are filled
1271 in here too, while we're at it. */
1274 assign_section_numbers (abfd
)
1277 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1279 unsigned int section_number
;
1280 Elf_Internal_Shdr
**i_shdrp
;
1284 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1286 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1288 d
->this_idx
= section_number
++;
1289 if ((sec
->flags
& SEC_RELOC
) == 0)
1292 d
->rel_idx
= section_number
++;
1295 t
->shstrtab_section
= section_number
++;
1296 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1297 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1298 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1300 if (abfd
->symcount
> 0)
1302 t
->symtab_section
= section_number
++;
1303 t
->strtab_section
= section_number
++;
1306 elf_elfheader (abfd
)->e_shnum
= section_number
;
1308 /* Set up the list of section header pointers, in agreement with the
1310 i_shdrp
= ((Elf_Internal_Shdr
**)
1311 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1312 if (i_shdrp
== NULL
)
1314 bfd_set_error (bfd_error_no_memory
);
1318 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1319 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1320 if (i_shdrp
[0] == NULL
)
1322 bfd_release (abfd
, i_shdrp
);
1323 bfd_set_error (bfd_error_no_memory
);
1326 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1328 elf_elfsections (abfd
) = i_shdrp
;
1330 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1331 if (abfd
->symcount
> 0)
1333 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1334 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1335 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1337 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1339 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1343 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1344 if (d
->rel_idx
!= 0)
1345 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1347 /* Fill in the sh_link and sh_info fields while we're at it. */
1349 /* sh_link of a reloc section is the section index of the symbol
1350 table. sh_info is the section index of the section to which
1351 the relocation entries apply. */
1352 if (d
->rel_idx
!= 0)
1354 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1355 d
->rel_hdr
.sh_info
= d
->this_idx
;
1358 switch (d
->this_hdr
.sh_type
)
1362 /* A reloc section which we are treating as a normal BFD
1363 section. sh_link is the section index of the symbol
1364 table. sh_info is the section index of the section to
1365 which the relocation entries apply. We assume that an
1366 allocated reloc section uses the dynamic symbol table.
1367 FIXME: How can we be sure? */
1368 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1370 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1372 /* We look up the section the relocs apply to by name. */
1374 if (d
->this_hdr
.sh_type
== SHT_REL
)
1378 s
= bfd_get_section_by_name (abfd
, name
);
1380 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1384 /* We assume that a section named .stab*str is a stabs
1385 string section. We look for a section with the same name
1386 but without the trailing ``str'', and set its sh_link
1387 field to point to this section. */
1388 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1389 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1394 len
= strlen (sec
->name
);
1395 alc
= (char *) malloc (len
- 2);
1398 bfd_set_error (bfd_error_no_memory
);
1401 strncpy (alc
, sec
->name
, len
- 3);
1402 alc
[len
- 3] = '\0';
1403 s
= bfd_get_section_by_name (abfd
, alc
);
1407 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1409 /* This is a .stab section. */
1410 elf_section_data (s
)->this_hdr
.sh_entsize
=
1411 4 + 2 * (ARCH_SIZE
/ 8);
1418 /* sh_link is the section header index of the string table
1419 used for the dynamic entries or symbol table. */
1420 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1422 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1426 /* sh_link is the section header index of the symbol table
1427 this hash table is for. */
1428 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1430 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1438 /* Map symbol from it's internal number to the external number, moving
1439 all local symbols to be at the head of the list. */
1442 sym_is_global (abfd
, sym
)
1446 /* If the backend has a special mapping, use it. */
1447 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1448 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1451 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1453 if (sym
->flags
& BSF_LOCAL
)
1457 if (sym
->section
== 0)
1459 /* Is this valid? */
1464 if (bfd_is_und_section (sym
->section
))
1466 if (bfd_is_com_section (sym
->section
))
1468 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1474 elf_map_symbols (abfd
)
1477 int symcount
= bfd_get_symcount (abfd
);
1478 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1479 asymbol
**sect_syms
;
1481 int num_globals
= 0;
1482 int num_locals2
= 0;
1483 int num_globals2
= 0;
1485 int num_sections
= 0;
1486 Elf_Sym_Extra
*sym_extra
;
1491 fprintf (stderr
, "elf_map_symbols\n");
1495 /* Add local symbols for each section for which there are relocs.
1496 FIXME: How can we tell which sections have relocs at this point?
1497 Will reloc_count always be accurate? Actually, I think most ELF
1498 targets create section symbols for all sections anyhow. */
1499 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1501 if (max_index
< asect
->index
)
1502 max_index
= asect
->index
;
1506 elf_num_section_syms (abfd
) = max_index
;
1507 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1508 elf_section_syms (abfd
) = sect_syms
;
1512 bfd_set_error (bfd_error_no_memory
);
1516 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1518 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1521 bfd_set_error (bfd_error_no_memory
);
1524 sym
->the_bfd
= abfd
;
1525 sym
->name
= asect
->name
;
1526 sym
->value
= asect
->vma
;
1527 sym
->flags
= BSF_SECTION_SYM
;
1528 sym
->section
= asect
;
1529 sect_syms
[asect
->index
] = sym
;
1533 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1534 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1541 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1542 ((symcount
+ num_sections
+ 1)
1543 * sizeof (asymbol
*)));
1545 syms
= (asymbol
**) bfd_alloc (abfd
,
1546 (num_sections
+ 1) * sizeof (asymbol
*));
1549 bfd_set_error (bfd_error_no_memory
);
1553 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1555 if (sect_syms
[asect
->index
])
1556 syms
[symcount
++] = sect_syms
[asect
->index
];
1559 syms
[symcount
] = (asymbol
*) 0;
1560 bfd_set_symtab (abfd
, syms
, symcount
);
1563 elf_sym_extra (abfd
) = sym_extra
1564 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1567 bfd_set_error (bfd_error_no_memory
);
1571 /* Identify and classify all of the symbols. */
1572 for (idx
= 0; idx
< symcount
; idx
++)
1574 if (!sym_is_global (abfd
, syms
[idx
]))
1580 /* Now provide mapping information. Add +1 for skipping over the
1582 for (idx
= 0; idx
< symcount
; idx
++)
1584 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1585 if (!sym_is_global (abfd
, syms
[idx
]))
1586 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1588 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1591 elf_num_locals (abfd
) = num_locals
;
1592 elf_num_globals (abfd
) = num_globals
;
1596 /* Compute the file positions we are going to put the sections at, and
1597 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1598 is not NULL, this is being called by the ELF backend linker. */
1601 elf_compute_section_file_positions (abfd
, link_info
)
1603 struct bfd_link_info
*link_info
;
1605 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1606 Elf_Internal_Shdr
*shstrtab_hdr
;
1608 if (abfd
->output_has_begun
)
1611 /* Do any elf backend specific processing first. */
1612 if (bed
->elf_backend_begin_write_processing
)
1613 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1615 if (! prep_headers (abfd
))
1618 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1620 if (!assign_section_numbers (abfd
))
1623 /* The backend linker builds symbol table information itself. */
1624 if (link_info
== NULL
)
1626 if (! swap_out_syms (abfd
))
1630 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1631 /* sh_name was set in prep_headers. */
1632 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1633 shstrtab_hdr
->sh_flags
= 0;
1634 shstrtab_hdr
->sh_addr
= 0;
1635 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1636 shstrtab_hdr
->sh_entsize
= 0;
1637 shstrtab_hdr
->sh_link
= 0;
1638 shstrtab_hdr
->sh_info
= 0;
1639 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1640 shstrtab_hdr
->sh_addralign
= 1;
1641 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1643 if (!assign_file_positions_except_relocs (abfd
,
1644 link_info
== NULL
? true : false))
1647 abfd
->output_has_begun
= true;
1653 /* Align to the maximum file alignment that could be required for any
1654 ELF data structure. */
1656 static INLINE file_ptr
1657 align_file_position (off
)
1660 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1663 /* Assign a file position to a section, optionally aligning to the
1664 required section alignment. */
1666 static INLINE file_ptr
1667 assign_file_position_for_section (i_shdrp
, offset
, align
)
1668 Elf_Internal_Shdr
*i_shdrp
;
1676 al
= i_shdrp
->sh_addralign
;
1678 offset
= BFD_ALIGN (offset
, al
);
1680 i_shdrp
->sh_offset
= offset
;
1681 if (i_shdrp
->rawdata
!= NULL
)
1682 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1683 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1684 offset
+= i_shdrp
->sh_size
;
1688 /* Get the size of the program header. This is called by the linker
1689 before any of the section VMA's are set, so it can't calculate the
1690 correct value for a strange memory layout. */
1692 static bfd_size_type
1693 get_program_header_size (abfd
)
1699 /* Assume we will need exactly two PT_LOAD segments: one for text
1700 and one for data. */
1703 s
= bfd_get_section_by_name (abfd
, ".interp");
1704 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1706 /* If we have a loadable interpreter section, we need a
1707 PT_INTERP segment. In this case, assume we also need a
1708 PT_PHDR segment, although that may not be true for all
1713 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1715 /* We need a PT_DYNAMIC segment. */
1719 return segs
* sizeof (Elf_External_Phdr
);
1722 /* Create the program header. OFF is the file offset where the
1723 program header should be written. FIRST is the first loadable ELF
1724 section. PHDR_SIZE is the size of the program header as returned
1725 by get_program_header_size. */
1728 map_program_segments (abfd
, off
, first
, phdr_size
)
1731 Elf_Internal_Shdr
*first
;
1732 bfd_size_type phdr_size
;
1734 Elf_Internal_Phdr phdrs
[10];
1735 unsigned int phdr_count
;
1736 Elf_Internal_Phdr
*phdr
;
1737 int phdr_size_adjust
;
1739 Elf_Internal_Shdr
**hdrpp
;
1740 asection
*sinterp
, *sdyn
;
1741 unsigned int last_type
;
1742 Elf_Internal_Ehdr
*i_ehdrp
;
1744 BFD_ASSERT ((abfd
->flags
& EXEC_P
) != 0);
1745 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1746 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1751 phdr_size_adjust
= 0;
1753 /* If we have a loadable .interp section, we must create a PT_INTERP
1754 segment which must precede all PT_LOAD segments. We assume that
1755 we must also create a PT_PHDR segment, although that may not be
1756 true for all targets. */
1757 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1758 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1760 BFD_ASSERT (first
!= NULL
);
1762 phdr
->p_type
= PT_PHDR
;
1764 phdr
->p_offset
= off
;
1766 /* Account for any adjustment made because of the alignment of
1767 the first loadable section. */
1768 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1769 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1771 /* The program header precedes all loadable sections. This lets
1772 us compute its loadable address. This depends on the linker
1774 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1777 phdr
->p_filesz
= phdr_size
;
1778 phdr
->p_memsz
= phdr_size
;
1780 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1781 phdr
->p_flags
= PF_R
| PF_X
;
1783 phdr
->p_align
= FILE_ALIGN
;
1784 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1786 /* Include the ELF header in the first loadable segment. */
1787 phdr_size_adjust
+= off
;
1792 phdr
->p_type
= PT_INTERP
;
1793 phdr
->p_offset
= sinterp
->filepos
;
1794 phdr
->p_vaddr
= sinterp
->vma
;
1796 phdr
->p_filesz
= sinterp
->_raw_size
;
1797 phdr
->p_memsz
= sinterp
->_raw_size
;
1798 phdr
->p_flags
= PF_R
;
1799 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1805 /* Look through the sections to see how they will be divided into
1806 program segments. The sections must be arranged in order by
1807 sh_addr for this to work correctly. */
1808 phdr
->p_type
= PT_NULL
;
1809 last_type
= SHT_PROGBITS
;
1810 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1811 i
< elf_elfheader (abfd
)->e_shnum
;
1814 Elf_Internal_Shdr
*hdr
;
1818 /* Ignore any section which will not be part of the process
1820 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1823 /* If this section fits in the segment we are constructing, add
1825 if (phdr
->p_type
!= PT_NULL
1826 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1827 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1828 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1830 bfd_size_type adjust
;
1832 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1833 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1834 if (hdr
->sh_type
!= SHT_NOBITS
)
1835 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1836 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1837 phdr
->p_flags
|= PF_W
;
1838 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1839 phdr
->p_flags
|= PF_X
;
1840 last_type
= hdr
->sh_type
;
1844 /* If we have a segment, move to the next one. */
1845 if (phdr
->p_type
!= PT_NULL
)
1851 /* Start a new segment. */
1852 phdr
->p_type
= PT_LOAD
;
1853 phdr
->p_offset
= hdr
->sh_offset
;
1854 phdr
->p_vaddr
= hdr
->sh_addr
;
1856 if (hdr
->sh_type
== SHT_NOBITS
)
1859 phdr
->p_filesz
= hdr
->sh_size
;
1860 phdr
->p_memsz
= hdr
->sh_size
;
1861 phdr
->p_flags
= PF_R
;
1862 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1863 phdr
->p_flags
|= PF_W
;
1864 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1865 phdr
->p_flags
|= PF_X
;
1866 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1870 && (sinterp
->flags
& SEC_LOAD
) != 0)
1872 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1873 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1874 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1875 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1878 last_type
= hdr
->sh_type
;
1881 if (phdr
->p_type
!= PT_NULL
)
1887 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1888 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1889 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1891 phdr
->p_type
= PT_DYNAMIC
;
1892 phdr
->p_offset
= sdyn
->filepos
;
1893 phdr
->p_vaddr
= sdyn
->vma
;
1895 phdr
->p_filesz
= sdyn
->_raw_size
;
1896 phdr
->p_memsz
= sdyn
->_raw_size
;
1897 phdr
->p_flags
= PF_R
;
1898 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1899 phdr
->p_flags
|= PF_W
;
1900 if ((sdyn
->flags
& SEC_CODE
) != 0)
1901 phdr
->p_flags
|= PF_X
;
1902 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1908 /* Make sure the return value from get_program_header_size matches
1909 what we computed here. */
1910 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1913 /* Set up program header information. */
1914 i_ehdrp
= elf_elfheader (abfd
);
1915 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1916 i_ehdrp
->e_phoff
= off
;
1917 i_ehdrp
->e_phnum
= phdr_count
;
1919 /* Save the program headers away. I don't think anybody uses this
1920 information right now. */
1921 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1924 * sizeof (Elf_Internal_Phdr
))));
1925 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1927 bfd_set_error (bfd_error_no_memory
);
1928 return (file_ptr
) -1;
1930 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1931 phdr_count
* sizeof (Elf_Internal_Phdr
));
1933 /* Write out the program headers. */
1934 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1935 return (file_ptr
) -1;
1937 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1939 Elf_External_Phdr extphdr
;
1941 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1942 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1943 != sizeof (Elf_External_Phdr
))
1944 return (file_ptr
) -1;
1947 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1950 /* Work out the file positions of all the sections. This is called by
1951 elf_compute_section_file_positions. All the section sizes and VMAs
1952 must be known before this is called.
1954 We do not consider reloc sections at this point, unless they form
1955 part of the loadable image. Reloc sections are assigned file
1956 positions in assign_file_positions_for_relocs, which is called by
1957 write_object_contents and final_link.
1959 If DOSYMS is false, we do not assign file positions for the symbol
1960 table or the string table. */
1963 assign_file_positions_except_relocs (abfd
, dosyms
)
1967 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1968 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1969 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1972 /* Start after the ELF header. */
1973 off
= i_ehdrp
->e_ehsize
;
1975 if ((abfd
->flags
& EXEC_P
) == 0)
1977 Elf_Internal_Shdr
**hdrpp
;
1980 /* We are not creating an executable, which means that we are
1981 not creating a program header, and that the actual order of
1982 the sections in the file is unimportant. */
1983 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1985 Elf_Internal_Shdr
*hdr
;
1988 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1990 hdr
->sh_offset
= -1;
1994 && (i
== tdata
->symtab_section
1995 || i
== tdata
->strtab_section
))
1997 hdr
->sh_offset
= -1;
2001 off
= assign_file_position_for_section (hdr
, off
, true);
2007 bfd_size_type phdr_size
;
2008 bfd_vma maxpagesize
;
2009 Elf_Internal_Shdr
**hdrpp
;
2011 Elf_Internal_Shdr
*first
;
2014 /* We are creating an executable. We must create a program
2015 header. We can't actually create the program header until we
2016 have set the file positions for the sections, but we can
2017 figure out how big it is going to be. */
2018 off
= align_file_position (off
);
2019 phdr_size
= get_program_header_size (abfd
);
2020 if (phdr_size
== (file_ptr
) -1)
2025 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2026 if (maxpagesize
== 0)
2029 /* FIXME: We might want to sort the sections on the sh_addr
2030 field here. For now, we just assume that the linker will
2031 create the sections in an appropriate order. */
2033 /* Assign file positions in two passes. In the first pass, we
2034 assign a file position to every section which forms part of
2035 the executable image. */
2037 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2039 Elf_Internal_Shdr
*hdr
;
2042 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2048 if ((abfd
->flags
& D_PAGED
) != 0)
2050 /* The section VMA must equal the file position modulo
2051 the page size. This is required by the program
2053 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2056 off
= assign_file_position_for_section (hdr
, off
, false);
2059 /* Assign file positions to all the sections which do not form
2060 part of the loadable image, except for the relocs. */
2061 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2063 Elf_Internal_Shdr
*hdr
;
2066 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2068 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2070 hdr
->sh_offset
= -1;
2074 && (i
== tdata
->symtab_section
2075 || i
== tdata
->strtab_section
))
2077 hdr
->sh_offset
= -1;
2081 off
= assign_file_position_for_section (hdr
, off
, true);
2084 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2085 if (phdr_map
== (file_ptr
) -1)
2087 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2090 /* Place the section headers. */
2091 off
= align_file_position (off
);
2092 i_ehdrp
->e_shoff
= off
;
2093 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2095 elf_tdata (abfd
)->next_file_pos
= off
;
2104 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2105 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2106 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2108 struct strtab
*shstrtab
;
2110 i_ehdrp
= elf_elfheader (abfd
);
2111 i_shdrp
= elf_elfsections (abfd
);
2113 shstrtab
= bfd_new_strtab (abfd
);
2117 elf_shstrtab (abfd
) = shstrtab
;
2119 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2120 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2121 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2122 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2124 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2125 i_ehdrp
->e_ident
[EI_DATA
] =
2126 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2127 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2129 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2130 i_ehdrp
->e_ident
[count
] = 0;
2132 if ((abfd
->flags
& DYNAMIC
) != 0)
2133 i_ehdrp
->e_type
= ET_DYN
;
2134 else if ((abfd
->flags
& EXEC_P
) != 0)
2135 i_ehdrp
->e_type
= ET_EXEC
;
2137 i_ehdrp
->e_type
= ET_REL
;
2139 switch (bfd_get_arch (abfd
))
2141 case bfd_arch_unknown
:
2142 i_ehdrp
->e_machine
= EM_NONE
;
2144 case bfd_arch_sparc
:
2146 i_ehdrp
->e_machine
= EM_SPARC64
;
2148 i_ehdrp
->e_machine
= EM_SPARC
;
2152 i_ehdrp
->e_machine
= EM_386
;
2155 i_ehdrp
->e_machine
= EM_68K
;
2158 i_ehdrp
->e_machine
= EM_88K
;
2161 i_ehdrp
->e_machine
= EM_860
;
2163 case bfd_arch_mips
: /* MIPS Rxxxx */
2164 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2167 i_ehdrp
->e_machine
= EM_PARISC
;
2169 case bfd_arch_powerpc
:
2170 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2172 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2174 i_ehdrp
->e_machine
= EM_NONE
;
2176 i_ehdrp
->e_version
= EV_CURRENT
;
2177 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2179 /* no program header, for now. */
2180 i_ehdrp
->e_phoff
= 0;
2181 i_ehdrp
->e_phentsize
= 0;
2182 i_ehdrp
->e_phnum
= 0;
2184 /* each bfd section is section header entry */
2185 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2186 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2188 /* if we're building an executable, we'll need a program header table */
2189 if (abfd
->flags
& EXEC_P
)
2191 /* it all happens later */
2193 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2195 /* elf_build_phdrs() returns a (NULL-terminated) array of
2196 Elf_Internal_Phdrs */
2197 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2198 i_ehdrp
->e_phoff
= outbase
;
2199 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2204 i_ehdrp
->e_phentsize
= 0;
2206 i_ehdrp
->e_phoff
= 0;
2209 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2211 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2213 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2215 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2216 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2217 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2224 swap_out_syms (abfd
)
2227 if (!elf_map_symbols (abfd
))
2230 /* Dump out the symtabs. */
2232 int symcount
= bfd_get_symcount (abfd
);
2233 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2234 struct strtab
*stt
= bfd_new_strtab (abfd
);
2235 Elf_Internal_Shdr
*symtab_hdr
;
2236 Elf_Internal_Shdr
*symstrtab_hdr
;
2237 Elf_External_Sym
*outbound_syms
;
2242 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2243 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2244 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2245 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2246 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2247 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2249 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2250 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2252 outbound_syms
= (Elf_External_Sym
*)
2253 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2256 bfd_set_error (bfd_error_no_memory
);
2259 /* now generate the data (for "contents") */
2261 /* Fill in zeroth symbol and swap it out. */
2262 Elf_Internal_Sym sym
;
2268 sym
.st_shndx
= SHN_UNDEF
;
2269 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2271 for (idx
= 0; idx
< symcount
; idx
++)
2273 Elf_Internal_Sym sym
;
2274 bfd_vma value
= syms
[idx
]->value
;
2275 elf_symbol_type
*type_ptr
;
2277 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2278 /* Section symbols have no names. */
2282 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2283 if (sym
.st_name
== (unsigned long) -1)
2287 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2289 if (bfd_is_com_section (syms
[idx
]->section
))
2291 /* ELF common symbols put the alignment into the `value' field,
2292 and the size into the `size' field. This is backwards from
2293 how BFD handles it, so reverse it here. */
2294 sym
.st_size
= value
;
2295 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2296 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2297 syms
[idx
]->section
);
2301 asection
*sec
= syms
[idx
]->section
;
2304 if (sec
->output_section
)
2306 value
+= sec
->output_offset
;
2307 sec
= sec
->output_section
;
2310 sym
.st_value
= value
;
2311 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2312 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2316 /* Writing this would be a hell of a lot easier if we had
2317 some decent documentation on bfd, and knew what to expect
2318 of the library, and what to demand of applications. For
2319 example, it appears that `objcopy' might not set the
2320 section of a symbol to be a section that is actually in
2322 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2323 BFD_ASSERT (sec2
!= 0);
2324 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2325 BFD_ASSERT (shndx
!= -1);
2329 if (bfd_is_com_section (syms
[idx
]->section
))
2330 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2331 else if (bfd_is_und_section (syms
[idx
]->section
))
2332 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2333 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2334 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2335 else if (syms
[idx
]->flags
& BSF_FILE
)
2336 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2339 int bind
= STB_LOCAL
;
2340 int type
= STT_OBJECT
;
2341 unsigned int flags
= syms
[idx
]->flags
;
2343 if (flags
& BSF_LOCAL
)
2345 else if (flags
& BSF_WEAK
)
2347 else if (flags
& BSF_GLOBAL
)
2350 if (flags
& BSF_FUNCTION
)
2353 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2357 elf_swap_symbol_out (abfd
, &sym
,
2359 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2362 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2363 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2364 symstrtab_hdr
->sh_size
= stt
->length
;
2365 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2367 symstrtab_hdr
->sh_flags
= 0;
2368 symstrtab_hdr
->sh_addr
= 0;
2369 symstrtab_hdr
->sh_entsize
= 0;
2370 symstrtab_hdr
->sh_link
= 0;
2371 symstrtab_hdr
->sh_info
= 0;
2372 symstrtab_hdr
->sh_addralign
= 1;
2373 symstrtab_hdr
->size
= 0;
2380 write_shdrs_and_ehdr (abfd
)
2383 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2384 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2385 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2386 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2388 struct strtab
*shstrtab
;
2390 i_ehdrp
= elf_elfheader (abfd
);
2391 i_shdrp
= elf_elfsections (abfd
);
2392 shstrtab
= elf_shstrtab (abfd
);
2394 /* swap the header before spitting it out... */
2397 elf_debug_file (i_ehdrp
);
2399 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2400 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2401 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2402 != sizeof (x_ehdr
)))
2405 /* at this point we've concocted all the ELF sections... */
2406 x_shdrp
= (Elf_External_Shdr
*)
2407 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2410 bfd_set_error (bfd_error_no_memory
);
2414 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2417 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2420 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2422 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2423 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2424 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2427 /* need to dump the string table too... */
2432 /* Assign file positions for all the reloc sections which are not part
2433 of the loadable file image. */
2436 assign_file_positions_for_relocs (abfd
)
2441 Elf_Internal_Shdr
**shdrpp
;
2443 off
= elf_tdata (abfd
)->next_file_pos
;
2445 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2446 i
< elf_elfheader (abfd
)->e_shnum
;
2449 Elf_Internal_Shdr
*shdrp
;
2452 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2453 && shdrp
->sh_offset
== -1)
2454 off
= assign_file_position_for_section (shdrp
, off
, true);
2457 elf_tdata (abfd
)->next_file_pos
= off
;
2461 NAME(bfd_elf
,write_object_contents
) (abfd
)
2464 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2465 Elf_Internal_Ehdr
*i_ehdrp
;
2466 Elf_Internal_Shdr
**i_shdrp
;
2469 if (! abfd
->output_has_begun
2470 && ! elf_compute_section_file_positions (abfd
,
2471 (struct bfd_link_info
*) NULL
))
2474 i_shdrp
= elf_elfsections (abfd
);
2475 i_ehdrp
= elf_elfheader (abfd
);
2477 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2478 assign_file_positions_for_relocs (abfd
);
2480 /* After writing the headers, we need to write the sections too... */
2481 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2483 if (bed
->elf_backend_section_processing
)
2484 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2485 if (i_shdrp
[count
]->contents
)
2487 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2488 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2490 != i_shdrp
[count
]->sh_size
))
2495 if (bed
->elf_backend_final_write_processing
)
2496 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
2498 return write_shdrs_and_ehdr (abfd
);
2501 /* Given an index of a section, retrieve a pointer to it. Note
2502 that for our purposes, sections are indexed by {1, 2, ...} with
2503 0 being an illegal index. */
2505 /* In the original, each ELF section went into exactly one BFD
2506 section. This doesn't really make sense, so we need a real mapping.
2507 The mapping has to hide in the Elf_Internal_Shdr since asection
2508 doesn't have anything like a tdata field... */
2511 section_from_elf_index (abfd
, index
)
2515 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2516 be returned from this routine? */
2518 if (index
== SHN_ABS
)
2519 return bfd_com_section_ptr
; /* not abs? */
2520 if (index
== SHN_COMMON
)
2521 return bfd_com_section_ptr
;
2523 if (index
> elf_elfheader (abfd
)->e_shnum
)
2527 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2529 switch (hdr
->sh_type
)
2531 /* ELF sections that map to BFD sections */
2536 if (hdr
->rawdata
== NULL
)
2538 if (! bfd_section_from_shdr (abfd
, index
))
2541 return (struct sec
*) hdr
->rawdata
;
2544 return bfd_abs_section_ptr
;
2549 /* given a section, search the header to find them... */
2551 elf_section_from_bfd_section (abfd
, asect
)
2555 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2557 Elf_Internal_Shdr
*hdr
;
2558 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2560 if (asect
->owner
== NULL
)
2562 if (bfd_is_abs_section (asect
))
2564 if (bfd_is_com_section (asect
))
2566 if (bfd_is_und_section (asect
))
2571 BFD_ASSERT (asect
->owner
== abfd
);
2573 for (index
= 0; index
< maxindex
; index
++)
2575 hdr
= i_shdrp
[index
];
2576 switch (hdr
->sh_type
)
2578 /* ELF sections that map to BFD sections */
2587 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2594 /* We sometimes map a reloc section to a BFD section. */
2595 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2596 && (asection
*) hdr
->rawdata
== asect
)
2601 /* We map most string tables to BFD sections. */
2602 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2603 && index
!= elf_onesymtab (abfd
)
2604 && (asection
*) hdr
->rawdata
== asect
)
2610 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2612 if (bed
->elf_backend_section_from_bfd_section
)
2617 if ((*bed
->elf_backend_section_from_bfd_section
)
2618 (abfd
, hdr
, asect
, &retval
))
2628 /* given a symbol, return the bfd index for that symbol. */
2630 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2632 struct symbol_cache_entry
**asym_ptr_ptr
;
2634 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2636 flagword flags
= asym_ptr
->flags
;
2638 /* When gas creates relocations against local labels, it creates its
2639 own symbol for the section, but does put the symbol into the
2640 symbol chain, so udata is 0. When the linker is generating
2641 relocatable output, this section symbol may be for one of the
2642 input sections rather than the output section. */
2643 if (asym_ptr
->udata
== (PTR
) 0
2644 && (flags
& BSF_SECTION_SYM
)
2645 && asym_ptr
->section
)
2649 if (asym_ptr
->section
->output_section
!= NULL
)
2650 indx
= asym_ptr
->section
->output_section
->index
;
2652 indx
= asym_ptr
->section
->index
;
2653 if (elf_section_syms (abfd
)[indx
])
2654 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2657 if (asym_ptr
->udata
)
2658 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2668 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2669 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2678 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2680 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2683 Elf_Internal_Shdr
*hdr
;
2684 long symcount
; /* Number of external ELF symbols */
2685 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2686 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2687 Elf_Internal_Sym i_sym
;
2688 Elf_External_Sym
*x_symp
= NULL
;
2690 /* Read each raw ELF symbol, converting from external ELF form to
2691 internal ELF form, and then using the information to create a
2692 canonical bfd symbol table entry.
2694 Note that we allocate the initial bfd canonical symbol buffer
2695 based on a one-to-one mapping of the ELF symbols to canonical
2696 symbols. We actually use all the ELF symbols, so there will be no
2697 space left over at the end. When we have all the symbols, we
2698 build the caller's pointer vector. */
2701 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2703 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2704 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2707 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2710 sym
= symbase
= NULL
;
2715 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2718 symbase
= ((elf_symbol_type
*)
2719 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2720 if (symbase
== (elf_symbol_type
*) NULL
)
2722 bfd_set_error (bfd_error_no_memory
);
2727 /* Temporarily allocate room for the raw ELF symbols. */
2728 x_symp
= ((Elf_External_Sym
*)
2729 malloc (symcount
* sizeof (Elf_External_Sym
)));
2730 if (x_symp
== NULL
&& symcount
!= 0)
2732 bfd_set_error (bfd_error_no_memory
);
2736 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2737 != symcount
* sizeof (Elf_External_Sym
))
2739 /* Skip first symbol, which is a null dummy. */
2740 for (i
= 1; i
< symcount
; i
++)
2742 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2743 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2744 #ifdef ELF_KEEP_EXTSYM
2745 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2747 sym
->symbol
.the_bfd
= abfd
;
2749 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2752 sym
->symbol
.value
= i_sym
.st_value
;
2754 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2756 sym
->symbol
.section
= section_from_elf_index (abfd
,
2758 if (sym
->symbol
.section
== NULL
)
2760 /* This symbol is in a section for which we did not
2761 create a BFD section. Just use bfd_abs_section,
2762 although it is wrong. FIXME. */
2763 sym
->symbol
.section
= bfd_abs_section_ptr
;
2766 else if (i_sym
.st_shndx
== SHN_ABS
)
2768 sym
->symbol
.section
= bfd_abs_section_ptr
;
2770 else if (i_sym
.st_shndx
== SHN_COMMON
)
2772 sym
->symbol
.section
= bfd_com_section_ptr
;
2773 /* Elf puts the alignment into the `value' field, and
2774 the size into the `size' field. BFD wants to see the
2775 size in the value field, and doesn't care (at the
2776 moment) about the alignment. */
2777 sym
->symbol
.value
= i_sym
.st_size
;
2779 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2781 sym
->symbol
.section
= bfd_und_section_ptr
;
2784 sym
->symbol
.section
= bfd_abs_section_ptr
;
2786 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2788 switch (ELF_ST_BIND (i_sym
.st_info
))
2791 sym
->symbol
.flags
|= BSF_LOCAL
;
2794 sym
->symbol
.flags
|= BSF_GLOBAL
;
2797 sym
->symbol
.flags
|= BSF_WEAK
;
2801 switch (ELF_ST_TYPE (i_sym
.st_info
))
2804 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2807 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2810 sym
->symbol
.flags
|= BSF_FUNCTION
;
2815 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2817 /* Do some backend-specific processing on this symbol. */
2819 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2820 if (ebd
->elf_backend_symbol_processing
)
2821 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2828 /* Do some backend-specific processing on this symbol table. */
2830 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2831 if (ebd
->elf_backend_symbol_table_processing
)
2832 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2835 /* We rely on the zalloc to clear out the final symbol entry. */
2837 symcount
= sym
- symbase
;
2839 /* Fill in the user's symbol pointer vector if needed. */
2847 *symptrs
++ = &sym
->symbol
;
2850 *symptrs
= 0; /* Final null pointer */
2862 /* Return the number of bytes required to hold the symtab vector.
2864 Note that we base it on the count plus 1, since we will null terminate
2865 the vector allocated based on this size. However, the ELF symbol table
2866 always has a dummy entry as symbol #0, so it ends up even. */
2869 elf_get_symtab_upper_bound (abfd
)
2874 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2876 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2877 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2883 elf_get_dynamic_symtab_upper_bound (abfd
)
2888 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2890 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2891 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2897 elf_get_reloc_upper_bound (abfd
, asect
)
2901 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2904 /* Read in and swap the external relocs. */
2907 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2912 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2913 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2914 PTR allocated
= NULL
;
2915 bfd_byte
*native_relocs
;
2921 if (asect
->relocation
!= NULL
)
2924 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2925 && (asect
->reloc_count
2926 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2928 native_relocs
= (bfd_byte
*) elf_section_data (asect
)->relocs
;
2929 if (native_relocs
== NULL
)
2931 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2932 if (allocated
== NULL
)
2934 bfd_set_error (bfd_error_no_memory
);
2938 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2939 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2940 != d
->rel_hdr
.sh_size
))
2943 native_relocs
= (bfd_byte
*) allocated
;
2946 relents
= ((arelent
*)
2947 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2948 if (relents
== NULL
)
2950 bfd_set_error (bfd_error_no_memory
);
2954 entsize
= d
->rel_hdr
.sh_entsize
;
2955 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2956 || entsize
== sizeof (Elf_External_Rela
));
2958 for (i
= 0, relent
= relents
;
2959 i
< asect
->reloc_count
;
2960 i
++, relent
++, native_relocs
+= entsize
)
2962 Elf_Internal_Rela rela
;
2963 Elf_Internal_Rel rel
;
2965 if (entsize
== sizeof (Elf_External_Rela
))
2966 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2969 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2970 rela
.r_offset
= rel
.r_offset
;
2971 rela
.r_info
= rel
.r_info
;
2975 /* The address of an ELF reloc is section relative for an object
2976 file, and absolute for an executable file or shared library.
2977 The address of a BFD reloc is always section relative. */
2978 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2979 relent
->address
= rela
.r_offset
;
2981 relent
->address
= rela
.r_offset
- asect
->vma
;
2983 if (ELF_R_SYM (rela
.r_info
) == 0)
2984 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2989 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
2992 /* Canonicalize ELF section symbols. FIXME: Why? */
2993 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
2994 relent
->sym_ptr_ptr
= ps
;
2996 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2999 relent
->addend
= rela
.r_addend
;
3001 if (entsize
== sizeof (Elf_External_Rela
))
3002 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3004 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3007 asect
->relocation
= relents
;
3009 if (allocated
!= NULL
)
3015 if (allocated
!= NULL
)
3022 elf_debug_section (str
, num
, hdr
)
3025 Elf_Internal_Shdr
*hdr
;
3027 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3029 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3030 (long) hdr
->sh_name
,
3031 (long) hdr
->sh_type
,
3032 (long) hdr
->sh_flags
);
3034 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3035 (long) hdr
->sh_addr
,
3036 (long) hdr
->sh_offset
,
3037 (long) hdr
->sh_size
);
3039 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3040 (long) hdr
->sh_link
,
3041 (long) hdr
->sh_info
,
3042 (long) hdr
->sh_addralign
);
3043 fprintf (stderr
, "sh_entsize = %ld\n",
3044 (long) hdr
->sh_entsize
);
3045 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3046 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3047 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3052 elf_debug_file (ehdrp
)
3053 Elf_Internal_Ehdr
*ehdrp
;
3055 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3056 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3057 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3058 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3059 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3060 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3061 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3065 /* Canonicalize the relocs. */
3068 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3077 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3080 tblptr
= section
->relocation
;
3081 for (i
= 0; i
< section
->reloc_count
; i
++)
3082 *relptr
++ = tblptr
++;
3086 return section
->reloc_count
;
3090 elf_get_symtab (abfd
, alocation
)
3092 asymbol
**alocation
;
3094 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3097 bfd_get_symcount (abfd
) = symcount
;
3102 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3104 asymbol
**alocation
;
3106 return elf_slurp_symbol_table (abfd
, alocation
, true);
3110 elf_make_empty_symbol (abfd
)
3113 elf_symbol_type
*newsym
;
3115 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3118 bfd_set_error (bfd_error_no_memory
);
3123 newsym
->symbol
.the_bfd
= abfd
;
3124 return &newsym
->symbol
;
3129 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3134 bfd_symbol_info (symbol
, ret
);
3138 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3142 bfd_print_symbol_type how
;
3144 FILE *file
= (FILE *) filep
;
3147 case bfd_print_symbol_name
:
3148 fprintf (file
, "%s", symbol
->name
);
3150 case bfd_print_symbol_more
:
3151 fprintf (file
, "elf ");
3152 fprintf_vma (file
, symbol
->value
);
3153 fprintf (file
, " %lx", (long) symbol
->flags
);
3155 case bfd_print_symbol_all
:
3157 CONST
char *section_name
;
3158 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3159 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3160 fprintf (file
, " %s\t%s",
3170 elf_get_lineno (ignore_abfd
, symbol
)
3174 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3181 elf_set_arch_mach (abfd
, arch
, machine
)
3183 enum bfd_architecture arch
;
3184 unsigned long machine
;
3186 /* If this isn't the right architecture for this backend, and this
3187 isn't the generic backend, fail. */
3188 if (arch
!= get_elf_backend_data (abfd
)->arch
3189 && arch
!= bfd_arch_unknown
3190 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3193 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3197 elf_find_nearest_line (abfd
,
3208 CONST
char **filename_ptr
;
3209 CONST
char **functionname_ptr
;
3210 unsigned int *line_ptr
;
3216 elf_sizeof_headers (abfd
, reloc
)
3222 ret
= sizeof (Elf_External_Ehdr
);
3224 ret
+= get_program_header_size (abfd
);
3229 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3234 bfd_size_type count
;
3236 Elf_Internal_Shdr
*hdr
;
3238 if (! abfd
->output_has_begun
3239 && ! elf_compute_section_file_positions (abfd
,
3240 (struct bfd_link_info
*) NULL
))
3243 hdr
= &elf_section_data (section
)->this_hdr
;
3245 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3247 if (bfd_write (location
, 1, count
, abfd
) != count
)
3254 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3257 Elf_Internal_Rela
*dst
;
3259 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3265 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3268 Elf_Internal_Rel
*dst
;
3270 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3276 /* Core file support */
3278 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3279 #include <sys/procfs.h>
3281 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3282 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3283 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3289 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3296 prstatus_t
*status
= (prstatus_t
*) 0;
3298 if (descsz
== sizeof (prstatus_t
))
3300 newsect
= bfd_make_section (abfd
, ".reg");
3301 if (newsect
== NULL
)
3303 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3304 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3305 newsect
->flags
= SEC_HAS_CONTENTS
;
3306 newsect
->alignment_power
= 2;
3307 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3309 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3315 /* Stash a copy of the prpsinfo structure away for future use. */
3318 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3324 if (descsz
== sizeof (prpsinfo_t
))
3326 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3328 bfd_set_error (bfd_error_no_memory
);
3331 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3337 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3345 newsect
= bfd_make_section (abfd
, ".reg2");
3346 if (newsect
== NULL
)
3348 newsect
->_raw_size
= descsz
;
3349 newsect
->filepos
= filepos
;
3350 newsect
->flags
= SEC_HAS_CONTENTS
;
3351 newsect
->alignment_power
= 2;
3355 #endif /* HAVE_PROCFS */
3357 /* Return a pointer to the args (including the command name) that were
3358 seen by the program that generated the core dump. Note that for
3359 some reason, a spurious space is tacked onto the end of the args
3360 in some (at least one anyway) implementations, so strip it off if
3364 elf_core_file_failing_command (abfd
)
3368 if (core_prpsinfo (abfd
))
3370 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3371 char *scan
= p
->pr_psargs
;
3376 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3380 return p
->pr_psargs
;
3386 /* Return the number of the signal that caused the core dump. Presumably,
3387 since we have a core file, we got a signal of some kind, so don't bother
3388 checking the other process status fields, just return the signal number.
3392 elf_core_file_failing_signal (abfd
)
3396 if (core_prstatus (abfd
))
3398 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3404 /* Check to see if the core file could reasonably be expected to have
3405 come for the current executable file. Note that by default we return
3406 true unless we find something that indicates that there might be a
3411 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3420 /* First, xvecs must match since both are ELF files for the same target. */
3422 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3424 bfd_set_error (bfd_error_system_call
);
3430 /* If no prpsinfo, just return true. Otherwise, grab the last component
3431 of the exec'd pathname from the prpsinfo. */
3433 if (core_prpsinfo (core_bfd
))
3435 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3442 /* Find the last component of the executable pathname. */
3444 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3450 execname
= (char *) exec_bfd
->filename
;
3453 /* See if they match */
3455 return strcmp (execname
, corename
) ? false : true;
3461 #endif /* HAVE_PROCFS */
3464 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3465 the information that would normally be available from the /proc interface
3466 for the process, at the time the process dumped core. Currently this
3467 includes copies of the prstatus, prpsinfo, and fpregset structures.
3469 Since these structures are potentially machine dependent in size and
3470 ordering, bfd provides two levels of support for them. The first level,
3471 available on all machines since it does not require that the host
3472 have /proc support or the relevant include files, is to create a bfd
3473 section for each of the prstatus, prpsinfo, and fpregset structures,
3474 without any interpretation of their contents. With just this support,
3475 the bfd client will have to interpret the structures itself. Even with
3476 /proc support, it might want these full structures for it's own reasons.
3478 In the second level of support, where HAVE_PROCFS is defined, bfd will
3479 pick apart the structures to gather some additional information that
3480 clients may want, such as the general register set, the name of the
3481 exec'ed file and its arguments, the signal (if any) that caused the
3487 elf_corefile_note (abfd
, hdr
)
3489 Elf_Internal_Phdr
*hdr
;
3491 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3492 Elf_Internal_Note i_note
; /* Elf note, internal form */
3493 char *buf
= NULL
; /* Entire note segment contents */
3494 char *namedata
; /* Name portion of the note */
3495 char *descdata
; /* Descriptor portion of the note */
3496 char *sectname
; /* Name to use for new section */
3497 long filepos
; /* File offset to descriptor data */
3500 if (hdr
->p_filesz
> 0
3501 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3502 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3503 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3505 x_note_p
= (Elf_External_Note
*) buf
;
3506 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3508 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3509 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3510 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3511 namedata
= x_note_p
->name
;
3512 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3513 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3514 switch (i_note
.type
)
3517 /* process descdata as prstatus info */
3518 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3520 sectname
= ".prstatus";
3523 /* process descdata as fpregset info */
3524 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3526 sectname
= ".fpregset";
3529 /* process descdata as prpsinfo */
3530 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3532 sectname
= ".prpsinfo";
3535 /* Unknown descriptor, just ignore it. */
3539 if (sectname
!= NULL
)
3541 newsect
= bfd_make_section (abfd
, sectname
);
3542 if (newsect
== NULL
)
3544 newsect
->_raw_size
= i_note
.descsz
;
3545 newsect
->filepos
= filepos
;
3546 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3547 newsect
->alignment_power
= 2;
3549 x_note_p
= (Elf_External_Note
*)
3550 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3557 else if (hdr
->p_filesz
> 0)
3559 bfd_set_error (bfd_error_no_memory
);
3566 /* Core files are simply standard ELF formatted files that partition
3567 the file using the execution view of the file (program header table)
3568 rather than the linking view. In fact, there is no section header
3569 table in a core file.
3571 The process status information (including the contents of the general
3572 register set) and the floating point register set are stored in a
3573 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3574 that allow standard bfd access to the general registers (.reg) and the
3575 floating point registers (.reg2).
3580 elf_core_file_p (abfd
)
3583 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3584 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3585 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3586 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3587 unsigned int phindex
;
3588 struct elf_backend_data
*ebd
;
3590 /* Read in the ELF header in external format. */
3592 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3594 if (bfd_get_error () != bfd_error_system_call
)
3595 bfd_set_error (bfd_error_wrong_format
);
3599 /* Now check to see if we have a valid ELF file, and one that BFD can
3600 make use of. The magic number must match, the address size ('class')
3601 and byte-swapping must match our XVEC entry, and it must have a
3602 program header table (FIXME: See comments re segments at top of this
3605 if (elf_file_p (&x_ehdr
) == false)
3608 bfd_set_error (bfd_error_wrong_format
);
3612 /* FIXME, Check EI_VERSION here ! */
3616 int desired_address_size
= ELFCLASS32
;
3619 int desired_address_size
= ELFCLASS64
;
3622 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3626 /* Switch xvec to match the specified byte order. */
3627 switch (x_ehdr
.e_ident
[EI_DATA
])
3629 case ELFDATA2MSB
: /* Big-endian */
3630 if (abfd
->xvec
->byteorder_big_p
== false)
3633 case ELFDATA2LSB
: /* Little-endian */
3634 if (abfd
->xvec
->byteorder_big_p
== true)
3637 case ELFDATANONE
: /* No data encoding specified */
3638 default: /* Unknown data encoding specified */
3642 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3643 the tdata pointer in the bfd. */
3646 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3647 if (elf_tdata (abfd
) == NULL
)
3649 bfd_set_error (bfd_error_no_memory
);
3653 /* FIXME, `wrong' returns from this point onward, leak memory. */
3655 /* Now that we know the byte order, swap in the rest of the header */
3656 i_ehdrp
= elf_elfheader (abfd
);
3657 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3659 elf_debug_file (i_ehdrp
);
3662 ebd
= get_elf_backend_data (abfd
);
3664 /* Check that the ELF e_machine field matches what this particular
3665 BFD format expects. */
3666 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3668 const bfd_target
* const *target_ptr
;
3670 if (ebd
->elf_machine_code
!= EM_NONE
)
3673 /* This is the generic ELF target. Let it match any ELF target
3674 for which we do not have a specific backend. */
3675 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3677 struct elf_backend_data
*back
;
3679 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3681 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3682 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3684 /* target_ptr is an ELF backend which matches this
3685 object file, so reject the generic ELF target. */
3691 /* If there is no program header, or the type is not a core file, then
3693 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3696 /* Allocate space for a copy of the program header table in
3697 internal form, seek to the program header table in the file,
3698 read it in, and convert it to internal form. As a simple sanity
3699 check, verify that the what BFD thinks is the size of each program
3700 header table entry actually matches the size recorded in the file. */
3702 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3704 i_phdrp
= (Elf_Internal_Phdr
*)
3705 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3708 bfd_set_error (bfd_error_no_memory
);
3711 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3713 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3715 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3718 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3721 /* Once all of the program headers have been read and converted, we
3722 can start processing them. */
3724 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3726 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3727 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3729 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3734 /* Remember the entry point specified in the ELF file header. */
3736 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3741 /* ELF linker code. */
3743 static boolean elf_link_add_object_symbols
3744 PARAMS ((bfd
*, struct bfd_link_info
*));
3745 static boolean elf_link_add_archive_symbols
3746 PARAMS ((bfd
*, struct bfd_link_info
*));
3747 static INLINE boolean elf_link_record_dynamic_symbol
3748 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
3749 static boolean elf_link_create_dynamic_sections
3750 PARAMS ((bfd
*, struct bfd_link_info
*));
3751 static boolean elf_adjust_dynamic_symbol
3752 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3754 /* Given an ELF BFD, add symbols to the global hash table as
3758 elf_bfd_link_add_symbols (abfd
, info
)
3760 struct bfd_link_info
*info
;
3762 switch (bfd_get_format (abfd
))
3765 return elf_link_add_object_symbols (abfd
, info
);
3767 return elf_link_add_archive_symbols (abfd
, info
);
3769 bfd_set_error (bfd_error_wrong_format
);
3774 /* Add symbols from an ELF archive file to the linker hash table. We
3775 don't use _bfd_generic_link_add_archive_symbols because of a
3776 problem which arises on UnixWare. The UnixWare libc.so is an
3777 archive which includes an entry libc.so.1 which defines a bunch of
3778 symbols. The libc.so archive also includes a number of other
3779 object files, which also define symbols, some of which are the same
3780 as those defined in libc.so.1. Correct linking requires that we
3781 consider each object file in turn, and include it if it defines any
3782 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3783 this; it looks through the list of undefined symbols, and includes
3784 any object file which defines them. When this algorithm is used on
3785 UnixWare, it winds up pulling in libc.so.1 early and defining a
3786 bunch of symbols. This means that some of the other objects in the
3787 archive are not included in the link, which is incorrect since they
3788 precede libc.so.1 in the archive.
3790 Fortunately, ELF archive handling is simpler than that done by
3791 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3792 oddities. In ELF, if we find a symbol in the archive map, and the
3793 symbol is currently undefined, we know that we must pull in that
3796 Unfortunately, we do have to make multiple passes over the symbol
3797 table until nothing further is resolved. */
3800 elf_link_add_archive_symbols (abfd
, info
)
3802 struct bfd_link_info
*info
;
3805 boolean
*defined
= NULL
;
3806 boolean
*included
= NULL
;
3810 if (! bfd_has_map (abfd
))
3812 bfd_set_error (bfd_error_no_symbols
);
3816 /* Keep track of all symbols we know to be already defined, and all
3817 files we know to be already included. This is to speed up the
3818 second and subsequent passes. */
3819 c
= bfd_ardata (abfd
)->symdef_count
;
3822 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3823 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3824 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3826 bfd_set_error (bfd_error_no_memory
);
3829 memset (defined
, 0, c
* sizeof (boolean
));
3830 memset (included
, 0, c
* sizeof (boolean
));
3832 symdefs
= bfd_ardata (abfd
)->symdefs
;
3845 symdefend
= symdef
+ c
;
3846 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3848 struct elf_link_hash_entry
*h
;
3850 struct bfd_link_hash_entry
*undefs_tail
;
3853 if (defined
[i
] || included
[i
])
3855 if (symdef
->file_offset
== last
)
3861 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3862 false, false, false);
3863 if (h
== (struct elf_link_hash_entry
*) NULL
)
3865 if (h
->root
.type
!= bfd_link_hash_undefined
)
3871 /* We need to include this archive member. */
3873 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3874 if (element
== (bfd
*) NULL
)
3877 if (! bfd_check_format (element
, bfd_object
))
3880 /* Doublecheck that we have not included this object
3881 already--it should be impossible, but there may be
3882 something wrong with the archive. */
3883 if (element
->archive_pass
!= 0)
3885 bfd_set_error (bfd_error_bad_value
);
3888 element
->archive_pass
= 1;
3890 undefs_tail
= info
->hash
->undefs_tail
;
3892 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3895 if (! elf_link_add_object_symbols (element
, info
))
3898 /* If there are any new undefined symbols, we need to make
3899 another pass through the archive in order to see whether
3900 they can be defined. FIXME: This isn't perfect, because
3901 common symbols wind up on undefs_tail and because an
3902 undefined symbol which is defined later on in this pass
3903 does not require another pass. This isn't a bug, but it
3904 does make the code less efficient than it could be. */
3905 if (undefs_tail
!= info
->hash
->undefs_tail
)
3908 /* Look backward to mark all symbols from this object file
3909 which we have already seen in this pass. */
3913 included
[mark
] = true;
3918 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3920 /* We mark subsequent symbols from this object file as we go
3921 on through the loop. */
3922 last
= symdef
->file_offset
;
3933 if (defined
!= (boolean
*) NULL
)
3935 if (included
!= (boolean
*) NULL
)
3940 /* Record a new dynamic symbol. We record the dynamic symbols as we
3941 read the input files, since we need to have a list of all of them
3942 before we can determine the final sizes of the output sections. */
3944 static INLINE boolean
3945 elf_link_record_dynamic_symbol (info
, h
)
3946 struct bfd_link_info
*info
;
3947 struct elf_link_hash_entry
*h
;
3949 if (h
->dynindx
== -1)
3951 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3952 ++elf_hash_table (info
)->dynsymcount
;
3953 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3954 elf_hash_table (info
)->dynstr
,
3955 h
->root
.root
.string
);
3956 if (h
->dynstr_index
== (unsigned long) -1)
3963 /* Add symbols from an ELF object file to the linker hash table. */
3966 elf_link_add_object_symbols (abfd
, info
)
3968 struct bfd_link_info
*info
;
3970 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3971 const Elf_Internal_Sym
*,
3972 const char **, flagword
*,
3973 asection
**, bfd_vma
*));
3975 Elf_Internal_Shdr
*hdr
;
3979 Elf_External_Sym
*buf
= NULL
;
3980 struct elf_link_hash_entry
**sym_hash
;
3982 Elf_External_Dyn
*dynbuf
= NULL
;
3983 struct elf_link_hash_entry
*weaks
;
3984 Elf_External_Sym
*esym
;
3985 Elf_External_Sym
*esymend
;
3987 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
3988 collect
= get_elf_backend_data (abfd
)->collect
;
3990 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3991 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3993 /* The sh_info field of the symtab header tells us where the
3994 external symbols start. We don't care about the local symbols at
3996 if (elf_bad_symtab (abfd
))
3998 extsymcount
= symcount
;
4003 extsymcount
= symcount
- hdr
->sh_info
;
4004 extsymoff
= hdr
->sh_info
;
4007 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4008 if (buf
== NULL
&& extsymcount
!= 0)
4010 bfd_set_error (bfd_error_no_memory
);
4014 /* We store a pointer to the hash table entry for each external
4016 sym_hash
= ((struct elf_link_hash_entry
**)
4018 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4019 if (sym_hash
== NULL
)
4021 bfd_set_error (bfd_error_no_memory
);
4024 elf_sym_hashes (abfd
) = sym_hash
;
4026 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4030 /* If we are creating a shared library, create all the dynamic
4031 sections immediately. We need to attach them to something,
4032 so we attach them to this BFD, provided it is the right
4033 format. FIXME: If there are no input BFD's of the same
4034 format as the output, we can't make a shared library. */
4036 && elf_hash_table (info
)->dynobj
== NULL
4037 && abfd
->xvec
== info
->hash
->creator
)
4039 if (! elf_link_create_dynamic_sections (abfd
, info
))
4041 elf_hash_table (info
)->dynobj
= abfd
;
4048 unsigned long strindex
;
4052 /* You can't use -r against a dynamic object. There's no hope
4053 of using a dynamic object which does not exactly match the
4054 format of the output file. */
4055 if (info
->relocateable
4056 || info
->hash
->creator
!= abfd
->xvec
)
4058 bfd_set_error (bfd_error_invalid_operation
);
4062 /* Find the name to use in a DT_NEEDED entry that refers to this
4063 object. If the object has a DT_SONAME entry, we use it.
4064 Otherwise, if the generic linker stuck something in
4065 elf_dt_needed_name, we use that. Otherwise, we just use the
4067 name
= bfd_get_filename (abfd
);
4068 if (elf_dt_needed_name (abfd
) != NULL
)
4069 name
= elf_dt_needed_name (abfd
);
4070 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4073 Elf_External_Dyn
*extdyn
;
4074 Elf_External_Dyn
*extdynend
;
4076 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4079 bfd_set_error (bfd_error_no_memory
);
4083 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4084 (file_ptr
) 0, s
->_raw_size
))
4088 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4089 for (; extdyn
< extdynend
; extdyn
++)
4091 Elf_Internal_Dyn dyn
;
4093 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4094 if (dyn
.d_tag
== DT_SONAME
)
4099 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4102 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4103 name
= elf_string_from_elf_section (abfd
, link
,
4116 /* We do not want to include any of the sections in a dynamic
4117 object in the output file. We hack by simply clobbering the
4118 list of sections in the BFD. This could be handled more
4119 cleanly by, say, a new section flag; the existing
4120 SEC_NEVER_LOAD flag is not the one we want, because that one
4121 still implies that the section takes up space in the output
4123 abfd
->sections
= NULL
;
4125 /* If this is the first dynamic object found in the link, create
4126 the special sections required for dynamic linking. We need
4127 to put them somewhere, and attaching them to the first
4128 dynamic object is as good place as any. */
4129 if (elf_hash_table (info
)->dynobj
== NULL
)
4131 if (! elf_link_create_dynamic_sections (abfd
, info
))
4133 elf_hash_table (info
)->dynobj
= abfd
;
4136 /* Add a DT_NEEDED entry for this dynamic object. */
4137 strindex
= bfd_add_to_strtab (abfd
,
4138 elf_hash_table (info
)->dynstr
,
4141 if (strindex
== (unsigned long) -1)
4143 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4148 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4150 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4151 != extsymcount
* sizeof (Elf_External_Sym
)))
4156 esymend
= buf
+ extsymcount
;
4157 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4159 Elf_Internal_Sym sym
;
4165 struct elf_link_hash_entry
*h
= NULL
;
4168 elf_swap_symbol_in (abfd
, esym
, &sym
);
4170 flags
= BSF_NO_FLAGS
;
4172 value
= sym
.st_value
;
4175 bind
= ELF_ST_BIND (sym
.st_info
);
4176 if (bind
== STB_LOCAL
)
4178 /* This should be impossible, since ELF requires that all
4179 global symbols follow all local symbols, and that sh_info
4180 point to the first global symbol. Unfortunatealy, Irix 5
4184 else if (bind
== STB_GLOBAL
)
4186 else if (bind
== STB_WEAK
)
4190 /* Leave it up to the processor backend. */
4193 if (sym
.st_shndx
== SHN_UNDEF
)
4194 sec
= bfd_und_section_ptr
;
4195 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4197 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4202 else if (sym
.st_shndx
== SHN_ABS
)
4203 sec
= bfd_abs_section_ptr
;
4204 else if (sym
.st_shndx
== SHN_COMMON
)
4206 sec
= bfd_com_section_ptr
;
4207 /* What ELF calls the size we call the value. What ELF
4208 calls the value we call the alignment. */
4209 value
= sym
.st_size
;
4213 /* Leave it up to the processor backend. */
4216 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4217 if (name
== (const char *) NULL
)
4220 if (add_symbol_hook
)
4222 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4226 /* The hook function sets the name to NULL if this symbol
4227 should be skipped for some reason. */
4228 if (name
== (const char *) NULL
)
4232 /* Sanity check that all possibilities were handled. */
4233 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4235 bfd_set_error (bfd_error_bad_value
);
4239 if (bfd_is_und_section (sec
)
4240 || bfd_is_com_section (sec
))
4245 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4247 /* We need to look up the symbol now in order to get some of
4248 the dynamic object handling right. We pass the hash
4249 table entry in to _bfd_generic_link_add_one_symbol so
4250 that it does not have to look it up again. */
4251 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4252 true, false, false);
4257 /* If we are looking at a dynamic object, and this is a
4258 definition, we need to see if it has already been defined
4259 by some other object. If it has, we want to use the
4260 existing definition, and we do not want to report a
4261 multiple symbol definition error; we do this by
4262 clobbering sec to be bfd_und_section_ptr. */
4263 if (dynamic
&& definition
)
4265 if (h
->root
.type
== bfd_link_hash_defined
)
4266 sec
= bfd_und_section_ptr
;
4269 /* Similarly, if we are not looking at a dynamic object, and
4270 we have a definition, we want to override any definition
4271 we may have from a dynamic object. Symbols from regular
4272 files always take precedence over symbols from dynamic
4273 objects, even if they are defined after the dynamic
4274 object in the link. */
4277 && h
->root
.type
== bfd_link_hash_defined
4278 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4279 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4280 == bfd_target_elf_flavour
)
4281 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4284 /* Change the hash table entry to undefined, and let
4285 _bfd_generic_link_add_one_symbol do the right thing
4286 with the new definition. */
4287 h
->root
.type
= bfd_link_hash_undefined
;
4288 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4289 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4292 /* If this is a weak definition which we are going to use,
4293 and the symbol is currently undefined, record that the
4294 definition is weak. */
4296 && (flags
& BSF_WEAK
) != 0
4297 && ! bfd_is_und_section (sec
)
4298 && (h
->root
.type
== bfd_link_hash_new
4299 || h
->root
.type
== bfd_link_hash_undefined
4300 || h
->root
.type
== bfd_link_hash_weak
))
4301 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4304 if (! (_bfd_generic_link_add_one_symbol
4305 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4306 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4311 && (flags
& BSF_WEAK
) != 0
4312 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4313 && (*sym_hash
)->weakdef
== NULL
)
4315 /* Keep a list of all weak defined non function symbols from
4316 a dynamic object, using the weakdef field. Later in this
4317 function we will set the weakdef field to the correct
4318 value. We only put non-function symbols from dynamic
4319 objects on this list, because that happens to be the only
4320 time we need to know the normal symbol corresponding to a
4321 weak symbol, and the information is time consuming to
4322 figure out. If the weakdef field is not already NULL,
4323 then this symbol was already defined by some previous
4324 dynamic object, and we will be using that previous
4325 definition anyhow. */
4327 (*sym_hash
)->weakdef
= weaks
;
4331 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4337 /* Remember the symbol size, type and alignment. */
4338 if (sym
.st_size
!= 0)
4340 /* FIXME: We should probably somehow give a warning if
4341 the symbol size changes. */
4342 h
->size
= sym
.st_size
;
4344 if (sym
.st_shndx
== SHN_COMMON
4345 && sym
.st_value
> h
->align
)
4346 h
->align
= sym
.st_value
;
4347 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4349 /* FIXME: We should probably somehow give a warning if
4350 the symbol type changes. */
4351 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4354 /* Set a flag in the hash table entry indicating the type of
4355 reference or definition we just found. Keep a count of
4356 the number of dynamic symbols we find. A dynamic symbol
4357 is one which is referenced or defined by both a regular
4358 object and a shared object, or one which is referenced or
4359 defined by more than one shared object. */
4360 old_flags
= h
->elf_link_hash_flags
;
4365 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4367 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4368 if ((old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4369 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4375 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4377 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4378 if ((old_flags
& new_flag
) != 0)
4381 new_flag
= ELF_LINK_HASH_REF_DYNAMIC_MULTIPLE
;
4383 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC_MULTIPLE
;
4388 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4389 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4394 h
->elf_link_hash_flags
|= new_flag
;
4395 if (dynsym
&& h
->dynindx
== -1)
4397 if (! elf_link_record_dynamic_symbol (info
, h
))
4403 /* Now set the weakdefs field correctly for all the weak defined
4404 symbols we found. The only way to do this is to search all the
4405 symbols. Since we only need the information for non functions in
4406 dynamic objects, that's the only time we actually put anything on
4407 the list WEAKS. We need this information so that if a regular
4408 object refers to a symbol defined weakly in a dynamic object, the
4409 real symbol in the dynamic object is also put in the dynamic
4410 symbols; we also must arrange for both symbols to point to the
4411 same memory location. We could handle the general case of symbol
4412 aliasing, but a general symbol alias can only be generated in
4413 assembler code, handling it correctly would be very time
4414 consuming, and other ELF linkers don't handle general aliasing
4416 while (weaks
!= NULL
)
4418 struct elf_link_hash_entry
*hlook
;
4421 struct elf_link_hash_entry
**hpp
;
4422 struct elf_link_hash_entry
**hppend
;
4425 weaks
= hlook
->weakdef
;
4426 hlook
->weakdef
= NULL
;
4428 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4429 slook
= hlook
->root
.u
.def
.section
;
4430 vlook
= hlook
->root
.u
.def
.value
;
4432 hpp
= elf_sym_hashes (abfd
);
4433 hppend
= hpp
+ extsymcount
;
4434 for (; hpp
< hppend
; hpp
++)
4436 struct elf_link_hash_entry
*h
;
4440 && h
->root
.type
== bfd_link_hash_defined
4441 && h
->root
.u
.def
.section
== slook
4442 && h
->root
.u
.def
.value
== vlook
)
4446 /* If the weak definition is in the list of dynamic
4447 symbols, make sure the real definition is put there
4449 if (hlook
->dynindx
!= -1
4450 && h
->dynindx
== -1)
4452 if (! elf_link_record_dynamic_symbol (info
, h
))
4474 /* Create some sections which will be filled in with dynamic linking
4475 information. The ABFD argument is an input file which is a dynamic
4476 object. The dynamic sections take up virtual memory space when the
4477 final executable is run, so we need to create them before addresses
4478 are assigned to the output sections. We work out the actual
4479 contents and size of these sections later. */
4482 elf_link_create_dynamic_sections (abfd
, info
)
4484 struct bfd_link_info
*info
;
4487 register asection
*s
;
4488 struct elf_link_hash_entry
*h
;
4489 struct elf_backend_data
*bed
;
4491 /* Note that we set the SEC_IN_MEMORY flag for all of these
4493 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4495 /* A dynamically linked executable has a .interp section, but a
4496 shared library does not. */
4499 s
= bfd_make_section (abfd
, ".interp");
4501 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4505 s
= bfd_make_section (abfd
, ".dynamic");
4507 || ! bfd_set_section_flags (abfd
, s
, flags
)
4508 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4511 /* The special symbol _DYNAMIC is always set to the start of the
4512 .dynamic section. This call occurs before we have processed the
4513 symbols for any dynamic object, so we don't have to worry about
4514 overriding a dynamic definition. We could set _DYNAMIC in a
4515 linker script, but we only want to define it if we are, in fact,
4516 creating a .dynamic section. We don't want to define it if there
4517 is no .dynamic section, since on some ELF platforms the start up
4518 code examines it to decide how to initialize the process. */
4520 if (! (_bfd_generic_link_add_one_symbol
4521 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4522 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4523 (struct bfd_link_hash_entry
**) &h
)))
4525 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4527 s
= bfd_make_section (abfd
, ".dynsym");
4529 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4530 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4533 /* The first .dynsym symbol is a dummy. */
4534 elf_hash_table (info
)->dynsymcount
= 1;
4536 s
= bfd_make_section (abfd
, ".dynstr");
4538 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4541 /* Create a strtab to hold the dynamic symbol names. */
4542 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4543 if (elf_hash_table (info
)->dynstr
== NULL
)
4546 s
= bfd_make_section (abfd
, ".hash");
4548 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4549 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4552 /* Let the backend create the rest of the sections. This lets the
4553 backend set the right flags. The backend will normally create
4554 the .got and .plt sections. */
4555 bed
= get_elf_backend_data (abfd
);
4556 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4559 /* Add an entry to the .dynamic table. */
4562 elf_add_dynamic_entry (info
, tag
, val
)
4563 struct bfd_link_info
*info
;
4567 Elf_Internal_Dyn dyn
;
4571 bfd_byte
*newcontents
;
4573 dynobj
= elf_hash_table (info
)->dynobj
;
4575 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4576 BFD_ASSERT (s
!= NULL
);
4578 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4579 if (s
->contents
== NULL
)
4580 newcontents
= (bfd_byte
*) malloc (newsize
);
4582 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4583 if (newcontents
== NULL
)
4585 bfd_set_error (bfd_error_no_memory
);
4590 dyn
.d_un
.d_val
= val
;
4591 elf_swap_dyn_out (dynobj
, &dyn
,
4592 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4594 s
->_raw_size
= newsize
;
4595 s
->contents
= newcontents
;
4600 /* Record an assignment to a symbol made by a linker script. We need
4601 this in case some dynamic object refers to this symbol. */
4605 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4607 struct bfd_link_info
*info
;
4610 struct elf_link_hash_entry
*h
;
4612 /* This is called after we have examined all the input objects. If
4613 the symbol does not exist, it merely means that no object refers
4614 to it, and we can just ignore it at this point. */
4615 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4616 false, false, false);
4620 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4622 if ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4623 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4624 && h
->dynindx
== -1)
4626 if (! elf_link_record_dynamic_symbol (info
, h
))
4629 /* If this is a weak defined symbol, and we know a corresponding
4630 real symbol from the same dynamic object, make sure the real
4631 symbol is also made into a dynamic symbol. */
4632 if (h
->weakdef
!= NULL
4633 && h
->weakdef
->dynindx
== -1)
4635 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4643 /* Array used to determine the number of hash table buckets to use
4644 based on the number of symbols there are. If there are fewer than
4645 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4646 fewer than 37 we use 17 buckets, and so forth. We never use more
4647 than 521 buckets. */
4649 static const size_t elf_buckets
[] =
4651 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4654 /* Set up the sizes and contents of the ELF dynamic sections. This is
4655 called by the ELF linker emulation before_allocation routine. We
4656 must set the sizes of the sections before the linker sets the
4657 addresses of the various sections. */
4660 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, info
, sinterpptr
)
4662 struct bfd_link_info
*info
;
4663 asection
**sinterpptr
;
4668 Elf_Internal_Sym isym
;
4671 struct elf_backend_data
*bed
;
4675 dynobj
= elf_hash_table (info
)->dynobj
;
4676 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4678 /* If there were no dynamic objects in the link, there is nothing to
4683 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4684 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4686 /* Set the size of the .dynsym and .hash sections. We counted the
4687 number of dynamic symbols in elf_link_add_object_symbols. We
4688 will build the contents of .dynsym and .hash when we build the
4689 final symbol table, because until then we do not know the correct
4690 value to give the symbols. We built the .dynstr section as we
4691 went along in elf_link_add_object_symbols. */
4692 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4693 BFD_ASSERT (s
!= NULL
);
4694 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4695 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4696 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4698 bfd_set_error (bfd_error_no_memory
);
4702 /* The first entry in .dynsym is a dummy symbol. */
4709 elf_swap_symbol_out (output_bfd
, &isym
,
4710 (Elf_External_Sym
*) s
->contents
);
4712 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4714 bucketcount
= elf_buckets
[i
];
4715 if (dynsymcount
< elf_buckets
[i
+ 1])
4719 s
= bfd_get_section_by_name (dynobj
, ".hash");
4720 BFD_ASSERT (s
!= NULL
);
4721 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4722 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4723 if (s
->contents
== NULL
)
4725 bfd_set_error (bfd_error_no_memory
);
4728 memset (s
->contents
, 0, s
->_raw_size
);
4730 put_word (output_bfd
, bucketcount
, s
->contents
);
4731 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4733 elf_hash_table (info
)->bucketcount
= bucketcount
;
4735 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4736 BFD_ASSERT (s
!= NULL
);
4737 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4738 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4740 /* Find all symbols which were defined in a dynamic object and make
4741 the backend pick a reasonable value for them. */
4742 elf_link_hash_traverse (elf_hash_table (info
),
4743 elf_adjust_dynamic_symbol
,
4746 /* Add some entries to the .dynamic section. We fill in some of the
4747 values later, in elf_bfd_final_link, but we must add the entries
4748 now so that we know the final size of the .dynamic section. */
4749 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4751 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4754 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4756 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4759 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4760 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4761 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4762 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4763 elf_hash_table (info
)->dynstr
->length
)
4764 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4765 sizeof (Elf_External_Sym
)))
4768 /* The backend must work out the sizes of all the other dynamic
4770 bed
= get_elf_backend_data (output_bfd
);
4771 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4774 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4777 /* Make the backend pick a good value for a dynamic symbol. This is
4778 called via elf_link_hash_traverse, and also calls itself
4782 elf_adjust_dynamic_symbol (h
, data
)
4783 struct elf_link_hash_entry
*h
;
4786 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4788 struct elf_backend_data
*bed
;
4790 /* If this symbol is not defined by a dynamic object, or is not
4791 referenced by a regular object, ignore it. FIXME: Do we need to
4792 worry about symbols which are defined by one dynamic object and
4793 referenced by another one? */
4794 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4795 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4796 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4799 /* If we've already adjusted this symbol, don't do it again. This
4800 can happen via a recursive call. */
4801 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4804 /* Don't look at this symbol again. Note that we must set this
4805 after checking the above conditions, because we may look at a
4806 symbol once, decide not to do anything, and then get called
4807 recursively later after REF_REGULAR is set below. */
4808 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4810 /* If this is a weak definition, and we know a real definition, and
4811 the real symbol is not itself defined by a regular object file,
4812 then get a good value for the real definition. We handle the
4813 real symbol first, for the convenience of the backend routine.
4815 Note that there is a confusing case here. If the real definition
4816 is defined by a regular object file, we don't get the real symbol
4817 from the dynamic object, but we do get the weak symbol. If the
4818 processor backend uses a COPY reloc, then if some routine in the
4819 dynamic object changes the real symbol, we will not see that
4820 change in the corresponding weak symbol. This is the way other
4821 ELF linkers work as well, and seems to be a result of the shared
4824 I will clarify this issue. Most SVR4 shared libraries define the
4825 variable _timezone and define timezone as a weak synonym. The
4826 tzset call changes _timezone. If you write
4827 extern int timezone;
4829 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4830 you might expect that, since timezone is a synonym for _timezone,
4831 the same number will print both times. However, if the processor
4832 backend uses a COPY reloc, then actually timezone will be copied
4833 into your process image, and, since you define _timezone
4834 yourself, _timezone will not. Thus timezone and _timezone will
4835 wind up at different memory locations. The tzset call will set
4836 _timezone, leaving timezone unchanged. */
4838 if (h
->weakdef
!= NULL
)
4840 struct elf_link_hash_entry
*weakdef
;
4842 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4843 weakdef
= h
->weakdef
;
4844 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4845 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4846 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4847 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4849 /* This symbol is defined or referenced by a regular object
4850 file, so we will not do anything special. Clear weakdef
4851 for the convenience of the processor backend. */
4856 /* There is an implicit reference by a regular object file
4857 via the weak symbol. */
4858 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
4859 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
4864 dynobj
= elf_hash_table (info
)->dynobj
;
4865 bed
= get_elf_backend_data (dynobj
);
4866 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
4868 /* FIXME: No way to return error. */
4875 /* Final phase of ELF linker. */
4877 /* A structure we use to avoid passing large numbers of arguments. */
4879 struct elf_final_link_info
4881 /* General link information. */
4882 struct bfd_link_info
*info
;
4885 /* Symbol string table. */
4886 struct strtab
*symstrtab
;
4887 /* .dynsym section. */
4888 asection
*dynsym_sec
;
4889 /* .hash section. */
4891 /* Buffer large enough to hold contents of any section. */
4893 /* Buffer large enough to hold external relocs of any section. */
4894 PTR external_relocs
;
4895 /* Buffer large enough to hold internal relocs of any section. */
4896 Elf_Internal_Rela
*internal_relocs
;
4897 /* Buffer large enough to hold external local symbols of any input
4899 Elf_External_Sym
*external_syms
;
4900 /* Buffer large enough to hold internal local symbols of any input
4902 Elf_Internal_Sym
*internal_syms
;
4903 /* Array large enough to hold a symbol index for each local symbol
4904 of any input BFD. */
4906 /* Array large enough to hold a section pointer for each local
4907 symbol of any input BFD. */
4908 asection
**sections
;
4909 /* Buffer to hold swapped out symbols. */
4910 Elf_External_Sym
*symbuf
;
4911 /* Number of swapped out symbols in buffer. */
4912 size_t symbuf_count
;
4913 /* Number of symbols which fit in symbuf. */
4917 static boolean elf_link_output_sym
4918 PARAMS ((struct elf_final_link_info
*, const char *,
4919 Elf_Internal_Sym
*, asection
*));
4920 static boolean elf_link_flush_output_syms
4921 PARAMS ((struct elf_final_link_info
*));
4922 static boolean elf_link_output_extsym
4923 PARAMS ((struct elf_link_hash_entry
*, PTR
));
4924 static boolean elf_link_input_bfd
4925 PARAMS ((struct elf_final_link_info
*, bfd
*));
4926 static boolean elf_reloc_link_order
4927 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4928 struct bfd_link_order
*));
4930 /* Do the final step of an ELF link. */
4933 elf_bfd_final_link (abfd
, info
)
4935 struct bfd_link_info
*info
;
4938 struct elf_final_link_info finfo
;
4939 register asection
*o
;
4940 register struct bfd_link_order
*p
;
4942 size_t max_contents_size
;
4943 size_t max_external_reloc_size
;
4944 size_t max_internal_reloc_count
;
4945 size_t max_sym_count
;
4947 Elf_Internal_Sym elfsym
;
4949 Elf_Internal_Shdr
*symtab_hdr
;
4950 Elf_Internal_Shdr
*symstrtab_hdr
;
4951 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4956 "Generating ELF shared libraries is not yet supported\n");
4957 bfd_set_error (bfd_error_invalid_operation
);
4961 dynobj
= elf_hash_table (info
)->dynobj
;
4964 finfo
.output_bfd
= abfd
;
4965 finfo
.symstrtab
= bfd_new_strtab (abfd
);
4966 if (finfo
.symstrtab
== NULL
)
4970 finfo
.dynsym_sec
= NULL
;
4971 finfo
.hash_sec
= NULL
;
4975 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
4976 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
4977 if (finfo
.dynsym_sec
== NULL
4978 || finfo
.hash_sec
== NULL
)
4981 finfo
.contents
= NULL
;
4982 finfo
.external_relocs
= NULL
;
4983 finfo
.internal_relocs
= NULL
;
4984 finfo
.external_syms
= NULL
;
4985 finfo
.internal_syms
= NULL
;
4986 finfo
.indices
= NULL
;
4987 finfo
.sections
= NULL
;
4988 finfo
.symbuf
= NULL
;
4989 finfo
.symbuf_count
= 0;
4991 /* Count up the number of relocations we will output for each output
4992 section, so that we know the sizes of the reloc sections. We
4993 also figure out some maximum sizes. */
4994 max_contents_size
= 0;
4995 max_external_reloc_size
= 0;
4996 max_internal_reloc_count
= 0;
4998 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5002 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5004 if (p
->type
== bfd_section_reloc_link_order
5005 || p
->type
== bfd_symbol_reloc_link_order
)
5007 else if (p
->type
== bfd_indirect_link_order
)
5011 sec
= p
->u
.indirect
.section
;
5013 if (info
->relocateable
)
5014 o
->reloc_count
+= sec
->reloc_count
;
5016 if (sec
->_raw_size
> max_contents_size
)
5017 max_contents_size
= sec
->_raw_size
;
5018 if (sec
->_cooked_size
> max_contents_size
)
5019 max_contents_size
= sec
->_cooked_size
;
5021 /* We are interested in just local symbols, not all
5023 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5027 if (elf_bad_symtab (sec
->owner
))
5028 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5029 / sizeof (Elf_External_Sym
));
5031 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5033 if (sym_count
> max_sym_count
)
5034 max_sym_count
= sym_count
;
5036 if ((sec
->flags
& SEC_RELOC
) != 0)
5040 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5041 if (ext_size
> max_external_reloc_size
)
5042 max_external_reloc_size
= ext_size
;
5043 if (sec
->reloc_count
> max_internal_reloc_count
)
5044 max_internal_reloc_count
= sec
->reloc_count
;
5050 if (o
->reloc_count
> 0)
5051 o
->flags
|= SEC_RELOC
;
5054 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5055 set it (this is probably a bug) and if it is set
5056 assign_section_numbers will create a reloc section. */
5057 o
->flags
&=~ SEC_RELOC
;
5061 /* Figure out the file positions for everything but the symbol table
5062 and the relocs. We set symcount to force assign_section_numbers
5063 to create a symbol table. */
5064 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5065 BFD_ASSERT (! abfd
->output_has_begun
);
5066 if (! elf_compute_section_file_positions (abfd
, info
))
5069 /* That created the reloc sections. Set their sizes, and assign
5070 them file positions, and allocate some buffers. */
5071 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5073 if ((o
->flags
& SEC_RELOC
) != 0)
5075 Elf_Internal_Shdr
*rel_hdr
;
5076 register struct elf_link_hash_entry
**p
, **pend
;
5078 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5080 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5082 /* The contents field must last into write_object_contents,
5083 so we allocate it with bfd_alloc rather than malloc. */
5084 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5085 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5087 bfd_set_error (bfd_error_no_memory
);
5091 p
= ((struct elf_link_hash_entry
**)
5092 malloc (o
->reloc_count
5093 * sizeof (struct elf_link_hash_entry
*)));
5094 if (p
== NULL
&& o
->reloc_count
!= 0)
5096 bfd_set_error (bfd_error_no_memory
);
5099 elf_section_data (o
)->rel_hashes
= p
;
5100 pend
= p
+ o
->reloc_count
;
5101 for (; p
< pend
; p
++)
5104 /* Use the reloc_count field as an index when outputting the
5110 assign_file_positions_for_relocs (abfd
);
5112 /* We have now assigned file positions for all the sections except
5113 .symtab and .strtab. We start the .symtab section at the current
5114 file position, and write directly to it. We build the .strtab
5115 section in memory. When we add .dynsym support, we will build
5116 that in memory as well (.dynsym is smaller than .symtab). */
5118 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5119 /* sh_name is set in prep_headers. */
5120 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5121 symtab_hdr
->sh_flags
= 0;
5122 symtab_hdr
->sh_addr
= 0;
5123 symtab_hdr
->sh_size
= 0;
5124 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5125 /* sh_link is set in assign_section_numbers. */
5126 /* sh_info is set below. */
5127 /* sh_offset is set just below. */
5128 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5130 off
= elf_tdata (abfd
)->next_file_pos
;
5131 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5133 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5134 incorrect. We do not yet know the size of the .symtab section.
5135 We correct next_file_pos below, after we do know the size. */
5137 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5138 continuously seeking to the right position in the file. */
5139 if (! info
->keep_memory
|| max_sym_count
< 20)
5140 finfo
.symbuf_size
= 20;
5142 finfo
.symbuf_size
= max_sym_count
;
5143 finfo
.symbuf
= ((Elf_External_Sym
*)
5144 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5145 if (finfo
.symbuf
== NULL
)
5147 bfd_set_error (bfd_error_no_memory
);
5151 /* Start writing out the symbol table. The first symbol is always a
5153 elfsym
.st_value
= 0;
5156 elfsym
.st_other
= 0;
5157 elfsym
.st_shndx
= SHN_UNDEF
;
5158 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5159 &elfsym
, bfd_und_section_ptr
))
5163 /* Some standard ELF linkers do this, but we don't because it causes
5164 bootstrap comparison failures. */
5165 /* Output a file symbol for the output file as the second symbol.
5166 We output this even if we are discarding local symbols, although
5167 I'm not sure if this is correct. */
5168 elfsym
.st_value
= 0;
5170 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5171 elfsym
.st_other
= 0;
5172 elfsym
.st_shndx
= SHN_ABS
;
5173 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5174 &elfsym
, bfd_abs_section_ptr
))
5178 /* Output a symbol for each section. We output these even if we are
5179 discarding local symbols, since they are used for relocs. These
5180 symbols have no names. We store the index of each one in the
5181 index field of the section, so that we can find it again when
5182 outputting relocs. */
5183 elfsym
.st_value
= 0;
5185 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5186 elfsym
.st_other
= 0;
5187 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5189 o
= section_from_elf_index (abfd
, i
);
5190 if (! bfd_is_abs_section (o
))
5191 o
->target_index
= abfd
->symcount
;
5192 elfsym
.st_shndx
= i
;
5193 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5198 /* Allocate some memory to hold information read in from the input
5200 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5201 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5202 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5203 malloc (max_internal_reloc_count
5204 * sizeof (Elf_Internal_Rela
)));
5205 finfo
.external_syms
= ((Elf_External_Sym
*)
5206 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5207 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5208 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5209 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5210 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5211 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5212 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5213 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5214 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5215 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5216 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5217 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5219 bfd_set_error (bfd_error_no_memory
);
5223 /* Since ELF permits relocations to be against local symbols, we
5224 must have the local symbols available when we do the relocations.
5225 Since we would rather only read the local symbols once, and we
5226 would rather not keep them in memory, we handle all the
5227 relocations for a single input file at the same time.
5229 Unfortunately, there is no way to know the total number of local
5230 symbols until we have seen all of them, and the local symbol
5231 indices precede the global symbol indices. This means that when
5232 we are generating relocateable output, and we see a reloc against
5233 a global symbol, we can not know the symbol index until we have
5234 finished examining all the local symbols to see which ones we are
5235 going to output. To deal with this, we keep the relocations in
5236 memory, and don't output them until the end of the link. This is
5237 an unfortunate waste of memory, but I don't see a good way around
5238 it. Fortunately, it only happens when performing a relocateable
5239 link, which is not the common case. FIXME: If keep_memory is set
5240 we could write the relocs out and then read them again; I don't
5241 know how bad the memory loss will be. */
5243 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5244 sub
->output_has_begun
= false;
5245 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5247 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5249 if (p
->type
== bfd_indirect_link_order
5250 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5251 == bfd_target_elf_flavour
))
5253 sub
= p
->u
.indirect
.section
->owner
;
5254 if (! sub
->output_has_begun
)
5256 if (! elf_link_input_bfd (&finfo
, sub
))
5258 sub
->output_has_begun
= true;
5261 else if (p
->type
== bfd_section_reloc_link_order
5262 || p
->type
== bfd_symbol_reloc_link_order
)
5264 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5269 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5275 /* That wrote out all the local symbols. Finish up the symbol table
5276 with the global symbols. */
5278 /* The sh_info field records the index of the first non local
5280 symtab_hdr
->sh_info
= abfd
->symcount
;
5282 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5284 /* We get the global symbols from the hash table. */
5285 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5288 /* Flush all symbols to the file. */
5289 if (! elf_link_flush_output_syms (&finfo
))
5292 /* Now we know the size of the symtab section. */
5293 off
+= symtab_hdr
->sh_size
;
5295 /* Finish up the symbol string table (.strtab) section. */
5296 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5297 /* sh_name was set in prep_headers. */
5298 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5299 symstrtab_hdr
->sh_flags
= 0;
5300 symstrtab_hdr
->sh_addr
= 0;
5301 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5302 symstrtab_hdr
->sh_entsize
= 0;
5303 symstrtab_hdr
->sh_link
= 0;
5304 symstrtab_hdr
->sh_info
= 0;
5305 /* sh_offset is set just below. */
5306 symstrtab_hdr
->sh_addralign
= 1;
5307 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5309 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5310 elf_tdata (abfd
)->next_file_pos
= off
;
5312 /* Adjust the relocs to have the correct symbol indices. */
5313 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5315 struct elf_link_hash_entry
**rel_hash
;
5316 Elf_Internal_Shdr
*rel_hdr
;
5318 if ((o
->flags
& SEC_RELOC
) == 0)
5321 rel_hash
= elf_section_data (o
)->rel_hashes
;
5322 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5323 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5325 if (*rel_hash
== NULL
)
5328 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5330 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5332 Elf_External_Rel
*erel
;
5333 Elf_Internal_Rel irel
;
5335 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5336 elf_swap_reloc_in (abfd
, erel
, &irel
);
5337 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5338 ELF_R_TYPE (irel
.r_info
));
5339 elf_swap_reloc_out (abfd
, &irel
, erel
);
5343 Elf_External_Rela
*erela
;
5344 Elf_Internal_Rela irela
;
5346 BFD_ASSERT (rel_hdr
->sh_entsize
5347 == sizeof (Elf_External_Rela
));
5349 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5350 elf_swap_reloca_in (abfd
, erela
, &irela
);
5351 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5352 ELF_R_TYPE (irela
.r_info
));
5353 elf_swap_reloca_out (abfd
, &irela
, erela
);
5357 /* Set the reloc_count field to 0 to prevent write_relocs from
5358 trying to swap the relocs out itself. */
5362 /* If we are linking against a dynamic object, finish up the dynamic
5363 linking information. */
5366 Elf_External_Dyn
*dyncon
, *dynconend
;
5368 /* Fix up .dynamic entries. */
5369 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5370 BFD_ASSERT (o
!= NULL
);
5372 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5373 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5374 for (; dyncon
< dynconend
; dyncon
++)
5376 Elf_Internal_Dyn dyn
;
5380 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5402 o
= bfd_get_section_by_name (abfd
, name
);
5403 BFD_ASSERT (o
!= NULL
);
5404 dyn
.d_un
.d_ptr
= o
->vma
;
5405 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5412 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5417 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5419 Elf_Internal_Shdr
*hdr
;
5421 hdr
= elf_elfsections (abfd
)[i
];
5422 if (hdr
->sh_type
== type
5423 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5425 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5426 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5429 if (dyn
.d_un
.d_val
== 0
5430 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5431 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5435 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5440 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5443 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5445 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5447 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5449 BFD_ASSERT (info
->shared
);
5452 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5453 o
->contents
, o
->output_offset
,
5459 /* Now backend stuff. */
5460 if (bed
->elf_backend_final_write_processing
)
5461 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5463 if (finfo
.contents
!= NULL
)
5464 free (finfo
.contents
);
5465 if (finfo
.external_relocs
!= NULL
)
5466 free (finfo
.external_relocs
);
5467 if (finfo
.internal_relocs
!= NULL
)
5468 free (finfo
.internal_relocs
);
5469 if (finfo
.external_syms
!= NULL
)
5470 free (finfo
.external_syms
);
5471 if (finfo
.internal_syms
!= NULL
)
5472 free (finfo
.internal_syms
);
5473 if (finfo
.indices
!= NULL
)
5474 free (finfo
.indices
);
5475 if (finfo
.sections
!= NULL
)
5476 free (finfo
.sections
);
5477 if (finfo
.symbuf
!= NULL
)
5478 free (finfo
.symbuf
);
5479 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5481 if ((o
->flags
& SEC_RELOC
) != 0
5482 && elf_section_data (o
)->rel_hashes
!= NULL
)
5483 free (elf_section_data (o
)->rel_hashes
);
5489 if (finfo
.contents
!= NULL
)
5490 free (finfo
.contents
);
5491 if (finfo
.external_relocs
!= NULL
)
5492 free (finfo
.external_relocs
);
5493 if (finfo
.internal_relocs
!= NULL
)
5494 free (finfo
.internal_relocs
);
5495 if (finfo
.external_syms
!= NULL
)
5496 free (finfo
.external_syms
);
5497 if (finfo
.internal_syms
!= NULL
)
5498 free (finfo
.internal_syms
);
5499 if (finfo
.indices
!= NULL
)
5500 free (finfo
.indices
);
5501 if (finfo
.sections
!= NULL
)
5502 free (finfo
.sections
);
5503 if (finfo
.symbuf
!= NULL
)
5504 free (finfo
.symbuf
);
5505 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5507 if ((o
->flags
& SEC_RELOC
) != 0
5508 && elf_section_data (o
)->rel_hashes
!= NULL
)
5509 free (elf_section_data (o
)->rel_hashes
);
5515 /* Add a symbol to the output symbol table. */
5518 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5519 struct elf_final_link_info
*finfo
;
5521 Elf_Internal_Sym
*elfsym
;
5522 asection
*input_sec
;
5524 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5525 struct bfd_link_info
*info
,
5530 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5531 elf_backend_link_output_symbol_hook
;
5532 if (output_symbol_hook
!= NULL
)
5534 if (! ((*output_symbol_hook
)
5535 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5539 if (name
== (const char *) NULL
|| *name
== '\0')
5540 elfsym
->st_name
= 0;
5543 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5544 finfo
->symstrtab
, name
);
5545 if (elfsym
->st_name
== (unsigned long) -1)
5549 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5551 if (! elf_link_flush_output_syms (finfo
))
5555 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5556 finfo
->symbuf
+ finfo
->symbuf_count
);
5557 ++finfo
->symbuf_count
;
5559 ++finfo
->output_bfd
->symcount
;
5564 /* Flush the output symbols to the file. */
5567 elf_link_flush_output_syms (finfo
)
5568 struct elf_final_link_info
*finfo
;
5570 Elf_Internal_Shdr
*symtab
;
5572 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5574 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5576 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5577 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5578 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5581 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5583 finfo
->symbuf_count
= 0;
5588 /* Add an external symbol to the symbol table. This is called from
5589 the hash table traversal routine. */
5592 elf_link_output_extsym (h
, data
)
5593 struct elf_link_hash_entry
*h
;
5596 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5598 Elf_Internal_Sym sym
;
5599 asection
*input_sec
;
5601 /* We don't want to output symbols that have never been mentioned by
5602 a regular file, or that we have been told to strip. However, if
5603 h->indx is set to -2, the symbol is used by a reloc and we must
5607 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5608 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5609 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5610 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5612 else if (finfo
->info
->strip
== strip_all
5613 || (finfo
->info
->strip
== strip_some
5614 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5615 h
->root
.root
.string
,
5616 false, false) == NULL
))
5621 /* If we're stripping it, and it's not a dynamic symbol, there's
5622 nothing else to do. */
5623 if (strip
&& h
->dynindx
== -1)
5627 sym
.st_size
= h
->size
;
5629 if (h
->root
.type
== bfd_link_hash_weak
5630 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5631 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5633 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5635 switch (h
->root
.type
)
5638 case bfd_link_hash_new
:
5642 case bfd_link_hash_undefined
:
5643 input_sec
= bfd_und_section_ptr
;
5644 sym
.st_shndx
= SHN_UNDEF
;
5647 case bfd_link_hash_weak
:
5648 input_sec
= bfd_und_section_ptr
;
5649 sym
.st_shndx
= SHN_UNDEF
;
5652 case bfd_link_hash_defined
:
5655 input_sec
= h
->root
.u
.def
.section
;
5656 if (input_sec
->output_section
!= NULL
)
5658 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5659 input_sec
->output_section
);
5660 if (sym
.st_shndx
== (unsigned short) -1)
5662 /* FIXME: No way to handle errors. */
5666 /* ELF symbols in relocateable files are section relative,
5667 but in nonrelocateable files they are virtual
5669 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5670 if (! finfo
->info
->relocateable
)
5671 sym
.st_value
+= input_sec
->output_section
->vma
;
5675 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5676 == bfd_target_elf_flavour
5677 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5678 sym
.st_shndx
= SHN_UNDEF
;
5679 input_sec
= bfd_und_section_ptr
;
5684 case bfd_link_hash_common
:
5685 input_sec
= bfd_com_section_ptr
;
5686 sym
.st_shndx
= SHN_COMMON
;
5690 sym
.st_value
= h
->align
;
5693 case bfd_link_hash_indirect
:
5694 case bfd_link_hash_warning
:
5695 /* I have no idea how these should be handled. */
5699 /* If this symbol should be put in the .dynsym section, then put it
5700 there now. We have already know the symbol index. We also fill
5701 in the entry in the .hash section. */
5702 if (h
->dynindx
!= -1)
5704 struct elf_backend_data
*bed
;
5707 bfd_byte
*bucketpos
;
5710 sym
.st_name
= h
->dynstr_index
;
5712 /* Give the processor backend a chance to tweak the symbol
5713 value, and also to finish up anything that needs to be done
5715 bed
= get_elf_backend_data (finfo
->output_bfd
);
5716 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5717 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5719 /* FIXME: No way to return error. */
5723 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5724 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5727 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5728 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5729 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5730 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5731 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5732 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5733 put_word (finfo
->output_bfd
, chain
,
5734 ((bfd_byte
*) finfo
->hash_sec
->contents
5735 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5738 /* If we're stripping it, then it was just a dynamic symbol, and
5739 there's nothing else to do. */
5743 h
->indx
= finfo
->output_bfd
->symcount
;
5745 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5747 /* FIXME: No way to return error. */
5754 /* Link an input file into the linker output file. This function
5755 handles all the sections and relocations of the input file at once.
5756 This is so that we only have to read the local symbols once, and
5757 don't have to keep them in memory. */
5760 elf_link_input_bfd (finfo
, input_bfd
)
5761 struct elf_final_link_info
*finfo
;
5764 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5765 bfd
*, asection
*, bfd_byte
*,
5766 Elf_Internal_Rela
*,
5768 asection
**, char *));
5770 Elf_Internal_Shdr
*symtab_hdr
;
5773 Elf_External_Sym
*esym
;
5774 Elf_External_Sym
*esymend
;
5775 Elf_Internal_Sym
*isym
;
5777 asection
**ppsection
;
5780 output_bfd
= finfo
->output_bfd
;
5782 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5784 /* If this is a dynamic object, we don't want to do anything here:
5785 we don't want the local symbols, and we don't want the section
5787 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5790 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5791 if (elf_bad_symtab (input_bfd
))
5793 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5798 locsymcount
= symtab_hdr
->sh_info
;
5799 extsymoff
= symtab_hdr
->sh_info
;
5802 /* Read the local symbols. */
5804 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5805 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5806 locsymcount
, input_bfd
)
5807 != locsymcount
* sizeof (Elf_External_Sym
))))
5810 /* Swap in the local symbols and write out the ones which we know
5811 are going into the output file. */
5812 esym
= finfo
->external_syms
;
5813 esymend
= esym
+ locsymcount
;
5814 isym
= finfo
->internal_syms
;
5815 pindex
= finfo
->indices
;
5816 ppsection
= finfo
->sections
;
5817 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5823 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5826 if (elf_bad_symtab (input_bfd
))
5828 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5835 if (isym
->st_shndx
== SHN_UNDEF
)
5836 isec
= bfd_und_section_ptr
;
5837 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5839 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5843 else if (isym
->st_shndx
== SHN_ABS
)
5844 isec
= bfd_abs_section_ptr
;
5845 else if (isym
->st_shndx
== SHN_COMMON
)
5846 isec
= bfd_com_section_ptr
;
5855 /* Don't output the first, undefined, symbol. */
5856 if (esym
== finfo
->external_syms
)
5859 /* If we are stripping all symbols, we don't want to output this
5861 if (finfo
->info
->strip
== strip_all
)
5864 /* We never output section symbols. Instead, we use the section
5865 symbol of the corresponding section in the output file. */
5866 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5869 /* If we are discarding all local symbols, we don't want to
5870 output this one. If we are generating a relocateable output
5871 file, then some of the local symbols may be required by
5872 relocs; we output them below as we discover that they are
5874 if (finfo
->info
->discard
== discard_all
)
5877 /* Get the name of the symbol. */
5878 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5883 /* See if we are discarding symbols with this name. */
5884 if ((finfo
->info
->strip
== strip_some
5885 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5887 || (finfo
->info
->discard
== discard_l
5888 && strncmp (name
, finfo
->info
->lprefix
,
5889 finfo
->info
->lprefix_len
) == 0))
5892 /* If we get here, we are going to output this symbol. */
5894 /* Adjust the section index for the output file. */
5895 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
5896 isec
->output_section
);
5897 if (isym
->st_shndx
== (unsigned short) -1)
5900 *pindex
= output_bfd
->symcount
;
5902 /* ELF symbols in relocateable files are section relative, but
5903 in executable files they are virtual addresses. Note that
5904 this code assumes that all ELF sections have an associated
5905 BFD section with a reasonable value for output_offset; below
5906 we assume that they also have a reasonable value for
5907 output_section. Any special sections must be set up to meet
5908 these requirements. */
5909 oldval
= isym
->st_value
;
5910 isym
->st_value
+= isec
->output_offset
;
5911 if (! finfo
->info
->relocateable
)
5912 isym
->st_value
+= isec
->output_section
->vma
;
5914 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
5917 /* Restore the old value for reloc handling. */
5918 isym
->st_value
= oldval
;
5921 /* Relocate the contents of each section. */
5922 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5924 Elf_Internal_Shdr
*input_rel_hdr
;
5926 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5929 if ((o
->flags
& SEC_IN_MEMORY
) != 0
5930 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
5932 /* Section was created by elf_link_create_dynamic_sections.
5933 FIXME: This test is fragile. */
5937 /* Read the contents of the section. */
5938 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5939 (file_ptr
) 0, o
->_raw_size
))
5942 if ((o
->flags
& SEC_RELOC
) != 0)
5944 PTR external_relocs
;
5946 /* Get the external relocs. They may have been cached. */
5947 external_relocs
= elf_section_data (o
)->relocs
;
5948 if (external_relocs
== NULL
)
5950 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5951 if ((bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
)
5953 || (bfd_read (finfo
->external_relocs
, 1,
5954 input_rel_hdr
->sh_size
, input_bfd
)
5955 != input_rel_hdr
->sh_size
))
5957 external_relocs
= finfo
->external_relocs
;
5960 /* Swap in the relocs. For convenience, we always produce
5961 an Elf_Internal_Rela array; if the relocs are Rel, we set
5963 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5965 Elf_External_Rel
*erel
;
5966 Elf_External_Rel
*erelend
;
5967 Elf_Internal_Rela
*irela
;
5969 erel
= (Elf_External_Rel
*) external_relocs
;
5970 erelend
= erel
+ o
->reloc_count
;
5971 irela
= finfo
->internal_relocs
;
5972 for (; erel
< erelend
; erel
++, irela
++)
5974 Elf_Internal_Rel irel
;
5976 elf_swap_reloc_in (input_bfd
, erel
, &irel
);
5977 irela
->r_offset
= irel
.r_offset
;
5978 irela
->r_info
= irel
.r_info
;
5979 irela
->r_addend
= 0;
5984 Elf_External_Rela
*erela
;
5985 Elf_External_Rela
*erelaend
;
5986 Elf_Internal_Rela
*irela
;
5988 BFD_ASSERT (input_rel_hdr
->sh_entsize
5989 == sizeof (Elf_External_Rela
));
5991 erela
= (Elf_External_Rela
*) external_relocs
;
5992 erelaend
= erela
+ o
->reloc_count
;
5993 irela
= finfo
->internal_relocs
;
5994 for (; erela
< erelaend
; erela
++, irela
++)
5995 elf_swap_reloca_in (input_bfd
, erela
, irela
);
5998 /* Relocate the section by invoking a back end routine.
6000 The back end routine is responsible for adjusting the
6001 section contents as necessary, and (if using Rela relocs
6002 and generating a relocateable output file) adjusting the
6003 reloc addend as necessary.
6005 The back end routine does not have to worry about setting
6006 the reloc address or the reloc symbol index.
6008 The back end routine is given a pointer to the swapped in
6009 internal symbols, and can access the hash table entries
6010 for the external symbols via elf_sym_hashes (input_bfd).
6012 When generating relocateable output, the back end routine
6013 must handle STB_LOCAL/STT_SECTION symbols specially. The
6014 output symbol is going to be a section symbol
6015 corresponding to the output section, which will require
6016 the addend to be adjusted. */
6018 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6021 finfo
->internal_relocs
,
6022 finfo
->internal_syms
,
6024 finfo
->symstrtab
->tab
))
6027 if (finfo
->info
->relocateable
)
6029 Elf_Internal_Rela
*irela
;
6030 Elf_Internal_Rela
*irelaend
;
6031 struct elf_link_hash_entry
**rel_hash
;
6032 Elf_Internal_Shdr
*output_rel_hdr
;
6034 /* Adjust the reloc addresses and symbol indices. */
6036 irela
= finfo
->internal_relocs
;
6037 irelaend
= irela
+ o
->reloc_count
;
6038 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6039 + o
->output_section
->reloc_count
);
6040 for (; irela
< irelaend
; irela
++, rel_hash
++)
6043 Elf_Internal_Sym
*isym
;
6046 irela
->r_offset
+= o
->output_offset
;
6048 r_symndx
= ELF_R_SYM (irela
->r_info
);
6053 if (r_symndx
>= locsymcount
6054 || (elf_bad_symtab (input_bfd
)
6055 && finfo
->sections
[r_symndx
] == NULL
))
6059 /* This is a reloc against a global symbol. We
6060 have not yet output all the local symbols, so
6061 we do not know the symbol index of any global
6062 symbol. We set the rel_hash entry for this
6063 reloc to point to the global hash table entry
6064 for this symbol. The symbol index is then
6065 set at the end of elf_bfd_final_link. */
6066 indx
= r_symndx
- extsymoff
;
6067 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6069 /* Setting the index to -2 tells
6070 elf_link_output_extsym that this symbol is
6072 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6073 (*rel_hash
)->indx
= -2;
6078 /* This is a reloc against a local symbol. */
6081 isym
= finfo
->internal_syms
+ r_symndx
;
6082 sec
= finfo
->sections
[r_symndx
];
6083 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6085 /* I suppose the backend ought to fill in the
6086 section of any STT_SECTION symbol against a
6087 processor specific section. */
6088 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6090 else if (sec
== NULL
|| sec
->owner
== NULL
)
6092 bfd_set_error (bfd_error_bad_value
);
6097 r_symndx
= sec
->output_section
->target_index
;
6104 if (finfo
->indices
[r_symndx
] == -1)
6110 if (finfo
->info
->strip
== strip_all
)
6112 /* You can't do ld -r -s. */
6113 bfd_set_error (bfd_error_invalid_operation
);
6117 /* This symbol was skipped earlier, but
6118 since it is needed by a reloc, we
6119 must output it now. */
6120 link
= symtab_hdr
->sh_link
;
6121 name
= elf_string_from_elf_section (input_bfd
,
6127 osec
= sec
->output_section
;
6129 elf_section_from_bfd_section (output_bfd
,
6131 if (isym
->st_shndx
== (unsigned short) -1)
6134 isym
->st_value
+= sec
->output_offset
;
6135 if (! finfo
->info
->relocateable
)
6136 isym
->st_value
+= osec
->vma
;
6138 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6140 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6144 r_symndx
= finfo
->indices
[r_symndx
];
6147 irela
->r_info
= ELF_R_INFO (r_symndx
,
6148 ELF_R_TYPE (irela
->r_info
));
6151 /* Swap out the relocs. */
6152 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6153 BFD_ASSERT (output_rel_hdr
->sh_entsize
6154 == input_rel_hdr
->sh_entsize
);
6155 irela
= finfo
->internal_relocs
;
6156 irelaend
= irela
+ o
->reloc_count
;
6157 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6159 Elf_External_Rel
*erel
;
6161 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6162 + o
->output_section
->reloc_count
);
6163 for (; irela
< irelaend
; irela
++, erel
++)
6165 Elf_Internal_Rel irel
;
6167 irel
.r_offset
= irela
->r_offset
;
6168 irel
.r_info
= irela
->r_info
;
6169 BFD_ASSERT (irela
->r_addend
== 0);
6170 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6175 Elf_External_Rela
*erela
;
6177 BFD_ASSERT (input_rel_hdr
->sh_entsize
6178 == sizeof (Elf_External_Rela
));
6179 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6180 + o
->output_section
->reloc_count
);
6181 for (; irela
< irelaend
; irela
++, erela
++)
6182 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6185 o
->output_section
->reloc_count
+= o
->reloc_count
;
6189 /* Write out the modified section contents. */
6190 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6191 finfo
->contents
, o
->output_offset
,
6192 (o
->_cooked_size
!= 0
6201 /* Generate a reloc when linking an ELF file. This is a reloc
6202 requested by the linker, and does come from any input file. This
6203 is used to build constructor and destructor tables when linking
6207 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6209 struct bfd_link_info
*info
;
6210 asection
*output_section
;
6211 struct bfd_link_order
*link_order
;
6213 const reloc_howto_type
*howto
;
6216 struct elf_link_hash_entry
**rel_hash_ptr
;
6217 Elf_Internal_Shdr
*rel_hdr
;
6219 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6222 bfd_set_error (bfd_error_bad_value
);
6226 /* If this is an inplace reloc, we must write the addend into the
6228 if (howto
->partial_inplace
6229 && link_order
->u
.reloc
.p
->addend
!= 0)
6232 bfd_reloc_status_type rstat
;
6236 size
= bfd_get_reloc_size (howto
);
6237 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6238 if (buf
== (bfd_byte
*) NULL
)
6240 bfd_set_error (bfd_error_no_memory
);
6243 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6244 link_order
->u
.reloc
.p
->addend
, buf
);
6250 case bfd_reloc_outofrange
:
6252 case bfd_reloc_overflow
:
6253 if (! ((*info
->callbacks
->reloc_overflow
)
6255 (link_order
->type
== bfd_section_reloc_link_order
6256 ? bfd_section_name (output_bfd
,
6257 link_order
->u
.reloc
.p
->u
.section
)
6258 : link_order
->u
.reloc
.p
->u
.name
),
6259 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6260 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6267 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6268 (file_ptr
) link_order
->offset
, size
);
6274 /* Figure out the symbol index. */
6275 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6276 + output_section
->reloc_count
);
6277 if (link_order
->type
== bfd_section_reloc_link_order
)
6279 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6282 *rel_hash_ptr
= NULL
;
6286 struct elf_link_hash_entry
*h
;
6288 h
= elf_link_hash_lookup (elf_hash_table (info
),
6289 link_order
->u
.reloc
.p
->u
.name
,
6290 false, false, true);
6293 /* Setting the index to -2 tells elf_link_output_extsym that
6294 this symbol is used by a reloc. */
6301 if (! ((*info
->callbacks
->unattached_reloc
)
6302 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6303 (asection
*) NULL
, (bfd_vma
) 0)))
6309 /* The address of a reloc is relative to the section in a
6310 relocateable file, and is a virtual address in an executable
6312 offset
= link_order
->offset
;
6313 if (! info
->relocateable
)
6314 offset
+= output_section
->vma
;
6316 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6318 if (rel_hdr
->sh_type
== SHT_REL
)
6320 Elf_Internal_Rel irel
;
6321 Elf_External_Rel
*erel
;
6323 irel
.r_offset
= offset
;
6324 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6325 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6326 + output_section
->reloc_count
);
6327 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6331 Elf_Internal_Rela irela
;
6332 Elf_External_Rela
*erela
;
6334 irela
.r_offset
= offset
;
6335 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6336 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6337 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6338 + output_section
->reloc_count
);
6339 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6342 ++output_section
->reloc_count
;