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 int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
149 struct symbol_cache_entry
**));
151 static boolean elf_compute_section_file_positions
152 PARAMS ((bfd
*, struct bfd_link_info
*));
153 static boolean prep_headers
PARAMS ((bfd
*));
154 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
155 static boolean assign_section_numbers
PARAMS ((bfd
*));
156 static file_ptr align_file_position
PARAMS ((file_ptr
));
157 static file_ptr assign_file_position_for_section
158 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
159 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
160 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
161 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
162 static file_ptr map_program_segments
163 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
165 static boolean elf_map_symbols
PARAMS ((bfd
*));
166 static boolean swap_out_syms
PARAMS ((bfd
*));
168 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
171 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
172 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
175 #define elf_string_from_elf_strtab(abfd,strindex) \
176 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
179 /* Structure swapping routines */
181 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
182 can be handled by explicitly specifying 32 bits or "the long type". */
184 #define put_word bfd_h_put_64
185 #define get_word bfd_h_get_64
188 #define put_word bfd_h_put_32
189 #define get_word bfd_h_get_32
192 /* Translate an ELF symbol in external format into an ELF symbol in internal
196 elf_swap_symbol_in (abfd
, src
, dst
)
198 Elf_External_Sym
*src
;
199 Elf_Internal_Sym
*dst
;
201 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
202 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
203 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
204 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
205 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
206 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
209 /* Translate an ELF symbol in internal format into an ELF symbol in external
213 elf_swap_symbol_out (abfd
, src
, dst
)
215 Elf_Internal_Sym
*src
;
216 Elf_External_Sym
*dst
;
218 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
219 put_word (abfd
, src
->st_value
, dst
->st_value
);
220 put_word (abfd
, src
->st_size
, dst
->st_size
);
221 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
222 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
223 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
227 /* Translate an ELF file header in external format into an ELF file header in
231 elf_swap_ehdr_in (abfd
, src
, dst
)
233 Elf_External_Ehdr
*src
;
234 Elf_Internal_Ehdr
*dst
;
236 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
237 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
238 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
239 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
240 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
241 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
242 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
243 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
244 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
245 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
246 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
247 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
248 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
249 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
252 /* Translate an ELF file header in internal format into an ELF file header in
256 elf_swap_ehdr_out (abfd
, src
, dst
)
258 Elf_Internal_Ehdr
*src
;
259 Elf_External_Ehdr
*dst
;
261 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
262 /* note that all elements of dst are *arrays of unsigned char* already... */
263 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
264 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
265 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
266 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
267 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
268 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
269 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
270 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
271 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
272 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
273 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
274 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
275 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
279 /* Translate an ELF section header table entry in external format into an
280 ELF section header table entry in internal format. */
283 elf_swap_shdr_in (abfd
, src
, dst
)
285 Elf_External_Shdr
*src
;
286 Elf_Internal_Shdr
*dst
;
288 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
289 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
290 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
291 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
292 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
293 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
294 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
295 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
296 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
297 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
298 /* we haven't done any processing on it yet, so... */
299 dst
->rawdata
= (void *) 0;
302 /* Translate an ELF section header table entry in internal format into an
303 ELF section header table entry in external format. */
306 elf_swap_shdr_out (abfd
, src
, dst
)
308 Elf_Internal_Shdr
*src
;
309 Elf_External_Shdr
*dst
;
311 /* note that all elements of dst are *arrays of unsigned char* already... */
312 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
313 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
314 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
315 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
316 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
317 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
318 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
319 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
320 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
321 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
325 /* Translate an ELF program header table entry in external format into an
326 ELF program header table entry in internal format. */
329 elf_swap_phdr_in (abfd
, src
, dst
)
331 Elf_External_Phdr
*src
;
332 Elf_Internal_Phdr
*dst
;
334 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
335 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
336 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
337 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
338 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
339 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
340 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
341 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
345 elf_swap_phdr_out (abfd
, src
, dst
)
347 Elf_Internal_Phdr
*src
;
348 Elf_External_Phdr
*dst
;
350 /* note that all elements of dst are *arrays of unsigned char* already... */
351 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
352 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
353 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
354 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
355 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
356 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
357 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
358 put_word (abfd
, src
->p_align
, dst
->p_align
);
361 /* Translate an ELF reloc from external format to internal format. */
363 elf_swap_reloc_in (abfd
, src
, dst
)
365 Elf_External_Rel
*src
;
366 Elf_Internal_Rel
*dst
;
368 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
369 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
373 elf_swap_reloca_in (abfd
, src
, dst
)
375 Elf_External_Rela
*src
;
376 Elf_Internal_Rela
*dst
;
378 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
379 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
380 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
383 /* Translate an ELF reloc from internal format to external format. */
385 elf_swap_reloc_out (abfd
, src
, dst
)
387 Elf_Internal_Rel
*src
;
388 Elf_External_Rel
*dst
;
390 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
391 put_word (abfd
, src
->r_info
, dst
->r_info
);
395 elf_swap_reloca_out (abfd
, src
, dst
)
397 Elf_Internal_Rela
*src
;
398 Elf_External_Rela
*dst
;
400 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
401 put_word (abfd
, src
->r_info
, dst
->r_info
);
402 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
406 elf_swap_dyn_in (abfd
, src
, dst
)
408 const Elf_External_Dyn
*src
;
409 Elf_Internal_Dyn
*dst
;
411 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
412 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
416 elf_swap_dyn_out (abfd
, src
, dst
)
418 const Elf_Internal_Dyn
*src
;
419 Elf_External_Dyn
*dst
;
421 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
422 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
425 /* String table creation/manipulation routines */
427 static struct strtab
*
428 bfd_new_strtab (abfd
)
433 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
436 bfd_set_error (bfd_error_no_memory
);
439 ss
->tab
= malloc (1);
442 bfd_set_error (bfd_error_no_memory
);
453 bfd_add_to_strtab (abfd
, ss
, str
)
458 /* should search first, but for now: */
459 /* include the trailing NUL */
460 int ln
= strlen (str
) + 1;
462 /* FIXME: This is slow. Also, we could combine this with the a.out
463 string table building and use a hash table, although it might not
464 be worth it since ELF symbols don't include debugging information
465 and thus have much less overlap. */
466 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
469 bfd_set_error (bfd_error_no_memory
);
470 return (unsigned long) -1;
473 strcpy (ss
->tab
+ ss
->length
, str
);
477 return ss
->length
- ln
;
481 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
487 /* should search first, but for now: */
488 /* include the trailing NUL */
489 int ln
= strlen (str
) + strlen (str2
) + 1;
491 /* should this be using obstacks? */
493 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
495 ss
->tab
= malloc (ln
);
497 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
498 strcpy (ss
->tab
+ ss
->length
, str
);
499 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
503 return ss
->length
- ln
;
506 /* ELF .o/exec file reading */
508 /* Create a new bfd section from an ELF section header. */
511 bfd_section_from_shdr (abfd
, shindex
)
513 unsigned int shindex
;
515 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
516 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
519 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
521 switch (hdr
->sh_type
)
524 /* Inactive section. Throw it away. */
527 case SHT_PROGBITS
: /* Normal section with contents. */
528 case SHT_DYNAMIC
: /* Dynamic linking information. */
529 case SHT_NOBITS
: /* .bss section. */
530 case SHT_HASH
: /* .hash section. */
531 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
533 case SHT_SYMTAB
: /* A symbol table */
534 if (elf_onesymtab (abfd
) == shindex
)
537 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
538 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
539 elf_onesymtab (abfd
) = shindex
;
540 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
541 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
542 abfd
->flags
|= HAS_SYMS
;
545 case SHT_DYNSYM
: /* A dynamic symbol table */
546 if (elf_dynsymtab (abfd
) == shindex
)
549 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
550 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
551 elf_dynsymtab (abfd
) = shindex
;
552 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
553 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
554 abfd
->flags
|= HAS_SYMS
;
556 /* Besides being a symbol table, we also treat this as a regular
557 section, so that objcopy can handle it. */
558 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
560 case SHT_STRTAB
: /* A string table */
561 if (hdr
->rawdata
!= NULL
)
563 if (ehdr
->e_shstrndx
== shindex
)
565 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
566 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
567 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
573 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
575 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
576 if (hdr2
->sh_link
== shindex
)
578 if (! bfd_section_from_shdr (abfd
, i
))
580 if (elf_onesymtab (abfd
) == i
)
582 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
583 elf_elfsections (abfd
)[shindex
] =
584 &elf_tdata (abfd
)->strtab_hdr
;
587 if (elf_dynsymtab (abfd
) == i
)
589 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
590 elf_elfsections (abfd
)[shindex
] =
591 &elf_tdata (abfd
)->dynstrtab_hdr
;
592 /* We also treat this as a regular section, so
593 that objcopy can handle it. */
596 #if 0 /* Not handling other string tables specially right now. */
597 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
598 /* We have a strtab for some random other section. */
599 newsect
= (asection
*) hdr2
->rawdata
;
602 hdr
->rawdata
= (PTR
) newsect
;
603 hdr2
= &elf_section_data (newsect
)->str_hdr
;
605 elf_elfsections (abfd
)[shindex
] = hdr2
;
611 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
615 /* *These* do a lot of work -- but build no sections! */
617 asection
*target_sect
;
618 Elf_Internal_Shdr
*hdr2
;
619 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
621 /* Get the symbol table. */
622 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
625 /* If this reloc section does not use the main symbol table we
626 don't treat it as a reloc section. BFD can't adequately
627 represent such a section, so at least for now, we don't
628 try. We just present it as a normal section. */
629 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
630 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
632 /* Don't allow REL relocations on a machine that uses RELA and
634 /* @@ Actually, the generic ABI does suggest that both might be
635 used in one file. But the four ABI Processor Supplements I
636 have access to right now all specify that only one is used on
637 each of those architectures. It's conceivable that, e.g., a
638 bunch of absolute 32-bit relocs might be more compact in REL
639 form even on a RELA machine... */
640 BFD_ASSERT (use_rela_p
641 ? (hdr
->sh_type
== SHT_RELA
642 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
643 : (hdr
->sh_type
== SHT_REL
644 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
646 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
648 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
649 if (target_sect
== NULL
650 || elf_section_data (target_sect
) == NULL
)
653 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
655 elf_elfsections (abfd
)[shindex
] = hdr2
;
656 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
657 target_sect
->flags
|= SEC_RELOC
;
658 target_sect
->relocation
= NULL
;
659 target_sect
->rel_filepos
= hdr
->sh_offset
;
660 abfd
->flags
|= HAS_RELOC
;
667 fprintf (stderr
, "Note Sections not yet supported.\n");
674 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
679 /* Check for any processor-specific section types. */
681 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
683 if (bed
->elf_backend_section_from_shdr
)
684 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
693 elf_new_section_hook (abfd
, sec
)
698 struct bfd_elf_section_data
*sdata
;
700 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
703 bfd_set_error (bfd_error_no_memory
);
706 sec
->used_by_bfd
= (PTR
) sdata
;
707 memset (sdata
, 0, sizeof (*sdata
));
711 /* Create a new bfd section from an ELF program header.
713 Since program segments have no names, we generate a synthetic name
714 of the form segment<NUM>, where NUM is generally the index in the
715 program header table. For segments that are split (see below) we
716 generate the names segment<NUM>a and segment<NUM>b.
718 Note that some program segments may have a file size that is different than
719 (less than) the memory size. All this means is that at execution the
720 system must allocate the amount of memory specified by the memory size,
721 but only initialize it with the first "file size" bytes read from the
722 file. This would occur for example, with program segments consisting
723 of combined data+bss.
725 To handle the above situation, this routine generates TWO bfd sections
726 for the single program segment. The first has the length specified by
727 the file size of the segment, and the second has the length specified
728 by the difference between the two sizes. In effect, the segment is split
729 into it's initialized and uninitialized parts.
734 bfd_section_from_phdr (abfd
, hdr
, index
)
736 Elf_Internal_Phdr
*hdr
;
744 split
= ((hdr
->p_memsz
> 0) &&
745 (hdr
->p_filesz
> 0) &&
746 (hdr
->p_memsz
> hdr
->p_filesz
));
747 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
748 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
751 bfd_set_error (bfd_error_no_memory
);
754 strcpy (name
, namebuf
);
755 newsect
= bfd_make_section (abfd
, name
);
758 newsect
->vma
= hdr
->p_vaddr
;
759 newsect
->_raw_size
= hdr
->p_filesz
;
760 newsect
->filepos
= hdr
->p_offset
;
761 newsect
->flags
|= SEC_HAS_CONTENTS
;
762 if (hdr
->p_type
== PT_LOAD
)
764 newsect
->flags
|= SEC_ALLOC
;
765 newsect
->flags
|= SEC_LOAD
;
766 if (hdr
->p_flags
& PF_X
)
768 /* FIXME: all we known is that it has execute PERMISSION,
770 newsect
->flags
|= SEC_CODE
;
773 if (!(hdr
->p_flags
& PF_W
))
775 newsect
->flags
|= SEC_READONLY
;
780 sprintf (namebuf
, "segment%db", index
);
781 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
784 bfd_set_error (bfd_error_no_memory
);
787 strcpy (name
, namebuf
);
788 newsect
= bfd_make_section (abfd
, name
);
791 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
792 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
793 if (hdr
->p_type
== PT_LOAD
)
795 newsect
->flags
|= SEC_ALLOC
;
796 if (hdr
->p_flags
& PF_X
)
797 newsect
->flags
|= SEC_CODE
;
799 if (!(hdr
->p_flags
& PF_W
))
800 newsect
->flags
|= SEC_READONLY
;
806 /* Begin processing a given object.
808 First we validate the file by reading in the ELF header and checking
811 static INLINE boolean
813 Elf_External_Ehdr
*x_ehdrp
;
815 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
816 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
817 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
818 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
821 /* Check to see if the file associated with ABFD matches the target vector
824 Note that we may be called several times with the same ABFD, but different
825 target vectors, most of which will not match. We have to avoid leaving
826 any side effects in ABFD, or any data it points to (like tdata), if the
827 file does not match the target vector. */
833 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
834 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
835 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
836 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
837 unsigned int shindex
;
838 char *shstrtab
; /* Internal copy of section header stringtab */
839 struct elf_backend_data
*ebd
;
840 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
841 struct elf_obj_tdata
*new_tdata
= NULL
;
843 /* Read in the ELF header in external format. */
845 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
847 if (bfd_get_error () != bfd_error_system_call
)
848 goto got_wrong_format_error
;
853 /* Now check to see if we have a valid ELF file, and one that BFD can
854 make use of. The magic number must match, the address size ('class')
855 and byte-swapping must match our XVEC entry, and it must have a
856 section header table (FIXME: See comments re sections at top of this
859 if ((elf_file_p (&x_ehdr
) == false) ||
860 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
861 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
862 goto got_wrong_format_error
;
864 /* Check that file's byte order matches xvec's */
865 switch (x_ehdr
.e_ident
[EI_DATA
])
867 case ELFDATA2MSB
: /* Big-endian */
868 if (!abfd
->xvec
->header_byteorder_big_p
)
869 goto got_wrong_format_error
;
871 case ELFDATA2LSB
: /* Little-endian */
872 if (abfd
->xvec
->header_byteorder_big_p
)
873 goto got_wrong_format_error
;
875 case ELFDATANONE
: /* No data encoding specified */
876 default: /* Unknown data encoding specified */
877 goto got_wrong_format_error
;
880 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
881 the tdata pointer in the bfd. */
883 new_tdata
= ((struct elf_obj_tdata
*)
884 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
885 if (new_tdata
== NULL
)
886 goto got_no_memory_error
;
887 elf_tdata (abfd
) = new_tdata
;
889 /* Now that we know the byte order, swap in the rest of the header */
890 i_ehdrp
= elf_elfheader (abfd
);
891 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
893 elf_debug_file (i_ehdrp
);
896 /* If there is no section header table, we're hosed. */
897 if (i_ehdrp
->e_shoff
== 0)
898 goto got_wrong_format_error
;
900 /* As a simple sanity check, verify that the what BFD thinks is the
901 size of each section header table entry actually matches the size
902 recorded in the file. */
903 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
904 goto got_wrong_format_error
;
906 ebd
= get_elf_backend_data (abfd
);
908 /* Check that the ELF e_machine field matches what this particular
909 BFD format expects. */
910 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
912 const bfd_target
* const *target_ptr
;
914 if (ebd
->elf_machine_code
!= EM_NONE
)
915 goto got_wrong_format_error
;
917 /* This is the generic ELF target. Let it match any ELF target
918 for which we do not have a specific backend. */
919 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
921 struct elf_backend_data
*back
;
923 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
925 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
926 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
928 /* target_ptr is an ELF backend which matches this
929 object file, so reject the generic ELF target. */
930 goto got_wrong_format_error
;
935 if (i_ehdrp
->e_type
== ET_EXEC
)
936 abfd
->flags
|= EXEC_P
;
937 else if (i_ehdrp
->e_type
== ET_DYN
)
938 abfd
->flags
|= DYNAMIC
;
940 if (i_ehdrp
->e_phnum
> 0)
941 abfd
->flags
|= D_PAGED
;
943 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
946 /* Remember the entry point specified in the ELF file header. */
947 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
949 /* Allocate space for a copy of the section header table in
950 internal form, seek to the section header table in the file,
951 read it in, and convert it to internal form. */
952 i_shdrp
= ((Elf_Internal_Shdr
*)
953 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
954 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
956 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
957 if (!i_shdrp
|| !elf_elfsections (abfd
))
958 goto got_no_memory_error
;
959 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
961 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
963 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
965 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
966 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
968 if (i_ehdrp
->e_shstrndx
)
970 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
974 /* Read in the string table containing the names of the sections. We
975 will need the base pointer to this table later. */
976 /* We read this inline now, so that we don't have to go through
977 bfd_section_from_shdr with it (since this particular strtab is
978 used to find all of the ELF section names.) */
980 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
984 /* Once all of the section headers have been read and converted, we
985 can start processing them. Note that the first section header is
986 a dummy placeholder entry, so we ignore it. */
988 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
990 if (! bfd_section_from_shdr (abfd
, shindex
))
994 /* Let the backend double check the format and override global
996 if (ebd
->elf_backend_object_p
)
998 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
999 goto got_wrong_format_error
;
1002 return (abfd
->xvec
);
1004 got_wrong_format_error
:
1005 bfd_set_error (bfd_error_wrong_format
);
1007 got_no_memory_error
:
1008 bfd_set_error (bfd_error_no_memory
);
1011 if (new_tdata
!= NULL
1012 && new_tdata
->elf_sect_ptr
!= NULL
)
1013 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1014 if (i_shdrp
!= NULL
)
1015 bfd_release (abfd
, i_shdrp
);
1016 if (new_tdata
!= NULL
)
1017 bfd_release (abfd
, new_tdata
);
1018 elf_tdata (abfd
) = preserved_tdata
;
1023 /* ELF .o/exec file writing */
1025 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1026 of the symbol if there is one. */
1027 static INLINE elf_symbol_type
*
1028 elf_symbol_from (ignore_abfd
, symbol
)
1032 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1035 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1038 return (elf_symbol_type
*) symbol
;
1042 write_relocs (abfd
, sec
, xxx
)
1047 Elf_Internal_Shdr
*rela_hdr
;
1048 Elf_External_Rela
*outbound_relocas
;
1049 Elf_External_Rel
*outbound_relocs
;
1051 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1052 asymbol
*last_sym
= 0;
1053 int last_sym_idx
= 9999999; /* should always be written before use */
1055 if ((sec
->flags
& SEC_RELOC
) == 0)
1058 /* The linker backend writes the relocs out itself, and sets the
1059 reloc_count field to zero to inhibit writing them here. Also,
1060 sometimes the SEC_RELOC flag gets set even when there aren't any
1062 if (sec
->reloc_count
== 0)
1065 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1067 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1068 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1069 if (!rela_hdr
->contents
)
1071 bfd_set_error (bfd_error_no_memory
);
1072 abort (); /* FIXME */
1075 /* orelocation has the data, reloc_count has the count... */
1078 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1080 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1082 Elf_Internal_Rela dst_rela
;
1083 Elf_External_Rela
*src_rela
;
1088 ptr
= sec
->orelocation
[idx
];
1089 src_rela
= outbound_relocas
+ idx
;
1090 if (!(abfd
->flags
& EXEC_P
))
1091 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1093 dst_rela
.r_offset
= ptr
->address
;
1095 sym
= *ptr
->sym_ptr_ptr
;
1096 if (sym
== last_sym
)
1101 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1103 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1105 dst_rela
.r_addend
= ptr
->addend
;
1106 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1110 /* REL relocations */
1112 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1114 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1116 Elf_Internal_Rel dst_rel
;
1117 Elf_External_Rel
*src_rel
;
1122 ptr
= sec
->orelocation
[idx
];
1123 sym
= *ptr
->sym_ptr_ptr
;
1124 src_rel
= outbound_relocs
+ idx
;
1125 if (!(abfd
->flags
& EXEC_P
))
1126 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1128 dst_rel
.r_offset
= ptr
->address
;
1130 if (sym
== last_sym
)
1135 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1137 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1139 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1144 /* Set up an ELF internal section header for a section. */
1148 elf_fake_sections (abfd
, asect
, ignore
)
1153 Elf_Internal_Shdr
*this_hdr
;
1155 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1157 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1159 if (this_hdr
->sh_name
== (unsigned long) -1)
1160 abort (); /* FIXME */
1162 this_hdr
->sh_flags
= 0;
1163 if ((asect
->flags
& SEC_ALLOC
) != 0)
1164 this_hdr
->sh_addr
= asect
->vma
;
1166 this_hdr
->sh_addr
= 0;
1167 this_hdr
->sh_offset
= 0;
1168 this_hdr
->sh_size
= asect
->_raw_size
;
1169 this_hdr
->sh_link
= 0;
1170 this_hdr
->sh_info
= 0;
1171 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1172 this_hdr
->sh_entsize
= 0;
1174 this_hdr
->rawdata
= (PTR
) asect
;
1175 this_hdr
->contents
= NULL
;
1178 /* FIXME: This should not be based on section names. */
1179 if (strcmp (asect
->name
, ".dynstr") == 0)
1180 this_hdr
->sh_type
= SHT_STRTAB
;
1181 else if (strcmp (asect
->name
, ".hash") == 0)
1183 this_hdr
->sh_type
= SHT_HASH
;
1184 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1186 else if (strcmp (asect
->name
, ".dynsym") == 0)
1188 this_hdr
->sh_type
= SHT_DYNSYM
;
1189 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1191 else if (strcmp (asect
->name
, ".dynamic") == 0)
1193 this_hdr
->sh_type
= SHT_DYNAMIC
;
1194 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1196 else if (strncmp (asect
->name
, ".rel.", 5) == 0)
1198 this_hdr
->sh_type
= SHT_REL
;
1199 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1201 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1203 this_hdr
->sh_type
= SHT_RELA
;
1204 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1206 else if (strcmp (asect
->name
, ".note") == 0)
1207 this_hdr
->sh_type
= SHT_NOTE
;
1208 else if (strncmp (asect
->name
, ".stab", 5) == 0
1209 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1210 this_hdr
->sh_type
= SHT_STRTAB
;
1211 else if ((asect
->flags
& SEC_ALLOC
) != 0
1212 && (asect
->flags
& SEC_LOAD
) != 0)
1213 this_hdr
->sh_type
= SHT_PROGBITS
;
1214 else if ((asect
->flags
& SEC_ALLOC
) != 0
1215 && ((asect
->flags
& SEC_LOAD
) == 0))
1217 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1218 || strcmp (asect
->name
, ".sbss") == 0);
1219 this_hdr
->sh_type
= SHT_NOBITS
;
1224 this_hdr
->sh_type
= SHT_PROGBITS
;
1227 if ((asect
->flags
& SEC_ALLOC
) != 0)
1228 this_hdr
->sh_flags
|= SHF_ALLOC
;
1229 if ((asect
->flags
& SEC_READONLY
) == 0)
1230 this_hdr
->sh_flags
|= SHF_WRITE
;
1231 if ((asect
->flags
& SEC_CODE
) != 0)
1232 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1234 /* Check for processor-specific section types. */
1236 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1238 if (bed
->elf_backend_fake_sections
)
1239 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1242 /* If the section has relocs, set up a section header for the
1243 SHT_REL[A] section. */
1244 if ((asect
->flags
& SEC_RELOC
) != 0)
1246 Elf_Internal_Shdr
*rela_hdr
;
1247 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1249 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1251 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1252 use_rela_p
? ".rela" : ".rel",
1254 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1255 rela_hdr
->sh_entsize
= (use_rela_p
1256 ? sizeof (Elf_External_Rela
)
1257 : sizeof (Elf_External_Rel
));
1258 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1259 rela_hdr
->sh_flags
= 0;
1260 rela_hdr
->sh_addr
= 0;
1261 rela_hdr
->sh_size
= 0;
1262 rela_hdr
->sh_offset
= 0;
1267 /* Assign all ELF section numbers. The dummy first section is handled here
1268 too. The link/info pointers for the standard section types are filled
1269 in here too, while we're at it. */
1272 assign_section_numbers (abfd
)
1275 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1277 unsigned int section_number
;
1278 Elf_Internal_Shdr
**i_shdrp
;
1282 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1284 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1286 d
->this_idx
= section_number
++;
1287 if ((sec
->flags
& SEC_RELOC
) == 0)
1290 d
->rel_idx
= section_number
++;
1293 t
->shstrtab_section
= section_number
++;
1294 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1295 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1296 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1298 if (abfd
->symcount
> 0)
1300 t
->symtab_section
= section_number
++;
1301 t
->strtab_section
= section_number
++;
1304 elf_elfheader (abfd
)->e_shnum
= section_number
;
1306 /* Set up the list of section header pointers, in agreement with the
1308 i_shdrp
= ((Elf_Internal_Shdr
**)
1309 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1310 if (i_shdrp
== NULL
)
1312 bfd_set_error (bfd_error_no_memory
);
1316 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1317 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1318 if (i_shdrp
[0] == NULL
)
1320 bfd_release (abfd
, i_shdrp
);
1321 bfd_set_error (bfd_error_no_memory
);
1324 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1326 elf_elfsections (abfd
) = i_shdrp
;
1328 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1329 if (abfd
->symcount
> 0)
1331 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1332 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1333 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1335 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1337 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1341 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1342 if (d
->rel_idx
!= 0)
1343 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1345 /* Fill in the sh_link and sh_info fields while we're at it. */
1347 /* sh_link of a reloc section is the section index of the symbol
1348 table. sh_info is the section index of the section to which
1349 the relocation entries apply. */
1350 if (d
->rel_idx
!= 0)
1352 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1353 d
->rel_hdr
.sh_info
= d
->this_idx
;
1356 switch (d
->this_hdr
.sh_type
)
1360 /* A reloc section which we are treating as a normal BFD
1361 section. sh_link is the section index of the symbol
1362 table. sh_info is the section index of the section to
1363 which the relocation entries apply. We assume that an
1364 allocated reloc section uses the dynamic symbol table.
1365 FIXME: How can we be sure? */
1366 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1368 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1370 /* We look up the section the relocs apply to by name. */
1372 if (d
->this_hdr
.sh_type
== SHT_REL
)
1376 s
= bfd_get_section_by_name (abfd
, name
);
1378 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1382 /* We assume that a section named .stab*str is a stabs
1383 string section. We look for a section with the same name
1384 but without the trailing ``str'', and set its sh_link
1385 field to point to this section. */
1386 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1387 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1392 len
= strlen (sec
->name
);
1393 alc
= (char *) malloc (len
- 2);
1396 bfd_set_error (bfd_error_no_memory
);
1399 strncpy (alc
, sec
->name
, len
- 3);
1400 alc
[len
- 3] = '\0';
1401 s
= bfd_get_section_by_name (abfd
, alc
);
1405 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1407 /* This is a .stab section. */
1408 elf_section_data (s
)->this_hdr
.sh_entsize
=
1409 4 + 2 * (ARCH_SIZE
/ 8);
1416 /* sh_link is the section header index of the string table
1417 used for the dynamic entries or symbol table. */
1418 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1420 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1424 /* sh_link is the section header index of the symbol table
1425 this hash table is for. */
1426 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1428 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1436 /* Map symbol from it's internal number to the external number, moving
1437 all local symbols to be at the head of the list. */
1440 sym_is_global (abfd
, sym
)
1444 /* If the backend has a special mapping, use it. */
1445 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1446 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1449 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1451 if (sym
->flags
& BSF_LOCAL
)
1455 if (sym
->section
== 0)
1457 /* Is this valid? */
1462 if (bfd_is_und_section (sym
->section
))
1464 if (bfd_is_com_section (sym
->section
))
1466 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1472 elf_map_symbols (abfd
)
1475 int symcount
= bfd_get_symcount (abfd
);
1476 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1477 asymbol
**sect_syms
;
1479 int num_globals
= 0;
1480 int num_locals2
= 0;
1481 int num_globals2
= 0;
1483 int num_sections
= 0;
1484 Elf_Sym_Extra
*sym_extra
;
1489 fprintf (stderr
, "elf_map_symbols\n");
1493 /* Add local symbols for each section for which there are relocs.
1494 FIXME: How can we tell which sections have relocs at this point?
1495 Will reloc_count always be accurate? Actually, I think most ELF
1496 targets create section symbols for all sections anyhow. */
1497 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1499 if (max_index
< asect
->index
)
1500 max_index
= asect
->index
;
1504 elf_num_section_syms (abfd
) = max_index
;
1505 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1506 elf_section_syms (abfd
) = sect_syms
;
1510 bfd_set_error (bfd_error_no_memory
);
1514 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1516 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1519 bfd_set_error (bfd_error_no_memory
);
1522 sym
->the_bfd
= abfd
;
1523 sym
->name
= asect
->name
;
1524 sym
->value
= asect
->vma
;
1525 sym
->flags
= BSF_SECTION_SYM
;
1526 sym
->section
= asect
;
1527 sect_syms
[asect
->index
] = sym
;
1531 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1532 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1539 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1540 ((symcount
+ num_sections
+ 1)
1541 * sizeof (asymbol
*)));
1543 syms
= (asymbol
**) bfd_alloc (abfd
,
1544 (num_sections
+ 1) * sizeof (asymbol
*));
1547 bfd_set_error (bfd_error_no_memory
);
1551 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1553 if (sect_syms
[asect
->index
])
1554 syms
[symcount
++] = sect_syms
[asect
->index
];
1557 syms
[symcount
] = (asymbol
*) 0;
1558 bfd_set_symtab (abfd
, syms
, symcount
);
1561 elf_sym_extra (abfd
) = sym_extra
1562 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1565 bfd_set_error (bfd_error_no_memory
);
1569 /* Identify and classify all of the symbols. */
1570 for (idx
= 0; idx
< symcount
; idx
++)
1572 if (!sym_is_global (abfd
, syms
[idx
]))
1578 /* Now provide mapping information. Add +1 for skipping over the
1580 for (idx
= 0; idx
< symcount
; idx
++)
1582 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1583 if (!sym_is_global (abfd
, syms
[idx
]))
1584 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1586 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1589 elf_num_locals (abfd
) = num_locals
;
1590 elf_num_globals (abfd
) = num_globals
;
1594 /* Compute the file positions we are going to put the sections at, and
1595 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1596 is not NULL, this is being called by the ELF backend linker. */
1599 elf_compute_section_file_positions (abfd
, link_info
)
1601 struct bfd_link_info
*link_info
;
1603 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1604 Elf_Internal_Shdr
*shstrtab_hdr
;
1606 if (abfd
->output_has_begun
)
1609 /* Do any elf backend specific processing first. */
1610 if (bed
->elf_backend_begin_write_processing
)
1611 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1613 if (! prep_headers (abfd
))
1616 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1618 if (!assign_section_numbers (abfd
))
1621 /* The backend linker builds symbol table information itself. */
1622 if (link_info
== NULL
)
1624 if (! swap_out_syms (abfd
))
1628 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1629 /* sh_name was set in prep_headers. */
1630 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1631 shstrtab_hdr
->sh_flags
= 0;
1632 shstrtab_hdr
->sh_addr
= 0;
1633 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1634 shstrtab_hdr
->sh_entsize
= 0;
1635 shstrtab_hdr
->sh_link
= 0;
1636 shstrtab_hdr
->sh_info
= 0;
1637 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1638 shstrtab_hdr
->sh_addralign
= 1;
1639 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1641 if (!assign_file_positions_except_relocs (abfd
,
1642 link_info
== NULL
? true : false))
1645 abfd
->output_has_begun
= true;
1651 /* Align to the maximum file alignment that could be required for any
1652 ELF data structure. */
1654 static INLINE file_ptr
1655 align_file_position (off
)
1658 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1661 /* Assign a file position to a section, optionally aligning to the
1662 required section alignment. */
1664 static INLINE file_ptr
1665 assign_file_position_for_section (i_shdrp
, offset
, align
)
1666 Elf_Internal_Shdr
*i_shdrp
;
1674 al
= i_shdrp
->sh_addralign
;
1676 offset
= BFD_ALIGN (offset
, al
);
1678 i_shdrp
->sh_offset
= offset
;
1679 if (i_shdrp
->rawdata
!= NULL
)
1680 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1681 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1682 offset
+= i_shdrp
->sh_size
;
1686 /* Get the size of the program header. This is called by the linker
1687 before any of the section VMA's are set, so it can't calculate the
1688 correct value for a strange memory layout. */
1690 static bfd_size_type
1691 get_program_header_size (abfd
)
1697 /* Assume we will need exactly two PT_LOAD segments: one for text
1698 and one for data. */
1701 s
= bfd_get_section_by_name (abfd
, ".interp");
1702 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1704 /* If we have a loadable interpreter section, we need a
1705 PT_INTERP segment. In this case, assume we also need a
1706 PT_PHDR segment, although that may not be true for all
1711 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1713 /* We need a PT_DYNAMIC segment. */
1717 return segs
* sizeof (Elf_External_Phdr
);
1720 /* Create the program header. OFF is the file offset where the
1721 program header should be written. FIRST is the first loadable ELF
1722 section. PHDR_SIZE is the size of the program header as returned
1723 by get_program_header_size. */
1726 map_program_segments (abfd
, off
, first
, phdr_size
)
1729 Elf_Internal_Shdr
*first
;
1730 bfd_size_type phdr_size
;
1732 Elf_Internal_Phdr phdrs
[10];
1733 unsigned int phdr_count
;
1734 Elf_Internal_Phdr
*phdr
;
1735 int phdr_size_adjust
;
1737 Elf_Internal_Shdr
**hdrpp
;
1738 asection
*sinterp
, *sdyn
;
1739 unsigned int last_type
;
1740 Elf_Internal_Ehdr
*i_ehdrp
;
1742 BFD_ASSERT ((abfd
->flags
& EXEC_P
) != 0);
1743 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1744 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1749 phdr_size_adjust
= 0;
1751 /* If we have a loadable .interp section, we must create a PT_INTERP
1752 segment which must precede all PT_LOAD segments. We assume that
1753 we must also create a PT_PHDR segment, although that may not be
1754 true for all targets. */
1755 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1756 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1758 BFD_ASSERT (first
!= NULL
);
1760 phdr
->p_type
= PT_PHDR
;
1762 phdr
->p_offset
= off
;
1764 /* Account for any adjustment made because of the alignment of
1765 the first loadable section. */
1766 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1767 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1769 /* The program header precedes all loadable sections. This lets
1770 us compute its loadable address. This depends on the linker
1772 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1775 phdr
->p_filesz
= phdr_size
;
1776 phdr
->p_memsz
= phdr_size
;
1778 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1779 phdr
->p_flags
= PF_R
| PF_X
;
1781 phdr
->p_align
= FILE_ALIGN
;
1782 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1784 /* Include the ELF header in the first loadable segment. */
1785 phdr_size_adjust
+= off
;
1790 phdr
->p_type
= PT_INTERP
;
1791 phdr
->p_offset
= sinterp
->filepos
;
1792 phdr
->p_vaddr
= sinterp
->vma
;
1794 phdr
->p_filesz
= sinterp
->_raw_size
;
1795 phdr
->p_memsz
= sinterp
->_raw_size
;
1796 phdr
->p_flags
= PF_R
;
1797 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1803 /* Look through the sections to see how they will be divided into
1804 program segments. The sections must be arranged in order by
1805 sh_addr for this to work correctly. */
1806 phdr
->p_type
= PT_NULL
;
1807 last_type
= SHT_PROGBITS
;
1808 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1809 i
< elf_elfheader (abfd
)->e_shnum
;
1812 Elf_Internal_Shdr
*hdr
;
1816 /* Ignore any section which will not be part of the process
1818 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1821 /* If this section fits in the segment we are constructing, add
1823 if (phdr
->p_type
!= PT_NULL
1824 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1825 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1826 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1828 bfd_size_type adjust
;
1830 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1831 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1832 if (hdr
->sh_type
!= SHT_NOBITS
)
1833 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1834 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1835 phdr
->p_flags
|= PF_W
;
1836 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1837 phdr
->p_flags
|= PF_X
;
1838 last_type
= hdr
->sh_type
;
1842 /* If we have a segment, move to the next one. */
1843 if (phdr
->p_type
!= PT_NULL
)
1849 /* Start a new segment. */
1850 phdr
->p_type
= PT_LOAD
;
1851 phdr
->p_offset
= hdr
->sh_offset
;
1852 phdr
->p_vaddr
= hdr
->sh_addr
;
1854 if (hdr
->sh_type
== SHT_NOBITS
)
1857 phdr
->p_filesz
= hdr
->sh_size
;
1858 phdr
->p_memsz
= hdr
->sh_size
;
1859 phdr
->p_flags
= PF_R
;
1860 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1861 phdr
->p_flags
|= PF_W
;
1862 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1863 phdr
->p_flags
|= PF_X
;
1864 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1868 && (sinterp
->flags
& SEC_LOAD
) != 0)
1870 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1871 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1872 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1873 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1876 last_type
= hdr
->sh_type
;
1879 if (phdr
->p_type
!= PT_NULL
)
1885 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1886 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1887 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1889 phdr
->p_type
= PT_DYNAMIC
;
1890 phdr
->p_offset
= sdyn
->filepos
;
1891 phdr
->p_vaddr
= sdyn
->vma
;
1893 phdr
->p_filesz
= sdyn
->_raw_size
;
1894 phdr
->p_memsz
= sdyn
->_raw_size
;
1895 phdr
->p_flags
= PF_R
;
1896 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1897 phdr
->p_flags
|= PF_W
;
1898 if ((sdyn
->flags
& SEC_CODE
) != 0)
1899 phdr
->p_flags
|= PF_X
;
1900 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1906 /* Make sure the return value from get_program_header_size matches
1907 what we computed here. */
1908 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1911 /* Set up program header information. */
1912 i_ehdrp
= elf_elfheader (abfd
);
1913 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1914 i_ehdrp
->e_phoff
= off
;
1915 i_ehdrp
->e_phnum
= phdr_count
;
1917 /* Save the program headers away. I don't think anybody uses this
1918 information right now. */
1919 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1922 * sizeof (Elf_Internal_Phdr
))));
1923 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1925 bfd_set_error (bfd_error_no_memory
);
1926 return (file_ptr
) -1;
1928 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1929 phdr_count
* sizeof (Elf_Internal_Phdr
));
1931 /* Write out the program headers. */
1932 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1933 return (file_ptr
) -1;
1935 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1937 Elf_External_Phdr extphdr
;
1939 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1940 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1941 != sizeof (Elf_External_Phdr
))
1942 return (file_ptr
) -1;
1945 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1948 /* Work out the file positions of all the sections. This is called by
1949 elf_compute_section_file_positions. All the section sizes and VMAs
1950 must be known before this is called.
1952 We do not consider reloc sections at this point, unless they form
1953 part of the loadable image. Reloc sections are assigned file
1954 positions in assign_file_positions_for_relocs, which is called by
1955 write_object_contents and final_link.
1957 If DOSYMS is false, we do not assign file positions for the symbol
1958 table or the string table. */
1961 assign_file_positions_except_relocs (abfd
, dosyms
)
1965 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1966 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1967 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1970 /* Start after the ELF header. */
1971 off
= i_ehdrp
->e_ehsize
;
1973 if ((abfd
->flags
& EXEC_P
) == 0)
1975 Elf_Internal_Shdr
**hdrpp
;
1978 /* We are not creating an executable, which means that we are
1979 not creating a program header, and that the actual order of
1980 the sections in the file is unimportant. */
1981 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1983 Elf_Internal_Shdr
*hdr
;
1986 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1988 hdr
->sh_offset
= -1;
1992 && (i
== tdata
->symtab_section
1993 || i
== tdata
->strtab_section
))
1995 hdr
->sh_offset
= -1;
1999 off
= assign_file_position_for_section (hdr
, off
, true);
2005 bfd_size_type phdr_size
;
2006 bfd_vma maxpagesize
;
2007 Elf_Internal_Shdr
**hdrpp
;
2009 Elf_Internal_Shdr
*first
;
2012 /* We are creating an executable. We must create a program
2013 header. We can't actually create the program header until we
2014 have set the file positions for the sections, but we can
2015 figure out how big it is going to be. */
2016 off
= align_file_position (off
);
2017 phdr_size
= get_program_header_size (abfd
);
2018 if (phdr_size
== (file_ptr
) -1)
2023 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2024 if (maxpagesize
== 0)
2027 /* FIXME: We might want to sort the sections on the sh_addr
2028 field here. For now, we just assume that the linker will
2029 create the sections in an appropriate order. */
2031 /* Assign file positions in two passes. In the first pass, we
2032 assign a file position to every section which forms part of
2033 the executable image. */
2035 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2037 Elf_Internal_Shdr
*hdr
;
2040 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2046 if ((abfd
->flags
& D_PAGED
) != 0)
2048 /* The section VMA must equal the file position modulo
2049 the page size. This is required by the program
2051 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2054 off
= assign_file_position_for_section (hdr
, off
, false);
2057 /* Assign file positions to all the sections which do not form
2058 part of the loadable image, except for the relocs. */
2059 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2061 Elf_Internal_Shdr
*hdr
;
2064 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2066 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2068 hdr
->sh_offset
= -1;
2072 && (i
== tdata
->symtab_section
2073 || i
== tdata
->strtab_section
))
2075 hdr
->sh_offset
= -1;
2079 off
= assign_file_position_for_section (hdr
, off
, true);
2082 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2083 if (phdr_map
== (file_ptr
) -1)
2085 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2088 /* Place the section headers. */
2089 off
= align_file_position (off
);
2090 i_ehdrp
->e_shoff
= off
;
2091 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2093 elf_tdata (abfd
)->next_file_pos
= off
;
2102 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2103 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2104 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2106 struct strtab
*shstrtab
;
2108 i_ehdrp
= elf_elfheader (abfd
);
2109 i_shdrp
= elf_elfsections (abfd
);
2111 shstrtab
= bfd_new_strtab (abfd
);
2115 elf_shstrtab (abfd
) = shstrtab
;
2117 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2118 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2119 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2120 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2122 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2123 i_ehdrp
->e_ident
[EI_DATA
] =
2124 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2125 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2127 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2128 i_ehdrp
->e_ident
[count
] = 0;
2130 if ((abfd
->flags
& DYNAMIC
) != 0)
2131 i_ehdrp
->e_type
= ET_DYN
;
2132 else if ((abfd
->flags
& EXEC_P
) != 0)
2133 i_ehdrp
->e_type
= ET_EXEC
;
2135 i_ehdrp
->e_type
= ET_REL
;
2137 switch (bfd_get_arch (abfd
))
2139 case bfd_arch_unknown
:
2140 i_ehdrp
->e_machine
= EM_NONE
;
2142 case bfd_arch_sparc
:
2144 i_ehdrp
->e_machine
= EM_SPARC64
;
2146 i_ehdrp
->e_machine
= EM_SPARC
;
2150 i_ehdrp
->e_machine
= EM_386
;
2153 i_ehdrp
->e_machine
= EM_68K
;
2156 i_ehdrp
->e_machine
= EM_88K
;
2159 i_ehdrp
->e_machine
= EM_860
;
2161 case bfd_arch_mips
: /* MIPS Rxxxx */
2162 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2165 i_ehdrp
->e_machine
= EM_PARISC
;
2167 case bfd_arch_powerpc
:
2168 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2170 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2172 i_ehdrp
->e_machine
= EM_NONE
;
2174 i_ehdrp
->e_version
= EV_CURRENT
;
2175 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2177 /* no program header, for now. */
2178 i_ehdrp
->e_phoff
= 0;
2179 i_ehdrp
->e_phentsize
= 0;
2180 i_ehdrp
->e_phnum
= 0;
2182 /* each bfd section is section header entry */
2183 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2184 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2186 /* if we're building an executable, we'll need a program header table */
2187 if (abfd
->flags
& EXEC_P
)
2189 /* it all happens later */
2191 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2193 /* elf_build_phdrs() returns a (NULL-terminated) array of
2194 Elf_Internal_Phdrs */
2195 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2196 i_ehdrp
->e_phoff
= outbase
;
2197 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2202 i_ehdrp
->e_phentsize
= 0;
2204 i_ehdrp
->e_phoff
= 0;
2207 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2209 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2211 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2213 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2214 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2215 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2222 swap_out_syms (abfd
)
2225 if (!elf_map_symbols (abfd
))
2228 /* Dump out the symtabs. */
2230 int symcount
= bfd_get_symcount (abfd
);
2231 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2232 struct strtab
*stt
= bfd_new_strtab (abfd
);
2233 Elf_Internal_Shdr
*symtab_hdr
;
2234 Elf_Internal_Shdr
*symstrtab_hdr
;
2235 Elf_External_Sym
*outbound_syms
;
2240 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2241 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2242 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2243 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2244 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2245 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2247 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2248 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2250 outbound_syms
= (Elf_External_Sym
*)
2251 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2254 bfd_set_error (bfd_error_no_memory
);
2257 /* now generate the data (for "contents") */
2259 /* Fill in zeroth symbol and swap it out. */
2260 Elf_Internal_Sym sym
;
2266 sym
.st_shndx
= SHN_UNDEF
;
2267 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2269 for (idx
= 0; idx
< symcount
; idx
++)
2271 Elf_Internal_Sym sym
;
2272 bfd_vma value
= syms
[idx
]->value
;
2273 elf_symbol_type
*type_ptr
;
2275 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2276 /* Section symbols have no names. */
2280 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2281 if (sym
.st_name
== (unsigned long) -1)
2285 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2287 if (bfd_is_com_section (syms
[idx
]->section
))
2289 /* ELF common symbols put the alignment into the `value' field,
2290 and the size into the `size' field. This is backwards from
2291 how BFD handles it, so reverse it here. */
2292 sym
.st_size
= value
;
2293 sym
.st_value
= type_ptr
? type_ptr
->internal_elf_sym
.st_value
: 16;
2294 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2295 syms
[idx
]->section
);
2299 asection
*sec
= syms
[idx
]->section
;
2302 if (sec
->output_section
)
2304 value
+= sec
->output_offset
;
2305 sec
= sec
->output_section
;
2308 sym
.st_value
= value
;
2309 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2310 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2314 /* Writing this would be a hell of a lot easier if we had
2315 some decent documentation on bfd, and knew what to expect
2316 of the library, and what to demand of applications. For
2317 example, it appears that `objcopy' might not set the
2318 section of a symbol to be a section that is actually in
2320 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2321 BFD_ASSERT (sec2
!= 0);
2322 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2323 BFD_ASSERT (shndx
!= -1);
2327 if (bfd_is_com_section (syms
[idx
]->section
))
2328 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2329 else if (bfd_is_und_section (syms
[idx
]->section
))
2330 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2331 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2332 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2333 else if (syms
[idx
]->flags
& BSF_FILE
)
2334 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2337 int bind
= STB_LOCAL
;
2338 int type
= STT_OBJECT
;
2339 unsigned int flags
= syms
[idx
]->flags
;
2341 if (flags
& BSF_LOCAL
)
2343 else if (flags
& BSF_WEAK
)
2345 else if (flags
& BSF_GLOBAL
)
2348 if (flags
& BSF_FUNCTION
)
2351 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2355 elf_swap_symbol_out (abfd
, &sym
,
2357 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2360 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2361 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2362 symstrtab_hdr
->sh_size
= stt
->length
;
2363 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2365 symstrtab_hdr
->sh_flags
= 0;
2366 symstrtab_hdr
->sh_addr
= 0;
2367 symstrtab_hdr
->sh_entsize
= 0;
2368 symstrtab_hdr
->sh_link
= 0;
2369 symstrtab_hdr
->sh_info
= 0;
2370 symstrtab_hdr
->sh_addralign
= 1;
2371 symstrtab_hdr
->size
= 0;
2378 write_shdrs_and_ehdr (abfd
)
2381 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2382 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2383 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2384 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2386 struct strtab
*shstrtab
;
2388 i_ehdrp
= elf_elfheader (abfd
);
2389 i_shdrp
= elf_elfsections (abfd
);
2390 shstrtab
= elf_shstrtab (abfd
);
2392 /* swap the header before spitting it out... */
2395 elf_debug_file (i_ehdrp
);
2397 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2398 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2399 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2400 != sizeof (x_ehdr
)))
2403 /* at this point we've concocted all the ELF sections... */
2404 x_shdrp
= (Elf_External_Shdr
*)
2405 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2408 bfd_set_error (bfd_error_no_memory
);
2412 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2415 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2418 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2420 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2421 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2422 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2425 /* need to dump the string table too... */
2430 /* Assign file positions for all the reloc sections which are not part
2431 of the loadable file image. */
2434 assign_file_positions_for_relocs (abfd
)
2439 Elf_Internal_Shdr
**shdrpp
;
2441 off
= elf_tdata (abfd
)->next_file_pos
;
2443 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2444 i
< elf_elfheader (abfd
)->e_shnum
;
2447 Elf_Internal_Shdr
*shdrp
;
2450 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2451 && shdrp
->sh_offset
== -1)
2452 off
= assign_file_position_for_section (shdrp
, off
, true);
2455 elf_tdata (abfd
)->next_file_pos
= off
;
2459 NAME(bfd_elf
,write_object_contents
) (abfd
)
2462 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2463 Elf_Internal_Ehdr
*i_ehdrp
;
2464 Elf_Internal_Shdr
**i_shdrp
;
2467 if (! abfd
->output_has_begun
2468 && ! elf_compute_section_file_positions (abfd
,
2469 (struct bfd_link_info
*) NULL
))
2472 i_shdrp
= elf_elfsections (abfd
);
2473 i_ehdrp
= elf_elfheader (abfd
);
2475 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2476 assign_file_positions_for_relocs (abfd
);
2478 /* After writing the headers, we need to write the sections too... */
2479 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2481 if (bed
->elf_backend_section_processing
)
2482 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2483 if (i_shdrp
[count
]->contents
)
2485 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2486 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2488 != i_shdrp
[count
]->sh_size
))
2493 if (bed
->elf_backend_final_write_processing
)
2494 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
2496 return write_shdrs_and_ehdr (abfd
);
2499 /* Given an index of a section, retrieve a pointer to it. Note
2500 that for our purposes, sections are indexed by {1, 2, ...} with
2501 0 being an illegal index. */
2503 /* In the original, each ELF section went into exactly one BFD
2504 section. This doesn't really make sense, so we need a real mapping.
2505 The mapping has to hide in the Elf_Internal_Shdr since asection
2506 doesn't have anything like a tdata field... */
2509 section_from_elf_index (abfd
, index
)
2513 /* @@ Is bfd_com_section_ptr really correct in all the places it could
2514 be returned from this routine? */
2516 if (index
== SHN_ABS
)
2517 return bfd_com_section_ptr
; /* not abs? */
2518 if (index
== SHN_COMMON
)
2519 return bfd_com_section_ptr
;
2521 if (index
> elf_elfheader (abfd
)->e_shnum
)
2525 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2527 switch (hdr
->sh_type
)
2529 /* ELF sections that map to BFD sections */
2534 if (hdr
->rawdata
== NULL
)
2536 if (! bfd_section_from_shdr (abfd
, index
))
2539 return (struct sec
*) hdr
->rawdata
;
2542 return bfd_abs_section_ptr
;
2547 /* given a section, search the header to find them... */
2549 elf_section_from_bfd_section (abfd
, asect
)
2553 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2555 Elf_Internal_Shdr
*hdr
;
2556 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2558 if (asect
->owner
== NULL
)
2560 if (bfd_is_abs_section (asect
))
2562 if (bfd_is_com_section (asect
))
2564 if (bfd_is_und_section (asect
))
2569 BFD_ASSERT (asect
->owner
== abfd
);
2571 for (index
= 0; index
< maxindex
; index
++)
2573 hdr
= i_shdrp
[index
];
2574 switch (hdr
->sh_type
)
2576 /* ELF sections that map to BFD sections */
2585 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2592 /* We sometimes map a reloc section to a BFD section. */
2593 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2594 && (asection
*) hdr
->rawdata
== asect
)
2599 /* We map most string tables to BFD sections. */
2600 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2601 && index
!= elf_onesymtab (abfd
)
2602 && (asection
*) hdr
->rawdata
== asect
)
2608 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2610 if (bed
->elf_backend_section_from_bfd_section
)
2615 if ((*bed
->elf_backend_section_from_bfd_section
)
2616 (abfd
, hdr
, asect
, &retval
))
2626 /* given a symbol, return the bfd index for that symbol. */
2628 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2630 struct symbol_cache_entry
**asym_ptr_ptr
;
2632 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2634 flagword flags
= asym_ptr
->flags
;
2636 /* When gas creates relocations against local labels, it creates its
2637 own symbol for the section, but does put the symbol into the
2638 symbol chain, so udata is 0. When the linker is generating
2639 relocatable output, this section symbol may be for one of the
2640 input sections rather than the output section. */
2641 if (asym_ptr
->udata
== (PTR
) 0
2642 && (flags
& BSF_SECTION_SYM
)
2643 && asym_ptr
->section
)
2647 if (asym_ptr
->section
->output_section
!= NULL
)
2648 indx
= asym_ptr
->section
->output_section
->index
;
2650 indx
= asym_ptr
->section
->index
;
2651 if (elf_section_syms (abfd
)[indx
])
2652 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2655 if (asym_ptr
->udata
)
2656 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2666 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2667 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2676 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2678 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2681 Elf_Internal_Shdr
*hdr
;
2682 long symcount
; /* Number of external ELF symbols */
2683 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2684 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2685 Elf_Internal_Sym i_sym
;
2686 Elf_External_Sym
*x_symp
= NULL
;
2688 /* Read each raw ELF symbol, converting from external ELF form to
2689 internal ELF form, and then using the information to create a
2690 canonical bfd symbol table entry.
2692 Note that we allocate the initial bfd canonical symbol buffer
2693 based on a one-to-one mapping of the ELF symbols to canonical
2694 symbols. We actually use all the ELF symbols, so there will be no
2695 space left over at the end. When we have all the symbols, we
2696 build the caller's pointer vector. */
2699 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2701 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2702 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2705 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2708 sym
= symbase
= NULL
;
2713 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2716 symbase
= ((elf_symbol_type
*)
2717 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2718 if (symbase
== (elf_symbol_type
*) NULL
)
2720 bfd_set_error (bfd_error_no_memory
);
2725 /* Temporarily allocate room for the raw ELF symbols. */
2726 x_symp
= ((Elf_External_Sym
*)
2727 malloc (symcount
* sizeof (Elf_External_Sym
)));
2728 if (x_symp
== NULL
&& symcount
!= 0)
2730 bfd_set_error (bfd_error_no_memory
);
2734 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2735 != symcount
* sizeof (Elf_External_Sym
))
2737 /* Skip first symbol, which is a null dummy. */
2738 for (i
= 1; i
< symcount
; i
++)
2740 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2741 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2742 #ifdef ELF_KEEP_EXTSYM
2743 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2745 sym
->symbol
.the_bfd
= abfd
;
2747 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2750 sym
->symbol
.value
= i_sym
.st_value
;
2752 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2754 sym
->symbol
.section
= section_from_elf_index (abfd
,
2756 if (sym
->symbol
.section
== NULL
)
2758 /* This symbol is in a section for which we did not
2759 create a BFD section. Just use bfd_abs_section,
2760 although it is wrong. FIXME. */
2761 sym
->symbol
.section
= bfd_abs_section_ptr
;
2764 else if (i_sym
.st_shndx
== SHN_ABS
)
2766 sym
->symbol
.section
= bfd_abs_section_ptr
;
2768 else if (i_sym
.st_shndx
== SHN_COMMON
)
2770 sym
->symbol
.section
= bfd_com_section_ptr
;
2771 /* Elf puts the alignment into the `value' field, and
2772 the size into the `size' field. BFD wants to see the
2773 size in the value field, and doesn't care (at the
2774 moment) about the alignment. */
2775 sym
->symbol
.value
= i_sym
.st_size
;
2777 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2779 sym
->symbol
.section
= bfd_und_section_ptr
;
2782 sym
->symbol
.section
= bfd_abs_section_ptr
;
2784 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2786 switch (ELF_ST_BIND (i_sym
.st_info
))
2789 sym
->symbol
.flags
|= BSF_LOCAL
;
2792 sym
->symbol
.flags
|= BSF_GLOBAL
;
2795 sym
->symbol
.flags
|= BSF_WEAK
;
2799 switch (ELF_ST_TYPE (i_sym
.st_info
))
2802 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2805 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2808 sym
->symbol
.flags
|= BSF_FUNCTION
;
2813 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2815 /* Do some backend-specific processing on this symbol. */
2817 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2818 if (ebd
->elf_backend_symbol_processing
)
2819 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2826 /* Do some backend-specific processing on this symbol table. */
2828 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2829 if (ebd
->elf_backend_symbol_table_processing
)
2830 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2833 /* We rely on the zalloc to clear out the final symbol entry. */
2835 symcount
= sym
- symbase
;
2837 /* Fill in the user's symbol pointer vector if needed. */
2845 *symptrs
++ = &sym
->symbol
;
2848 *symptrs
= 0; /* Final null pointer */
2860 /* Return the number of bytes required to hold the symtab vector.
2862 Note that we base it on the count plus 1, since we will null terminate
2863 the vector allocated based on this size. However, the ELF symbol table
2864 always has a dummy entry as symbol #0, so it ends up even. */
2867 elf_get_symtab_upper_bound (abfd
)
2872 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2874 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2875 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2881 elf_get_dynamic_symtab_upper_bound (abfd
)
2886 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2888 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2889 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2895 elf_get_reloc_upper_bound (abfd
, asect
)
2899 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2903 elf_slurp_reloca_table (abfd
, asect
, symbols
)
2908 Elf_External_Rela
*native_relocs
;
2909 arelent
*reloc_cache
;
2914 if (asect
->relocation
)
2916 if (asect
->reloc_count
== 0)
2918 if (asect
->flags
& SEC_CONSTRUCTOR
)
2921 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2923 native_relocs
= (Elf_External_Rela
*)
2924 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2927 bfd_set_error (bfd_error_no_memory
);
2930 if (bfd_read ((PTR
) native_relocs
,
2931 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
)
2932 != sizeof (Elf_External_Rela
) * asect
->reloc_count
)
2935 reloc_cache
= (arelent
*)
2936 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2940 bfd_set_error (bfd_error_no_memory
);
2944 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2946 Elf_Internal_Rela dst
;
2947 Elf_External_Rela
*src
;
2949 cache_ptr
= reloc_cache
+ idx
;
2950 src
= native_relocs
+ idx
;
2951 elf_swap_reloca_in (abfd
, src
, &dst
);
2953 #ifdef RELOC_PROCESSING
2954 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2956 if (asect
->flags
& SEC_RELOC
)
2958 /* relocatable, so the offset is off of the section */
2959 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2963 /* non-relocatable, so the offset a virtual address */
2964 cache_ptr
->address
= dst
.r_offset
;
2967 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2968 of zero points to the dummy symbol, which was not read into
2969 the symbol table SYMBOLS. */
2970 if (ELF_R_SYM (dst
.r_info
) == 0)
2971 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2976 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2978 /* Translate any ELF section symbol into a BFD section
2980 s
= *(cache_ptr
->sym_ptr_ptr
);
2981 if (s
->flags
& BSF_SECTION_SYM
)
2983 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2984 s
= *cache_ptr
->sym_ptr_ptr
;
2985 if (s
->name
== 0 || s
->name
[0] == 0)
2989 cache_ptr
->addend
= dst
.r_addend
;
2991 /* Fill in the cache_ptr->howto field from dst.r_type */
2993 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2994 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2999 asect
->relocation
= reloc_cache
;
3005 elf_debug_section (str
, num
, hdr
)
3008 Elf_Internal_Shdr
*hdr
;
3010 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3012 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3013 (long) hdr
->sh_name
,
3014 (long) hdr
->sh_type
,
3015 (long) hdr
->sh_flags
);
3017 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3018 (long) hdr
->sh_addr
,
3019 (long) hdr
->sh_offset
,
3020 (long) hdr
->sh_size
);
3022 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3023 (long) hdr
->sh_link
,
3024 (long) hdr
->sh_info
,
3025 (long) hdr
->sh_addralign
);
3026 fprintf (stderr
, "sh_entsize = %ld\n",
3027 (long) hdr
->sh_entsize
);
3028 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3029 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3030 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3035 elf_debug_file (ehdrp
)
3036 Elf_Internal_Ehdr
*ehdrp
;
3038 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3039 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3040 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3041 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3042 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3043 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3044 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3049 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3054 Elf_External_Rel
*native_relocs
;
3055 arelent
*reloc_cache
;
3057 Elf_Internal_Shdr
*data_hdr
;
3059 unsigned long data_max
;
3060 char buf
[4]; /* FIXME -- might be elf64 */
3064 if (asect
->relocation
)
3066 if (asect
->reloc_count
== 0)
3068 if (asect
->flags
& SEC_CONSTRUCTOR
)
3071 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
3073 native_relocs
= (Elf_External_Rel
*)
3074 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
3077 bfd_set_error (bfd_error_no_memory
);
3080 if (bfd_read ((PTR
) native_relocs
,
3081 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
)
3082 != sizeof (Elf_External_Rel
) * asect
->reloc_count
)
3085 reloc_cache
= (arelent
*)
3086 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3090 bfd_set_error (bfd_error_no_memory
);
3094 /* Get the offset of the start of the segment we are relocating to read in
3095 the implicit addend. */
3096 data_hdr
= &elf_section_data (asect
)->this_hdr
;
3097 data_off
= data_hdr
->sh_offset
;
3098 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
3101 elf_debug_section ("data section", -1, data_hdr
);
3104 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3106 #ifdef RELOC_PROCESSING
3107 Elf_Internal_Rel dst
;
3108 Elf_External_Rel
*src
;
3110 cache_ptr
= reloc_cache
+ idx
;
3111 src
= native_relocs
+ idx
;
3112 elf_swap_reloc_in (abfd
, src
, &dst
);
3114 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3116 Elf_Internal_Rel dst
;
3117 Elf_External_Rel
*src
;
3119 cache_ptr
= reloc_cache
+ idx
;
3120 src
= native_relocs
+ idx
;
3122 elf_swap_reloc_in (abfd
, src
, &dst
);
3124 if (asect
->flags
& SEC_RELOC
)
3126 /* relocatable, so the offset is off of the section */
3127 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3131 /* non-relocatable, so the offset a virtual address */
3132 cache_ptr
->address
= dst
.r_offset
;
3135 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3136 of zero points to the dummy symbol, which was not read into
3137 the symbol table SYMBOLS. */
3138 if (ELF_R_SYM (dst
.r_info
) == 0)
3139 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3144 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3146 /* Translate any ELF section symbol into a BFD section
3148 s
= *(cache_ptr
->sym_ptr_ptr
);
3149 if (s
->flags
& BSF_SECTION_SYM
)
3151 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3152 s
= *cache_ptr
->sym_ptr_ptr
;
3153 if (s
->name
== 0 || s
->name
[0] == 0)
3157 BFD_ASSERT (dst
.r_offset
<= data_max
);
3158 cache_ptr
->addend
= 0;
3160 /* Fill in the cache_ptr->howto field from dst.r_type */
3162 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3163 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3168 asect
->relocation
= reloc_cache
;
3173 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3179 arelent
*tblptr
= section
->relocation
;
3180 unsigned int count
= 0;
3181 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3183 /* snarfed from coffcode.h */
3186 if (! elf_slurp_reloca_table (abfd
, section
, symbols
))
3191 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3195 tblptr
= section
->relocation
;
3197 for (; count
++ < section
->reloc_count
;)
3198 *relptr
++ = tblptr
++;
3201 return section
->reloc_count
;
3205 elf_get_symtab (abfd
, alocation
)
3207 asymbol
**alocation
;
3209 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3212 bfd_get_symcount (abfd
) = symcount
;
3217 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3219 asymbol
**alocation
;
3221 return elf_slurp_symbol_table (abfd
, alocation
, true);
3225 elf_make_empty_symbol (abfd
)
3228 elf_symbol_type
*newsym
;
3230 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3233 bfd_set_error (bfd_error_no_memory
);
3238 newsym
->symbol
.the_bfd
= abfd
;
3239 return &newsym
->symbol
;
3244 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3249 bfd_symbol_info (symbol
, ret
);
3253 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3257 bfd_print_symbol_type how
;
3259 FILE *file
= (FILE *) filep
;
3262 case bfd_print_symbol_name
:
3263 fprintf (file
, "%s", symbol
->name
);
3265 case bfd_print_symbol_more
:
3266 fprintf (file
, "elf ");
3267 fprintf_vma (file
, symbol
->value
);
3268 fprintf (file
, " %lx", (long) symbol
->flags
);
3270 case bfd_print_symbol_all
:
3272 CONST
char *section_name
;
3273 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3274 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3275 fprintf (file
, " %s\t%s",
3285 elf_get_lineno (ignore_abfd
, symbol
)
3289 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3296 elf_set_arch_mach (abfd
, arch
, machine
)
3298 enum bfd_architecture arch
;
3299 unsigned long machine
;
3301 /* If this isn't the right architecture for this backend, and this
3302 isn't the generic backend, fail. */
3303 if (arch
!= get_elf_backend_data (abfd
)->arch
3304 && arch
!= bfd_arch_unknown
3305 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3308 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3312 elf_find_nearest_line (abfd
,
3323 CONST
char **filename_ptr
;
3324 CONST
char **functionname_ptr
;
3325 unsigned int *line_ptr
;
3331 elf_sizeof_headers (abfd
, reloc
)
3337 ret
= sizeof (Elf_External_Ehdr
);
3339 ret
+= get_program_header_size (abfd
);
3344 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3349 bfd_size_type count
;
3351 Elf_Internal_Shdr
*hdr
;
3353 if (! abfd
->output_has_begun
3354 && ! elf_compute_section_file_positions (abfd
,
3355 (struct bfd_link_info
*) NULL
))
3358 hdr
= &elf_section_data (section
)->this_hdr
;
3360 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3362 if (bfd_write (location
, 1, count
, abfd
) != count
)
3369 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3372 Elf_Internal_Rela
*dst
;
3374 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3380 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3383 Elf_Internal_Rel
*dst
;
3385 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3391 /* Core file support */
3393 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3394 #include <sys/procfs.h>
3396 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3397 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3398 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3404 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3411 prstatus_t
*status
= (prstatus_t
*) 0;
3413 if (descsz
== sizeof (prstatus_t
))
3415 newsect
= bfd_make_section (abfd
, ".reg");
3416 if (newsect
== NULL
)
3418 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3419 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3420 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3421 newsect
->alignment_power
= 2;
3422 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3424 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3430 /* Stash a copy of the prpsinfo structure away for future use. */
3433 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3439 if (descsz
== sizeof (prpsinfo_t
))
3441 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3443 bfd_set_error (bfd_error_no_memory
);
3446 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3452 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3460 newsect
= bfd_make_section (abfd
, ".reg2");
3461 if (newsect
== NULL
)
3463 newsect
->_raw_size
= descsz
;
3464 newsect
->filepos
= filepos
;
3465 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3466 newsect
->alignment_power
= 2;
3470 #endif /* HAVE_PROCFS */
3472 /* Return a pointer to the args (including the command name) that were
3473 seen by the program that generated the core dump. Note that for
3474 some reason, a spurious space is tacked onto the end of the args
3475 in some (at least one anyway) implementations, so strip it off if
3479 elf_core_file_failing_command (abfd
)
3483 if (core_prpsinfo (abfd
))
3485 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3486 char *scan
= p
->pr_psargs
;
3491 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3495 return p
->pr_psargs
;
3501 /* Return the number of the signal that caused the core dump. Presumably,
3502 since we have a core file, we got a signal of some kind, so don't bother
3503 checking the other process status fields, just return the signal number.
3507 elf_core_file_failing_signal (abfd
)
3511 if (core_prstatus (abfd
))
3513 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3519 /* Check to see if the core file could reasonably be expected to have
3520 come for the current executable file. Note that by default we return
3521 true unless we find something that indicates that there might be a
3526 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3535 /* First, xvecs must match since both are ELF files for the same target. */
3537 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3539 bfd_set_error (bfd_error_system_call
);
3545 /* If no prpsinfo, just return true. Otherwise, grab the last component
3546 of the exec'd pathname from the prpsinfo. */
3548 if (core_prpsinfo (core_bfd
))
3550 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3557 /* Find the last component of the executable pathname. */
3559 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3565 execname
= (char *) exec_bfd
->filename
;
3568 /* See if they match */
3570 return strcmp (execname
, corename
) ? false : true;
3576 #endif /* HAVE_PROCFS */
3579 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3580 the information that would normally be available from the /proc interface
3581 for the process, at the time the process dumped core. Currently this
3582 includes copies of the prstatus, prpsinfo, and fpregset structures.
3584 Since these structures are potentially machine dependent in size and
3585 ordering, bfd provides two levels of support for them. The first level,
3586 available on all machines since it does not require that the host
3587 have /proc support or the relevant include files, is to create a bfd
3588 section for each of the prstatus, prpsinfo, and fpregset structures,
3589 without any interpretation of their contents. With just this support,
3590 the bfd client will have to interpret the structures itself. Even with
3591 /proc support, it might want these full structures for it's own reasons.
3593 In the second level of support, where HAVE_PROCFS is defined, bfd will
3594 pick apart the structures to gather some additional information that
3595 clients may want, such as the general register set, the name of the
3596 exec'ed file and its arguments, the signal (if any) that caused the
3602 elf_corefile_note (abfd
, hdr
)
3604 Elf_Internal_Phdr
*hdr
;
3606 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3607 Elf_Internal_Note i_note
; /* Elf note, internal form */
3608 char *buf
= NULL
; /* Entire note segment contents */
3609 char *namedata
; /* Name portion of the note */
3610 char *descdata
; /* Descriptor portion of the note */
3611 char *sectname
; /* Name to use for new section */
3612 long filepos
; /* File offset to descriptor data */
3615 if (hdr
->p_filesz
> 0
3616 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3617 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3618 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3620 x_note_p
= (Elf_External_Note
*) buf
;
3621 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3623 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3624 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3625 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3626 namedata
= x_note_p
->name
;
3627 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3628 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3629 switch (i_note
.type
)
3632 /* process descdata as prstatus info */
3633 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3635 sectname
= ".prstatus";
3638 /* process descdata as fpregset info */
3639 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3641 sectname
= ".fpregset";
3644 /* process descdata as prpsinfo */
3645 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3647 sectname
= ".prpsinfo";
3650 /* Unknown descriptor, just ignore it. */
3654 if (sectname
!= NULL
)
3656 newsect
= bfd_make_section (abfd
, sectname
);
3657 if (newsect
== NULL
)
3659 newsect
->_raw_size
= i_note
.descsz
;
3660 newsect
->filepos
= filepos
;
3661 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3662 newsect
->alignment_power
= 2;
3664 x_note_p
= (Elf_External_Note
*)
3665 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3672 else if (hdr
->p_filesz
> 0)
3674 bfd_set_error (bfd_error_no_memory
);
3681 /* Core files are simply standard ELF formatted files that partition
3682 the file using the execution view of the file (program header table)
3683 rather than the linking view. In fact, there is no section header
3684 table in a core file.
3686 The process status information (including the contents of the general
3687 register set) and the floating point register set are stored in a
3688 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3689 that allow standard bfd access to the general registers (.reg) and the
3690 floating point registers (.reg2).
3695 elf_core_file_p (abfd
)
3698 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3699 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3700 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3701 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3702 unsigned int phindex
;
3703 struct elf_backend_data
*ebd
;
3705 /* Read in the ELF header in external format. */
3707 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3709 if (bfd_get_error () != bfd_error_system_call
)
3710 bfd_set_error (bfd_error_wrong_format
);
3714 /* Now check to see if we have a valid ELF file, and one that BFD can
3715 make use of. The magic number must match, the address size ('class')
3716 and byte-swapping must match our XVEC entry, and it must have a
3717 program header table (FIXME: See comments re segments at top of this
3720 if (elf_file_p (&x_ehdr
) == false)
3723 bfd_set_error (bfd_error_wrong_format
);
3727 /* FIXME, Check EI_VERSION here ! */
3731 int desired_address_size
= ELFCLASS32
;
3734 int desired_address_size
= ELFCLASS64
;
3737 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3741 /* Switch xvec to match the specified byte order. */
3742 switch (x_ehdr
.e_ident
[EI_DATA
])
3744 case ELFDATA2MSB
: /* Big-endian */
3745 if (abfd
->xvec
->byteorder_big_p
== false)
3748 case ELFDATA2LSB
: /* Little-endian */
3749 if (abfd
->xvec
->byteorder_big_p
== true)
3752 case ELFDATANONE
: /* No data encoding specified */
3753 default: /* Unknown data encoding specified */
3757 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3758 the tdata pointer in the bfd. */
3761 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3762 if (elf_tdata (abfd
) == NULL
)
3764 bfd_set_error (bfd_error_no_memory
);
3768 /* FIXME, `wrong' returns from this point onward, leak memory. */
3770 /* Now that we know the byte order, swap in the rest of the header */
3771 i_ehdrp
= elf_elfheader (abfd
);
3772 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3774 elf_debug_file (i_ehdrp
);
3777 ebd
= get_elf_backend_data (abfd
);
3779 /* Check that the ELF e_machine field matches what this particular
3780 BFD format expects. */
3781 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3783 const bfd_target
* const *target_ptr
;
3785 if (ebd
->elf_machine_code
!= EM_NONE
)
3788 /* This is the generic ELF target. Let it match any ELF target
3789 for which we do not have a specific backend. */
3790 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3792 struct elf_backend_data
*back
;
3794 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3796 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3797 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3799 /* target_ptr is an ELF backend which matches this
3800 object file, so reject the generic ELF target. */
3806 /* If there is no program header, or the type is not a core file, then
3808 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3811 /* Allocate space for a copy of the program header table in
3812 internal form, seek to the program header table in the file,
3813 read it in, and convert it to internal form. As a simple sanity
3814 check, verify that the what BFD thinks is the size of each program
3815 header table entry actually matches the size recorded in the file. */
3817 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3819 i_phdrp
= (Elf_Internal_Phdr
*)
3820 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3823 bfd_set_error (bfd_error_no_memory
);
3826 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3828 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3830 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3833 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3836 /* Once all of the program headers have been read and converted, we
3837 can start processing them. */
3839 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3841 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3842 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3844 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3849 /* Remember the entry point specified in the ELF file header. */
3851 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3856 /* ELF linker code. */
3858 static boolean elf_link_add_object_symbols
3859 PARAMS ((bfd
*, struct bfd_link_info
*));
3860 static boolean elf_link_add_archive_symbols
3861 PARAMS ((bfd
*, struct bfd_link_info
*));
3862 static INLINE boolean elf_link_record_dynamic_symbol
3863 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
3864 static boolean elf_link_create_dynamic_sections
3865 PARAMS ((bfd
*, struct bfd_link_info
*));
3866 static boolean elf_adjust_dynamic_symbol
3867 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3869 /* Given an ELF BFD, add symbols to the global hash table as
3873 elf_bfd_link_add_symbols (abfd
, info
)
3875 struct bfd_link_info
*info
;
3877 switch (bfd_get_format (abfd
))
3880 return elf_link_add_object_symbols (abfd
, info
);
3882 return elf_link_add_archive_symbols (abfd
, info
);
3884 bfd_set_error (bfd_error_wrong_format
);
3889 /* Add symbols from an ELF archive file to the linker hash table. We
3890 don't use _bfd_generic_link_add_archive_symbols because of a
3891 problem which arises on UnixWare. The UnixWare libc.so is an
3892 archive which includes an entry libc.so.1 which defines a bunch of
3893 symbols. The libc.so archive also includes a number of other
3894 object files, which also define symbols, some of which are the same
3895 as those defined in libc.so.1. Correct linking requires that we
3896 consider each object file in turn, and include it if it defines any
3897 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3898 this; it looks through the list of undefined symbols, and includes
3899 any object file which defines them. When this algorithm is used on
3900 UnixWare, it winds up pulling in libc.so.1 early and defining a
3901 bunch of symbols. This means that some of the other objects in the
3902 archive are not included in the link, which is incorrect since they
3903 precede libc.so.1 in the archive.
3905 Fortunately, ELF archive handling is simpler than that done by
3906 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3907 oddities. In ELF, if we find a symbol in the archive map, and the
3908 symbol is currently undefined, we know that we must pull in that
3911 Unfortunately, we do have to make multiple passes over the symbol
3912 table until nothing further is resolved. */
3915 elf_link_add_archive_symbols (abfd
, info
)
3917 struct bfd_link_info
*info
;
3920 boolean
*defined
= NULL
;
3921 boolean
*included
= NULL
;
3925 if (! bfd_has_map (abfd
))
3927 bfd_set_error (bfd_error_no_symbols
);
3931 /* Keep track of all symbols we know to be already defined, and all
3932 files we know to be already included. This is to speed up the
3933 second and subsequent passes. */
3934 c
= bfd_ardata (abfd
)->symdef_count
;
3937 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3938 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3939 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3941 bfd_set_error (bfd_error_no_memory
);
3944 memset (defined
, 0, c
* sizeof (boolean
));
3945 memset (included
, 0, c
* sizeof (boolean
));
3947 symdefs
= bfd_ardata (abfd
)->symdefs
;
3960 symdefend
= symdef
+ c
;
3961 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3963 struct elf_link_hash_entry
*h
;
3965 struct bfd_link_hash_entry
*undefs_tail
;
3968 if (defined
[i
] || included
[i
])
3970 if (symdef
->file_offset
== last
)
3976 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3977 false, false, false);
3978 if (h
== (struct elf_link_hash_entry
*) NULL
)
3980 if (h
->root
.type
!= bfd_link_hash_undefined
)
3986 /* We need to include this archive member. */
3988 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3989 if (element
== (bfd
*) NULL
)
3992 if (! bfd_check_format (element
, bfd_object
))
3995 /* Doublecheck that we have not included this object
3996 already--it should be impossible, but there may be
3997 something wrong with the archive. */
3998 if (element
->archive_pass
!= 0)
4000 bfd_set_error (bfd_error_bad_value
);
4003 element
->archive_pass
= 1;
4005 undefs_tail
= info
->hash
->undefs_tail
;
4007 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4010 if (! elf_link_add_object_symbols (element
, info
))
4013 /* If there are any new undefined symbols, we need to make
4014 another pass through the archive in order to see whether
4015 they can be defined. FIXME: This isn't perfect, because
4016 common symbols wind up on undefs_tail and because an
4017 undefined symbol which is defined later on in this pass
4018 does not require another pass. This isn't a bug, but it
4019 does make the code less efficient than it could be. */
4020 if (undefs_tail
!= info
->hash
->undefs_tail
)
4023 /* Look backward to mark all symbols from this object file
4024 which we have already seen in this pass. */
4028 included
[mark
] = true;
4033 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4035 /* We mark subsequent symbols from this object file as we go
4036 on through the loop. */
4037 last
= symdef
->file_offset
;
4048 if (defined
!= (boolean
*) NULL
)
4050 if (included
!= (boolean
*) NULL
)
4055 /* Record a new dynamic symbol. We record the dynamic symbols as we
4056 read the input files, since we need to have a list of all of them
4057 before we can determine the final sizes of the output sections. */
4059 static INLINE boolean
4060 elf_link_record_dynamic_symbol (info
, h
)
4061 struct bfd_link_info
*info
;
4062 struct elf_link_hash_entry
*h
;
4064 if (h
->dynindx
== -1)
4066 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4067 ++elf_hash_table (info
)->dynsymcount
;
4068 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
4069 elf_hash_table (info
)->dynstr
,
4070 h
->root
.root
.string
);
4071 if (h
->dynstr_index
== (unsigned long) -1)
4078 /* Add symbols from an ELF object file to the linker hash table. */
4081 elf_link_add_object_symbols (abfd
, info
)
4083 struct bfd_link_info
*info
;
4085 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4086 const Elf_Internal_Sym
*,
4087 const char **, flagword
*,
4088 asection
**, bfd_vma
*));
4090 Elf_Internal_Shdr
*hdr
;
4094 Elf_External_Sym
*buf
= NULL
;
4095 struct elf_link_hash_entry
**sym_hash
;
4097 Elf_External_Dyn
*dynbuf
= NULL
;
4098 struct elf_link_hash_entry
*weaks
;
4099 Elf_External_Sym
*esym
;
4100 Elf_External_Sym
*esymend
;
4102 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4103 collect
= get_elf_backend_data (abfd
)->collect
;
4105 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4106 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4108 /* The sh_info field of the symtab header tells us where the
4109 external symbols start. We don't care about the local symbols at
4111 if (elf_bad_symtab (abfd
))
4113 extsymcount
= symcount
;
4118 extsymcount
= symcount
- hdr
->sh_info
;
4119 extsymoff
= hdr
->sh_info
;
4122 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4123 if (buf
== NULL
&& extsymcount
!= 0)
4125 bfd_set_error (bfd_error_no_memory
);
4129 /* We store a pointer to the hash table entry for each external
4131 sym_hash
= ((struct elf_link_hash_entry
**)
4133 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4134 if (sym_hash
== NULL
)
4136 bfd_set_error (bfd_error_no_memory
);
4139 elf_sym_hashes (abfd
) = sym_hash
;
4141 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4145 /* If we are creating a shared library, create all the dynamic
4146 sections immediately. We need to attach them to something,
4147 so we attach them to this BFD, provided it is the right
4148 format. FIXME: If there are no input BFD's of the same
4149 format as the output, we can't make a shared library. */
4151 && elf_hash_table (info
)->dynobj
== NULL
4152 && abfd
->xvec
== info
->hash
->creator
)
4154 if (! elf_link_create_dynamic_sections (abfd
, info
))
4156 elf_hash_table (info
)->dynobj
= abfd
;
4163 unsigned long strindex
;
4167 /* You can't use -r against a dynamic object. There's no hope
4168 of using a dynamic object which does not exactly match the
4169 format of the output file. */
4170 if (info
->relocateable
4171 || info
->hash
->creator
!= abfd
->xvec
)
4173 bfd_set_error (bfd_error_invalid_operation
);
4177 /* Find the name to use in a DT_NEEDED entry that refers to this
4178 object. If the object has a DT_SONAME entry, we use it.
4179 Otherwise, if the generic linker stuck something in
4180 elf_dt_needed_name, we use that. Otherwise, we just use the
4182 name
= bfd_get_filename (abfd
);
4183 if (elf_dt_needed_name (abfd
) != NULL
)
4184 name
= elf_dt_needed_name (abfd
);
4185 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4188 Elf_External_Dyn
*extdyn
;
4189 Elf_External_Dyn
*extdynend
;
4191 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4194 bfd_set_error (bfd_error_no_memory
);
4198 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4199 (file_ptr
) 0, s
->_raw_size
))
4203 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4204 for (; extdyn
< extdynend
; extdyn
++)
4206 Elf_Internal_Dyn dyn
;
4208 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4209 if (dyn
.d_tag
== DT_SONAME
)
4214 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4217 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4218 name
= elf_string_from_elf_section (abfd
, link
,
4231 /* We do not want to include any of the sections in a dynamic
4232 object in the output file. We hack by simply clobbering the
4233 list of sections in the BFD. This could be handled more
4234 cleanly by, say, a new section flag; the existing
4235 SEC_NEVER_LOAD flag is not the one we want, because that one
4236 still implies that the section takes up space in the output
4238 abfd
->sections
= NULL
;
4240 /* If this is the first dynamic object found in the link, create
4241 the special sections required for dynamic linking. We need
4242 to put them somewhere, and attaching them to the first
4243 dynamic object is as good place as any. */
4244 if (elf_hash_table (info
)->dynobj
== NULL
)
4246 if (! elf_link_create_dynamic_sections (abfd
, info
))
4248 elf_hash_table (info
)->dynobj
= abfd
;
4251 /* Add a DT_NEEDED entry for this dynamic object. */
4252 strindex
= bfd_add_to_strtab (abfd
,
4253 elf_hash_table (info
)->dynstr
,
4256 if (strindex
== (unsigned long) -1)
4258 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4263 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4265 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4266 != extsymcount
* sizeof (Elf_External_Sym
)))
4271 esymend
= buf
+ extsymcount
;
4272 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4274 Elf_Internal_Sym sym
;
4280 struct elf_link_hash_entry
*h
= NULL
;
4283 elf_swap_symbol_in (abfd
, esym
, &sym
);
4285 flags
= BSF_NO_FLAGS
;
4287 value
= sym
.st_value
;
4290 bind
= ELF_ST_BIND (sym
.st_info
);
4291 if (bind
== STB_LOCAL
)
4293 /* This should be impossible, since ELF requires that all
4294 global symbols follow all local symbols, and that sh_info
4295 point to the first global symbol. Unfortunatealy, Irix 5
4299 else if (bind
== STB_GLOBAL
)
4301 else if (bind
== STB_WEAK
)
4305 /* Leave it up to the processor backend. */
4308 if (sym
.st_shndx
== SHN_UNDEF
)
4309 sec
= bfd_und_section_ptr
;
4310 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4312 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4317 else if (sym
.st_shndx
== SHN_ABS
)
4318 sec
= bfd_abs_section_ptr
;
4319 else if (sym
.st_shndx
== SHN_COMMON
)
4321 sec
= bfd_com_section_ptr
;
4322 /* What ELF calls the size we call the value. What ELF
4323 calls the value we call the alignment. */
4324 value
= sym
.st_size
;
4328 /* Leave it up to the processor backend. */
4331 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4332 if (name
== (const char *) NULL
)
4335 if (add_symbol_hook
)
4337 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4341 /* The hook function sets the name to NULL if this symbol
4342 should be skipped for some reason. */
4343 if (name
== (const char *) NULL
)
4347 /* Sanity check that all possibilities were handled. */
4348 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4350 bfd_set_error (bfd_error_bad_value
);
4354 if (bfd_is_und_section (sec
)
4355 || bfd_is_com_section (sec
))
4360 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4362 /* We need to look up the symbol now in order to get some of
4363 the dynamic object handling right. We pass the hash
4364 table entry in to _bfd_generic_link_add_one_symbol so
4365 that it does not have to look it up again. */
4366 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4367 true, false, false);
4372 /* If we are looking at a dynamic object, and this is a
4373 definition, we need to see if it has already been defined
4374 by some other object. If it has, we want to use the
4375 existing definition, and we do not want to report a
4376 multiple symbol definition error; we do this by
4377 clobbering sec to be bfd_und_section_ptr. */
4378 if (dynamic
&& definition
)
4380 if (h
->root
.type
== bfd_link_hash_defined
)
4381 sec
= bfd_und_section_ptr
;
4384 /* Similarly, if we are not looking at a dynamic object, and
4385 we have a definition, we want to override any definition
4386 we may have from a dynamic object. Symbols from regular
4387 files always take precedence over symbols from dynamic
4388 objects, even if they are defined after the dynamic
4389 object in the link. */
4392 && h
->root
.type
== bfd_link_hash_defined
4393 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4394 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4395 == bfd_target_elf_flavour
)
4396 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4399 /* Change the hash table entry to undefined, and let
4400 _bfd_generic_link_add_one_symbol do the right thing
4401 with the new definition. */
4402 h
->root
.type
= bfd_link_hash_undefined
;
4403 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4407 if (! (_bfd_generic_link_add_one_symbol
4408 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4409 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4414 && (flags
& BSF_WEAK
) != 0
4415 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4416 && (*sym_hash
)->weakdef
== NULL
)
4418 /* Keep a list of all weak defined non function symbols from
4419 a dynamic object, using the weakdef field. Later in this
4420 function we will set the weakdef field to the correct
4421 value. We only put non-function symbols from dynamic
4422 objects on this list, because that happens to be the only
4423 time we need to know the normal symbol corresponding to a
4424 weak symbol, and the information is time consuming to
4425 figure out. If the weakdef field is not already NULL,
4426 then this symbol was already defined by some previous
4427 dynamic object, and we will be using that previous
4428 definition anyhow. */
4430 (*sym_hash
)->weakdef
= weaks
;
4434 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4440 /* Remember the symbol size, type and alignment. */
4441 if (sym
.st_size
!= 0)
4443 /* FIXME: We should probably somehow give a warning if
4444 the symbol size changes. */
4445 h
->size
= sym
.st_size
;
4447 if (sym
.st_shndx
== SHN_COMMON
4448 && sym
.st_value
> h
->align
)
4449 h
->align
= sym
.st_value
;
4450 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4452 /* FIXME: We should probably somehow give a warning if
4453 the symbol type changes. */
4454 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4457 /* Set a flag in the hash table entry indicating the type of
4458 reference or definition we just found. Keep a count of
4459 the number of dynamic symbols we find. A dynamic symbol
4460 is one which is referenced or defined by both a regular
4461 object and a shared object, or one which is referenced or
4462 defined by more than one shared object. */
4463 old_flags
= h
->elf_link_hash_flags
;
4468 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4470 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4471 if ((old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4472 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4478 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4480 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4481 if ((old_flags
& new_flag
) != 0)
4484 new_flag
= ELF_LINK_HASH_REF_DYNAMIC_MULTIPLE
;
4486 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC_MULTIPLE
;
4491 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4492 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4497 h
->elf_link_hash_flags
|= new_flag
;
4498 if (dynsym
&& h
->dynindx
== -1)
4500 if (! elf_link_record_dynamic_symbol (info
, h
))
4506 /* Now set the weakdefs field correctly for all the weak defined
4507 symbols we found. The only way to do this is to search all the
4508 symbols. Since we only need the information for non functions in
4509 dynamic objects, that's the only time we actually put anything on
4510 the list WEAKS. We need this information so that if a regular
4511 object refers to a symbol defined weakly in a dynamic object, the
4512 real symbol in the dynamic object is also put in the dynamic
4513 symbols; we also must arrange for both symbols to point to the
4514 same memory location. We could handle the general case of symbol
4515 aliasing, but a general symbol alias can only be generated in
4516 assembler code, handling it correctly would be very time
4517 consuming, and other ELF linkers don't handle general aliasing
4519 while (weaks
!= NULL
)
4521 struct elf_link_hash_entry
*hlook
;
4524 struct elf_link_hash_entry
**hpp
;
4525 struct elf_link_hash_entry
**hppend
;
4528 weaks
= hlook
->weakdef
;
4529 hlook
->weakdef
= NULL
;
4531 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4532 slook
= hlook
->root
.u
.def
.section
;
4533 vlook
= hlook
->root
.u
.def
.value
;
4535 hpp
= elf_sym_hashes (abfd
);
4536 hppend
= hpp
+ extsymcount
;
4537 for (; hpp
< hppend
; hpp
++)
4539 struct elf_link_hash_entry
*h
;
4543 && h
->root
.type
== bfd_link_hash_defined
4544 && h
->root
.u
.def
.section
== slook
4545 && h
->root
.u
.def
.value
== vlook
)
4549 /* If the weak definition is in the list of dynamic
4550 symbols, make sure the real definition is put there
4552 if (hlook
->dynindx
!= -1
4553 && h
->dynindx
== -1)
4555 if (! elf_link_record_dynamic_symbol (info
, h
))
4577 /* Create some sections which will be filled in with dynamic linking
4578 information. The ABFD argument is an input file which is a dynamic
4579 object. The dynamic sections take up virtual memory space when the
4580 final executable is run, so we need to create them before addresses
4581 are assigned to the output sections. We work out the actual
4582 contents and size of these sections later. */
4585 elf_link_create_dynamic_sections (abfd
, info
)
4587 struct bfd_link_info
*info
;
4590 register asection
*s
;
4591 struct elf_link_hash_entry
*h
;
4592 struct elf_backend_data
*bed
;
4594 /* Note that we set the SEC_IN_MEMORY flag for all of these
4596 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4598 /* A dynamically linked executable has a .interp section, but a
4599 shared library does not. */
4602 s
= bfd_make_section (abfd
, ".interp");
4604 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4608 s
= bfd_make_section (abfd
, ".dynamic");
4610 || ! bfd_set_section_flags (abfd
, s
, flags
)
4611 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4614 /* The special symbol _DYNAMIC is always set to the start of the
4615 .dynamic section. This call occurs before we have processed the
4616 symbols for any dynamic object, so we don't have to worry about
4617 overriding a dynamic definition. We could set _DYNAMIC in a
4618 linker script, but we only want to define it if we are, in fact,
4619 creating a .dynamic section. We don't want to define it if there
4620 is no .dynamic section, since on some ELF platforms the start up
4621 code examines it to decide how to initialize the process. */
4623 if (! (_bfd_generic_link_add_one_symbol
4624 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4625 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4626 (struct bfd_link_hash_entry
**) &h
)))
4628 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4630 s
= bfd_make_section (abfd
, ".dynsym");
4632 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4633 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4636 /* The first .dynsym symbol is a dummy. */
4637 elf_hash_table (info
)->dynsymcount
= 1;
4639 s
= bfd_make_section (abfd
, ".dynstr");
4641 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4644 /* Create a strtab to hold the dynamic symbol names. */
4645 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4646 if (elf_hash_table (info
)->dynstr
== NULL
)
4649 s
= bfd_make_section (abfd
, ".hash");
4651 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4652 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4655 /* Let the backend create the rest of the sections. This lets the
4656 backend set the right flags. The backend will normally create
4657 the .got and .plt sections. */
4658 bed
= get_elf_backend_data (abfd
);
4659 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4662 /* Add an entry to the .dynamic table. */
4665 elf_add_dynamic_entry (info
, tag
, val
)
4666 struct bfd_link_info
*info
;
4670 Elf_Internal_Dyn dyn
;
4674 bfd_byte
*newcontents
;
4676 dynobj
= elf_hash_table (info
)->dynobj
;
4678 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4679 BFD_ASSERT (s
!= NULL
);
4681 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4682 if (s
->contents
== NULL
)
4683 newcontents
= (bfd_byte
*) malloc (newsize
);
4685 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4686 if (newcontents
== NULL
)
4688 bfd_set_error (bfd_error_no_memory
);
4693 dyn
.d_un
.d_val
= val
;
4694 elf_swap_dyn_out (dynobj
, &dyn
,
4695 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4697 s
->_raw_size
= newsize
;
4698 s
->contents
= newcontents
;
4703 /* Record an assignment to a symbol made by a linker script. We need
4704 this in case some dynamic object refers to this symbol. */
4708 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4710 struct bfd_link_info
*info
;
4713 struct elf_link_hash_entry
*h
;
4715 /* This is called after we have examined all the input objects. If
4716 the symbol does not exist, it merely means that no object refers
4717 to it, and we can just ignore it at this point. */
4718 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4719 false, false, false);
4723 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4725 if ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4726 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4727 && h
->dynindx
== -1)
4729 if (! elf_link_record_dynamic_symbol (info
, h
))
4732 /* If this is a weak defined symbol, and we know a corresponding
4733 real symbol from the same dynamic object, make sure the real
4734 symbol is also made into a dynamic symbol. */
4735 if (h
->weakdef
!= NULL
4736 && h
->weakdef
->dynindx
== -1)
4738 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4746 /* Array used to determine the number of hash table buckets to use
4747 based on the number of symbols there are. If there are fewer than
4748 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4749 fewer than 37 we use 17 buckets, and so forth. We never use more
4750 than 521 buckets. */
4752 static const size_t elf_buckets
[] =
4754 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4757 /* Set up the sizes and contents of the ELF dynamic sections. This is
4758 called by the ELF linker emulation before_allocation routine. We
4759 must set the sizes of the sections before the linker sets the
4760 addresses of the various sections. */
4763 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, info
, sinterpptr
)
4765 struct bfd_link_info
*info
;
4766 asection
**sinterpptr
;
4771 Elf_Internal_Sym isym
;
4774 struct elf_backend_data
*bed
;
4778 dynobj
= elf_hash_table (info
)->dynobj
;
4779 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4781 /* If there were no dynamic objects in the link, there is nothing to
4786 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4787 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
4789 /* Set the size of the .dynsym and .hash sections. We counted the
4790 number of dynamic symbols in elf_link_add_object_symbols. We
4791 will build the contents of .dynsym and .hash when we build the
4792 final symbol table, because until then we do not know the correct
4793 value to give the symbols. We built the .dynstr section as we
4794 went along in elf_link_add_object_symbols. */
4795 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4796 BFD_ASSERT (s
!= NULL
);
4797 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4798 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4799 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4801 bfd_set_error (bfd_error_no_memory
);
4805 /* The first entry in .dynsym is a dummy symbol. */
4812 elf_swap_symbol_out (output_bfd
, &isym
,
4813 (Elf_External_Sym
*) s
->contents
);
4815 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4817 bucketcount
= elf_buckets
[i
];
4818 if (dynsymcount
< elf_buckets
[i
+ 1])
4822 s
= bfd_get_section_by_name (dynobj
, ".hash");
4823 BFD_ASSERT (s
!= NULL
);
4824 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4825 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4826 if (s
->contents
== NULL
)
4828 bfd_set_error (bfd_error_no_memory
);
4831 memset (s
->contents
, 0, s
->_raw_size
);
4833 put_word (output_bfd
, bucketcount
, s
->contents
);
4834 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4836 elf_hash_table (info
)->bucketcount
= bucketcount
;
4838 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4839 BFD_ASSERT (s
!= NULL
);
4840 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4841 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4843 /* Find all symbols which were defined in a dynamic object and make
4844 the backend pick a reasonable value for them. */
4845 elf_link_hash_traverse (elf_hash_table (info
),
4846 elf_adjust_dynamic_symbol
,
4849 /* Add some entries to the .dynamic section. We fill in some of the
4850 values later, in elf_bfd_final_link, but we must add the entries
4851 now so that we know the final size of the .dynamic section. */
4852 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4854 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4857 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4859 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4862 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4863 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4864 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4865 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4866 elf_hash_table (info
)->dynstr
->length
)
4867 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4868 sizeof (Elf_External_Sym
)))
4871 /* The backend must work out the sizes of all the other dynamic
4873 bed
= get_elf_backend_data (output_bfd
);
4874 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4877 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4880 /* Make the backend pick a good value for a dynamic symbol. This is
4881 called via elf_link_hash_traverse, and also calls itself
4885 elf_adjust_dynamic_symbol (h
, data
)
4886 struct elf_link_hash_entry
*h
;
4889 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4891 struct elf_backend_data
*bed
;
4893 /* If this symbol is not defined by a dynamic object, or is not
4894 referenced by a regular object, ignore it. FIXME: Do we need to
4895 worry about symbols which are defined by one dynamic object and
4896 referenced by another one? */
4897 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4898 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4899 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4902 /* If we've already adjusted this symbol, don't do it again. This
4903 can happen via a recursive call. */
4904 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4907 /* Don't look at this symbol again. Note that we must set this
4908 after checking the above conditions, because we may look at a
4909 symbol once, decide not to do anything, and then get called
4910 recursively later after REF_REGULAR is set below. */
4911 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4913 /* If this is a weak definition, and we know a real definition, and
4914 the real symbol is not itself defined by a regular object file,
4915 then get a good value for the real definition. We handle the
4916 real symbol first, for the convenience of the backend routine.
4918 Note that there is a confusing case here. If the real definition
4919 is defined by a regular object file, we don't get the real symbol
4920 from the dynamic object, but we do get the weak symbol. If the
4921 processor backend uses a COPY reloc, then if some routine in the
4922 dynamic object changes the real symbol, we will not see that
4923 change in the corresponding weak symbol. This is the way other
4924 ELF linkers work as well, and seems to be a result of the shared
4927 I will clarify this issue. Most SVR4 shared libraries define the
4928 variable _timezone and define timezone as a weak synonym. The
4929 tzset call changes _timezone. If you write
4930 extern int timezone;
4932 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4933 you might expect that, since timezone is a synonym for _timezone,
4934 the same number will print both times. However, if the processor
4935 backend uses a COPY reloc, then actually timezone will be copied
4936 into your process image, and, since you define _timezone
4937 yourself, _timezone will not. Thus timezone and _timezone will
4938 wind up at different memory locations. The tzset call will set
4939 _timezone, leaving timezone unchanged. */
4941 if (h
->weakdef
!= NULL
)
4943 struct elf_link_hash_entry
*weakdef
;
4945 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4946 weakdef
= h
->weakdef
;
4947 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4948 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4949 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4950 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4952 /* This symbol is defined or referenced by a regular object
4953 file, so we will not do anything special. Clear weakdef
4954 for the convenience of the processor backend. */
4959 /* There is an implicit reference by a regular object file
4960 via the weak symbol. */
4961 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
4962 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
4967 dynobj
= elf_hash_table (info
)->dynobj
;
4968 bed
= get_elf_backend_data (dynobj
);
4969 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
4971 /* FIXME: No way to return error. */
4978 /* Final phase of ELF linker. */
4980 /* A structure we use to avoid passing large numbers of arguments. */
4982 struct elf_final_link_info
4984 /* General link information. */
4985 struct bfd_link_info
*info
;
4988 /* Symbol string table. */
4989 struct strtab
*symstrtab
;
4990 /* .dynsym section. */
4991 asection
*dynsym_sec
;
4992 /* .hash section. */
4994 /* Buffer large enough to hold contents of any section. */
4996 /* Buffer large enough to hold external relocs of any section. */
4997 PTR external_relocs
;
4998 /* Buffer large enough to hold internal relocs of any section. */
4999 Elf_Internal_Rela
*internal_relocs
;
5000 /* Buffer large enough to hold external local symbols of any input
5002 Elf_External_Sym
*external_syms
;
5003 /* Buffer large enough to hold internal local symbols of any input
5005 Elf_Internal_Sym
*internal_syms
;
5006 /* Array large enough to hold a symbol index for each local symbol
5007 of any input BFD. */
5009 /* Array large enough to hold a section pointer for each local
5010 symbol of any input BFD. */
5011 asection
**sections
;
5012 /* Buffer to hold swapped out symbols. */
5013 Elf_External_Sym
*symbuf
;
5014 /* Number of swapped out symbols in buffer. */
5015 size_t symbuf_count
;
5016 /* Number of symbols which fit in symbuf. */
5020 static boolean elf_link_output_sym
5021 PARAMS ((struct elf_final_link_info
*, const char *,
5022 Elf_Internal_Sym
*, asection
*));
5023 static boolean elf_link_flush_output_syms
5024 PARAMS ((struct elf_final_link_info
*));
5025 static boolean elf_link_output_extsym
5026 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5027 static boolean elf_link_input_bfd
5028 PARAMS ((struct elf_final_link_info
*, bfd
*));
5029 static boolean elf_reloc_link_order
5030 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5031 struct bfd_link_order
*));
5033 /* Do the final step of an ELF link. */
5036 elf_bfd_final_link (abfd
, info
)
5038 struct bfd_link_info
*info
;
5041 struct elf_final_link_info finfo
;
5042 register asection
*o
;
5043 register struct bfd_link_order
*p
;
5045 size_t max_contents_size
;
5046 size_t max_external_reloc_size
;
5047 size_t max_internal_reloc_count
;
5048 size_t max_sym_count
;
5050 Elf_Internal_Sym elfsym
;
5052 Elf_Internal_Shdr
*symtab_hdr
;
5053 Elf_Internal_Shdr
*symstrtab_hdr
;
5054 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5059 "Generating ELF shared libraries is not yet supported\n");
5060 bfd_set_error (bfd_error_invalid_operation
);
5064 dynobj
= elf_hash_table (info
)->dynobj
;
5067 finfo
.output_bfd
= abfd
;
5068 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5069 if (finfo
.symstrtab
== NULL
)
5073 finfo
.dynsym_sec
= NULL
;
5074 finfo
.hash_sec
= NULL
;
5078 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5079 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5080 if (finfo
.dynsym_sec
== NULL
5081 || finfo
.hash_sec
== NULL
)
5084 finfo
.contents
= NULL
;
5085 finfo
.external_relocs
= NULL
;
5086 finfo
.internal_relocs
= NULL
;
5087 finfo
.external_syms
= NULL
;
5088 finfo
.internal_syms
= NULL
;
5089 finfo
.indices
= NULL
;
5090 finfo
.sections
= NULL
;
5091 finfo
.symbuf
= NULL
;
5092 finfo
.symbuf_count
= 0;
5094 /* Count up the number of relocations we will output for each output
5095 section, so that we know the sizes of the reloc sections. We
5096 also figure out some maximum sizes. */
5097 max_contents_size
= 0;
5098 max_external_reloc_size
= 0;
5099 max_internal_reloc_count
= 0;
5101 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5105 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5107 if (p
->type
== bfd_section_reloc_link_order
5108 || p
->type
== bfd_symbol_reloc_link_order
)
5110 else if (p
->type
== bfd_indirect_link_order
)
5114 sec
= p
->u
.indirect
.section
;
5116 if (info
->relocateable
)
5117 o
->reloc_count
+= sec
->reloc_count
;
5119 if (sec
->_raw_size
> max_contents_size
)
5120 max_contents_size
= sec
->_raw_size
;
5121 if (sec
->_cooked_size
> max_contents_size
)
5122 max_contents_size
= sec
->_cooked_size
;
5124 /* We are interested in just local symbols, not all
5126 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5130 if (elf_bad_symtab (sec
->owner
))
5131 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5132 / sizeof (Elf_External_Sym
));
5134 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5136 if (sym_count
> max_sym_count
)
5137 max_sym_count
= sym_count
;
5139 if ((sec
->flags
& SEC_RELOC
) != 0)
5143 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5144 if (ext_size
> max_external_reloc_size
)
5145 max_external_reloc_size
= ext_size
;
5146 if (sec
->reloc_count
> max_internal_reloc_count
)
5147 max_internal_reloc_count
= sec
->reloc_count
;
5153 if (o
->reloc_count
> 0)
5154 o
->flags
|= SEC_RELOC
;
5157 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5158 set it (this is probably a bug) and if it is set
5159 assign_section_numbers will create a reloc section. */
5160 o
->flags
&=~ SEC_RELOC
;
5164 /* Figure out the file positions for everything but the symbol table
5165 and the relocs. We set symcount to force assign_section_numbers
5166 to create a symbol table. */
5167 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5168 BFD_ASSERT (! abfd
->output_has_begun
);
5169 if (! elf_compute_section_file_positions (abfd
, info
))
5172 /* That created the reloc sections. Set their sizes, and assign
5173 them file positions, and allocate some buffers. */
5174 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5176 if ((o
->flags
& SEC_RELOC
) != 0)
5178 Elf_Internal_Shdr
*rel_hdr
;
5179 register struct elf_link_hash_entry
**p
, **pend
;
5181 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5183 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5185 /* The contents field must last into write_object_contents,
5186 so we allocate it with bfd_alloc rather than malloc. */
5187 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5188 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5190 bfd_set_error (bfd_error_no_memory
);
5194 p
= ((struct elf_link_hash_entry
**)
5195 malloc (o
->reloc_count
5196 * sizeof (struct elf_link_hash_entry
*)));
5197 if (p
== NULL
&& o
->reloc_count
!= 0)
5199 bfd_set_error (bfd_error_no_memory
);
5202 elf_section_data (o
)->rel_hashes
= p
;
5203 pend
= p
+ o
->reloc_count
;
5204 for (; p
< pend
; p
++)
5207 /* Use the reloc_count field as an index when outputting the
5213 assign_file_positions_for_relocs (abfd
);
5215 /* We have now assigned file positions for all the sections except
5216 .symtab and .strtab. We start the .symtab section at the current
5217 file position, and write directly to it. We build the .strtab
5218 section in memory. When we add .dynsym support, we will build
5219 that in memory as well (.dynsym is smaller than .symtab). */
5221 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5222 /* sh_name is set in prep_headers. */
5223 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5224 symtab_hdr
->sh_flags
= 0;
5225 symtab_hdr
->sh_addr
= 0;
5226 symtab_hdr
->sh_size
= 0;
5227 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5228 /* sh_link is set in assign_section_numbers. */
5229 /* sh_info is set below. */
5230 /* sh_offset is set just below. */
5231 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5233 off
= elf_tdata (abfd
)->next_file_pos
;
5234 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5236 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5237 incorrect. We do not yet know the size of the .symtab section.
5238 We correct next_file_pos below, after we do know the size. */
5240 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5241 continuously seeking to the right position in the file. */
5242 if (! info
->keep_memory
|| max_sym_count
< 20)
5243 finfo
.symbuf_size
= 20;
5245 finfo
.symbuf_size
= max_sym_count
;
5246 finfo
.symbuf
= ((Elf_External_Sym
*)
5247 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5248 if (finfo
.symbuf
== NULL
)
5250 bfd_set_error (bfd_error_no_memory
);
5254 /* Start writing out the symbol table. The first symbol is always a
5256 elfsym
.st_value
= 0;
5259 elfsym
.st_other
= 0;
5260 elfsym
.st_shndx
= SHN_UNDEF
;
5261 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5262 &elfsym
, bfd_und_section_ptr
))
5266 /* Some standard ELF linkers do this, but we don't because it causes
5267 bootstrap comparison failures. */
5268 /* Output a file symbol for the output file as the second symbol.
5269 We output this even if we are discarding local symbols, although
5270 I'm not sure if this is correct. */
5271 elfsym
.st_value
= 0;
5273 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5274 elfsym
.st_other
= 0;
5275 elfsym
.st_shndx
= SHN_ABS
;
5276 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
5277 &elfsym
, bfd_abs_section_ptr
))
5281 /* Output a symbol for each section. We output these even if we are
5282 discarding local symbols, since they are used for relocs. These
5283 symbols have no names. We store the index of each one in the
5284 index field of the section, so that we can find it again when
5285 outputting relocs. */
5286 elfsym
.st_value
= 0;
5288 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5289 elfsym
.st_other
= 0;
5290 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5292 o
= section_from_elf_index (abfd
, i
);
5293 if (! bfd_is_abs_section (o
))
5294 o
->target_index
= abfd
->symcount
;
5295 elfsym
.st_shndx
= i
;
5296 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
5301 /* Allocate some memory to hold information read in from the input
5303 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5304 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5305 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5306 malloc (max_internal_reloc_count
5307 * sizeof (Elf_Internal_Rela
)));
5308 finfo
.external_syms
= ((Elf_External_Sym
*)
5309 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5310 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5311 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5312 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5313 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5314 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5315 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5316 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5317 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5318 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5319 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5320 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5322 bfd_set_error (bfd_error_no_memory
);
5326 /* Since ELF permits relocations to be against local symbols, we
5327 must have the local symbols available when we do the relocations.
5328 Since we would rather only read the local symbols once, and we
5329 would rather not keep them in memory, we handle all the
5330 relocations for a single input file at the same time.
5332 Unfortunately, there is no way to know the total number of local
5333 symbols until we have seen all of them, and the local symbol
5334 indices precede the global symbol indices. This means that when
5335 we are generating relocateable output, and we see a reloc against
5336 a global symbol, we can not know the symbol index until we have
5337 finished examining all the local symbols to see which ones we are
5338 going to output. To deal with this, we keep the relocations in
5339 memory, and don't output them until the end of the link. This is
5340 an unfortunate waste of memory, but I don't see a good way around
5341 it. Fortunately, it only happens when performing a relocateable
5342 link, which is not the common case. FIXME: If keep_memory is set
5343 we could write the relocs out and then read them again; I don't
5344 know how bad the memory loss will be. */
5346 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5347 sub
->output_has_begun
= false;
5348 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5350 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5352 if (p
->type
== bfd_indirect_link_order
5353 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5354 == bfd_target_elf_flavour
))
5356 sub
= p
->u
.indirect
.section
->owner
;
5357 if (! sub
->output_has_begun
)
5359 if (! elf_link_input_bfd (&finfo
, sub
))
5361 sub
->output_has_begun
= true;
5364 else if (p
->type
== bfd_section_reloc_link_order
5365 || p
->type
== bfd_symbol_reloc_link_order
)
5367 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5372 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5378 /* That wrote out all the local symbols. Finish up the symbol table
5379 with the global symbols. */
5381 /* The sh_info field records the index of the first non local
5383 symtab_hdr
->sh_info
= abfd
->symcount
;
5385 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5387 /* We get the global symbols from the hash table. */
5388 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5391 /* Flush all symbols to the file. */
5392 if (! elf_link_flush_output_syms (&finfo
))
5395 /* Now we know the size of the symtab section. */
5396 off
+= symtab_hdr
->sh_size
;
5398 /* Finish up the symbol string table (.strtab) section. */
5399 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5400 /* sh_name was set in prep_headers. */
5401 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5402 symstrtab_hdr
->sh_flags
= 0;
5403 symstrtab_hdr
->sh_addr
= 0;
5404 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5405 symstrtab_hdr
->sh_entsize
= 0;
5406 symstrtab_hdr
->sh_link
= 0;
5407 symstrtab_hdr
->sh_info
= 0;
5408 /* sh_offset is set just below. */
5409 symstrtab_hdr
->sh_addralign
= 1;
5410 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5412 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5413 elf_tdata (abfd
)->next_file_pos
= off
;
5415 /* Adjust the relocs to have the correct symbol indices. */
5416 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5418 struct elf_link_hash_entry
**rel_hash
;
5419 Elf_Internal_Shdr
*rel_hdr
;
5421 if ((o
->flags
& SEC_RELOC
) == 0)
5424 rel_hash
= elf_section_data (o
)->rel_hashes
;
5425 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5426 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5428 if (*rel_hash
== NULL
)
5431 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5433 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5435 Elf_External_Rel
*erel
;
5436 Elf_Internal_Rel irel
;
5438 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5439 elf_swap_reloc_in (abfd
, erel
, &irel
);
5440 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5441 ELF_R_TYPE (irel
.r_info
));
5442 elf_swap_reloc_out (abfd
, &irel
, erel
);
5446 Elf_External_Rela
*erela
;
5447 Elf_Internal_Rela irela
;
5449 BFD_ASSERT (rel_hdr
->sh_entsize
5450 == sizeof (Elf_External_Rela
));
5452 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5453 elf_swap_reloca_in (abfd
, erela
, &irela
);
5454 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5455 ELF_R_TYPE (irela
.r_info
));
5456 elf_swap_reloca_out (abfd
, &irela
, erela
);
5460 /* Set the reloc_count field to 0 to prevent write_relocs from
5461 trying to swap the relocs out itself. */
5465 /* If we are linking against a dynamic object, finish up the dynamic
5466 linking information. */
5469 Elf_External_Dyn
*dyncon
, *dynconend
;
5471 /* Fix up .dynamic entries. */
5472 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5473 BFD_ASSERT (o
!= NULL
);
5475 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5476 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5477 for (; dyncon
< dynconend
; dyncon
++)
5479 Elf_Internal_Dyn dyn
;
5483 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5505 o
= bfd_get_section_by_name (abfd
, name
);
5506 BFD_ASSERT (o
!= NULL
);
5507 dyn
.d_un
.d_ptr
= o
->vma
;
5508 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5515 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5520 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5522 Elf_Internal_Shdr
*hdr
;
5524 hdr
= elf_elfsections (abfd
)[i
];
5525 if (hdr
->sh_type
== type
5526 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5528 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5529 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5532 if (dyn
.d_un
.d_val
== 0
5533 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5534 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5538 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5543 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5546 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5548 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5550 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
5552 BFD_ASSERT (info
->shared
);
5555 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5556 o
->contents
, o
->output_offset
,
5562 /* Now backend stuff. */
5563 if (bed
->elf_backend_final_write_processing
)
5564 (*bed
->elf_backend_final_write_processing
) (abfd
, NULL
);
5566 if (finfo
.contents
!= NULL
)
5567 free (finfo
.contents
);
5568 if (finfo
.external_relocs
!= NULL
)
5569 free (finfo
.external_relocs
);
5570 if (finfo
.internal_relocs
!= NULL
)
5571 free (finfo
.internal_relocs
);
5572 if (finfo
.external_syms
!= NULL
)
5573 free (finfo
.external_syms
);
5574 if (finfo
.internal_syms
!= NULL
)
5575 free (finfo
.internal_syms
);
5576 if (finfo
.indices
!= NULL
)
5577 free (finfo
.indices
);
5578 if (finfo
.sections
!= NULL
)
5579 free (finfo
.sections
);
5580 if (finfo
.symbuf
!= NULL
)
5581 free (finfo
.symbuf
);
5582 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5584 if ((o
->flags
& SEC_RELOC
) != 0
5585 && elf_section_data (o
)->rel_hashes
!= NULL
)
5586 free (elf_section_data (o
)->rel_hashes
);
5592 if (finfo
.contents
!= NULL
)
5593 free (finfo
.contents
);
5594 if (finfo
.external_relocs
!= NULL
)
5595 free (finfo
.external_relocs
);
5596 if (finfo
.internal_relocs
!= NULL
)
5597 free (finfo
.internal_relocs
);
5598 if (finfo
.external_syms
!= NULL
)
5599 free (finfo
.external_syms
);
5600 if (finfo
.internal_syms
!= NULL
)
5601 free (finfo
.internal_syms
);
5602 if (finfo
.indices
!= NULL
)
5603 free (finfo
.indices
);
5604 if (finfo
.sections
!= NULL
)
5605 free (finfo
.sections
);
5606 if (finfo
.symbuf
!= NULL
)
5607 free (finfo
.symbuf
);
5608 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5610 if ((o
->flags
& SEC_RELOC
) != 0
5611 && elf_section_data (o
)->rel_hashes
!= NULL
)
5612 free (elf_section_data (o
)->rel_hashes
);
5618 /* Add a symbol to the output symbol table. */
5621 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
5622 struct elf_final_link_info
*finfo
;
5624 Elf_Internal_Sym
*elfsym
;
5625 asection
*input_sec
;
5627 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
5628 struct bfd_link_info
*info
,
5633 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
5634 elf_backend_link_output_symbol_hook
;
5635 if (! ((*output_symbol_hook
)
5636 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
5639 if (name
== (const char *) NULL
|| *name
== '\0')
5640 elfsym
->st_name
= 0;
5643 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5644 finfo
->symstrtab
, name
);
5645 if (elfsym
->st_name
== (unsigned long) -1)
5649 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5651 if (! elf_link_flush_output_syms (finfo
))
5655 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5656 finfo
->symbuf
+ finfo
->symbuf_count
);
5657 ++finfo
->symbuf_count
;
5659 ++finfo
->output_bfd
->symcount
;
5664 /* Flush the output symbols to the file. */
5667 elf_link_flush_output_syms (finfo
)
5668 struct elf_final_link_info
*finfo
;
5670 Elf_Internal_Shdr
*symtab
;
5672 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5674 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5676 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5677 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5678 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5681 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5683 finfo
->symbuf_count
= 0;
5688 /* Add an external symbol to the symbol table. This is called from
5689 the hash table traversal routine. */
5692 elf_link_output_extsym (h
, data
)
5693 struct elf_link_hash_entry
*h
;
5696 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5698 Elf_Internal_Sym sym
;
5699 asection
*input_sec
;
5701 /* We don't want to output symbols that have never been mentioned by
5702 a regular file, or that we have been told to strip. However, if
5703 h->indx is set to -2, the symbol is used by a reloc and we must
5707 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5708 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5709 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5710 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5712 else if (finfo
->info
->strip
== strip_all
5713 || (finfo
->info
->strip
== strip_some
5714 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5715 h
->root
.root
.string
,
5716 false, false) == NULL
))
5721 /* If we're stripping it, and it's not a dynamic symbol, there's
5722 nothing else to do. */
5723 if (strip
&& h
->dynindx
== -1)
5727 sym
.st_size
= h
->size
;
5728 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5731 switch (h
->root
.type
)
5734 case bfd_link_hash_new
:
5738 case bfd_link_hash_undefined
:
5739 input_sec
= bfd_und_section_ptr
;
5740 sym
.st_shndx
= SHN_UNDEF
;
5743 case bfd_link_hash_weak
:
5744 input_sec
= bfd_und_section_ptr
;
5745 sym
.st_shndx
= SHN_UNDEF
;
5746 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5749 case bfd_link_hash_defined
:
5752 input_sec
= h
->root
.u
.def
.section
;
5753 if (input_sec
->output_section
!= NULL
)
5755 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5756 input_sec
->output_section
);
5757 if (sym
.st_shndx
== (unsigned short) -1)
5759 /* FIXME: No way to handle errors. */
5763 /* ELF symbols in relocateable files are section relative,
5764 but in nonrelocateable files they are virtual
5766 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
5767 if (! finfo
->info
->relocateable
)
5768 sym
.st_value
+= input_sec
->output_section
->vma
;
5772 BFD_ASSERT (bfd_get_flavour (input_sec
->owner
)
5773 == bfd_target_elf_flavour
5774 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
5775 sym
.st_shndx
= SHN_UNDEF
;
5776 input_sec
= bfd_und_section_ptr
;
5781 case bfd_link_hash_common
:
5782 input_sec
= bfd_com_section_ptr
;
5783 sym
.st_shndx
= SHN_COMMON
;
5787 sym
.st_value
= h
->align
;
5790 case bfd_link_hash_indirect
:
5791 case bfd_link_hash_warning
:
5792 /* I have no idea how these should be handled. */
5796 /* If this symbol should be put in the .dynsym section, then put it
5797 there now. We have already know the symbol index. We also fill
5798 in the entry in the .hash section. */
5799 if (h
->dynindx
!= -1)
5801 struct elf_backend_data
*bed
;
5804 bfd_byte
*bucketpos
;
5807 sym
.st_name
= h
->dynstr_index
;
5809 /* Give the processor backend a chance to tweak the symbol
5810 value, and also to finish up anything that needs to be done
5812 bed
= get_elf_backend_data (finfo
->output_bfd
);
5813 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5814 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5816 /* FIXME: No way to return error. */
5820 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5821 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5824 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5825 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5826 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5827 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5828 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5829 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5830 put_word (finfo
->output_bfd
, chain
,
5831 ((bfd_byte
*) finfo
->hash_sec
->contents
5832 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5835 /* If we're stripping it, then it was just a dynamic symbol, and
5836 there's nothing else to do. */
5840 h
->indx
= finfo
->output_bfd
->symcount
;
5842 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
5844 /* FIXME: No way to return error. */
5851 /* Link an input file into the linker output file. This function
5852 handles all the sections and relocations of the input file at once.
5853 This is so that we only have to read the local symbols once, and
5854 don't have to keep them in memory. */
5857 elf_link_input_bfd (finfo
, input_bfd
)
5858 struct elf_final_link_info
*finfo
;
5861 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5862 bfd
*, asection
*, bfd_byte
*,
5863 Elf_Internal_Rela
*,
5865 asection
**, char *));
5867 Elf_Internal_Shdr
*symtab_hdr
;
5870 Elf_External_Sym
*esym
;
5871 Elf_External_Sym
*esymend
;
5872 Elf_Internal_Sym
*isym
;
5874 asection
**ppsection
;
5877 output_bfd
= finfo
->output_bfd
;
5879 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5881 /* If this is a dynamic object, we don't want to do anything here:
5882 we don't want the local symbols, and we don't want the section
5884 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5887 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5888 if (elf_bad_symtab (input_bfd
))
5890 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5895 locsymcount
= symtab_hdr
->sh_info
;
5896 extsymoff
= symtab_hdr
->sh_info
;
5899 /* Read the local symbols. */
5901 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5902 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5903 locsymcount
, input_bfd
)
5904 != locsymcount
* sizeof (Elf_External_Sym
))))
5907 /* Swap in the local symbols and write out the ones which we know
5908 are going into the output file. */
5909 esym
= finfo
->external_syms
;
5910 esymend
= esym
+ locsymcount
;
5911 isym
= finfo
->internal_syms
;
5912 pindex
= finfo
->indices
;
5913 ppsection
= finfo
->sections
;
5914 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5920 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5923 if (elf_bad_symtab (input_bfd
))
5925 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5932 if (isym
->st_shndx
== SHN_UNDEF
)
5933 isec
= bfd_und_section_ptr
;
5934 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5936 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5940 else if (isym
->st_shndx
== SHN_ABS
)
5941 isec
= bfd_abs_section_ptr
;
5942 else if (isym
->st_shndx
== SHN_COMMON
)
5943 isec
= bfd_com_section_ptr
;
5952 /* Don't output the first, undefined, symbol. */
5953 if (esym
== finfo
->external_syms
)
5956 /* If we are stripping all symbols, we don't want to output this
5958 if (finfo
->info
->strip
== strip_all
)
5961 /* We never output section symbols. Instead, we use the section
5962 symbol of the corresponding section in the output file. */
5963 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5966 /* If we are discarding all local symbols, we don't want to
5967 output this one. If we are generating a relocateable output
5968 file, then some of the local symbols may be required by
5969 relocs; we output them below as we discover that they are
5971 if (finfo
->info
->discard
== discard_all
)
5974 /* Get the name of the symbol. */
5975 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5980 /* See if we are discarding symbols with this name. */
5981 if ((finfo
->info
->strip
== strip_some
5982 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5984 || (finfo
->info
->discard
== discard_l
5985 && strncmp (name
, finfo
->info
->lprefix
,
5986 finfo
->info
->lprefix_len
) == 0))
5989 /* If we get here, we are going to output this symbol. */
5991 /* Adjust the section index for the output file. */
5992 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
5993 isec
->output_section
);
5994 if (isym
->st_shndx
== (unsigned short) -1)
5997 *pindex
= output_bfd
->symcount
;
5999 /* ELF symbols in relocateable files are section relative, but
6000 in executable files they are virtual addresses. Note that
6001 this code assumes that all ELF sections have an associated
6002 BFD section with a reasonable value for output_offset; below
6003 we assume that they also have a reasonable value for
6004 output_section. Any special sections must be set up to meet
6005 these requirements. */
6006 oldval
= isym
->st_value
;
6007 isym
->st_value
+= isec
->output_offset
;
6008 if (! finfo
->info
->relocateable
)
6009 isym
->st_value
+= isec
->output_section
->vma
;
6011 if (! elf_link_output_sym (finfo
, name
, isym
, isec
))
6014 /* Restore the old value for reloc handling. */
6015 isym
->st_value
= oldval
;
6018 /* Relocate the contents of each section. */
6019 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6021 Elf_Internal_Shdr
*input_rel_hdr
;
6023 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
6026 if ((o
->flags
& SEC_IN_MEMORY
) != 0
6027 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
6029 /* Section was created by elf_link_create_dynamic_sections.
6030 FIXME: This test is fragile. */
6034 /* Read the contents of the section. */
6035 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
6036 (file_ptr
) 0, o
->_raw_size
))
6039 if ((o
->flags
& SEC_RELOC
) != 0)
6041 /* Read in the relocs. */
6042 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6043 if (bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
) != 0
6044 || bfd_read (finfo
->external_relocs
, 1, input_rel_hdr
->sh_size
,
6045 input_bfd
) != input_rel_hdr
->sh_size
)
6048 /* Swap in the relocs. For convenience, we always produce
6049 an Elf_Internal_Rela array; if the relocs are Rel, we set
6051 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6053 Elf_External_Rel
*erel
;
6054 Elf_External_Rel
*erelend
;
6055 Elf_Internal_Rela
*irela
;
6057 erel
= (Elf_External_Rel
*) finfo
->external_relocs
;
6058 erelend
= erel
+ o
->reloc_count
;
6059 irela
= finfo
->internal_relocs
;
6060 for (; erel
< erelend
; erel
++, irela
++)
6062 Elf_Internal_Rel irel
;
6064 elf_swap_reloc_in (input_bfd
, erel
, &irel
);
6065 irela
->r_offset
= irel
.r_offset
;
6066 irela
->r_info
= irel
.r_info
;
6067 irela
->r_addend
= 0;
6072 Elf_External_Rela
*erela
;
6073 Elf_External_Rela
*erelaend
;
6074 Elf_Internal_Rela
*irela
;
6076 BFD_ASSERT (input_rel_hdr
->sh_entsize
6077 == sizeof (Elf_External_Rela
));
6079 erela
= (Elf_External_Rela
*) finfo
->external_relocs
;
6080 erelaend
= erela
+ o
->reloc_count
;
6081 irela
= finfo
->internal_relocs
;
6082 for (; erela
< erelaend
; erela
++, irela
++)
6083 elf_swap_reloca_in (input_bfd
, erela
, irela
);
6086 /* Relocate the section by invoking a back end routine.
6088 The back end routine is responsible for adjusting the
6089 section contents as necessary, and (if using Rela relocs
6090 and generating a relocateable output file) adjusting the
6091 reloc addend as necessary.
6093 The back end routine does not have to worry about setting
6094 the reloc address or the reloc symbol index.
6096 The back end routine is given a pointer to the swapped in
6097 internal symbols, and can access the hash table entries
6098 for the external symbols via elf_sym_hashes (input_bfd).
6100 When generating relocateable output, the back end routine
6101 must handle STB_LOCAL/STT_SECTION symbols specially. The
6102 output symbol is going to be a section symbol
6103 corresponding to the output section, which will require
6104 the addend to be adjusted. */
6106 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6109 finfo
->internal_relocs
,
6110 finfo
->internal_syms
,
6112 finfo
->symstrtab
->tab
))
6115 if (finfo
->info
->relocateable
)
6117 Elf_Internal_Rela
*irela
;
6118 Elf_Internal_Rela
*irelaend
;
6119 struct elf_link_hash_entry
**rel_hash
;
6120 Elf_Internal_Shdr
*output_rel_hdr
;
6122 /* Adjust the reloc addresses and symbol indices. */
6124 irela
= finfo
->internal_relocs
;
6125 irelaend
= irela
+ o
->reloc_count
;
6126 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6127 + o
->output_section
->reloc_count
);
6128 for (; irela
< irelaend
; irela
++, rel_hash
++)
6131 Elf_Internal_Sym
*isym
;
6134 irela
->r_offset
+= o
->output_offset
;
6136 r_symndx
= ELF_R_SYM (irela
->r_info
);
6141 if (r_symndx
>= locsymcount
6142 || (elf_bad_symtab (input_bfd
)
6143 && finfo
->sections
[r_symndx
] == NULL
))
6147 /* This is a reloc against a global symbol. We
6148 have not yet output all the local symbols, so
6149 we do not know the symbol index of any global
6150 symbol. We set the rel_hash entry for this
6151 reloc to point to the global hash table entry
6152 for this symbol. The symbol index is then
6153 set at the end of elf_bfd_final_link. */
6154 indx
= r_symndx
- extsymoff
;
6155 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6157 /* Setting the index to -2 tells
6158 elf_link_output_extsym that this symbol is
6160 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6161 (*rel_hash
)->indx
= -2;
6166 /* This is a reloc against a local symbol. */
6169 isym
= finfo
->internal_syms
+ r_symndx
;
6170 sec
= finfo
->sections
[r_symndx
];
6171 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6173 /* I suppose the backend ought to fill in the
6174 section of any STT_SECTION symbol against a
6175 processor specific section. */
6176 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6178 else if (sec
== NULL
|| sec
->owner
== NULL
)
6180 bfd_set_error (bfd_error_bad_value
);
6185 r_symndx
= sec
->output_section
->target_index
;
6192 if (finfo
->indices
[r_symndx
] == -1)
6198 if (finfo
->info
->strip
== strip_all
)
6200 /* You can't do ld -r -s. */
6201 bfd_set_error (bfd_error_invalid_operation
);
6205 /* This symbol was skipped earlier, but
6206 since it is needed by a reloc, we
6207 must output it now. */
6208 link
= symtab_hdr
->sh_link
;
6209 name
= elf_string_from_elf_section (input_bfd
,
6215 osec
= sec
->output_section
;
6217 elf_section_from_bfd_section (output_bfd
,
6219 if (isym
->st_shndx
== (unsigned short) -1)
6222 isym
->st_value
+= sec
->output_offset
;
6223 if (! finfo
->info
->relocateable
)
6224 isym
->st_value
+= osec
->vma
;
6226 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6228 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
6232 r_symndx
= finfo
->indices
[r_symndx
];
6235 irela
->r_info
= ELF_R_INFO (r_symndx
,
6236 ELF_R_TYPE (irela
->r_info
));
6239 /* Swap out the relocs. */
6240 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6241 BFD_ASSERT (output_rel_hdr
->sh_entsize
6242 == input_rel_hdr
->sh_entsize
);
6243 irela
= finfo
->internal_relocs
;
6244 irelaend
= irela
+ o
->reloc_count
;
6245 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6247 Elf_External_Rel
*erel
;
6249 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6250 + o
->output_section
->reloc_count
);
6251 for (; irela
< irelaend
; irela
++, erel
++)
6253 Elf_Internal_Rel irel
;
6255 irel
.r_offset
= irela
->r_offset
;
6256 irel
.r_info
= irela
->r_info
;
6257 BFD_ASSERT (irela
->r_addend
== 0);
6258 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6263 Elf_External_Rela
*erela
;
6265 BFD_ASSERT (input_rel_hdr
->sh_entsize
6266 == sizeof (Elf_External_Rela
));
6267 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6268 + o
->output_section
->reloc_count
);
6269 for (; irela
< irelaend
; irela
++, erela
++)
6270 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6273 o
->output_section
->reloc_count
+= o
->reloc_count
;
6277 /* Write out the modified section contents. */
6278 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6279 finfo
->contents
, o
->output_offset
,
6280 (o
->_cooked_size
!= 0
6289 /* Generate a reloc when linking an ELF file. This is a reloc
6290 requested by the linker, and does come from any input file. This
6291 is used to build constructor and destructor tables when linking
6295 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6297 struct bfd_link_info
*info
;
6298 asection
*output_section
;
6299 struct bfd_link_order
*link_order
;
6301 const reloc_howto_type
*howto
;
6304 struct elf_link_hash_entry
**rel_hash_ptr
;
6305 Elf_Internal_Shdr
*rel_hdr
;
6307 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6310 bfd_set_error (bfd_error_bad_value
);
6314 /* If this is an inplace reloc, we must write the addend into the
6316 if (howto
->partial_inplace
6317 && link_order
->u
.reloc
.p
->addend
!= 0)
6320 bfd_reloc_status_type rstat
;
6324 size
= bfd_get_reloc_size (howto
);
6325 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6326 if (buf
== (bfd_byte
*) NULL
)
6328 bfd_set_error (bfd_error_no_memory
);
6331 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6332 link_order
->u
.reloc
.p
->addend
, buf
);
6338 case bfd_reloc_outofrange
:
6340 case bfd_reloc_overflow
:
6341 if (! ((*info
->callbacks
->reloc_overflow
)
6343 (link_order
->type
== bfd_section_reloc_link_order
6344 ? bfd_section_name (output_bfd
,
6345 link_order
->u
.reloc
.p
->u
.section
)
6346 : link_order
->u
.reloc
.p
->u
.name
),
6347 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6348 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6355 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6356 (file_ptr
) link_order
->offset
, size
);
6362 /* Figure out the symbol index. */
6363 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6364 + output_section
->reloc_count
);
6365 if (link_order
->type
== bfd_section_reloc_link_order
)
6367 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6370 *rel_hash_ptr
= NULL
;
6374 struct elf_link_hash_entry
*h
;
6376 h
= elf_link_hash_lookup (elf_hash_table (info
),
6377 link_order
->u
.reloc
.p
->u
.name
,
6378 false, false, true);
6381 /* Setting the index to -2 tells elf_link_output_extsym that
6382 this symbol is used by a reloc. */
6389 if (! ((*info
->callbacks
->unattached_reloc
)
6390 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6391 (asection
*) NULL
, (bfd_vma
) 0)))
6397 /* The address of a reloc is relative to the section in a
6398 relocateable file, and is a virtual address in an executable
6400 offset
= link_order
->offset
;
6401 if (! info
->relocateable
)
6402 offset
+= output_section
->vma
;
6404 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6406 if (rel_hdr
->sh_type
== SHT_REL
)
6408 Elf_Internal_Rel irel
;
6409 Elf_External_Rel
*erel
;
6411 irel
.r_offset
= offset
;
6412 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6413 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6414 + output_section
->reloc_count
);
6415 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6419 Elf_Internal_Rela irela
;
6420 Elf_External_Rela
*erela
;
6422 irela
.r_offset
= offset
;
6423 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6424 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6425 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6426 + output_section
->reloc_count
);
6427 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6430 ++output_section
->reloc_count
;