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 if (elf_dynsymtab (abfd
) == 0)
2892 bfd_set_error (bfd_error_invalid_operation
);
2896 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2897 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2903 elf_get_reloc_upper_bound (abfd
, asect
)
2907 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2910 /* Read in and swap the external relocs. */
2913 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2918 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
2919 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
2920 PTR allocated
= NULL
;
2921 bfd_byte
*native_relocs
;
2927 if (asect
->relocation
!= NULL
)
2930 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
2931 && (asect
->reloc_count
2932 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
2934 native_relocs
= (bfd_byte
*) elf_section_data (asect
)->relocs
;
2935 if (native_relocs
== NULL
)
2937 allocated
= (PTR
) malloc (d
->rel_hdr
.sh_size
);
2938 if (allocated
== NULL
)
2940 bfd_set_error (bfd_error_no_memory
);
2944 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
2945 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
2946 != d
->rel_hdr
.sh_size
))
2949 native_relocs
= (bfd_byte
*) allocated
;
2952 relents
= ((arelent
*)
2953 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
2954 if (relents
== NULL
)
2956 bfd_set_error (bfd_error_no_memory
);
2960 entsize
= d
->rel_hdr
.sh_entsize
;
2961 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
2962 || entsize
== sizeof (Elf_External_Rela
));
2964 for (i
= 0, relent
= relents
;
2965 i
< asect
->reloc_count
;
2966 i
++, relent
++, native_relocs
+= entsize
)
2968 Elf_Internal_Rela rela
;
2969 Elf_Internal_Rel rel
;
2971 if (entsize
== sizeof (Elf_External_Rela
))
2972 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
2975 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
2976 rela
.r_offset
= rel
.r_offset
;
2977 rela
.r_info
= rel
.r_info
;
2981 /* The address of an ELF reloc is section relative for an object
2982 file, and absolute for an executable file or shared library.
2983 The address of a BFD reloc is always section relative. */
2984 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2985 relent
->address
= rela
.r_offset
;
2987 relent
->address
= rela
.r_offset
- asect
->vma
;
2989 if (ELF_R_SYM (rela
.r_info
) == 0)
2990 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2995 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
2998 /* Canonicalize ELF section symbols. FIXME: Why? */
2999 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
3000 relent
->sym_ptr_ptr
= ps
;
3002 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3005 relent
->addend
= rela
.r_addend
;
3007 if (entsize
== sizeof (Elf_External_Rela
))
3008 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
3010 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
3013 asect
->relocation
= relents
;
3015 if (allocated
!= NULL
)
3021 if (allocated
!= NULL
)
3028 elf_debug_section (str
, num
, hdr
)
3031 Elf_Internal_Shdr
*hdr
;
3033 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3035 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3036 (long) hdr
->sh_name
,
3037 (long) hdr
->sh_type
,
3038 (long) hdr
->sh_flags
);
3040 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3041 (long) hdr
->sh_addr
,
3042 (long) hdr
->sh_offset
,
3043 (long) hdr
->sh_size
);
3045 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3046 (long) hdr
->sh_link
,
3047 (long) hdr
->sh_info
,
3048 (long) hdr
->sh_addralign
);
3049 fprintf (stderr
, "sh_entsize = %ld\n",
3050 (long) hdr
->sh_entsize
);
3051 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3052 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3053 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3058 elf_debug_file (ehdrp
)
3059 Elf_Internal_Ehdr
*ehdrp
;
3061 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3062 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3063 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3064 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3065 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3066 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3067 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3071 /* Canonicalize the relocs. */
3074 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3083 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3086 tblptr
= section
->relocation
;
3087 for (i
= 0; i
< section
->reloc_count
; i
++)
3088 *relptr
++ = tblptr
++;
3092 return section
->reloc_count
;
3096 elf_get_symtab (abfd
, alocation
)
3098 asymbol
**alocation
;
3100 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3103 bfd_get_symcount (abfd
) = symcount
;
3108 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3110 asymbol
**alocation
;
3112 return elf_slurp_symbol_table (abfd
, alocation
, true);
3116 elf_make_empty_symbol (abfd
)
3119 elf_symbol_type
*newsym
;
3121 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3124 bfd_set_error (bfd_error_no_memory
);
3129 newsym
->symbol
.the_bfd
= abfd
;
3130 return &newsym
->symbol
;
3135 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3140 bfd_symbol_info (symbol
, ret
);
3144 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3148 bfd_print_symbol_type how
;
3150 FILE *file
= (FILE *) filep
;
3153 case bfd_print_symbol_name
:
3154 fprintf (file
, "%s", symbol
->name
);
3156 case bfd_print_symbol_more
:
3157 fprintf (file
, "elf ");
3158 fprintf_vma (file
, symbol
->value
);
3159 fprintf (file
, " %lx", (long) symbol
->flags
);
3161 case bfd_print_symbol_all
:
3163 CONST
char *section_name
;
3164 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3165 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3166 fprintf (file
, " %s\t%s",
3176 elf_get_lineno (ignore_abfd
, symbol
)
3180 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3187 elf_set_arch_mach (abfd
, arch
, machine
)
3189 enum bfd_architecture arch
;
3190 unsigned long machine
;
3192 /* If this isn't the right architecture for this backend, and this
3193 isn't the generic backend, fail. */
3194 if (arch
!= get_elf_backend_data (abfd
)->arch
3195 && arch
!= bfd_arch_unknown
3196 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3199 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3203 elf_find_nearest_line (abfd
,
3214 CONST
char **filename_ptr
;
3215 CONST
char **functionname_ptr
;
3216 unsigned int *line_ptr
;
3222 elf_sizeof_headers (abfd
, reloc
)
3228 ret
= sizeof (Elf_External_Ehdr
);
3230 ret
+= get_program_header_size (abfd
);
3235 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3240 bfd_size_type count
;
3242 Elf_Internal_Shdr
*hdr
;
3244 if (! abfd
->output_has_begun
3245 && ! elf_compute_section_file_positions (abfd
,
3246 (struct bfd_link_info
*) NULL
))
3249 hdr
= &elf_section_data (section
)->this_hdr
;
3251 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3253 if (bfd_write (location
, 1, count
, abfd
) != count
)
3260 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3263 Elf_Internal_Rela
*dst
;
3265 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3271 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3274 Elf_Internal_Rel
*dst
;
3276 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3282 /* Core file support */
3284 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3285 #include <sys/procfs.h>
3287 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3288 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3289 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3295 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3302 prstatus_t
*status
= (prstatus_t
*) 0;
3304 if (descsz
== sizeof (prstatus_t
))
3306 newsect
= bfd_make_section (abfd
, ".reg");
3307 if (newsect
== NULL
)
3309 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3310 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3311 newsect
->flags
= SEC_HAS_CONTENTS
;
3312 newsect
->alignment_power
= 2;
3313 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3315 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3321 /* Stash a copy of the prpsinfo structure away for future use. */
3324 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3330 if (descsz
== sizeof (prpsinfo_t
))
3332 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3334 bfd_set_error (bfd_error_no_memory
);
3337 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3343 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3351 newsect
= bfd_make_section (abfd
, ".reg2");
3352 if (newsect
== NULL
)
3354 newsect
->_raw_size
= descsz
;
3355 newsect
->filepos
= filepos
;
3356 newsect
->flags
= SEC_HAS_CONTENTS
;
3357 newsect
->alignment_power
= 2;
3361 #endif /* HAVE_PROCFS */
3363 /* Return a pointer to the args (including the command name) that were
3364 seen by the program that generated the core dump. Note that for
3365 some reason, a spurious space is tacked onto the end of the args
3366 in some (at least one anyway) implementations, so strip it off if
3370 elf_core_file_failing_command (abfd
)
3374 if (core_prpsinfo (abfd
))
3376 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3377 char *scan
= p
->pr_psargs
;
3382 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3386 return p
->pr_psargs
;
3392 /* Return the number of the signal that caused the core dump. Presumably,
3393 since we have a core file, we got a signal of some kind, so don't bother
3394 checking the other process status fields, just return the signal number.
3398 elf_core_file_failing_signal (abfd
)
3402 if (core_prstatus (abfd
))
3404 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3410 /* Check to see if the core file could reasonably be expected to have
3411 come for the current executable file. Note that by default we return
3412 true unless we find something that indicates that there might be a
3417 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3426 /* First, xvecs must match since both are ELF files for the same target. */
3428 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3430 bfd_set_error (bfd_error_system_call
);
3436 /* If no prpsinfo, just return true. Otherwise, grab the last component
3437 of the exec'd pathname from the prpsinfo. */
3439 if (core_prpsinfo (core_bfd
))
3441 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3448 /* Find the last component of the executable pathname. */
3450 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3456 execname
= (char *) exec_bfd
->filename
;
3459 /* See if they match */
3461 return strcmp (execname
, corename
) ? false : true;
3467 #endif /* HAVE_PROCFS */
3470 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3471 the information that would normally be available from the /proc interface
3472 for the process, at the time the process dumped core. Currently this
3473 includes copies of the prstatus, prpsinfo, and fpregset structures.
3475 Since these structures are potentially machine dependent in size and
3476 ordering, bfd provides two levels of support for them. The first level,
3477 available on all machines since it does not require that the host
3478 have /proc support or the relevant include files, is to create a bfd
3479 section for each of the prstatus, prpsinfo, and fpregset structures,
3480 without any interpretation of their contents. With just this support,
3481 the bfd client will have to interpret the structures itself. Even with
3482 /proc support, it might want these full structures for it's own reasons.
3484 In the second level of support, where HAVE_PROCFS is defined, bfd will
3485 pick apart the structures to gather some additional information that
3486 clients may want, such as the general register set, the name of the
3487 exec'ed file and its arguments, the signal (if any) that caused the
3493 elf_corefile_note (abfd
, hdr
)
3495 Elf_Internal_Phdr
*hdr
;
3497 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3498 Elf_Internal_Note i_note
; /* Elf note, internal form */
3499 char *buf
= NULL
; /* Entire note segment contents */
3500 char *namedata
; /* Name portion of the note */
3501 char *descdata
; /* Descriptor portion of the note */
3502 char *sectname
; /* Name to use for new section */
3503 long filepos
; /* File offset to descriptor data */
3506 if (hdr
->p_filesz
> 0
3507 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3508 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3509 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3511 x_note_p
= (Elf_External_Note
*) buf
;
3512 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3514 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3515 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3516 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3517 namedata
= x_note_p
->name
;
3518 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3519 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3520 switch (i_note
.type
)
3523 /* process descdata as prstatus info */
3524 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3526 sectname
= ".prstatus";
3529 /* process descdata as fpregset info */
3530 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3532 sectname
= ".fpregset";
3535 /* process descdata as prpsinfo */
3536 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3538 sectname
= ".prpsinfo";
3541 /* Unknown descriptor, just ignore it. */
3545 if (sectname
!= NULL
)
3547 newsect
= bfd_make_section (abfd
, sectname
);
3548 if (newsect
== NULL
)
3550 newsect
->_raw_size
= i_note
.descsz
;
3551 newsect
->filepos
= filepos
;
3552 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3553 newsect
->alignment_power
= 2;
3555 x_note_p
= (Elf_External_Note
*)
3556 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3563 else if (hdr
->p_filesz
> 0)
3565 bfd_set_error (bfd_error_no_memory
);
3572 /* Core files are simply standard ELF formatted files that partition
3573 the file using the execution view of the file (program header table)
3574 rather than the linking view. In fact, there is no section header
3575 table in a core file.
3577 The process status information (including the contents of the general
3578 register set) and the floating point register set are stored in a
3579 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3580 that allow standard bfd access to the general registers (.reg) and the
3581 floating point registers (.reg2).
3586 elf_core_file_p (abfd
)
3589 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3590 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3591 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3592 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3593 unsigned int phindex
;
3594 struct elf_backend_data
*ebd
;
3596 /* Read in the ELF header in external format. */
3598 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3600 if (bfd_get_error () != bfd_error_system_call
)
3601 bfd_set_error (bfd_error_wrong_format
);
3605 /* Now check to see if we have a valid ELF file, and one that BFD can
3606 make use of. The magic number must match, the address size ('class')
3607 and byte-swapping must match our XVEC entry, and it must have a
3608 program header table (FIXME: See comments re segments at top of this
3611 if (elf_file_p (&x_ehdr
) == false)
3614 bfd_set_error (bfd_error_wrong_format
);
3618 /* FIXME, Check EI_VERSION here ! */
3622 int desired_address_size
= ELFCLASS32
;
3625 int desired_address_size
= ELFCLASS64
;
3628 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3632 /* Switch xvec to match the specified byte order. */
3633 switch (x_ehdr
.e_ident
[EI_DATA
])
3635 case ELFDATA2MSB
: /* Big-endian */
3636 if (abfd
->xvec
->byteorder_big_p
== false)
3639 case ELFDATA2LSB
: /* Little-endian */
3640 if (abfd
->xvec
->byteorder_big_p
== true)
3643 case ELFDATANONE
: /* No data encoding specified */
3644 default: /* Unknown data encoding specified */
3648 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3649 the tdata pointer in the bfd. */
3652 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3653 if (elf_tdata (abfd
) == NULL
)
3655 bfd_set_error (bfd_error_no_memory
);
3659 /* FIXME, `wrong' returns from this point onward, leak memory. */
3661 /* Now that we know the byte order, swap in the rest of the header */
3662 i_ehdrp
= elf_elfheader (abfd
);
3663 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3665 elf_debug_file (i_ehdrp
);
3668 ebd
= get_elf_backend_data (abfd
);
3670 /* Check that the ELF e_machine field matches what this particular
3671 BFD format expects. */
3672 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3674 const bfd_target
* const *target_ptr
;
3676 if (ebd
->elf_machine_code
!= EM_NONE
)
3679 /* This is the generic ELF target. Let it match any ELF target
3680 for which we do not have a specific backend. */
3681 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3683 struct elf_backend_data
*back
;
3685 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3687 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3688 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3690 /* target_ptr is an ELF backend which matches this
3691 object file, so reject the generic ELF target. */
3697 /* If there is no program header, or the type is not a core file, then
3699 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3702 /* Allocate space for a copy of the program header table in
3703 internal form, seek to the program header table in the file,
3704 read it in, and convert it to internal form. As a simple sanity
3705 check, verify that the what BFD thinks is the size of each program
3706 header table entry actually matches the size recorded in the file. */
3708 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3710 i_phdrp
= (Elf_Internal_Phdr
*)
3711 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3714 bfd_set_error (bfd_error_no_memory
);
3717 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3719 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3721 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3724 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3727 /* Once all of the program headers have been read and converted, we
3728 can start processing them. */
3730 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3732 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3733 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3735 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3740 /* Remember the entry point specified in the ELF file header. */
3742 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3747 /* ELF linker code. */
3749 static boolean elf_link_add_object_symbols
3750 PARAMS ((bfd
*, struct bfd_link_info
*));
3751 static boolean elf_link_add_archive_symbols
3752 PARAMS ((bfd
*, struct bfd_link_info
*));
3753 static INLINE boolean elf_link_record_dynamic_symbol
3754 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
3755 static boolean elf_link_create_dynamic_sections
3756 PARAMS ((bfd
*, struct bfd_link_info
*));
3757 static boolean elf_adjust_dynamic_symbol
3758 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3760 /* Given an ELF BFD, add symbols to the global hash table as
3764 elf_bfd_link_add_symbols (abfd
, info
)
3766 struct bfd_link_info
*info
;
3768 switch (bfd_get_format (abfd
))
3771 return elf_link_add_object_symbols (abfd
, info
);
3773 return elf_link_add_archive_symbols (abfd
, info
);
3775 bfd_set_error (bfd_error_wrong_format
);
3780 /* Add symbols from an ELF archive file to the linker hash table. We
3781 don't use _bfd_generic_link_add_archive_symbols because of a
3782 problem which arises on UnixWare. The UnixWare libc.so is an
3783 archive which includes an entry libc.so.1 which defines a bunch of
3784 symbols. The libc.so archive also includes a number of other
3785 object files, which also define symbols, some of which are the same
3786 as those defined in libc.so.1. Correct linking requires that we
3787 consider each object file in turn, and include it if it defines any
3788 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3789 this; it looks through the list of undefined symbols, and includes
3790 any object file which defines them. When this algorithm is used on
3791 UnixWare, it winds up pulling in libc.so.1 early and defining a
3792 bunch of symbols. This means that some of the other objects in the
3793 archive are not included in the link, which is incorrect since they
3794 precede libc.so.1 in the archive.
3796 Fortunately, ELF archive handling is simpler than that done by
3797 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3798 oddities. In ELF, if we find a symbol in the archive map, and the
3799 symbol is currently undefined, we know that we must pull in that
3802 Unfortunately, we do have to make multiple passes over the symbol
3803 table until nothing further is resolved. */
3806 elf_link_add_archive_symbols (abfd
, info
)
3808 struct bfd_link_info
*info
;
3811 boolean
*defined
= NULL
;
3812 boolean
*included
= NULL
;
3816 if (! bfd_has_map (abfd
))
3818 bfd_set_error (bfd_error_no_symbols
);
3822 /* Keep track of all symbols we know to be already defined, and all
3823 files we know to be already included. This is to speed up the
3824 second and subsequent passes. */
3825 c
= bfd_ardata (abfd
)->symdef_count
;
3828 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3829 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3830 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3832 bfd_set_error (bfd_error_no_memory
);
3835 memset (defined
, 0, c
* sizeof (boolean
));
3836 memset (included
, 0, c
* sizeof (boolean
));
3838 symdefs
= bfd_ardata (abfd
)->symdefs
;
3851 symdefend
= symdef
+ c
;
3852 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3854 struct elf_link_hash_entry
*h
;
3856 struct bfd_link_hash_entry
*undefs_tail
;
3859 if (defined
[i
] || included
[i
])
3861 if (symdef
->file_offset
== last
)
3867 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3868 false, false, false);
3869 if (h
== (struct elf_link_hash_entry
*) NULL
)
3871 if (h
->root
.type
!= bfd_link_hash_undefined
)
3877 /* We need to include this archive member. */
3879 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3880 if (element
== (bfd
*) NULL
)
3883 if (! bfd_check_format (element
, bfd_object
))
3886 /* Doublecheck that we have not included this object
3887 already--it should be impossible, but there may be
3888 something wrong with the archive. */
3889 if (element
->archive_pass
!= 0)
3891 bfd_set_error (bfd_error_bad_value
);
3894 element
->archive_pass
= 1;
3896 undefs_tail
= info
->hash
->undefs_tail
;
3898 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
3901 if (! elf_link_add_object_symbols (element
, info
))
3904 /* If there are any new undefined symbols, we need to make
3905 another pass through the archive in order to see whether
3906 they can be defined. FIXME: This isn't perfect, because
3907 common symbols wind up on undefs_tail and because an
3908 undefined symbol which is defined later on in this pass
3909 does not require another pass. This isn't a bug, but it
3910 does make the code less efficient than it could be. */
3911 if (undefs_tail
!= info
->hash
->undefs_tail
)
3914 /* Look backward to mark all symbols from this object file
3915 which we have already seen in this pass. */
3919 included
[mark
] = true;
3924 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
3926 /* We mark subsequent symbols from this object file as we go
3927 on through the loop. */
3928 last
= symdef
->file_offset
;
3939 if (defined
!= (boolean
*) NULL
)
3941 if (included
!= (boolean
*) NULL
)
3946 /* Record a new dynamic symbol. We record the dynamic symbols as we
3947 read the input files, since we need to have a list of all of them
3948 before we can determine the final sizes of the output sections. */
3950 static INLINE boolean
3951 elf_link_record_dynamic_symbol (info
, h
)
3952 struct bfd_link_info
*info
;
3953 struct elf_link_hash_entry
*h
;
3955 if (h
->dynindx
== -1)
3957 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3958 ++elf_hash_table (info
)->dynsymcount
;
3959 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
3960 elf_hash_table (info
)->dynstr
,
3961 h
->root
.root
.string
);
3962 if (h
->dynstr_index
== (unsigned long) -1)
3969 /* Add symbols from an ELF object file to the linker hash table. */
3972 elf_link_add_object_symbols (abfd
, info
)
3974 struct bfd_link_info
*info
;
3976 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
3977 const Elf_Internal_Sym
*,
3978 const char **, flagword
*,
3979 asection
**, bfd_vma
*));
3981 Elf_Internal_Shdr
*hdr
;
3985 Elf_External_Sym
*buf
= NULL
;
3986 struct elf_link_hash_entry
**sym_hash
;
3988 Elf_External_Dyn
*dynbuf
= NULL
;
3989 struct elf_link_hash_entry
*weaks
;
3990 Elf_External_Sym
*esym
;
3991 Elf_External_Sym
*esymend
;
3993 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
3994 collect
= get_elf_backend_data (abfd
)->collect
;
3996 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3997 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
3999 /* The sh_info field of the symtab header tells us where the
4000 external symbols start. We don't care about the local symbols at
4002 if (elf_bad_symtab (abfd
))
4004 extsymcount
= symcount
;
4009 extsymcount
= symcount
- hdr
->sh_info
;
4010 extsymoff
= hdr
->sh_info
;
4013 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4014 if (buf
== NULL
&& extsymcount
!= 0)
4016 bfd_set_error (bfd_error_no_memory
);
4020 /* We store a pointer to the hash table entry for each external
4022 sym_hash
= ((struct elf_link_hash_entry
**)
4024 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4025 if (sym_hash
== NULL
)
4027 bfd_set_error (bfd_error_no_memory
);
4030 elf_sym_hashes (abfd
) = sym_hash
;
4032 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4036 /* If we are creating a shared library, create all the dynamic
4037 sections immediately. We need to attach them to something,
4038 so we attach them to this BFD, provided it is the right
4039 format. FIXME: If there are no input BFD's of the same
4040 format as the output, we can't make a shared library. */
4042 && elf_hash_table (info
)->dynobj
== NULL
4043 && abfd
->xvec
== info
->hash
->creator
)
4045 if (! elf_link_create_dynamic_sections (abfd
, info
))
4047 elf_hash_table (info
)->dynobj
= abfd
;
4054 unsigned long strindex
;
4058 /* You can't use -r against a dynamic object. There's no hope
4059 of using a dynamic object which does not exactly match the
4060 format of the output file. */
4061 if (info
->relocateable
4062 || info
->hash
->creator
!= abfd
->xvec
)
4064 bfd_set_error (bfd_error_invalid_operation
);
4068 /* Find the name to use in a DT_NEEDED entry that refers to this
4069 object. If the object has a DT_SONAME entry, we use it.
4070 Otherwise, if the generic linker stuck something in
4071 elf_dt_needed_name, we use that. Otherwise, we just use the
4073 name
= bfd_get_filename (abfd
);
4074 if (elf_dt_needed_name (abfd
) != NULL
)
4075 name
= elf_dt_needed_name (abfd
);
4076 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4079 Elf_External_Dyn
*extdyn
;
4080 Elf_External_Dyn
*extdynend
;
4082 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4085 bfd_set_error (bfd_error_no_memory
);
4089 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4090 (file_ptr
) 0, s
->_raw_size
))
4094 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4095 for (; extdyn
< extdynend
; extdyn
++)
4097 Elf_Internal_Dyn dyn
;
4099 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4100 if (dyn
.d_tag
== DT_SONAME
)
4105 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4108 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4109 name
= elf_string_from_elf_section (abfd
, link
,
4122 /* We do not want to include any of the sections in a dynamic
4123 object in the output file. We hack by simply clobbering the
4124 list of sections in the BFD. This could be handled more
4125 cleanly by, say, a new section flag; the existing
4126 SEC_NEVER_LOAD flag is not the one we want, because that one
4127 still implies that the section takes up space in the output
4129 abfd
->sections
= NULL
;
4131 /* If this is the first dynamic object found in the link, create
4132 the special sections required for dynamic linking. We need
4133 to put them somewhere, and attaching them to the first
4134 dynamic object is as good place as any. */
4135 if (elf_hash_table (info
)->dynobj
== NULL
)
4137 if (! elf_link_create_dynamic_sections (abfd
, info
))
4139 elf_hash_table (info
)->dynobj
= abfd
;
4142 /* Add a DT_NEEDED entry for this dynamic object. */
4143 strindex
= bfd_add_to_strtab (abfd
,
4144 elf_hash_table (info
)->dynstr
,
4147 if (strindex
== (unsigned long) -1)
4149 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4154 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4156 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4157 != extsymcount
* sizeof (Elf_External_Sym
)))
4162 esymend
= buf
+ extsymcount
;
4163 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4165 Elf_Internal_Sym sym
;
4171 struct elf_link_hash_entry
*h
= NULL
;
4174 elf_swap_symbol_in (abfd
, esym
, &sym
);
4176 flags
= BSF_NO_FLAGS
;
4178 value
= sym
.st_value
;
4181 bind
= ELF_ST_BIND (sym
.st_info
);
4182 if (bind
== STB_LOCAL
)
4184 /* This should be impossible, since ELF requires that all
4185 global symbols follow all local symbols, and that sh_info
4186 point to the first global symbol. Unfortunatealy, Irix 5
4190 else if (bind
== STB_GLOBAL
)
4192 else if (bind
== STB_WEAK
)
4196 /* Leave it up to the processor backend. */
4199 if (sym
.st_shndx
== SHN_UNDEF
)
4200 sec
= bfd_und_section_ptr
;
4201 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4203 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4208 else if (sym
.st_shndx
== SHN_ABS
)
4209 sec
= bfd_abs_section_ptr
;
4210 else if (sym
.st_shndx
== SHN_COMMON
)
4212 sec
= bfd_com_section_ptr
;
4213 /* What ELF calls the size we call the value. What ELF
4214 calls the value we call the alignment. */
4215 value
= sym
.st_size
;
4219 /* Leave it up to the processor backend. */
4222 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4223 if (name
== (const char *) NULL
)
4226 if (add_symbol_hook
)
4228 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4232 /* The hook function sets the name to NULL if this symbol
4233 should be skipped for some reason. */
4234 if (name
== (const char *) NULL
)
4238 /* Sanity check that all possibilities were handled. */
4239 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4241 bfd_set_error (bfd_error_bad_value
);
4245 if (bfd_is_und_section (sec
)
4246 || bfd_is_com_section (sec
))
4251 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4253 /* We need to look up the symbol now in order to get some of
4254 the dynamic object handling right. We pass the hash
4255 table entry in to _bfd_generic_link_add_one_symbol so
4256 that it does not have to look it up again. */
4257 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4258 true, false, false);
4263 /* If we are looking at a dynamic object, and this is a
4264 definition, we need to see if it has already been defined
4265 by some other object. If it has, we want to use the
4266 existing definition, and we do not want to report a
4267 multiple symbol definition error; we do this by
4268 clobbering sec to be bfd_und_section_ptr. */
4269 if (dynamic
&& definition
)
4271 if (h
->root
.type
== bfd_link_hash_defined
)
4272 sec
= bfd_und_section_ptr
;
4275 /* Similarly, if we are not looking at a dynamic object, and
4276 we have a definition, we want to override any definition
4277 we may have from a dynamic object. Symbols from regular
4278 files always take precedence over symbols from dynamic
4279 objects, even if they are defined after the dynamic
4280 object in the link. */
4283 && h
->root
.type
== bfd_link_hash_defined
4284 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4285 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4286 == bfd_target_elf_flavour
)
4287 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4290 /* Change the hash table entry to undefined, and let
4291 _bfd_generic_link_add_one_symbol do the right thing
4292 with the new definition. */
4293 h
->root
.type
= bfd_link_hash_undefined
;
4294 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4295 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEFINED_WEAK
;
4298 /* If this is a weak definition which we are going to use,
4299 and the symbol is currently undefined, record that the
4300 definition is weak. */
4302 && (flags
& BSF_WEAK
) != 0
4303 && ! bfd_is_und_section (sec
)
4304 && (h
->root
.type
== bfd_link_hash_new
4305 || h
->root
.type
== bfd_link_hash_undefined
4306 || h
->root
.type
== bfd_link_hash_weak
))
4307 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEFINED_WEAK
;
4310 if (! (_bfd_generic_link_add_one_symbol
4311 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4312 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4317 && (flags
& BSF_WEAK
) != 0
4318 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4319 && (*sym_hash
)->weakdef
== NULL
)
4321 /* Keep a list of all weak defined non function symbols from
4322 a dynamic object, using the weakdef field. Later in this
4323 function we will set the weakdef field to the correct
4324 value. We only put non-function symbols from dynamic
4325 objects on this list, because that happens to be the only
4326 time we need to know the normal symbol corresponding to a
4327 weak symbol, and the information is time consuming to
4328 figure out. If the weakdef field is not already NULL,
4329 then this symbol was already defined by some previous
4330 dynamic object, and we will be using that previous
4331 definition anyhow. */
4333 (*sym_hash
)->weakdef
= weaks
;
4337 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4343 /* Remember the symbol size, type and alignment. */
4344 if (sym
.st_size
!= 0)
4346 /* FIXME: We should probably somehow give a warning if
4347 the symbol size changes. */
4348 h
->size
= sym
.st_size
;
4350 if (sym
.st_shndx
== SHN_COMMON
4351 && sym
.st_value
> h
->align
)
4352 h
->align
= sym
.st_value
;
4353 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4355 /* FIXME: We should probably somehow give a warning if
4356 the symbol type changes. */
4357 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4360 /* Set a flag in the hash table entry indicating the type of
4361 reference or definition we just found. Keep a count of
4362 the number of dynamic symbols we find. A dynamic symbol
4363 is one which is referenced or defined by both a regular
4364 object and a shared object, or one which is referenced or
4365 defined by more than one shared object. */
4366 old_flags
= h
->elf_link_hash_flags
;
4371 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4373 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4374 if ((old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4375 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4381 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4383 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4384 if ((old_flags
& new_flag
) != 0)
4387 new_flag
= ELF_LINK_HASH_REF_DYNAMIC_MULTIPLE
;
4389 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC_MULTIPLE
;
4394 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4395 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4400 h
->elf_link_hash_flags
|= new_flag
;
4401 if (dynsym
&& h
->dynindx
== -1)
4403 if (! elf_link_record_dynamic_symbol (info
, h
))
4409 /* Now set the weakdefs field correctly for all the weak defined
4410 symbols we found. The only way to do this is to search all the
4411 symbols. Since we only need the information for non functions in
4412 dynamic objects, that's the only time we actually put anything on
4413 the list WEAKS. We need this information so that if a regular
4414 object refers to a symbol defined weakly in a dynamic object, the
4415 real symbol in the dynamic object is also put in the dynamic
4416 symbols; we also must arrange for both symbols to point to the
4417 same memory location. We could handle the general case of symbol
4418 aliasing, but a general symbol alias can only be generated in
4419 assembler code, handling it correctly would be very time
4420 consuming, and other ELF linkers don't handle general aliasing
4422 while (weaks
!= NULL
)
4424 struct elf_link_hash_entry
*hlook
;
4427 struct elf_link_hash_entry
**hpp
;
4428 struct elf_link_hash_entry
**hppend
;
4431 weaks
= hlook
->weakdef
;
4432 hlook
->weakdef
= NULL
;
4434 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4435 slook
= hlook
->root
.u
.def
.section
;
4436 vlook
= hlook
->root
.u
.def
.value
;
4438 hpp
= elf_sym_hashes (abfd
);
4439 hppend
= hpp
+ extsymcount
;
4440 for (; hpp
< hppend
; hpp
++)
4442 struct elf_link_hash_entry
*h
;
4446 && h
->root
.type
== bfd_link_hash_defined
4447 && h
->root
.u
.def
.section
== slook
4448 && h
->root
.u
.def
.value
== vlook
)
4452 /* If the weak definition is in the list of dynamic
4453 symbols, make sure the real definition is put there
4455 if (hlook
->dynindx
!= -1
4456 && h
->dynindx
== -1)
4458 if (! elf_link_record_dynamic_symbol (info
, h
))
4480 /* Create some sections which will be filled in with dynamic linking
4481 information. The ABFD argument is an input file which is a dynamic
4482 object. The dynamic sections take up virtual memory space when the
4483 final executable is run, so we need to create them before addresses
4484 are assigned to the output sections. We work out the actual
4485 contents and size of these sections later. */
4488 elf_link_create_dynamic_sections (abfd
, info
)
4490 struct bfd_link_info
*info
;
4493 register asection
*s
;
4494 struct elf_link_hash_entry
*h
;
4495 struct elf_backend_data
*bed
;
4497 /* Note that we set the SEC_IN_MEMORY flag for all of these
4499 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4501 /* A dynamically linked executable has a .interp section, but a
4502 shared library does not. */
4505 s
= bfd_make_section (abfd
, ".interp");
4507 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4511 s
= bfd_make_section (abfd
, ".dynamic");
4513 || ! bfd_set_section_flags (abfd
, s
, flags
)
4514 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4517 /* The special symbol _DYNAMIC is always set to the start of the
4518 .dynamic section. This call occurs before we have processed the
4519 symbols for any dynamic object, so we don't have to worry about
4520 overriding a dynamic definition. We could set _DYNAMIC in a
4521 linker script, but we only want to define it if we are, in fact,
4522 creating a .dynamic section. We don't want to define it if there
4523 is no .dynamic section, since on some ELF platforms the start up
4524 code examines it to decide how to initialize the process. */
4526 if (! (_bfd_generic_link_add_one_symbol
4527 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4528 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4529 (struct bfd_link_hash_entry
**) &h
)))
4531 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4533 s
= bfd_make_section (abfd
, ".dynsym");
4535 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4536 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4539 /* The first .dynsym symbol is a dummy. */
4540 elf_hash_table (info
)->dynsymcount
= 1;
4542 s
= bfd_make_section (abfd
, ".dynstr");
4544 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4547 /* Create a strtab to hold the dynamic symbol names. */
4548 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4549 if (elf_hash_table (info
)->dynstr
== NULL
)
4552 s
= bfd_make_section (abfd
, ".hash");
4554 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4555 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4558 /* Let the backend create the rest of the sections. This lets the
4559 backend set the right flags. The backend will normally create
4560 the .got and .plt sections. */
4561 bed
= get_elf_backend_data (abfd
);
4562 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4565 /* Add an entry to the .dynamic table. */
4568 elf_add_dynamic_entry (info
, tag
, val
)
4569 struct bfd_link_info
*info
;
4573 Elf_Internal_Dyn dyn
;
4577 bfd_byte
*newcontents
;
4579 dynobj
= elf_hash_table (info
)->dynobj
;
4581 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4582 BFD_ASSERT (s
!= NULL
);
4584 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4585 if (s
->contents
== NULL
)
4586 newcontents
= (bfd_byte
*) malloc (newsize
);
4588 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4589 if (newcontents
== NULL
)
4591 bfd_set_error (bfd_error_no_memory
);
4596 dyn
.d_un
.d_val
= val
;
4597 elf_swap_dyn_out (dynobj
, &dyn
,
4598 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4600 s
->_raw_size
= newsize
;
4601 s
->contents
= newcontents
;
4606 /* Record an assignment to a symbol made by a linker script. We need
4607 this in case some dynamic object refers to this symbol. */
4611 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4613 struct bfd_link_info
*info
;
4616 struct elf_link_hash_entry
*h
;
4618 /* This is called after we have examined all the input objects. If
4619 the symbol does not exist, it merely means that no object refers
4620 to it, and we can just ignore it at this point. */
4621 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4622 false, false, false);
4626 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4628 if ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4629 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4630 && h
->dynindx
== -1)
4632 if (! elf_link_record_dynamic_symbol (info
, h
))
4635 /* If this is a weak defined symbol, and we know a corresponding
4636 real symbol from the same dynamic object, make sure the real
4637 symbol is also made into a dynamic symbol. */
4638 if (h
->weakdef
!= NULL
4639 && h
->weakdef
->dynindx
== -1)
4641 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4649 /* Array used to determine the number of hash table buckets to use
4650 based on the number of symbols there are. If there are fewer than
4651 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4652 fewer than 37 we use 17 buckets, and so forth. We never use more
4653 than 521 buckets. */
4655 static const size_t elf_buckets
[] =
4657 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4660 /* Set up the sizes and contents of the ELF dynamic sections. This is
4661 called by the ELF linker emulation before_allocation routine. We
4662 must set the sizes of the sections before the linker sets the
4663 addresses of the various sections. */
4666 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, rpath
, info
, sinterpptr
)
4669 struct bfd_link_info
*info
;
4670 asection
**sinterpptr
;
4675 Elf_Internal_Sym isym
;
4678 struct elf_backend_data
*bed
;
4682 dynobj
= elf_hash_table (info
)->dynobj
;
4683 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4685 /* If there were no dynamic objects in the link, there is nothing to
4690 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4691 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4693 /* Set the size of the .dynsym and .hash sections. We counted the
4694 number of dynamic symbols in elf_link_add_object_symbols. We
4695 will build the contents of .dynsym and .hash when we build the
4696 final symbol table, because until then we do not know the correct
4697 value to give the symbols. We built the .dynstr section as we
4698 went along in elf_link_add_object_symbols. */
4699 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4700 BFD_ASSERT (s
!= NULL
);
4701 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4702 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4703 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4705 bfd_set_error (bfd_error_no_memory
);
4709 /* The first entry in .dynsym is a dummy symbol. */
4716 elf_swap_symbol_out (output_bfd
, &isym
,
4717 (Elf_External_Sym
*) s
->contents
);
4719 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4721 bucketcount
= elf_buckets
[i
];
4722 if (dynsymcount
< elf_buckets
[i
+ 1])
4726 s
= bfd_get_section_by_name (dynobj
, ".hash");
4727 BFD_ASSERT (s
!= NULL
);
4728 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4729 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4730 if (s
->contents
== NULL
)
4732 bfd_set_error (bfd_error_no_memory
);
4735 memset (s
->contents
, 0, s
->_raw_size
);
4737 put_word (output_bfd
, bucketcount
, s
->contents
);
4738 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4740 elf_hash_table (info
)->bucketcount
= bucketcount
;
4746 indx
= bfd_add_to_strtab (dynobj
, elf_hash_table (info
)->dynstr
, rpath
);
4747 if (indx
== (unsigned long) -1
4748 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
4752 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4753 BFD_ASSERT (s
!= NULL
);
4754 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4755 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4757 /* Find all symbols which were defined in a dynamic object and make
4758 the backend pick a reasonable value for them. */
4759 elf_link_hash_traverse (elf_hash_table (info
),
4760 elf_adjust_dynamic_symbol
,
4763 /* Add some entries to the .dynamic section. We fill in some of the
4764 values later, in elf_bfd_final_link, but we must add the entries
4765 now so that we know the final size of the .dynamic section. */
4766 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4768 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4771 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4773 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4776 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4777 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4778 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4779 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4780 elf_hash_table (info
)->dynstr
->length
)
4781 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4782 sizeof (Elf_External_Sym
)))
4785 /* The backend must work out the sizes of all the other dynamic
4787 bed
= get_elf_backend_data (output_bfd
);
4788 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4791 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4794 /* Make the backend pick a good value for a dynamic symbol. This is
4795 called via elf_link_hash_traverse, and also calls itself
4799 elf_adjust_dynamic_symbol (h
, data
)
4800 struct elf_link_hash_entry
*h
;
4803 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4805 struct elf_backend_data
*bed
;
4807 /* If this symbol is not defined by a dynamic object, or is not
4808 referenced by a regular object, ignore it. FIXME: Do we need to
4809 worry about symbols which are defined by one dynamic object and
4810 referenced by another one? */
4811 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4812 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4813 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4816 /* If we've already adjusted this symbol, don't do it again. This
4817 can happen via a recursive call. */
4818 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4821 /* Don't look at this symbol again. Note that we must set this
4822 after checking the above conditions, because we may look at a
4823 symbol once, decide not to do anything, and then get called
4824 recursively later after REF_REGULAR is set below. */
4825 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4827 /* If this is a weak definition, and we know a real definition, and
4828 the real symbol is not itself defined by a regular object file,
4829 then get a good value for the real definition. We handle the
4830 real symbol first, for the convenience of the backend routine.
4832 Note that there is a confusing case here. If the real definition
4833 is defined by a regular object file, we don't get the real symbol
4834 from the dynamic object, but we do get the weak symbol. If the
4835 processor backend uses a COPY reloc, then if some routine in the
4836 dynamic object changes the real symbol, we will not see that
4837 change in the corresponding weak symbol. This is the way other
4838 ELF linkers work as well, and seems to be a result of the shared
4841 I will clarify this issue. Most SVR4 shared libraries define the
4842 variable _timezone and define timezone as a weak synonym. The
4843 tzset call changes _timezone. If you write
4844 extern int timezone;
4846 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4847 you might expect that, since timezone is a synonym for _timezone,
4848 the same number will print both times. However, if the processor
4849 backend uses a COPY reloc, then actually timezone will be copied
4850 into your process image, and, since you define _timezone
4851 yourself, _timezone will not. Thus timezone and _timezone will
4852 wind up at different memory locations. The tzset call will set
4853 _timezone, leaving timezone unchanged. */
4855 if (h
->weakdef
!= NULL
)
4857 struct elf_link_hash_entry
*weakdef
;
4859 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4860 weakdef
= h
->weakdef
;
4861 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4862 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4863 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4864 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4866 /* This symbol is defined or referenced by a regular object
4867 file, so we will not do anything special. Clear weakdef
4868 for the convenience of the processor backend. */
4873 /* There is an implicit reference by a regular object file
4874 via the weak symbol. */
4875 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
4876 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
4881 dynobj
= elf_hash_table (info
)->dynobj
;
4882 bed
= get_elf_backend_data (dynobj
);
4883 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
4885 /* FIXME: No way to return error. */
4892 /* Final phase of ELF linker. */
4894 /* A structure we use to avoid passing large numbers of arguments. */
4896 struct elf_final_link_info
4898 /* General link information. */
4899 struct bfd_link_info
*info
;
4902 /* Symbol string table. */
4903 struct strtab
*symstrtab
;
4904 /* .dynsym section. */
4905 asection
*dynsym_sec
;
4906 /* .hash section. */
4908 /* Buffer large enough to hold contents of any section. */
4910 /* Buffer large enough to hold external relocs of any section. */
4911 PTR external_relocs
;
4912 /* Buffer large enough to hold internal relocs of any section. */
4913 Elf_Internal_Rela
*internal_relocs
;
4914 /* Buffer large enough to hold external local symbols of any input
4916 Elf_External_Sym
*external_syms
;
4917 /* Buffer large enough to hold internal local symbols of any input
4919 Elf_Internal_Sym
*internal_syms
;
4920 /* Array large enough to hold a symbol index for each local symbol
4921 of any input BFD. */
4923 /* Array large enough to hold a section pointer for each local
4924 symbol of any input BFD. */
4925 asection
**sections
;
4926 /* Buffer to hold swapped out symbols. */
4927 Elf_External_Sym
*symbuf
;
4928 /* Number of swapped out symbols in buffer. */
4929 size_t symbuf_count
;
4930 /* Number of symbols which fit in symbuf. */
4934 static boolean elf_link_output_sym
4935 PARAMS ((struct elf_final_link_info
*, const char *,
4936 Elf_Internal_Sym
*, asection
*));
4937 static boolean elf_link_flush_output_syms
4938 PARAMS ((struct elf_final_link_info
*));
4939 static boolean elf_link_output_extsym
4940 PARAMS ((struct elf_link_hash_entry
*, PTR
));
4941 static boolean elf_link_input_bfd
4942 PARAMS ((struct elf_final_link_info
*, bfd
*));
4943 static boolean elf_reloc_link_order
4944 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4945 struct bfd_link_order
*));
4947 /* Do the final step of an ELF link. */
4950 elf_bfd_final_link (abfd
, info
)
4952 struct bfd_link_info
*info
;
4955 struct elf_final_link_info finfo
;
4956 register asection
*o
;
4957 register struct bfd_link_order
*p
;
4959 size_t max_contents_size
;
4960 size_t max_external_reloc_size
;
4961 size_t max_internal_reloc_count
;
4962 size_t max_sym_count
;
4964 Elf_Internal_Sym elfsym
;
4966 Elf_Internal_Shdr
*symtab_hdr
;
4967 Elf_Internal_Shdr
*symstrtab_hdr
;
4968 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4973 "Generating ELF shared libraries is not yet supported\n");
4974 bfd_set_error (bfd_error_invalid_operation
);
4978 dynobj
= elf_hash_table (info
)->dynobj
;
4981 finfo
.output_bfd
= abfd
;
4982 finfo
.symstrtab
= bfd_new_strtab (abfd
);
4983 if (finfo
.symstrtab
== NULL
)
4987 finfo
.dynsym_sec
= NULL
;
4988 finfo
.hash_sec
= NULL
;
4992 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
4993 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
4994 if (finfo
.dynsym_sec
== NULL
4995 || finfo
.hash_sec
== NULL
)
4998 finfo
.contents
= NULL
;
4999 finfo
.external_relocs
= NULL
;
5000 finfo
.internal_relocs
= NULL
;
5001 finfo
.external_syms
= NULL
;
5002 finfo
.internal_syms
= NULL
;
5003 finfo
.indices
= NULL
;
5004 finfo
.sections
= NULL
;
5005 finfo
.symbuf
= NULL
;
5006 finfo
.symbuf_count
= 0;
5008 /* Count up the number of relocations we will output for each output
5009 section, so that we know the sizes of the reloc sections. We
5010 also figure out some maximum sizes. */
5011 max_contents_size
= 0;
5012 max_external_reloc_size
= 0;
5013 max_internal_reloc_count
= 0;
5015 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5019 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5021 if (p
->type
== bfd_section_reloc_link_order
5022 || p
->type
== bfd_symbol_reloc_link_order
)
5024 else if (p
->type
== bfd_indirect_link_order
)
5028 sec
= p
->u
.indirect
.section
;
5030 if (info
->relocateable
)
5031 o
->reloc_count
+= sec
->reloc_count
;
5033 if (sec
->_raw_size
> max_contents_size
)
5034 max_contents_size
= sec
->_raw_size
;
5035 if (sec
->_cooked_size
> max_contents_size
)
5036 max_contents_size
= sec
->_cooked_size
;
5038 /* We are interested in just local symbols, not all
5040 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5044 if (elf_bad_symtab (sec
->owner
))
5045 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5046 / sizeof (Elf_External_Sym
));
5048 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5050 if (sym_count
> max_sym_count
)
5051 max_sym_count
= sym_count
;
5053 if ((sec
->flags
& SEC_RELOC
) != 0)
5057 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5058 if (ext_size
> max_external_reloc_size
)
5059 max_external_reloc_size
= ext_size
;
5060 if (sec
->reloc_count
> max_internal_reloc_count
)
5061 max_internal_reloc_count
= sec
->reloc_count
;
5067 if (o
->reloc_count
> 0)
5068 o
->flags
|= SEC_RELOC
;
5071 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5072 set it (this is probably a bug) and if it is set
5073 assign_section_numbers will create a reloc section. */
5074 o
->flags
&=~ SEC_RELOC
;
5078 /* Figure out the file positions for everything but the symbol table
5079 and the relocs. We set symcount to force assign_section_numbers
5080 to create a symbol table. */
5081 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5082 BFD_ASSERT (! abfd
->output_has_begun
);
5083 if (! elf_compute_section_file_positions (abfd
, info
))
5086 /* That created the reloc sections. Set their sizes, and assign
5087 them file positions, and allocate some buffers. */
5088 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5090 if ((o
->flags
& SEC_RELOC
) != 0)
5092 Elf_Internal_Shdr
*rel_hdr
;
5093 register struct elf_link_hash_entry
**p
, **pend
;
5095 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5097 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5099 /* The contents field must last into write_object_contents,
5100 so we allocate it with bfd_alloc rather than malloc. */
5101 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5102 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5104 bfd_set_error (bfd_error_no_memory
);
5108 p
= ((struct elf_link_hash_entry
**)
5109 malloc (o
->reloc_count
5110 * sizeof (struct elf_link_hash_entry
*)));
5111 if (p
== NULL
&& o
->reloc_count
!= 0)
5113 bfd_set_error (bfd_error_no_memory
);
5116 elf_section_data (o
)->rel_hashes
= p
;
5117 pend
= p
+ o
->reloc_count
;
5118 for (; p
< pend
; p
++)
5121 /* Use the reloc_count field as an index when outputting the
5127 assign_file_positions_for_relocs (abfd
);
5129 /* We have now assigned file positions for all the sections except
5130 .symtab and .strtab. We start the .symtab section at the current
5131 file position, and write directly to it. We build the .strtab
5132 section in memory. When we add .dynsym support, we will build
5133 that in memory as well (.dynsym is smaller than .symtab). */
5135 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5136 /* sh_name is set in prep_headers. */
5137 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5138 symtab_hdr
->sh_flags
= 0;
5139 symtab_hdr
->sh_addr
= 0;
5140 symtab_hdr
->sh_size
= 0;
5141 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5142 /* sh_link is set in assign_section_numbers. */
5143 /* sh_info is set below. */
5144 /* sh_offset is set just below. */
5145 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5147 off
= elf_tdata (abfd
)->next_file_pos
;
5148 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5150 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5151 incorrect. We do not yet know the size of the .symtab section.
5152 We correct next_file_pos below, after we do know the size. */
5154 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5155 continuously seeking to the right position in the file. */
5156 if (! info
->keep_memory
|| max_sym_count
< 20)
5157 finfo
.symbuf_size
= 20;
5159 finfo
.symbuf_size
= max_sym_count
;
5160 finfo
.symbuf
= ((Elf_External_Sym
*)
5161 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5162 if (finfo
.symbuf
== NULL
)
5164 bfd_set_error (bfd_error_no_memory
);
5168 /* Start writing out the symbol table. The first symbol is always a
5170 elfsym
.st_value
= 0;
5173 elfsym
.st_other
= 0;
5174 elfsym
.st_shndx
= SHN_UNDEF
;
5175 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5176 &elfsym
, bfd_und_section_ptr
))
5180 /* Some standard ELF linkers do this, but we don't because it causes
5181 bootstrap comparison failures. */
5182 /* Output a file symbol for the output file as the second symbol.
5183 We output this even if we are discarding local symbols, although
5184 I'm not sure if this is correct. */
5185 elfsym
.st_value
= 0;
5187 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5188 elfsym
.st_other
= 0;
5189 elfsym
.st_shndx
= SHN_ABS
;
5190 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5191 &elfsym
, bfd_abs_section_ptr
))
5195 /* Output a symbol for each section. We output these even if we are
5196 discarding local symbols, since they are used for relocs. These
5197 symbols have no names. We store the index of each one in the
5198 index field of the section, so that we can find it again when
5199 outputting relocs. */
5200 elfsym
.st_value
= 0;
5202 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5203 elfsym
.st_other
= 0;
5204 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5206 o
= section_from_elf_index (abfd
, i
);
5207 if (! bfd_is_abs_section (o
))
5208 o
->target_index
= abfd
->symcount
;
5209 elfsym
.st_shndx
= i
;
5210 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5215 /* Allocate some memory to hold information read in from the input
5217 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5218 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5219 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5220 malloc (max_internal_reloc_count
5221 * sizeof (Elf_Internal_Rela
)));
5222 finfo
.external_syms
= ((Elf_External_Sym
*)
5223 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5224 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5225 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5226 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5227 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5228 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5229 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5230 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5231 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5232 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5233 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5234 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5236 bfd_set_error (bfd_error_no_memory
);
5240 /* Since ELF permits relocations to be against local symbols, we
5241 must have the local symbols available when we do the relocations.
5242 Since we would rather only read the local symbols once, and we
5243 would rather not keep them in memory, we handle all the
5244 relocations for a single input file at the same time.
5246 Unfortunately, there is no way to know the total number of local
5247 symbols until we have seen all of them, and the local symbol
5248 indices precede the global symbol indices. This means that when
5249 we are generating relocateable output, and we see a reloc against
5250 a global symbol, we can not know the symbol index until we have
5251 finished examining all the local symbols to see which ones we are
5252 going to output. To deal with this, we keep the relocations in
5253 memory, and don't output them until the end of the link. This is
5254 an unfortunate waste of memory, but I don't see a good way around
5255 it. Fortunately, it only happens when performing a relocateable
5256 link, which is not the common case. FIXME: If keep_memory is set
5257 we could write the relocs out and then read them again; I don't
5258 know how bad the memory loss will be. */
5260 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5261 sub
->output_has_begun
= false;
5262 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5264 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5266 if (p
->type
== bfd_indirect_link_order
5267 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5268 == bfd_target_elf_flavour
))
5270 sub
= p
->u
.indirect
.section
->owner
;
5271 if (! sub
->output_has_begun
)
5273 if (! elf_link_input_bfd (&finfo
, sub
))
5275 sub
->output_has_begun
= true;
5278 else if (p
->type
== bfd_section_reloc_link_order
5279 || p
->type
== bfd_symbol_reloc_link_order
)
5281 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5286 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5292 /* That wrote out all the local symbols. Finish up the symbol table
5293 with the global symbols. */
5295 /* The sh_info field records the index of the first non local
5297 symtab_hdr
->sh_info
= abfd
->symcount
;
5299 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5301 /* We get the global symbols from the hash table. */
5302 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5305 /* Flush all symbols to the file. */
5306 if (! elf_link_flush_output_syms (&finfo
))
5309 /* Now we know the size of the symtab section. */
5310 off
+= symtab_hdr
->sh_size
;
5312 /* Finish up the symbol string table (.strtab) section. */
5313 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5314 /* sh_name was set in prep_headers. */
5315 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5316 symstrtab_hdr
->sh_flags
= 0;
5317 symstrtab_hdr
->sh_addr
= 0;
5318 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5319 symstrtab_hdr
->sh_entsize
= 0;
5320 symstrtab_hdr
->sh_link
= 0;
5321 symstrtab_hdr
->sh_info
= 0;
5322 /* sh_offset is set just below. */
5323 symstrtab_hdr
->sh_addralign
= 1;
5324 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5326 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5327 elf_tdata (abfd
)->next_file_pos
= off
;
5329 /* Adjust the relocs to have the correct symbol indices. */
5330 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5332 struct elf_link_hash_entry
**rel_hash
;
5333 Elf_Internal_Shdr
*rel_hdr
;
5335 if ((o
->flags
& SEC_RELOC
) == 0)
5338 rel_hash
= elf_section_data (o
)->rel_hashes
;
5339 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5340 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5342 if (*rel_hash
== NULL
)
5345 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5347 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5349 Elf_External_Rel
*erel
;
5350 Elf_Internal_Rel irel
;
5352 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5353 elf_swap_reloc_in (abfd
, erel
, &irel
);
5354 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5355 ELF_R_TYPE (irel
.r_info
));
5356 elf_swap_reloc_out (abfd
, &irel
, erel
);
5360 Elf_External_Rela
*erela
;
5361 Elf_Internal_Rela irela
;
5363 BFD_ASSERT (rel_hdr
->sh_entsize
5364 == sizeof (Elf_External_Rela
));
5366 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5367 elf_swap_reloca_in (abfd
, erela
, &irela
);
5368 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5369 ELF_R_TYPE (irela
.r_info
));
5370 elf_swap_reloca_out (abfd
, &irela
, erela
);
5374 /* Set the reloc_count field to 0 to prevent write_relocs from
5375 trying to swap the relocs out itself. */
5379 /* If we are linking against a dynamic object, finish up the dynamic
5380 linking information. */
5383 Elf_External_Dyn
*dyncon
, *dynconend
;
5385 /* Fix up .dynamic entries. */
5386 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5387 BFD_ASSERT (o
!= NULL
);
5389 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5390 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5391 for (; dyncon
< dynconend
; dyncon
++)
5393 Elf_Internal_Dyn dyn
;
5397 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5419 o
= bfd_get_section_by_name (abfd
, name
);
5420 BFD_ASSERT (o
!= NULL
);
5421 dyn
.d_un
.d_ptr
= o
->vma
;
5422 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5429 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5434 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5436 Elf_Internal_Shdr
*hdr
;
5438 hdr
= elf_elfsections (abfd
)[i
];
5439 if (hdr
->sh_type
== type
5440 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5442 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5443 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5446 if (dyn
.d_un
.d_val
== 0
5447 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5448 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5452 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5457 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5460 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5462 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5464 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5466 BFD_ASSERT (info
->shared
);
5469 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5470 o
->contents
, o
->output_offset
,
5476 /* Now backend stuff. */
5477 if (bed
->elf_backend_final_write_processing
)
5478 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5480 if (finfo
.contents
!= NULL
)
5481 free (finfo
.contents
);
5482 if (finfo
.external_relocs
!= NULL
)
5483 free (finfo
.external_relocs
);
5484 if (finfo
.internal_relocs
!= NULL
)
5485 free (finfo
.internal_relocs
);
5486 if (finfo
.external_syms
!= NULL
)
5487 free (finfo
.external_syms
);
5488 if (finfo
.internal_syms
!= NULL
)
5489 free (finfo
.internal_syms
);
5490 if (finfo
.indices
!= NULL
)
5491 free (finfo
.indices
);
5492 if (finfo
.sections
!= NULL
)
5493 free (finfo
.sections
);
5494 if (finfo
.symbuf
!= NULL
)
5495 free (finfo
.symbuf
);
5496 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5498 if ((o
->flags
& SEC_RELOC
) != 0
5499 && elf_section_data (o
)->rel_hashes
!= NULL
)
5500 free (elf_section_data (o
)->rel_hashes
);
5506 if (finfo
.contents
!= NULL
)
5507 free (finfo
.contents
);
5508 if (finfo
.external_relocs
!= NULL
)
5509 free (finfo
.external_relocs
);
5510 if (finfo
.internal_relocs
!= NULL
)
5511 free (finfo
.internal_relocs
);
5512 if (finfo
.external_syms
!= NULL
)
5513 free (finfo
.external_syms
);
5514 if (finfo
.internal_syms
!= NULL
)
5515 free (finfo
.internal_syms
);
5516 if (finfo
.indices
!= NULL
)
5517 free (finfo
.indices
);
5518 if (finfo
.sections
!= NULL
)
5519 free (finfo
.sections
);
5520 if (finfo
.symbuf
!= NULL
)
5521 free (finfo
.symbuf
);
5522 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5524 if ((o
->flags
& SEC_RELOC
) != 0
5525 && elf_section_data (o
)->rel_hashes
!= NULL
)
5526 free (elf_section_data (o
)->rel_hashes
);
5532 /* Add a symbol to the output symbol table. */
5535 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5536 struct elf_final_link_info
*finfo
;
5538 Elf_Internal_Sym
*elfsym
;
5539 asection
*input_sec
;
5541 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5542 struct bfd_link_info
*info
,
5547 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5548 elf_backend_link_output_symbol_hook
;
5549 if (output_symbol_hook
!= NULL
)
5551 if (! ((*output_symbol_hook
)
5552 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5556 if (name
== (const char *) NULL
|| *name
== '\0')
5557 elfsym
->st_name
= 0;
5560 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5561 finfo
->symstrtab
, name
);
5562 if (elfsym
->st_name
== (unsigned long) -1)
5566 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5568 if (! elf_link_flush_output_syms (finfo
))
5572 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5573 finfo
->symbuf
+ finfo
->symbuf_count
);
5574 ++finfo
->symbuf_count
;
5576 ++finfo
->output_bfd
->symcount
;
5581 /* Flush the output symbols to the file. */
5584 elf_link_flush_output_syms (finfo
)
5585 struct elf_final_link_info
*finfo
;
5587 Elf_Internal_Shdr
*symtab
;
5589 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5591 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5593 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5594 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5595 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5598 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5600 finfo
->symbuf_count
= 0;
5605 /* Add an external symbol to the symbol table. This is called from
5606 the hash table traversal routine. */
5609 elf_link_output_extsym (h
, data
)
5610 struct elf_link_hash_entry
*h
;
5613 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5615 Elf_Internal_Sym sym
;
5616 asection
*input_sec
;
5618 /* We don't want to output symbols that have never been mentioned by
5619 a regular file, or that we have been told to strip. However, if
5620 h->indx is set to -2, the symbol is used by a reloc and we must
5624 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5625 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5626 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5627 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5629 else if (finfo
->info
->strip
== strip_all
5630 || (finfo
->info
->strip
== strip_some
5631 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5632 h
->root
.root
.string
,
5633 false, false) == NULL
))
5638 /* If we're stripping it, and it's not a dynamic symbol, there's
5639 nothing else to do. */
5640 if (strip
&& h
->dynindx
== -1)
5644 sym
.st_size
= h
->size
;
5646 if (h
->root
.type
== bfd_link_hash_weak
5647 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEFINED_WEAK
) != 0)
5648 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5650 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5652 switch (h
->root
.type
)
5655 case bfd_link_hash_new
:
5659 case bfd_link_hash_undefined
:
5660 input_sec
= bfd_und_section_ptr
;
5661 sym
.st_shndx
= SHN_UNDEF
;
5664 case bfd_link_hash_weak
:
5665 input_sec
= bfd_und_section_ptr
;
5666 sym
.st_shndx
= SHN_UNDEF
;
5669 case bfd_link_hash_defined
:
5672 input_sec
= h
->root
.u
.def
.section
;
5673 if (input_sec
->output_section
!= NULL
)
5675 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5676 input_sec
->output_section
);
5677 if (sym
.st_shndx
== (unsigned short) -1)
5679 /* FIXME: No way to handle errors. */
5683 /* ELF symbols in relocateable files are section relative,
5684 but in nonrelocateable files they are virtual
5686 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5687 if (! finfo
->info
->relocateable
)
5688 sym
.st_value
+= input_sec
->output_section
->vma
;
5692 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5693 == bfd_target_elf_flavour
5694 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5695 sym
.st_shndx
= SHN_UNDEF
;
5696 input_sec
= bfd_und_section_ptr
;
5701 case bfd_link_hash_common
:
5702 input_sec
= bfd_com_section_ptr
;
5703 sym
.st_shndx
= SHN_COMMON
;
5707 sym
.st_value
= h
->align
;
5710 case bfd_link_hash_indirect
:
5711 case bfd_link_hash_warning
:
5712 /* I have no idea how these should be handled. */
5716 /* If this symbol should be put in the .dynsym section, then put it
5717 there now. We have already know the symbol index. We also fill
5718 in the entry in the .hash section. */
5719 if (h
->dynindx
!= -1)
5721 struct elf_backend_data
*bed
;
5724 bfd_byte
*bucketpos
;
5727 sym
.st_name
= h
->dynstr_index
;
5729 /* Give the processor backend a chance to tweak the symbol
5730 value, and also to finish up anything that needs to be done
5732 bed
= get_elf_backend_data (finfo
->output_bfd
);
5733 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5734 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5736 /* FIXME: No way to return error. */
5740 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5741 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5744 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5745 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5746 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5747 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5748 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5749 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5750 put_word (finfo
->output_bfd
, chain
,
5751 ((bfd_byte
*) finfo
->hash_sec
->contents
5752 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5755 /* If we're stripping it, then it was just a dynamic symbol, and
5756 there's nothing else to do. */
5760 h
->indx
= finfo
->output_bfd
->symcount
;
5762 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5764 /* FIXME: No way to return error. */
5771 /* Link an input file into the linker output file. This function
5772 handles all the sections and relocations of the input file at once.
5773 This is so that we only have to read the local symbols once, and
5774 don't have to keep them in memory. */
5777 elf_link_input_bfd (finfo
, input_bfd
)
5778 struct elf_final_link_info
*finfo
;
5781 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5782 bfd
*, asection
*, bfd_byte
*,
5783 Elf_Internal_Rela
*,
5785 asection
**, char *));
5787 Elf_Internal_Shdr
*symtab_hdr
;
5790 Elf_External_Sym
*esym
;
5791 Elf_External_Sym
*esymend
;
5792 Elf_Internal_Sym
*isym
;
5794 asection
**ppsection
;
5797 output_bfd
= finfo
->output_bfd
;
5799 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5801 /* If this is a dynamic object, we don't want to do anything here:
5802 we don't want the local symbols, and we don't want the section
5804 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5807 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5808 if (elf_bad_symtab (input_bfd
))
5810 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5815 locsymcount
= symtab_hdr
->sh_info
;
5816 extsymoff
= symtab_hdr
->sh_info
;
5819 /* Read the local symbols. */
5821 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5822 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5823 locsymcount
, input_bfd
)
5824 != locsymcount
* sizeof (Elf_External_Sym
))))
5827 /* Swap in the local symbols and write out the ones which we know
5828 are going into the output file. */
5829 esym
= finfo
->external_syms
;
5830 esymend
= esym
+ locsymcount
;
5831 isym
= finfo
->internal_syms
;
5832 pindex
= finfo
->indices
;
5833 ppsection
= finfo
->sections
;
5834 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5840 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5843 if (elf_bad_symtab (input_bfd
))
5845 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5852 if (isym
->st_shndx
== SHN_UNDEF
)
5853 isec
= bfd_und_section_ptr
;
5854 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5856 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5860 else if (isym
->st_shndx
== SHN_ABS
)
5861 isec
= bfd_abs_section_ptr
;
5862 else if (isym
->st_shndx
== SHN_COMMON
)
5863 isec
= bfd_com_section_ptr
;
5872 /* Don't output the first, undefined, symbol. */
5873 if (esym
== finfo
->external_syms
)
5876 /* If we are stripping all symbols, we don't want to output this
5878 if (finfo
->info
->strip
== strip_all
)
5881 /* We never output section symbols. Instead, we use the section
5882 symbol of the corresponding section in the output file. */
5883 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5886 /* If we are discarding all local symbols, we don't want to
5887 output this one. If we are generating a relocateable output
5888 file, then some of the local symbols may be required by
5889 relocs; we output them below as we discover that they are
5891 if (finfo
->info
->discard
== discard_all
)
5894 /* Get the name of the symbol. */
5895 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5900 /* See if we are discarding symbols with this name. */
5901 if ((finfo
->info
->strip
== strip_some
5902 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5904 || (finfo
->info
->discard
== discard_l
5905 && strncmp (name
, finfo
->info
->lprefix
,
5906 finfo
->info
->lprefix_len
) == 0))
5909 /* If we get here, we are going to output this symbol. */
5911 /* Adjust the section index for the output file. */
5912 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
5913 isec
->output_section
);
5914 if (isym
->st_shndx
== (unsigned short) -1)
5917 *pindex
= output_bfd
->symcount
;
5919 /* ELF symbols in relocateable files are section relative, but
5920 in executable files they are virtual addresses. Note that
5921 this code assumes that all ELF sections have an associated
5922 BFD section with a reasonable value for output_offset; below
5923 we assume that they also have a reasonable value for
5924 output_section. Any special sections must be set up to meet
5925 these requirements. */
5926 oldval
= isym
->st_value
;
5927 isym
->st_value
+= isec
->output_offset
;
5928 if (! finfo
->info
->relocateable
)
5929 isym
->st_value
+= isec
->output_section
->vma
;
5931 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
5934 /* Restore the old value for reloc handling. */
5935 isym
->st_value
= oldval
;
5938 /* Relocate the contents of each section. */
5939 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5941 Elf_Internal_Shdr
*input_rel_hdr
;
5943 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5946 if ((o
->flags
& SEC_IN_MEMORY
) != 0
5947 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
5949 /* Section was created by elf_link_create_dynamic_sections.
5950 FIXME: This test is fragile. */
5954 /* Read the contents of the section. */
5955 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5956 (file_ptr
) 0, o
->_raw_size
))
5959 if ((o
->flags
& SEC_RELOC
) != 0)
5961 PTR external_relocs
;
5963 /* Get the external relocs. They may have been cached. */
5964 external_relocs
= elf_section_data (o
)->relocs
;
5965 if (external_relocs
== NULL
)
5967 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5968 if ((bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
)
5970 || (bfd_read (finfo
->external_relocs
, 1,
5971 input_rel_hdr
->sh_size
, input_bfd
)
5972 != input_rel_hdr
->sh_size
))
5974 external_relocs
= finfo
->external_relocs
;
5977 /* Swap in the relocs. For convenience, we always produce
5978 an Elf_Internal_Rela array; if the relocs are Rel, we set
5980 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5982 Elf_External_Rel
*erel
;
5983 Elf_External_Rel
*erelend
;
5984 Elf_Internal_Rela
*irela
;
5986 erel
= (Elf_External_Rel
*) external_relocs
;
5987 erelend
= erel
+ o
->reloc_count
;
5988 irela
= finfo
->internal_relocs
;
5989 for (; erel
< erelend
; erel
++, irela
++)
5991 Elf_Internal_Rel irel
;
5993 elf_swap_reloc_in (input_bfd
, erel
, &irel
);
5994 irela
->r_offset
= irel
.r_offset
;
5995 irela
->r_info
= irel
.r_info
;
5996 irela
->r_addend
= 0;
6001 Elf_External_Rela
*erela
;
6002 Elf_External_Rela
*erelaend
;
6003 Elf_Internal_Rela
*irela
;
6005 BFD_ASSERT (input_rel_hdr
->sh_entsize
6006 == sizeof (Elf_External_Rela
));
6008 erela
= (Elf_External_Rela
*) external_relocs
;
6009 erelaend
= erela
+ o
->reloc_count
;
6010 irela
= finfo
->internal_relocs
;
6011 for (; erela
< erelaend
; erela
++, irela
++)
6012 elf_swap_reloca_in (input_bfd
, erela
, irela
);
6015 /* Relocate the section by invoking a back end routine.
6017 The back end routine is responsible for adjusting the
6018 section contents as necessary, and (if using Rela relocs
6019 and generating a relocateable output file) adjusting the
6020 reloc addend as necessary.
6022 The back end routine does not have to worry about setting
6023 the reloc address or the reloc symbol index.
6025 The back end routine is given a pointer to the swapped in
6026 internal symbols, and can access the hash table entries
6027 for the external symbols via elf_sym_hashes (input_bfd).
6029 When generating relocateable output, the back end routine
6030 must handle STB_LOCAL/STT_SECTION symbols specially. The
6031 output symbol is going to be a section symbol
6032 corresponding to the output section, which will require
6033 the addend to be adjusted. */
6035 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6038 finfo
->internal_relocs
,
6039 finfo
->internal_syms
,
6041 finfo
->symstrtab
->tab
))
6044 if (finfo
->info
->relocateable
)
6046 Elf_Internal_Rela
*irela
;
6047 Elf_Internal_Rela
*irelaend
;
6048 struct elf_link_hash_entry
**rel_hash
;
6049 Elf_Internal_Shdr
*output_rel_hdr
;
6051 /* Adjust the reloc addresses and symbol indices. */
6053 irela
= finfo
->internal_relocs
;
6054 irelaend
= irela
+ o
->reloc_count
;
6055 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6056 + o
->output_section
->reloc_count
);
6057 for (; irela
< irelaend
; irela
++, rel_hash
++)
6060 Elf_Internal_Sym
*isym
;
6063 irela
->r_offset
+= o
->output_offset
;
6065 r_symndx
= ELF_R_SYM (irela
->r_info
);
6070 if (r_symndx
>= locsymcount
6071 || (elf_bad_symtab (input_bfd
)
6072 && finfo
->sections
[r_symndx
] == NULL
))
6076 /* This is a reloc against a global symbol. We
6077 have not yet output all the local symbols, so
6078 we do not know the symbol index of any global
6079 symbol. We set the rel_hash entry for this
6080 reloc to point to the global hash table entry
6081 for this symbol. The symbol index is then
6082 set at the end of elf_bfd_final_link. */
6083 indx
= r_symndx
- extsymoff
;
6084 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6086 /* Setting the index to -2 tells
6087 elf_link_output_extsym that this symbol is
6089 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6090 (*rel_hash
)->indx
= -2;
6095 /* This is a reloc against a local symbol. */
6098 isym
= finfo
->internal_syms
+ r_symndx
;
6099 sec
= finfo
->sections
[r_symndx
];
6100 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6102 /* I suppose the backend ought to fill in the
6103 section of any STT_SECTION symbol against a
6104 processor specific section. */
6105 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6107 else if (sec
== NULL
|| sec
->owner
== NULL
)
6109 bfd_set_error (bfd_error_bad_value
);
6114 r_symndx
= sec
->output_section
->target_index
;
6121 if (finfo
->indices
[r_symndx
] == -1)
6127 if (finfo
->info
->strip
== strip_all
)
6129 /* You can't do ld -r -s. */
6130 bfd_set_error (bfd_error_invalid_operation
);
6134 /* This symbol was skipped earlier, but
6135 since it is needed by a reloc, we
6136 must output it now. */
6137 link
= symtab_hdr
->sh_link
;
6138 name
= elf_string_from_elf_section (input_bfd
,
6144 osec
= sec
->output_section
;
6146 elf_section_from_bfd_section (output_bfd
,
6148 if (isym
->st_shndx
== (unsigned short) -1)
6151 isym
->st_value
+= sec
->output_offset
;
6152 if (! finfo
->info
->relocateable
)
6153 isym
->st_value
+= osec
->vma
;
6155 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6157 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6161 r_symndx
= finfo
->indices
[r_symndx
];
6164 irela
->r_info
= ELF_R_INFO (r_symndx
,
6165 ELF_R_TYPE (irela
->r_info
));
6168 /* Swap out the relocs. */
6169 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6170 BFD_ASSERT (output_rel_hdr
->sh_entsize
6171 == input_rel_hdr
->sh_entsize
);
6172 irela
= finfo
->internal_relocs
;
6173 irelaend
= irela
+ o
->reloc_count
;
6174 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6176 Elf_External_Rel
*erel
;
6178 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6179 + o
->output_section
->reloc_count
);
6180 for (; irela
< irelaend
; irela
++, erel
++)
6182 Elf_Internal_Rel irel
;
6184 irel
.r_offset
= irela
->r_offset
;
6185 irel
.r_info
= irela
->r_info
;
6186 BFD_ASSERT (irela
->r_addend
== 0);
6187 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6192 Elf_External_Rela
*erela
;
6194 BFD_ASSERT (input_rel_hdr
->sh_entsize
6195 == sizeof (Elf_External_Rela
));
6196 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6197 + o
->output_section
->reloc_count
);
6198 for (; irela
< irelaend
; irela
++, erela
++)
6199 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6202 o
->output_section
->reloc_count
+= o
->reloc_count
;
6206 /* Write out the modified section contents. */
6207 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6208 finfo
->contents
, o
->output_offset
,
6209 (o
->_cooked_size
!= 0
6218 /* Generate a reloc when linking an ELF file. This is a reloc
6219 requested by the linker, and does come from any input file. This
6220 is used to build constructor and destructor tables when linking
6224 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6226 struct bfd_link_info
*info
;
6227 asection
*output_section
;
6228 struct bfd_link_order
*link_order
;
6230 const reloc_howto_type
*howto
;
6233 struct elf_link_hash_entry
**rel_hash_ptr
;
6234 Elf_Internal_Shdr
*rel_hdr
;
6236 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6239 bfd_set_error (bfd_error_bad_value
);
6243 /* If this is an inplace reloc, we must write the addend into the
6245 if (howto
->partial_inplace
6246 && link_order
->u
.reloc
.p
->addend
!= 0)
6249 bfd_reloc_status_type rstat
;
6253 size
= bfd_get_reloc_size (howto
);
6254 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6255 if (buf
== (bfd_byte
*) NULL
)
6257 bfd_set_error (bfd_error_no_memory
);
6260 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6261 link_order
->u
.reloc
.p
->addend
, buf
);
6267 case bfd_reloc_outofrange
:
6269 case bfd_reloc_overflow
:
6270 if (! ((*info
->callbacks
->reloc_overflow
)
6272 (link_order
->type
== bfd_section_reloc_link_order
6273 ? bfd_section_name (output_bfd
,
6274 link_order
->u
.reloc
.p
->u
.section
)
6275 : link_order
->u
.reloc
.p
->u
.name
),
6276 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6277 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6284 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6285 (file_ptr
) link_order
->offset
, size
);
6291 /* Figure out the symbol index. */
6292 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6293 + output_section
->reloc_count
);
6294 if (link_order
->type
== bfd_section_reloc_link_order
)
6296 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6299 *rel_hash_ptr
= NULL
;
6303 struct elf_link_hash_entry
*h
;
6305 h
= elf_link_hash_lookup (elf_hash_table (info
),
6306 link_order
->u
.reloc
.p
->u
.name
,
6307 false, false, true);
6310 /* Setting the index to -2 tells elf_link_output_extsym that
6311 this symbol is used by a reloc. */
6318 if (! ((*info
->callbacks
->unattached_reloc
)
6319 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6320 (asection
*) NULL
, (bfd_vma
) 0)))
6326 /* The address of a reloc is relative to the section in a
6327 relocateable file, and is a virtual address in an executable
6329 offset
= link_order
->offset
;
6330 if (! info
->relocateable
)
6331 offset
+= output_section
->vma
;
6333 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6335 if (rel_hdr
->sh_type
== SHT_REL
)
6337 Elf_Internal_Rel irel
;
6338 Elf_External_Rel
*erel
;
6340 irel
.r_offset
= offset
;
6341 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6342 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6343 + output_section
->reloc_count
);
6344 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6348 Elf_Internal_Rela irela
;
6349 Elf_External_Rela
*erela
;
6351 irela
.r_offset
= offset
;
6352 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6353 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6354 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6355 + output_section
->reloc_count
);
6356 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6359 ++output_section
->reloc_count
;