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