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_dyn_in NAME(bfd_elf,swap_dyn_in)
96 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
97 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
98 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
99 #define elf_get_symtab NAME(bfd_elf,get_symtab)
100 #define elf_canonicalize_dynamic_symtab \
101 NAME(bfd_elf,canonicalize_dynamic_symtab)
102 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
103 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
104 #define elf_print_symbol NAME(bfd_elf,print_symbol)
105 #define elf_get_lineno NAME(bfd_elf,get_lineno)
106 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
107 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
108 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
109 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
110 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
111 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
112 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
113 #define write_relocs NAME(bfd_elf,_write_relocs)
114 #define elf_find_section NAME(bfd_elf,find_section)
115 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
116 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
117 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
120 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
121 #define ELF_R_SYM(X) ELF64_R_SYM(X)
122 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
123 #define ELFCLASS ELFCLASS64
125 #define LOG_FILE_ALIGN 3
128 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
129 #define ELF_R_SYM(X) ELF32_R_SYM(X)
130 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
131 #define ELFCLASS ELFCLASS32
133 #define LOG_FILE_ALIGN 2
136 /* Forward declarations of static functions */
138 static unsigned long bfd_add_to_strtab
139 PARAMS ((bfd
*, struct strtab
*, const char *));
140 static asection
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
142 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
144 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
146 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
147 struct symbol_cache_entry
**));
149 static boolean elf_compute_section_file_positions
150 PARAMS ((bfd
*, struct bfd_link_info
*));
151 static boolean prep_headers
PARAMS ((bfd
*));
152 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
153 static boolean assign_section_numbers
PARAMS ((bfd
*));
154 static file_ptr align_file_position
PARAMS ((file_ptr
));
155 static file_ptr assign_file_position_for_section
156 PARAMS ((Elf_Internal_Shdr
*, file_ptr
, boolean
));
157 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
158 static void assign_file_positions_for_relocs
PARAMS ((bfd
*));
159 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
160 static file_ptr map_program_segments
161 PARAMS ((bfd
*, file_ptr
, Elf_Internal_Shdr
*, bfd_size_type
));
163 static boolean elf_map_symbols
PARAMS ((bfd
*));
164 static boolean swap_out_syms
PARAMS ((bfd
*));
166 static boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
169 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
170 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
173 #define elf_string_from_elf_strtab(abfd,strindex) \
174 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
177 /* Structure swapping routines */
179 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
180 can be handled by explicitly specifying 32 bits or "the long type". */
182 #define put_word bfd_h_put_64
183 #define get_word bfd_h_get_64
186 #define put_word bfd_h_put_32
187 #define get_word bfd_h_get_32
190 /* Translate an ELF symbol in external format into an ELF symbol in internal
194 elf_swap_symbol_in (abfd
, src
, dst
)
196 Elf_External_Sym
*src
;
197 Elf_Internal_Sym
*dst
;
199 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
200 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
201 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
202 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
203 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
204 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
207 /* Translate an ELF symbol in internal format into an ELF symbol in external
211 elf_swap_symbol_out (abfd
, src
, dst
)
213 Elf_Internal_Sym
*src
;
214 Elf_External_Sym
*dst
;
216 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
217 put_word (abfd
, src
->st_value
, dst
->st_value
);
218 put_word (abfd
, src
->st_size
, dst
->st_size
);
219 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
220 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
221 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
225 /* Translate an ELF file header in external format into an ELF file header in
229 elf_swap_ehdr_in (abfd
, src
, dst
)
231 Elf_External_Ehdr
*src
;
232 Elf_Internal_Ehdr
*dst
;
234 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
235 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
236 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
237 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
238 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
239 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
240 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
241 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
242 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
243 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
244 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
245 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
246 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
247 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
250 /* Translate an ELF file header in internal format into an ELF file header in
254 elf_swap_ehdr_out (abfd
, src
, dst
)
256 Elf_Internal_Ehdr
*src
;
257 Elf_External_Ehdr
*dst
;
259 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
260 /* note that all elements of dst are *arrays of unsigned char* already... */
261 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
262 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
263 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
264 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
265 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
266 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
267 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
268 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
269 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
270 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
271 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
272 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
273 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
277 /* Translate an ELF section header table entry in external format into an
278 ELF section header table entry in internal format. */
281 elf_swap_shdr_in (abfd
, src
, dst
)
283 Elf_External_Shdr
*src
;
284 Elf_Internal_Shdr
*dst
;
286 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
287 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
288 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
289 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
290 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
291 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
292 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
293 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
294 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
295 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
296 /* we haven't done any processing on it yet, so... */
297 dst
->rawdata
= (void *) 0;
300 /* Translate an ELF section header table entry in internal format into an
301 ELF section header table entry in external format. */
304 elf_swap_shdr_out (abfd
, src
, dst
)
306 Elf_Internal_Shdr
*src
;
307 Elf_External_Shdr
*dst
;
309 /* note that all elements of dst are *arrays of unsigned char* already... */
310 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
311 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
312 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
313 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
314 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
315 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
316 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
317 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
318 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
319 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
323 /* Translate an ELF program header table entry in external format into an
324 ELF program header table entry in internal format. */
327 elf_swap_phdr_in (abfd
, src
, dst
)
329 Elf_External_Phdr
*src
;
330 Elf_Internal_Phdr
*dst
;
332 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
333 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
334 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
335 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
336 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
337 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
338 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
339 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
343 elf_swap_phdr_out (abfd
, src
, dst
)
345 Elf_Internal_Phdr
*src
;
346 Elf_External_Phdr
*dst
;
348 /* note that all elements of dst are *arrays of unsigned char* already... */
349 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
350 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
351 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
352 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
353 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
354 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
355 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
356 put_word (abfd
, src
->p_align
, dst
->p_align
);
359 /* Translate an ELF reloc from external format to internal format. */
361 elf_swap_reloc_in (abfd
, src
, dst
)
363 Elf_External_Rel
*src
;
364 Elf_Internal_Rel
*dst
;
366 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
367 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
371 elf_swap_reloca_in (abfd
, src
, dst
)
373 Elf_External_Rela
*src
;
374 Elf_Internal_Rela
*dst
;
376 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
377 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
378 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
381 /* Translate an ELF reloc from internal format to external format. */
383 elf_swap_reloc_out (abfd
, src
, dst
)
385 Elf_Internal_Rel
*src
;
386 Elf_External_Rel
*dst
;
388 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
389 put_word (abfd
, src
->r_info
, dst
->r_info
);
393 elf_swap_reloca_out (abfd
, src
, dst
)
395 Elf_Internal_Rela
*src
;
396 Elf_External_Rela
*dst
;
398 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
399 put_word (abfd
, src
->r_info
, dst
->r_info
);
400 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
404 elf_swap_dyn_in (abfd
, src
, dst
)
406 const Elf_External_Dyn
*src
;
407 Elf_Internal_Dyn
*dst
;
409 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
410 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
414 elf_swap_dyn_out (abfd
, src
, dst
)
416 const Elf_Internal_Dyn
*src
;
417 Elf_External_Dyn
*dst
;
419 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
420 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
423 /* String table creation/manipulation routines */
425 static struct strtab
*
426 bfd_new_strtab (abfd
)
431 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
434 bfd_set_error (bfd_error_no_memory
);
437 ss
->tab
= malloc (1);
440 bfd_set_error (bfd_error_no_memory
);
451 bfd_add_to_strtab (abfd
, ss
, str
)
456 /* should search first, but for now: */
457 /* include the trailing NUL */
458 int ln
= strlen (str
) + 1;
460 /* FIXME: This is slow. Also, we could combine this with the a.out
461 string table building and use a hash table, although it might not
462 be worth it since ELF symbols don't include debugging information
463 and thus have much less overlap. */
464 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
467 bfd_set_error (bfd_error_no_memory
);
468 return (unsigned long) -1;
471 strcpy (ss
->tab
+ ss
->length
, str
);
475 return ss
->length
- ln
;
479 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
485 /* should search first, but for now: */
486 /* include the trailing NUL */
487 int ln
= strlen (str
) + strlen (str2
) + 1;
489 /* should this be using obstacks? */
491 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
493 ss
->tab
= malloc (ln
);
495 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
496 strcpy (ss
->tab
+ ss
->length
, str
);
497 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
501 return ss
->length
- ln
;
504 /* ELF .o/exec file reading */
506 /* Create a new bfd section from an ELF section header. */
509 bfd_section_from_shdr (abfd
, shindex
)
511 unsigned int shindex
;
513 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
514 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
517 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
519 switch (hdr
->sh_type
)
522 /* Inactive section. Throw it away. */
525 case SHT_PROGBITS
: /* Normal section with contents. */
526 case SHT_DYNAMIC
: /* Dynamic linking information. */
527 case SHT_NOBITS
: /* .bss section. */
528 case SHT_HASH
: /* .hash section. */
529 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
531 case SHT_SYMTAB
: /* A symbol table */
532 if (elf_onesymtab (abfd
) == shindex
)
535 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
536 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
537 elf_onesymtab (abfd
) = shindex
;
538 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
539 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
540 abfd
->flags
|= HAS_SYMS
;
543 case SHT_DYNSYM
: /* A dynamic symbol table */
544 if (elf_dynsymtab (abfd
) == shindex
)
547 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
548 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
549 elf_dynsymtab (abfd
) = shindex
;
550 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
551 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
552 abfd
->flags
|= HAS_SYMS
;
554 /* Besides being a symbol table, we also treat this as a regular
555 section, so that objcopy can handle it. */
556 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
558 case SHT_STRTAB
: /* A string table */
559 if (hdr
->rawdata
!= NULL
)
561 if (ehdr
->e_shstrndx
== shindex
)
563 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
564 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
565 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
571 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
573 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
574 if (hdr2
->sh_link
== shindex
)
576 if (! bfd_section_from_shdr (abfd
, i
))
578 if (elf_onesymtab (abfd
) == i
)
580 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
581 elf_elfsections (abfd
)[shindex
] =
582 &elf_tdata (abfd
)->strtab_hdr
;
585 if (elf_dynsymtab (abfd
) == i
)
587 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
588 elf_elfsections (abfd
)[shindex
] =
589 &elf_tdata (abfd
)->dynstrtab_hdr
;
590 /* We also treat this as a regular section, so
591 that objcopy can handle it. */
594 #if 0 /* Not handling other string tables specially right now. */
595 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
596 /* We have a strtab for some random other section. */
597 newsect
= (asection
*) hdr2
->rawdata
;
600 hdr
->rawdata
= (PTR
) newsect
;
601 hdr2
= &elf_section_data (newsect
)->str_hdr
;
603 elf_elfsections (abfd
)[shindex
] = hdr2
;
609 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
613 /* *These* do a lot of work -- but build no sections! */
615 asection
*target_sect
;
616 Elf_Internal_Shdr
*hdr2
;
617 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
619 /* Get the symbol table. */
620 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
623 /* If this reloc section does not use the main symbol table we
624 don't treat it as a reloc section. BFD can't adequately
625 represent such a section, so at least for now, we don't
626 try. We just present it as a normal section. */
627 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
628 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
630 /* Don't allow REL relocations on a machine that uses RELA and
632 /* @@ Actually, the generic ABI does suggest that both might be
633 used in one file. But the four ABI Processor Supplements I
634 have access to right now all specify that only one is used on
635 each of those architectures. It's conceivable that, e.g., a
636 bunch of absolute 32-bit relocs might be more compact in REL
637 form even on a RELA machine... */
638 BFD_ASSERT (use_rela_p
639 ? (hdr
->sh_type
== SHT_RELA
640 && hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
641 : (hdr
->sh_type
== SHT_REL
642 && hdr
->sh_entsize
== sizeof (Elf_External_Rel
)));
644 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
646 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
647 if (target_sect
== NULL
648 || elf_section_data (target_sect
) == NULL
)
651 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
653 elf_elfsections (abfd
)[shindex
] = hdr2
;
654 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
655 target_sect
->flags
|= SEC_RELOC
;
656 target_sect
->relocation
= NULL
;
657 target_sect
->rel_filepos
= hdr
->sh_offset
;
658 abfd
->flags
|= HAS_RELOC
;
665 fprintf (stderr
, "Note Sections not yet supported.\n");
672 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
677 /* Check for any processor-specific section types. */
679 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
681 if (bed
->elf_backend_section_from_shdr
)
682 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
691 elf_new_section_hook (abfd
, sec
)
696 struct bfd_elf_section_data
*sdata
;
698 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
701 bfd_set_error (bfd_error_no_memory
);
704 sec
->used_by_bfd
= (PTR
) sdata
;
705 memset (sdata
, 0, sizeof (*sdata
));
709 /* Create a new bfd section from an ELF program header.
711 Since program segments have no names, we generate a synthetic name
712 of the form segment<NUM>, where NUM is generally the index in the
713 program header table. For segments that are split (see below) we
714 generate the names segment<NUM>a and segment<NUM>b.
716 Note that some program segments may have a file size that is different than
717 (less than) the memory size. All this means is that at execution the
718 system must allocate the amount of memory specified by the memory size,
719 but only initialize it with the first "file size" bytes read from the
720 file. This would occur for example, with program segments consisting
721 of combined data+bss.
723 To handle the above situation, this routine generates TWO bfd sections
724 for the single program segment. The first has the length specified by
725 the file size of the segment, and the second has the length specified
726 by the difference between the two sizes. In effect, the segment is split
727 into it's initialized and uninitialized parts.
732 bfd_section_from_phdr (abfd
, hdr
, index
)
734 Elf_Internal_Phdr
*hdr
;
742 split
= ((hdr
->p_memsz
> 0) &&
743 (hdr
->p_filesz
> 0) &&
744 (hdr
->p_memsz
> hdr
->p_filesz
));
745 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
746 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
749 bfd_set_error (bfd_error_no_memory
);
752 strcpy (name
, namebuf
);
753 newsect
= bfd_make_section (abfd
, name
);
756 newsect
->vma
= hdr
->p_vaddr
;
757 newsect
->_raw_size
= hdr
->p_filesz
;
758 newsect
->filepos
= hdr
->p_offset
;
759 newsect
->flags
|= SEC_HAS_CONTENTS
;
760 if (hdr
->p_type
== PT_LOAD
)
762 newsect
->flags
|= SEC_ALLOC
;
763 newsect
->flags
|= SEC_LOAD
;
764 if (hdr
->p_flags
& PF_X
)
766 /* FIXME: all we known is that it has execute PERMISSION,
768 newsect
->flags
|= SEC_CODE
;
771 if (!(hdr
->p_flags
& PF_W
))
773 newsect
->flags
|= SEC_READONLY
;
778 sprintf (namebuf
, "segment%db", index
);
779 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
782 bfd_set_error (bfd_error_no_memory
);
785 strcpy (name
, namebuf
);
786 newsect
= bfd_make_section (abfd
, name
);
789 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
790 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
791 if (hdr
->p_type
== PT_LOAD
)
793 newsect
->flags
|= SEC_ALLOC
;
794 if (hdr
->p_flags
& PF_X
)
795 newsect
->flags
|= SEC_CODE
;
797 if (!(hdr
->p_flags
& PF_W
))
798 newsect
->flags
|= SEC_READONLY
;
804 /* Begin processing a given object.
806 First we validate the file by reading in the ELF header and checking
809 static INLINE boolean
811 Elf_External_Ehdr
*x_ehdrp
;
813 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
814 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
815 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
816 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
819 /* Check to see if the file associated with ABFD matches the target vector
822 Note that we may be called several times with the same ABFD, but different
823 target vectors, most of which will not match. We have to avoid leaving
824 any side effects in ABFD, or any data it points to (like tdata), if the
825 file does not match the target vector. */
831 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
832 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
833 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
834 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
835 unsigned int shindex
;
836 char *shstrtab
; /* Internal copy of section header stringtab */
837 struct elf_backend_data
*ebd
;
838 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
839 struct elf_obj_tdata
*new_tdata
= NULL
;
841 /* Read in the ELF header in external format. */
843 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
845 if (bfd_get_error () != bfd_error_system_call
)
846 goto got_wrong_format_error
;
851 /* Now check to see if we have a valid ELF file, and one that BFD can
852 make use of. The magic number must match, the address size ('class')
853 and byte-swapping must match our XVEC entry, and it must have a
854 section header table (FIXME: See comments re sections at top of this
857 if ((elf_file_p (&x_ehdr
) == false) ||
858 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
859 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
860 goto got_wrong_format_error
;
862 /* Check that file's byte order matches xvec's */
863 switch (x_ehdr
.e_ident
[EI_DATA
])
865 case ELFDATA2MSB
: /* Big-endian */
866 if (!abfd
->xvec
->header_byteorder_big_p
)
867 goto got_wrong_format_error
;
869 case ELFDATA2LSB
: /* Little-endian */
870 if (abfd
->xvec
->header_byteorder_big_p
)
871 goto got_wrong_format_error
;
873 case ELFDATANONE
: /* No data encoding specified */
874 default: /* Unknown data encoding specified */
875 goto got_wrong_format_error
;
878 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
879 the tdata pointer in the bfd. */
881 new_tdata
= ((struct elf_obj_tdata
*)
882 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
883 if (new_tdata
== NULL
)
884 goto got_no_memory_error
;
885 elf_tdata (abfd
) = new_tdata
;
887 /* Now that we know the byte order, swap in the rest of the header */
888 i_ehdrp
= elf_elfheader (abfd
);
889 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
891 elf_debug_file (i_ehdrp
);
894 /* If there is no section header table, we're hosed. */
895 if (i_ehdrp
->e_shoff
== 0)
896 goto got_wrong_format_error
;
898 /* As a simple sanity check, verify that the what BFD thinks is the
899 size of each section header table entry actually matches the size
900 recorded in the file. */
901 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
902 goto got_wrong_format_error
;
904 ebd
= get_elf_backend_data (abfd
);
906 /* Check that the ELF e_machine field matches what this particular
907 BFD format expects. */
908 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
910 bfd_target
**target_ptr
;
912 if (ebd
->elf_machine_code
!= EM_NONE
)
913 goto got_wrong_format_error
;
915 /* This is the generic ELF target. Let it match any ELF target
916 for which we do not have a specific backend. */
917 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
919 struct elf_backend_data
*back
;
921 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
923 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
924 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
926 /* target_ptr is an ELF backend which matches this
927 object file, so reject the generic ELF target. */
928 goto got_wrong_format_error
;
933 if (i_ehdrp
->e_type
== ET_EXEC
)
934 abfd
->flags
|= EXEC_P
;
935 else if (i_ehdrp
->e_type
== ET_DYN
)
936 abfd
->flags
|= DYNAMIC
;
938 if (i_ehdrp
->e_phnum
> 0)
939 abfd
->flags
|= D_PAGED
;
941 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
944 /* Remember the entry point specified in the ELF file header. */
945 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
947 /* Allocate space for a copy of the section header table in
948 internal form, seek to the section header table in the file,
949 read it in, and convert it to internal form. */
950 i_shdrp
= ((Elf_Internal_Shdr
*)
951 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
952 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
954 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
955 if (!i_shdrp
|| !elf_elfsections (abfd
))
956 goto got_no_memory_error
;
957 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
959 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
961 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
963 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
964 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
966 /* If this is a .dynamic section, mark the object file as being
967 dynamically linked. */
968 if (i_shdrp
[shindex
].sh_type
== SHT_DYNAMIC
)
969 abfd
->flags
|= DYNAMIC
;
971 if (i_ehdrp
->e_shstrndx
)
973 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
977 /* Read in the string table containing the names of the sections. We
978 will need the base pointer to this table later. */
979 /* We read this inline now, so that we don't have to go through
980 bfd_section_from_shdr with it (since this particular strtab is
981 used to find all of the ELF section names.) */
983 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
987 /* Once all of the section headers have been read and converted, we
988 can start processing them. Note that the first section header is
989 a dummy placeholder entry, so we ignore it. */
991 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
993 if (! bfd_section_from_shdr (abfd
, shindex
))
997 /* Let the backend double check the format and override global
999 if (ebd
->elf_backend_object_p
)
1001 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
1002 goto got_wrong_format_error
;
1005 return (abfd
->xvec
);
1007 got_wrong_format_error
:
1008 bfd_set_error (bfd_error_wrong_format
);
1010 got_no_memory_error
:
1011 bfd_set_error (bfd_error_no_memory
);
1014 if (new_tdata
!= NULL
1015 && new_tdata
->elf_sect_ptr
!= NULL
)
1016 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
1017 if (i_shdrp
!= NULL
)
1018 bfd_release (abfd
, i_shdrp
);
1019 if (new_tdata
!= NULL
)
1020 bfd_release (abfd
, new_tdata
);
1021 elf_tdata (abfd
) = preserved_tdata
;
1026 /* ELF .o/exec file writing */
1028 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1029 of the symbol if there is one. */
1030 static INLINE elf_symbol_type
*
1031 elf_symbol_from (ignore_abfd
, symbol
)
1035 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1038 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1041 return (elf_symbol_type
*) symbol
;
1045 write_relocs (abfd
, sec
, xxx
)
1050 Elf_Internal_Shdr
*rela_hdr
;
1051 Elf_External_Rela
*outbound_relocas
;
1052 Elf_External_Rel
*outbound_relocs
;
1054 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1055 asymbol
*last_sym
= 0;
1056 int last_sym_idx
= 9999999; /* should always be written before use */
1058 if ((sec
->flags
& SEC_RELOC
) == 0)
1061 /* The linker backend writes the relocs out itself, and sets the
1062 reloc_count field to zero to inhibit writing them here. Also,
1063 sometimes the SEC_RELOC flag gets set even when there aren't any
1065 if (sec
->reloc_count
== 0)
1068 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1070 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1071 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1072 if (!rela_hdr
->contents
)
1074 bfd_set_error (bfd_error_no_memory
);
1075 abort (); /* FIXME */
1078 /* orelocation has the data, reloc_count has the count... */
1081 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1083 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1085 Elf_Internal_Rela dst_rela
;
1086 Elf_External_Rela
*src_rela
;
1091 ptr
= sec
->orelocation
[idx
];
1092 src_rela
= outbound_relocas
+ idx
;
1093 if (!(abfd
->flags
& EXEC_P
))
1094 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1096 dst_rela
.r_offset
= ptr
->address
;
1098 sym
= *ptr
->sym_ptr_ptr
;
1099 if (sym
== last_sym
)
1104 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1106 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1108 dst_rela
.r_addend
= ptr
->addend
;
1109 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1113 /* REL relocations */
1115 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1117 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1119 Elf_Internal_Rel dst_rel
;
1120 Elf_External_Rel
*src_rel
;
1125 ptr
= sec
->orelocation
[idx
];
1126 sym
= *ptr
->sym_ptr_ptr
;
1127 src_rel
= outbound_relocs
+ idx
;
1128 if (!(abfd
->flags
& EXEC_P
))
1129 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1131 dst_rel
.r_offset
= ptr
->address
;
1133 if (sym
== last_sym
)
1138 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1140 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1142 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1147 /* Set up an ELF internal section header for a section. */
1151 elf_fake_sections (abfd
, asect
, ignore
)
1156 Elf_Internal_Shdr
*this_hdr
;
1158 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1160 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
),
1162 if (this_hdr
->sh_name
== (unsigned long) -1)
1163 abort (); /* FIXME */
1165 this_hdr
->sh_flags
= 0;
1166 if ((asect
->flags
& SEC_ALLOC
) != 0)
1167 this_hdr
->sh_addr
= asect
->vma
;
1169 this_hdr
->sh_addr
= 0;
1170 this_hdr
->sh_offset
= 0;
1171 this_hdr
->sh_size
= asect
->_raw_size
;
1172 this_hdr
->sh_link
= 0;
1173 this_hdr
->sh_info
= 0;
1174 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1175 this_hdr
->sh_entsize
= 0;
1177 this_hdr
->rawdata
= (PTR
) asect
;
1178 this_hdr
->contents
= NULL
;
1181 /* FIXME: This should not be based on section names. */
1182 if (strcmp (asect
->name
, ".dynstr") == 0)
1183 this_hdr
->sh_type
= SHT_STRTAB
;
1184 else if (strcmp (asect
->name
, ".hash") == 0)
1186 this_hdr
->sh_type
= SHT_HASH
;
1187 this_hdr
->sh_entsize
= ARCH_SIZE
/ 8;
1189 else if (strcmp (asect
->name
, ".dynsym") == 0)
1191 this_hdr
->sh_type
= SHT_DYNSYM
;
1192 this_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1194 else if (strcmp (asect
->name
, ".dynamic") == 0)
1196 this_hdr
->sh_type
= SHT_DYNAMIC
;
1197 this_hdr
->sh_entsize
= sizeof (Elf_External_Dyn
);
1199 else if (strncmp (asect
->name
, ".rel.", 5) == 0)
1201 this_hdr
->sh_type
= SHT_REL
;
1202 this_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1204 else if (strncmp (asect
->name
, ".rela.", 6) == 0)
1206 this_hdr
->sh_type
= SHT_RELA
;
1207 this_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1209 else if (strcmp (asect
->name
, ".note") == 0)
1210 this_hdr
->sh_type
= SHT_NOTE
;
1211 else if (strncmp (asect
->name
, ".stab", 5) == 0
1212 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1213 this_hdr
->sh_type
= SHT_STRTAB
;
1214 else if ((asect
->flags
& SEC_ALLOC
) != 0
1215 && (asect
->flags
& SEC_LOAD
) != 0)
1216 this_hdr
->sh_type
= SHT_PROGBITS
;
1217 else if ((asect
->flags
& SEC_ALLOC
) != 0
1218 && ((asect
->flags
& SEC_LOAD
) == 0))
1220 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1221 || strcmp (asect
->name
, ".sbss") == 0);
1222 this_hdr
->sh_type
= SHT_NOBITS
;
1227 this_hdr
->sh_type
= SHT_PROGBITS
;
1230 if ((asect
->flags
& SEC_ALLOC
) != 0)
1231 this_hdr
->sh_flags
|= SHF_ALLOC
;
1232 if ((asect
->flags
& SEC_READONLY
) == 0)
1233 this_hdr
->sh_flags
|= SHF_WRITE
;
1234 if ((asect
->flags
& SEC_CODE
) != 0)
1235 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1237 /* Check for processor-specific section types. */
1239 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1241 if (bed
->elf_backend_fake_sections
)
1242 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1245 /* If the section has relocs, set up a section header for the
1246 SHT_REL[A] section. */
1247 if ((asect
->flags
& SEC_RELOC
) != 0)
1249 Elf_Internal_Shdr
*rela_hdr
;
1250 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1252 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1254 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1255 use_rela_p
? ".rela" : ".rel",
1257 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1258 rela_hdr
->sh_entsize
= (use_rela_p
1259 ? sizeof (Elf_External_Rela
)
1260 : sizeof (Elf_External_Rel
));
1261 rela_hdr
->sh_addralign
= FILE_ALIGN
;
1262 rela_hdr
->sh_flags
= 0;
1263 rela_hdr
->sh_addr
= 0;
1264 rela_hdr
->sh_size
= 0;
1265 rela_hdr
->sh_offset
= 0;
1270 /* Assign all ELF section numbers. The dummy first section is handled here
1271 too. The link/info pointers for the standard section types are filled
1272 in here too, while we're at it. */
1275 assign_section_numbers (abfd
)
1278 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1280 unsigned int section_number
;
1281 Elf_Internal_Shdr
**i_shdrp
;
1285 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1287 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1289 d
->this_idx
= section_number
++;
1290 if ((sec
->flags
& SEC_RELOC
) == 0)
1293 d
->rel_idx
= section_number
++;
1296 t
->shstrtab_section
= section_number
++;
1297 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1298 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1299 t
->shstrtab_hdr
.contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1301 if (abfd
->symcount
> 0)
1303 t
->symtab_section
= section_number
++;
1304 t
->strtab_section
= section_number
++;
1307 elf_elfheader (abfd
)->e_shnum
= section_number
;
1309 /* Set up the list of section header pointers, in agreement with the
1311 i_shdrp
= ((Elf_Internal_Shdr
**)
1312 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1313 if (i_shdrp
== NULL
)
1315 bfd_set_error (bfd_error_no_memory
);
1319 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1320 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1321 if (i_shdrp
[0] == NULL
)
1323 bfd_release (abfd
, i_shdrp
);
1324 bfd_set_error (bfd_error_no_memory
);
1327 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1329 elf_elfsections (abfd
) = i_shdrp
;
1331 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1332 if (abfd
->symcount
> 0)
1334 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1335 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1336 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1338 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1340 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1344 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1345 if (d
->rel_idx
!= 0)
1346 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1348 /* Fill in the sh_link and sh_info fields while we're at it. */
1350 /* sh_link of a reloc section is the section index of the symbol
1351 table. sh_info is the section index of the section to which
1352 the relocation entries apply. */
1353 if (d
->rel_idx
!= 0)
1355 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1356 d
->rel_hdr
.sh_info
= d
->this_idx
;
1359 switch (d
->this_hdr
.sh_type
)
1363 /* A reloc section which we are treating as a normal BFD
1364 section. sh_link is the section index of the symbol
1365 table. sh_info is the section index of the section to
1366 which the relocation entries apply. We assume that an
1367 allocated reloc section uses the dynamic symbol table.
1368 FIXME: How can we be sure? */
1369 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1371 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1373 /* We look up the section the relocs apply to by name. */
1375 if (d
->this_hdr
.sh_type
== SHT_REL
)
1379 s
= bfd_get_section_by_name (abfd
, name
);
1381 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1385 /* We assume that a section named .stab*str is a stabs
1386 string section. We look for a section with the same name
1387 but without the trailing ``str'', and set its sh_link
1388 field to point to this section. */
1389 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1390 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1395 len
= strlen (sec
->name
);
1396 alc
= (char *) malloc (len
- 2);
1399 bfd_set_error (bfd_error_no_memory
);
1402 strncpy (alc
, sec
->name
, len
- 3);
1403 alc
[len
- 3] = '\0';
1404 s
= bfd_get_section_by_name (abfd
, alc
);
1408 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1410 /* This is a .stab section. */
1411 elf_section_data (s
)->this_hdr
.sh_entsize
=
1412 4 + 2 * (ARCH_SIZE
/ 8);
1419 /* sh_link is the section header index of the string table
1420 used for the dynamic entries or symbol table. */
1421 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1423 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1427 /* sh_link is the section header index of the symbol table
1428 this hash table is for. */
1429 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1431 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1439 /* Map symbol from it's internal number to the external number, moving
1440 all local symbols to be at the head of the list. */
1443 sym_is_global (abfd
, sym
)
1447 /* If the backend has a special mapping, use it. */
1448 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1449 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1452 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1454 if (sym
->flags
& BSF_LOCAL
)
1458 if (sym
->section
== 0)
1460 /* Is this valid? */
1465 if (sym
->section
== &bfd_und_section
)
1467 if (bfd_is_com_section (sym
->section
))
1469 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1475 elf_map_symbols (abfd
)
1478 int symcount
= bfd_get_symcount (abfd
);
1479 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1480 asymbol
**sect_syms
;
1482 int num_globals
= 0;
1483 int num_locals2
= 0;
1484 int num_globals2
= 0;
1486 int num_sections
= 0;
1487 Elf_Sym_Extra
*sym_extra
;
1492 fprintf (stderr
, "elf_map_symbols\n");
1496 /* Add local symbols for each section for which there are relocs.
1497 FIXME: How can we tell which sections have relocs at this point?
1498 Will reloc_count always be accurate? Actually, I think most ELF
1499 targets create section symbols for all sections anyhow. */
1500 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1502 if (max_index
< asect
->index
)
1503 max_index
= asect
->index
;
1507 elf_num_section_syms (abfd
) = max_index
;
1508 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1509 elf_section_syms (abfd
) = sect_syms
;
1513 bfd_set_error (bfd_error_no_memory
);
1517 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1519 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1522 bfd_set_error (bfd_error_no_memory
);
1525 sym
->the_bfd
= abfd
;
1526 sym
->name
= asect
->name
;
1527 sym
->value
= asect
->vma
;
1528 sym
->flags
= BSF_SECTION_SYM
;
1529 sym
->section
= asect
;
1530 sect_syms
[asect
->index
] = sym
;
1534 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1535 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1542 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1543 ((symcount
+ num_sections
+ 1)
1544 * sizeof (asymbol
*)));
1546 syms
= (asymbol
**) bfd_alloc (abfd
,
1547 (num_sections
+ 1) * sizeof (asymbol
*));
1550 bfd_set_error (bfd_error_no_memory
);
1554 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1556 if (sect_syms
[asect
->index
])
1557 syms
[symcount
++] = sect_syms
[asect
->index
];
1560 syms
[symcount
] = (asymbol
*) 0;
1561 bfd_set_symtab (abfd
, syms
, symcount
);
1564 elf_sym_extra (abfd
) = sym_extra
1565 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1568 bfd_set_error (bfd_error_no_memory
);
1572 /* Identify and classify all of the symbols. */
1573 for (idx
= 0; idx
< symcount
; idx
++)
1575 if (!sym_is_global (abfd
, syms
[idx
]))
1581 /* Now provide mapping information. Add +1 for skipping over the
1583 for (idx
= 0; idx
< symcount
; idx
++)
1585 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1586 if (!sym_is_global (abfd
, syms
[idx
]))
1587 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1589 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1592 elf_num_locals (abfd
) = num_locals
;
1593 elf_num_globals (abfd
) = num_globals
;
1597 /* Compute the file positions we are going to put the sections at, and
1598 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1599 is not NULL, this is being called by the ELF backend linker. */
1602 elf_compute_section_file_positions (abfd
, link_info
)
1604 struct bfd_link_info
*link_info
;
1606 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1607 Elf_Internal_Shdr
*shstrtab_hdr
;
1609 if (abfd
->output_has_begun
)
1612 /* Do any elf backend specific processing first. */
1613 if (bed
->elf_backend_begin_write_processing
)
1614 (*bed
->elf_backend_begin_write_processing
) (abfd
);
1616 if (! prep_headers (abfd
))
1619 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1621 if (!assign_section_numbers (abfd
))
1624 /* The backend linker builds symbol table information itself. */
1625 if (link_info
== NULL
)
1627 if (! swap_out_syms (abfd
))
1631 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1632 /* sh_name was set in prep_headers. */
1633 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1634 shstrtab_hdr
->sh_flags
= 0;
1635 shstrtab_hdr
->sh_addr
= 0;
1636 shstrtab_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
1637 shstrtab_hdr
->sh_entsize
= 0;
1638 shstrtab_hdr
->sh_link
= 0;
1639 shstrtab_hdr
->sh_info
= 0;
1640 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1641 shstrtab_hdr
->sh_addralign
= 1;
1642 shstrtab_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
1644 if (!assign_file_positions_except_relocs (abfd
,
1645 link_info
== NULL
? true : false))
1648 abfd
->output_has_begun
= true;
1654 /* Align to the maximum file alignment that could be required for any
1655 ELF data structure. */
1657 static INLINE file_ptr
1658 align_file_position (off
)
1661 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1664 /* Assign a file position to a section, optionally aligning to the
1665 required section alignment. */
1667 static INLINE file_ptr
1668 assign_file_position_for_section (i_shdrp
, offset
, align
)
1669 Elf_Internal_Shdr
*i_shdrp
;
1677 al
= i_shdrp
->sh_addralign
;
1679 offset
= BFD_ALIGN (offset
, al
);
1681 i_shdrp
->sh_offset
= offset
;
1682 if (i_shdrp
->rawdata
!= NULL
)
1683 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1684 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1685 offset
+= i_shdrp
->sh_size
;
1689 /* Get the size of the program header. This is called by the linker
1690 before any of the section VMA's are set, so it can't calculate the
1691 correct value for a strange memory layout. */
1693 static bfd_size_type
1694 get_program_header_size (abfd
)
1700 /* Assume we will need exactly two PT_LOAD segments: one for text
1701 and one for data. */
1704 s
= bfd_get_section_by_name (abfd
, ".interp");
1705 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1707 /* If we have a loadable interpreter section, we need a
1708 PT_INTERP segment. In this case, assume we also need a
1709 PT_PHDR segment, although that may not be true for all
1714 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1716 /* We need a PT_DYNAMIC segment. */
1720 return segs
* sizeof (Elf_External_Phdr
);
1723 /* Create the program header. OFF is the file offset where the
1724 program header should be written. FIRST is the first loadable ELF
1725 section. PHDR_SIZE is the size of the program header as returned
1726 by get_program_header_size. */
1729 map_program_segments (abfd
, off
, first
, phdr_size
)
1732 Elf_Internal_Shdr
*first
;
1733 bfd_size_type phdr_size
;
1735 Elf_Internal_Phdr phdrs
[10];
1736 unsigned int phdr_count
;
1737 Elf_Internal_Phdr
*phdr
;
1738 int phdr_size_adjust
;
1740 Elf_Internal_Shdr
**hdrpp
;
1741 asection
*sinterp
, *sdyn
;
1742 unsigned int last_type
;
1743 Elf_Internal_Ehdr
*i_ehdrp
;
1745 BFD_ASSERT ((abfd
->flags
& EXEC_P
) != 0);
1746 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1747 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1752 phdr_size_adjust
= 0;
1754 /* If we have a loadable .interp section, we must create a PT_INTERP
1755 segment which must precede all PT_LOAD segments. We assume that
1756 we must also create a PT_PHDR segment, although that may not be
1757 true for all targets. */
1758 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1759 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1761 BFD_ASSERT (first
!= NULL
);
1763 phdr
->p_type
= PT_PHDR
;
1765 phdr
->p_offset
= off
;
1767 /* Account for any adjustment made because of the alignment of
1768 the first loadable section. */
1769 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1770 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1772 /* The program header precedes all loadable sections. This lets
1773 us compute its loadable address. This depends on the linker
1775 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1778 phdr
->p_filesz
= phdr_size
;
1779 phdr
->p_memsz
= phdr_size
;
1781 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1782 phdr
->p_flags
= PF_R
| PF_X
;
1784 phdr
->p_align
= FILE_ALIGN
;
1785 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % FILE_ALIGN
== 0);
1787 /* Include the ELF header in the first loadable segment. */
1788 phdr_size_adjust
+= off
;
1793 phdr
->p_type
= PT_INTERP
;
1794 phdr
->p_offset
= sinterp
->filepos
;
1795 phdr
->p_vaddr
= sinterp
->vma
;
1797 phdr
->p_filesz
= sinterp
->_raw_size
;
1798 phdr
->p_memsz
= sinterp
->_raw_size
;
1799 phdr
->p_flags
= PF_R
;
1800 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1806 /* Look through the sections to see how they will be divided into
1807 program segments. The sections must be arranged in order by
1808 sh_addr for this to work correctly. */
1809 phdr
->p_type
= PT_NULL
;
1810 last_type
= SHT_PROGBITS
;
1811 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1812 i
< elf_elfheader (abfd
)->e_shnum
;
1815 Elf_Internal_Shdr
*hdr
;
1819 /* Ignore any section which will not be part of the process
1821 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1824 /* If this section fits in the segment we are constructing, add
1826 if (phdr
->p_type
!= PT_NULL
1827 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1828 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1829 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1831 bfd_size_type adjust
;
1833 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1834 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1835 if (hdr
->sh_type
!= SHT_NOBITS
)
1836 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1837 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1838 phdr
->p_flags
|= PF_W
;
1839 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1840 phdr
->p_flags
|= PF_X
;
1841 last_type
= hdr
->sh_type
;
1845 /* If we have a segment, move to the next one. */
1846 if (phdr
->p_type
!= PT_NULL
)
1852 /* Start a new segment. */
1853 phdr
->p_type
= PT_LOAD
;
1854 phdr
->p_offset
= hdr
->sh_offset
;
1855 phdr
->p_vaddr
= hdr
->sh_addr
;
1857 if (hdr
->sh_type
== SHT_NOBITS
)
1860 phdr
->p_filesz
= hdr
->sh_size
;
1861 phdr
->p_memsz
= hdr
->sh_size
;
1862 phdr
->p_flags
= PF_R
;
1863 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1864 phdr
->p_flags
|= PF_W
;
1865 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1866 phdr
->p_flags
|= PF_X
;
1867 phdr
->p_align
= get_elf_backend_data (abfd
)->maxpagesize
;
1871 && (sinterp
->flags
& SEC_LOAD
) != 0)
1873 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1874 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1875 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1876 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1879 last_type
= hdr
->sh_type
;
1882 if (phdr
->p_type
!= PT_NULL
)
1888 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1889 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1890 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1892 phdr
->p_type
= PT_DYNAMIC
;
1893 phdr
->p_offset
= sdyn
->filepos
;
1894 phdr
->p_vaddr
= sdyn
->vma
;
1896 phdr
->p_filesz
= sdyn
->_raw_size
;
1897 phdr
->p_memsz
= sdyn
->_raw_size
;
1898 phdr
->p_flags
= PF_R
;
1899 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1900 phdr
->p_flags
|= PF_W
;
1901 if ((sdyn
->flags
& SEC_CODE
) != 0)
1902 phdr
->p_flags
|= PF_X
;
1903 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1909 /* Make sure the return value from get_program_header_size matches
1910 what we computed here. */
1911 if (phdr_count
!= phdr_size
/ sizeof (Elf_External_Phdr
))
1914 /* Set up program header information. */
1915 i_ehdrp
= elf_elfheader (abfd
);
1916 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1917 i_ehdrp
->e_phoff
= off
;
1918 i_ehdrp
->e_phnum
= phdr_count
;
1920 /* Save the program headers away. I don't think anybody uses this
1921 information right now. */
1922 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1925 * sizeof (Elf_Internal_Phdr
))));
1926 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1928 bfd_set_error (bfd_error_no_memory
);
1929 return (file_ptr
) -1;
1931 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1932 phdr_count
* sizeof (Elf_Internal_Phdr
));
1934 /* Write out the program headers. */
1935 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1936 return (file_ptr
) -1;
1938 for (i
= 0, phdr
= phdrs
; i
< phdr_count
; i
++, phdr
++)
1940 Elf_External_Phdr extphdr
;
1942 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1943 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
1944 != sizeof (Elf_External_Phdr
))
1945 return (file_ptr
) -1;
1948 return off
+ phdr_count
* sizeof (Elf_External_Phdr
);
1951 /* Work out the file positions of all the sections. This is called by
1952 elf_compute_section_file_positions. All the section sizes and VMAs
1953 must be known before this is called.
1955 We do not consider reloc sections at this point, unless they form
1956 part of the loadable image. Reloc sections are assigned file
1957 positions in assign_file_positions_for_relocs, which is called by
1958 write_object_contents and final_link.
1960 If DOSYMS is false, we do not assign file positions for the symbol
1961 table or the string table. */
1964 assign_file_positions_except_relocs (abfd
, dosyms
)
1968 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1969 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1970 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1973 /* Start after the ELF header. */
1974 off
= i_ehdrp
->e_ehsize
;
1976 if ((abfd
->flags
& EXEC_P
) == 0)
1978 Elf_Internal_Shdr
**hdrpp
;
1981 /* We are not creating an executable, which means that we are
1982 not creating a program header, and that the actual order of
1983 the sections in the file is unimportant. */
1984 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1986 Elf_Internal_Shdr
*hdr
;
1989 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1991 hdr
->sh_offset
= -1;
1995 && (i
== tdata
->symtab_section
1996 || i
== tdata
->strtab_section
))
1998 hdr
->sh_offset
= -1;
2002 off
= assign_file_position_for_section (hdr
, off
, true);
2008 bfd_size_type phdr_size
;
2009 bfd_vma maxpagesize
;
2010 Elf_Internal_Shdr
**hdrpp
;
2012 Elf_Internal_Shdr
*first
;
2015 /* We are creating an executable. We must create a program
2016 header. We can't actually create the program header until we
2017 have set the file positions for the sections, but we can
2018 figure out how big it is going to be. */
2019 off
= align_file_position (off
);
2020 phdr_size
= get_program_header_size (abfd
);
2021 if (phdr_size
== (file_ptr
) -1)
2026 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2027 if (maxpagesize
== 0)
2030 /* FIXME: We might want to sort the sections on the sh_addr
2031 field here. For now, we just assume that the linker will
2032 create the sections in an appropriate order. */
2034 /* Assign file positions in two passes. In the first pass, we
2035 assign a file position to every section which forms part of
2036 the executable image. */
2038 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2040 Elf_Internal_Shdr
*hdr
;
2043 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
2049 if ((abfd
->flags
& D_PAGED
) != 0)
2051 /* The section VMA must equal the file position modulo
2052 the page size. This is required by the program
2054 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
2057 off
= assign_file_position_for_section (hdr
, off
, false);
2060 /* Assign file positions to all the sections which do not form
2061 part of the loadable image, except for the relocs. */
2062 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2064 Elf_Internal_Shdr
*hdr
;
2067 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2069 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2071 hdr
->sh_offset
= -1;
2075 && (i
== tdata
->symtab_section
2076 || i
== tdata
->strtab_section
))
2078 hdr
->sh_offset
= -1;
2082 off
= assign_file_position_for_section (hdr
, off
, true);
2085 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, phdr_size
);
2086 if (phdr_map
== (file_ptr
) -1)
2088 BFD_ASSERT (phdr_map
== phdr_off
+ phdr_size
);
2091 /* Place the section headers. */
2092 off
= align_file_position (off
);
2093 i_ehdrp
->e_shoff
= off
;
2094 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2096 elf_tdata (abfd
)->next_file_pos
= off
;
2105 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2106 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2107 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2109 struct strtab
*shstrtab
;
2111 i_ehdrp
= elf_elfheader (abfd
);
2112 i_shdrp
= elf_elfsections (abfd
);
2114 shstrtab
= bfd_new_strtab (abfd
);
2118 elf_shstrtab (abfd
) = shstrtab
;
2120 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2121 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2122 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2123 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2125 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2126 i_ehdrp
->e_ident
[EI_DATA
] =
2127 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2128 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2130 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2131 i_ehdrp
->e_ident
[count
] = 0;
2133 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
2134 switch (bfd_get_arch (abfd
))
2136 case bfd_arch_unknown
:
2137 i_ehdrp
->e_machine
= EM_NONE
;
2139 case bfd_arch_sparc
:
2141 i_ehdrp
->e_machine
= EM_SPARC64
;
2143 i_ehdrp
->e_machine
= EM_SPARC
;
2147 i_ehdrp
->e_machine
= EM_386
;
2150 i_ehdrp
->e_machine
= EM_68K
;
2153 i_ehdrp
->e_machine
= EM_88K
;
2156 i_ehdrp
->e_machine
= EM_860
;
2158 case bfd_arch_mips
: /* MIPS Rxxxx */
2159 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2162 i_ehdrp
->e_machine
= EM_PARISC
;
2164 case bfd_arch_powerpc
:
2165 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2167 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2169 i_ehdrp
->e_machine
= EM_NONE
;
2171 i_ehdrp
->e_version
= EV_CURRENT
;
2172 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2174 /* no program header, for now. */
2175 i_ehdrp
->e_phoff
= 0;
2176 i_ehdrp
->e_phentsize
= 0;
2177 i_ehdrp
->e_phnum
= 0;
2179 /* each bfd section is section header entry */
2180 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2181 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2183 /* if we're building an executable, we'll need a program header table */
2184 if (abfd
->flags
& EXEC_P
)
2186 /* it all happens later */
2188 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2190 /* elf_build_phdrs() returns a (NULL-terminated) array of
2191 Elf_Internal_Phdrs */
2192 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2193 i_ehdrp
->e_phoff
= outbase
;
2194 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2199 i_ehdrp
->e_phentsize
= 0;
2201 i_ehdrp
->e_phoff
= 0;
2204 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2206 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2208 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2210 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2211 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2212 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2219 swap_out_syms (abfd
)
2222 if (!elf_map_symbols (abfd
))
2225 /* Dump out the symtabs. */
2227 int symcount
= bfd_get_symcount (abfd
);
2228 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2229 struct strtab
*stt
= bfd_new_strtab (abfd
);
2230 Elf_Internal_Shdr
*symtab_hdr
;
2231 Elf_Internal_Shdr
*symstrtab_hdr
;
2232 Elf_External_Sym
*outbound_syms
;
2237 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2238 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2239 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2240 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2241 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2242 symtab_hdr
->sh_addralign
= FILE_ALIGN
;
2244 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2245 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2247 outbound_syms
= (Elf_External_Sym
*)
2248 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2251 bfd_set_error (bfd_error_no_memory
);
2254 /* now generate the data (for "contents") */
2256 /* Fill in zeroth symbol and swap it out. */
2257 Elf_Internal_Sym sym
;
2263 sym
.st_shndx
= SHN_UNDEF
;
2264 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2266 for (idx
= 0; idx
< symcount
; idx
++)
2268 Elf_Internal_Sym sym
;
2269 bfd_vma value
= syms
[idx
]->value
;
2271 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2272 /* Section symbols have no names. */
2276 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2277 if (sym
.st_name
== (unsigned long) -1)
2281 if (bfd_is_com_section (syms
[idx
]->section
))
2283 /* ELF common symbols put the alignment into the `value' field,
2284 and the size into the `size' field. This is backwards from
2285 how BFD handles it, so reverse it here. */
2286 sym
.st_size
= value
;
2287 /* Should retrieve this from somewhere... */
2289 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2290 syms
[idx
]->section
);
2294 asection
*sec
= syms
[idx
]->section
;
2295 elf_symbol_type
*type_ptr
;
2298 if (sec
->output_section
)
2300 value
+= sec
->output_offset
;
2301 sec
= sec
->output_section
;
2304 sym
.st_value
= value
;
2305 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2306 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2307 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2311 /* Writing this would be a hell of a lot easier if we had
2312 some decent documentation on bfd, and knew what to expect
2313 of the library, and what to demand of applications. For
2314 example, it appears that `objcopy' might not set the
2315 section of a symbol to be a section that is actually in
2317 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2318 BFD_ASSERT (sec2
!= 0);
2319 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2320 BFD_ASSERT (shndx
!= -1);
2324 if (bfd_is_com_section (syms
[idx
]->section
))
2325 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2326 else if (syms
[idx
]->section
== &bfd_und_section
)
2327 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2328 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2329 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2330 else if (syms
[idx
]->flags
& BSF_FILE
)
2331 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2334 int bind
= STB_LOCAL
;
2335 int type
= STT_OBJECT
;
2336 unsigned int flags
= syms
[idx
]->flags
;
2338 if (flags
& BSF_LOCAL
)
2340 else if (flags
& BSF_WEAK
)
2342 else if (flags
& BSF_GLOBAL
)
2345 if (flags
& BSF_FUNCTION
)
2348 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2352 elf_swap_symbol_out (abfd
, &sym
,
2354 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2357 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2358 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2359 symstrtab_hdr
->sh_size
= stt
->length
;
2360 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2362 symstrtab_hdr
->sh_flags
= 0;
2363 symstrtab_hdr
->sh_addr
= 0;
2364 symstrtab_hdr
->sh_entsize
= 0;
2365 symstrtab_hdr
->sh_link
= 0;
2366 symstrtab_hdr
->sh_info
= 0;
2367 symstrtab_hdr
->sh_addralign
= 1;
2368 symstrtab_hdr
->size
= 0;
2375 write_shdrs_and_ehdr (abfd
)
2378 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2379 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2380 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2381 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2383 struct strtab
*shstrtab
;
2385 i_ehdrp
= elf_elfheader (abfd
);
2386 i_shdrp
= elf_elfsections (abfd
);
2387 shstrtab
= elf_shstrtab (abfd
);
2389 /* swap the header before spitting it out... */
2392 elf_debug_file (i_ehdrp
);
2394 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2395 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2396 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2397 != sizeof (x_ehdr
)))
2400 /* at this point we've concocted all the ELF sections... */
2401 x_shdrp
= (Elf_External_Shdr
*)
2402 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2405 bfd_set_error (bfd_error_no_memory
);
2409 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2412 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2415 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2417 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2418 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2419 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2422 /* need to dump the string table too... */
2427 /* Assign file positions for all the reloc sections which are not part
2428 of the loadable file image. */
2431 assign_file_positions_for_relocs (abfd
)
2436 Elf_Internal_Shdr
**shdrpp
;
2438 off
= elf_tdata (abfd
)->next_file_pos
;
2440 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2441 i
< elf_elfheader (abfd
)->e_shnum
;
2444 Elf_Internal_Shdr
*shdrp
;
2447 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2448 && shdrp
->sh_offset
== -1)
2449 off
= assign_file_position_for_section (shdrp
, off
, true);
2452 elf_tdata (abfd
)->next_file_pos
= off
;
2456 NAME(bfd_elf
,write_object_contents
) (abfd
)
2459 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2460 Elf_Internal_Ehdr
*i_ehdrp
;
2461 Elf_Internal_Shdr
**i_shdrp
;
2464 if (! abfd
->output_has_begun
2465 && ! elf_compute_section_file_positions (abfd
,
2466 (struct bfd_link_info
*) NULL
))
2469 i_shdrp
= elf_elfsections (abfd
);
2470 i_ehdrp
= elf_elfheader (abfd
);
2472 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2473 assign_file_positions_for_relocs (abfd
);
2475 /* After writing the headers, we need to write the sections too... */
2476 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2478 if (bed
->elf_backend_section_processing
)
2479 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2480 if (i_shdrp
[count
]->contents
)
2482 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2483 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2485 != i_shdrp
[count
]->sh_size
))
2490 if (bed
->elf_backend_final_write_processing
)
2491 (*bed
->elf_backend_final_write_processing
) (abfd
);
2493 return write_shdrs_and_ehdr (abfd
);
2496 /* Given an index of a section, retrieve a pointer to it. Note
2497 that for our purposes, sections are indexed by {1, 2, ...} with
2498 0 being an illegal index. */
2500 /* In the original, each ELF section went into exactly one BFD
2501 section. This doesn't really make sense, so we need a real mapping.
2502 The mapping has to hide in the Elf_Internal_Shdr since asection
2503 doesn't have anything like a tdata field... */
2506 section_from_elf_index (abfd
, index
)
2510 /* @@ Is bfd_com_section really correct in all the places it could
2511 be returned from this routine? */
2513 if (index
== SHN_ABS
)
2514 return &bfd_com_section
; /* not abs? */
2515 if (index
== SHN_COMMON
)
2516 return &bfd_com_section
;
2518 if (index
> elf_elfheader (abfd
)->e_shnum
)
2522 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2524 switch (hdr
->sh_type
)
2526 /* ELF sections that map to BFD sections */
2531 if (hdr
->rawdata
== NULL
)
2533 if (! bfd_section_from_shdr (abfd
, index
))
2536 return (struct sec
*) hdr
->rawdata
;
2539 return (struct sec
*) &bfd_abs_section
;
2544 /* given a section, search the header to find them... */
2546 elf_section_from_bfd_section (abfd
, asect
)
2550 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2552 Elf_Internal_Shdr
*hdr
;
2553 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2555 if (asect
== &bfd_abs_section
)
2557 if (asect
== &bfd_com_section
)
2559 if (asect
== &bfd_und_section
)
2562 for (index
= 0; index
< maxindex
; index
++)
2564 hdr
= i_shdrp
[index
];
2565 switch (hdr
->sh_type
)
2567 /* ELF sections that map to BFD sections */
2576 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2583 /* We sometimes map a reloc section to a BFD section. */
2584 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2585 && (asection
*) hdr
->rawdata
== asect
)
2590 /* We map most string tables to BFD sections. */
2591 if (index
!= elf_elfheader (abfd
)->e_shstrndx
2592 && index
!= elf_onesymtab (abfd
)
2593 && (asection
*) hdr
->rawdata
== asect
)
2599 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2601 if (bed
->elf_backend_section_from_bfd_section
)
2606 if ((*bed
->elf_backend_section_from_bfd_section
)
2607 (abfd
, hdr
, asect
, &retval
))
2617 /* given a symbol, return the bfd index for that symbol. */
2619 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2621 struct symbol_cache_entry
**asym_ptr_ptr
;
2623 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2625 flagword flags
= asym_ptr
->flags
;
2627 /* When gas creates relocations against local labels, it creates its
2628 own symbol for the section, but does put the symbol into the
2629 symbol chain, so udata is 0. When the linker is generating
2630 relocatable output, this section symbol may be for one of the
2631 input sections rather than the output section. */
2632 if (asym_ptr
->udata
== (PTR
) 0
2633 && (flags
& BSF_SECTION_SYM
)
2634 && asym_ptr
->section
)
2638 if (asym_ptr
->section
->output_section
!= NULL
)
2639 indx
= asym_ptr
->section
->output_section
->index
;
2641 indx
= asym_ptr
->section
->index
;
2642 if (elf_section_syms (abfd
)[indx
])
2643 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2646 if (asym_ptr
->udata
)
2647 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2657 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2658 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2667 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
2669 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2672 Elf_Internal_Shdr
*hdr
;
2673 long symcount
; /* Number of external ELF symbols */
2674 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2675 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2676 Elf_Internal_Sym i_sym
;
2677 Elf_External_Sym
*x_symp
= NULL
;
2679 /* Read each raw ELF symbol, converting from external ELF form to
2680 internal ELF form, and then using the information to create a
2681 canonical bfd symbol table entry.
2683 Note that we allocate the initial bfd canonical symbol buffer
2684 based on a one-to-one mapping of the ELF symbols to canonical
2685 symbols. We actually use all the ELF symbols, so there will be no
2686 space left over at the end. When we have all the symbols, we
2687 build the caller's pointer vector. */
2690 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2692 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2693 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2696 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2699 sym
= symbase
= NULL
;
2704 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2707 symbase
= ((elf_symbol_type
*)
2708 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2709 if (symbase
== (elf_symbol_type
*) NULL
)
2711 bfd_set_error (bfd_error_no_memory
);
2716 /* Temporarily allocate room for the raw ELF symbols. */
2717 x_symp
= ((Elf_External_Sym
*)
2718 malloc (symcount
* sizeof (Elf_External_Sym
)));
2719 if (x_symp
== NULL
&& symcount
!= 0)
2721 bfd_set_error (bfd_error_no_memory
);
2725 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2726 != symcount
* sizeof (Elf_External_Sym
))
2728 /* Skip first symbol, which is a null dummy. */
2729 for (i
= 1; i
< symcount
; i
++)
2731 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2732 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2733 #ifdef ELF_KEEP_EXTSYM
2734 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2736 sym
->symbol
.the_bfd
= abfd
;
2738 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2741 sym
->symbol
.value
= i_sym
.st_value
;
2743 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
2745 sym
->symbol
.section
= section_from_elf_index (abfd
,
2747 if (sym
->symbol
.section
== NULL
)
2749 /* This symbol is in a section for which we did not
2750 create a BFD section. Just use bfd_abs_section,
2751 although it is wrong. FIXME. */
2752 sym
->symbol
.section
= &bfd_abs_section
;
2755 else if (i_sym
.st_shndx
== SHN_ABS
)
2757 sym
->symbol
.section
= &bfd_abs_section
;
2759 else if (i_sym
.st_shndx
== SHN_COMMON
)
2761 sym
->symbol
.section
= &bfd_com_section
;
2762 /* Elf puts the alignment into the `value' field, and
2763 the size into the `size' field. BFD wants to see the
2764 size in the value field, and doesn't care (at the
2765 moment) about the alignment. */
2766 sym
->symbol
.value
= i_sym
.st_size
;
2768 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2770 sym
->symbol
.section
= &bfd_und_section
;
2773 sym
->symbol
.section
= &bfd_abs_section
;
2775 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2777 switch (ELF_ST_BIND (i_sym
.st_info
))
2780 sym
->symbol
.flags
|= BSF_LOCAL
;
2783 sym
->symbol
.flags
|= BSF_GLOBAL
;
2786 sym
->symbol
.flags
|= BSF_WEAK
;
2790 switch (ELF_ST_TYPE (i_sym
.st_info
))
2793 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2796 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2799 sym
->symbol
.flags
|= BSF_FUNCTION
;
2804 sym
->symbol
.flags
|= BSF_DYNAMIC
;
2806 /* Do some backend-specific processing on this symbol. */
2808 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2809 if (ebd
->elf_backend_symbol_processing
)
2810 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2817 /* Do some backend-specific processing on this symbol table. */
2819 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2820 if (ebd
->elf_backend_symbol_table_processing
)
2821 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2824 /* We rely on the zalloc to clear out the final symbol entry. */
2826 symcount
= sym
- symbase
;
2828 /* Fill in the user's symbol pointer vector if needed. */
2836 *symptrs
++ = &sym
->symbol
;
2839 *symptrs
= 0; /* Final null pointer */
2851 /* Return the number of bytes required to hold the symtab vector.
2853 Note that we base it on the count plus 1, since we will null terminate
2854 the vector allocated based on this size. However, the ELF symbol table
2855 always has a dummy entry as symbol #0, so it ends up even. */
2858 elf_get_symtab_upper_bound (abfd
)
2863 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2865 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2866 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2872 elf_get_dynamic_symtab_upper_bound (abfd
)
2877 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2879 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2880 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2886 This function return the number of bytes required to store the
2887 relocation information associated with section <<sect>>
2888 attached to bfd <<abfd>>
2892 elf_get_reloc_upper_bound (abfd
, asect
)
2896 if (asect
->flags
& SEC_RELOC
)
2898 /* either rel or rela */
2899 return elf_section_data (asect
)->rel_hdr
.sh_size
;
2906 elf_slurp_reloca_table (abfd
, asect
, symbols
)
2911 Elf_External_Rela
*native_relocs
;
2912 arelent
*reloc_cache
;
2917 if (asect
->relocation
)
2919 if (asect
->reloc_count
== 0)
2921 if (asect
->flags
& SEC_CONSTRUCTOR
)
2924 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2926 native_relocs
= (Elf_External_Rela
*)
2927 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2930 bfd_set_error (bfd_error_no_memory
);
2933 if (bfd_read ((PTR
) native_relocs
,
2934 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
)
2935 != sizeof (Elf_External_Rela
) * asect
->reloc_count
)
2938 reloc_cache
= (arelent
*)
2939 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2943 bfd_set_error (bfd_error_no_memory
);
2947 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2949 Elf_Internal_Rela dst
;
2950 Elf_External_Rela
*src
;
2952 cache_ptr
= reloc_cache
+ idx
;
2953 src
= native_relocs
+ idx
;
2954 elf_swap_reloca_in (abfd
, src
, &dst
);
2956 #ifdef RELOC_PROCESSING
2957 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2959 if (asect
->flags
& SEC_RELOC
)
2961 /* relocatable, so the offset is off of the section */
2962 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2966 /* non-relocatable, so the offset a virtual address */
2967 cache_ptr
->address
= dst
.r_offset
;
2970 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2971 of zero points to the dummy symbol, which was not read into
2972 the symbol table SYMBOLS. */
2973 if (ELF_R_SYM (dst
.r_info
) == 0)
2974 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2979 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2981 /* Translate any ELF section symbol into a BFD section
2983 s
= *(cache_ptr
->sym_ptr_ptr
);
2984 if (s
->flags
& BSF_SECTION_SYM
)
2986 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2987 s
= *cache_ptr
->sym_ptr_ptr
;
2988 if (s
->name
== 0 || s
->name
[0] == 0)
2992 cache_ptr
->addend
= dst
.r_addend
;
2994 /* Fill in the cache_ptr->howto field from dst.r_type */
2996 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2997 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
3002 asect
->relocation
= reloc_cache
;
3008 elf_debug_section (str
, num
, hdr
)
3011 Elf_Internal_Shdr
*hdr
;
3013 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
3015 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
3016 (long) hdr
->sh_name
,
3017 (long) hdr
->sh_type
,
3018 (long) hdr
->sh_flags
);
3020 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
3021 (long) hdr
->sh_addr
,
3022 (long) hdr
->sh_offset
,
3023 (long) hdr
->sh_size
);
3025 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
3026 (long) hdr
->sh_link
,
3027 (long) hdr
->sh_info
,
3028 (long) hdr
->sh_addralign
);
3029 fprintf (stderr
, "sh_entsize = %ld\n",
3030 (long) hdr
->sh_entsize
);
3031 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
3032 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
3033 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3038 elf_debug_file (ehdrp
)
3039 Elf_Internal_Ehdr
*ehdrp
;
3041 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
3042 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
3043 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
3044 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
3045 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
3046 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
3047 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
3052 elf_slurp_reloc_table (abfd
, asect
, symbols
)
3057 Elf_External_Rel
*native_relocs
;
3058 arelent
*reloc_cache
;
3060 Elf_Internal_Shdr
*data_hdr
;
3062 unsigned long data_max
;
3063 char buf
[4]; /* FIXME -- might be elf64 */
3067 if (asect
->relocation
)
3069 if (asect
->reloc_count
== 0)
3071 if (asect
->flags
& SEC_CONSTRUCTOR
)
3074 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
3076 native_relocs
= (Elf_External_Rel
*)
3077 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
3080 bfd_set_error (bfd_error_no_memory
);
3083 if (bfd_read ((PTR
) native_relocs
,
3084 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
)
3085 != sizeof (Elf_External_Rel
) * asect
->reloc_count
)
3088 reloc_cache
= (arelent
*)
3089 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3093 bfd_set_error (bfd_error_no_memory
);
3097 /* Get the offset of the start of the segment we are relocating to read in
3098 the implicit addend. */
3099 data_hdr
= &elf_section_data (asect
)->this_hdr
;
3100 data_off
= data_hdr
->sh_offset
;
3101 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
3104 elf_debug_section ("data section", -1, data_hdr
);
3107 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3109 #ifdef RELOC_PROCESSING
3110 Elf_Internal_Rel dst
;
3111 Elf_External_Rel
*src
;
3113 cache_ptr
= reloc_cache
+ idx
;
3114 src
= native_relocs
+ idx
;
3115 elf_swap_reloc_in (abfd
, src
, &dst
);
3117 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3119 Elf_Internal_Rel dst
;
3120 Elf_External_Rel
*src
;
3122 cache_ptr
= reloc_cache
+ idx
;
3123 src
= native_relocs
+ idx
;
3125 elf_swap_reloc_in (abfd
, src
, &dst
);
3127 if (asect
->flags
& SEC_RELOC
)
3129 /* relocatable, so the offset is off of the section */
3130 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3134 /* non-relocatable, so the offset a virtual address */
3135 cache_ptr
->address
= dst
.r_offset
;
3138 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3139 of zero points to the dummy symbol, which was not read into
3140 the symbol table SYMBOLS. */
3141 if (ELF_R_SYM (dst
.r_info
) == 0)
3142 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3147 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3149 /* Translate any ELF section symbol into a BFD section
3151 s
= *(cache_ptr
->sym_ptr_ptr
);
3152 if (s
->flags
& BSF_SECTION_SYM
)
3154 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3155 s
= *cache_ptr
->sym_ptr_ptr
;
3156 if (s
->name
== 0 || s
->name
[0] == 0)
3160 BFD_ASSERT (dst
.r_offset
<= data_max
);
3161 cache_ptr
->addend
= 0;
3163 /* Fill in the cache_ptr->howto field from dst.r_type */
3165 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3166 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3171 asect
->relocation
= reloc_cache
;
3176 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3182 arelent
*tblptr
= section
->relocation
;
3183 unsigned int count
= 0;
3184 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3186 /* snarfed from coffcode.h */
3189 if (! elf_slurp_reloca_table (abfd
, section
, symbols
))
3194 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3198 tblptr
= section
->relocation
;
3200 for (; count
++ < section
->reloc_count
;)
3201 *relptr
++ = tblptr
++;
3204 return section
->reloc_count
;
3208 elf_get_symtab (abfd
, alocation
)
3210 asymbol
**alocation
;
3212 long symcount
= elf_slurp_symbol_table (abfd
, alocation
, false);
3215 bfd_get_symcount (abfd
) = symcount
;
3220 elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3222 asymbol
**alocation
;
3224 return elf_slurp_symbol_table (abfd
, alocation
, true);
3228 elf_make_empty_symbol (abfd
)
3231 elf_symbol_type
*newsym
;
3233 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3236 bfd_set_error (bfd_error_no_memory
);
3241 newsym
->symbol
.the_bfd
= abfd
;
3242 return &newsym
->symbol
;
3247 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3252 bfd_symbol_info (symbol
, ret
);
3256 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3260 bfd_print_symbol_type how
;
3262 FILE *file
= (FILE *) filep
;
3265 case bfd_print_symbol_name
:
3266 fprintf (file
, "%s", symbol
->name
);
3268 case bfd_print_symbol_more
:
3269 fprintf (file
, "elf ");
3270 fprintf_vma (file
, symbol
->value
);
3271 fprintf (file
, " %lx", (long) symbol
->flags
);
3273 case bfd_print_symbol_all
:
3275 CONST
char *section_name
;
3276 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3277 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3278 fprintf (file
, " %s\t%s",
3288 elf_get_lineno (ignore_abfd
, symbol
)
3292 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3299 elf_set_arch_mach (abfd
, arch
, machine
)
3301 enum bfd_architecture arch
;
3302 unsigned long machine
;
3304 /* If this isn't the right architecture for this backend, and this
3305 isn't the generic backend, fail. */
3306 if (arch
!= get_elf_backend_data (abfd
)->arch
3307 && arch
!= bfd_arch_unknown
3308 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3311 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3315 elf_find_nearest_line (abfd
,
3326 CONST
char **filename_ptr
;
3327 CONST
char **functionname_ptr
;
3328 unsigned int *line_ptr
;
3334 elf_sizeof_headers (abfd
, reloc
)
3340 ret
= sizeof (Elf_External_Ehdr
);
3342 ret
+= get_program_header_size (abfd
);
3347 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3352 bfd_size_type count
;
3354 Elf_Internal_Shdr
*hdr
;
3356 if (! abfd
->output_has_begun
3357 && ! elf_compute_section_file_positions (abfd
,
3358 (struct bfd_link_info
*) NULL
))
3361 hdr
= &elf_section_data (section
)->this_hdr
;
3363 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3365 if (bfd_write (location
, 1, count
, abfd
) != count
)
3372 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3375 Elf_Internal_Rela
*dst
;
3377 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3383 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3386 Elf_Internal_Rel
*dst
;
3388 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3394 /* Core file support */
3396 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3397 #include <sys/procfs.h>
3399 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3400 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3401 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3407 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3414 prstatus_t
*status
= (prstatus_t
*) 0;
3416 if (descsz
== sizeof (prstatus_t
))
3418 newsect
= bfd_make_section (abfd
, ".reg");
3419 if (newsect
== NULL
)
3421 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3422 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3423 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3424 newsect
->alignment_power
= 2;
3425 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3427 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3433 /* Stash a copy of the prpsinfo structure away for future use. */
3436 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3442 if (descsz
== sizeof (prpsinfo_t
))
3444 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) == NULL
)
3446 bfd_set_error (bfd_error_no_memory
);
3449 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3455 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3463 newsect
= bfd_make_section (abfd
, ".reg2");
3464 if (newsect
== NULL
)
3466 newsect
->_raw_size
= descsz
;
3467 newsect
->filepos
= filepos
;
3468 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3469 newsect
->alignment_power
= 2;
3473 #endif /* HAVE_PROCFS */
3475 /* Return a pointer to the args (including the command name) that were
3476 seen by the program that generated the core dump. Note that for
3477 some reason, a spurious space is tacked onto the end of the args
3478 in some (at least one anyway) implementations, so strip it off if
3482 elf_core_file_failing_command (abfd
)
3486 if (core_prpsinfo (abfd
))
3488 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3489 char *scan
= p
->pr_psargs
;
3494 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3498 return p
->pr_psargs
;
3504 /* Return the number of the signal that caused the core dump. Presumably,
3505 since we have a core file, we got a signal of some kind, so don't bother
3506 checking the other process status fields, just return the signal number.
3510 elf_core_file_failing_signal (abfd
)
3514 if (core_prstatus (abfd
))
3516 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3522 /* Check to see if the core file could reasonably be expected to have
3523 come for the current executable file. Note that by default we return
3524 true unless we find something that indicates that there might be a
3529 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3538 /* First, xvecs must match since both are ELF files for the same target. */
3540 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3542 bfd_set_error (bfd_error_system_call
);
3548 /* If no prpsinfo, just return true. Otherwise, grab the last component
3549 of the exec'd pathname from the prpsinfo. */
3551 if (core_prpsinfo (core_bfd
))
3553 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3560 /* Find the last component of the executable pathname. */
3562 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3568 execname
= (char *) exec_bfd
->filename
;
3571 /* See if they match */
3573 return strcmp (execname
, corename
) ? false : true;
3579 #endif /* HAVE_PROCFS */
3582 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3583 the information that would normally be available from the /proc interface
3584 for the process, at the time the process dumped core. Currently this
3585 includes copies of the prstatus, prpsinfo, and fpregset structures.
3587 Since these structures are potentially machine dependent in size and
3588 ordering, bfd provides two levels of support for them. The first level,
3589 available on all machines since it does not require that the host
3590 have /proc support or the relevant include files, is to create a bfd
3591 section for each of the prstatus, prpsinfo, and fpregset structures,
3592 without any interpretation of their contents. With just this support,
3593 the bfd client will have to interpret the structures itself. Even with
3594 /proc support, it might want these full structures for it's own reasons.
3596 In the second level of support, where HAVE_PROCFS is defined, bfd will
3597 pick apart the structures to gather some additional information that
3598 clients may want, such as the general register set, the name of the
3599 exec'ed file and its arguments, the signal (if any) that caused the
3605 elf_corefile_note (abfd
, hdr
)
3607 Elf_Internal_Phdr
*hdr
;
3609 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3610 Elf_Internal_Note i_note
; /* Elf note, internal form */
3611 char *buf
= NULL
; /* Entire note segment contents */
3612 char *namedata
; /* Name portion of the note */
3613 char *descdata
; /* Descriptor portion of the note */
3614 char *sectname
; /* Name to use for new section */
3615 long filepos
; /* File offset to descriptor data */
3618 if (hdr
->p_filesz
> 0
3619 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3620 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3621 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3623 x_note_p
= (Elf_External_Note
*) buf
;
3624 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3626 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3627 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3628 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3629 namedata
= x_note_p
->name
;
3630 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3631 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3632 switch (i_note
.type
)
3635 /* process descdata as prstatus info */
3636 if (! bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
))
3638 sectname
= ".prstatus";
3641 /* process descdata as fpregset info */
3642 if (! bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
))
3644 sectname
= ".fpregset";
3647 /* process descdata as prpsinfo */
3648 if (! bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
))
3650 sectname
= ".prpsinfo";
3653 /* Unknown descriptor, just ignore it. */
3657 if (sectname
!= NULL
)
3659 newsect
= bfd_make_section (abfd
, sectname
);
3660 if (newsect
== NULL
)
3662 newsect
->_raw_size
= i_note
.descsz
;
3663 newsect
->filepos
= filepos
;
3664 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3665 newsect
->alignment_power
= 2;
3667 x_note_p
= (Elf_External_Note
*)
3668 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3675 else if (hdr
->p_filesz
> 0)
3677 bfd_set_error (bfd_error_no_memory
);
3684 /* Core files are simply standard ELF formatted files that partition
3685 the file using the execution view of the file (program header table)
3686 rather than the linking view. In fact, there is no section header
3687 table in a core file.
3689 The process status information (including the contents of the general
3690 register set) and the floating point register set are stored in a
3691 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3692 that allow standard bfd access to the general registers (.reg) and the
3693 floating point registers (.reg2).
3698 elf_core_file_p (abfd
)
3701 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3702 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3703 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3704 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3705 unsigned int phindex
;
3706 struct elf_backend_data
*ebd
;
3708 /* Read in the ELF header in external format. */
3710 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3712 if (bfd_get_error () != bfd_error_system_call
)
3713 bfd_set_error (bfd_error_wrong_format
);
3717 /* Now check to see if we have a valid ELF file, and one that BFD can
3718 make use of. The magic number must match, the address size ('class')
3719 and byte-swapping must match our XVEC entry, and it must have a
3720 program header table (FIXME: See comments re segments at top of this
3723 if (elf_file_p (&x_ehdr
) == false)
3726 bfd_set_error (bfd_error_wrong_format
);
3730 /* FIXME, Check EI_VERSION here ! */
3734 int desired_address_size
= ELFCLASS32
;
3737 int desired_address_size
= ELFCLASS64
;
3740 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3744 /* Switch xvec to match the specified byte order. */
3745 switch (x_ehdr
.e_ident
[EI_DATA
])
3747 case ELFDATA2MSB
: /* Big-endian */
3748 if (abfd
->xvec
->byteorder_big_p
== false)
3751 case ELFDATA2LSB
: /* Little-endian */
3752 if (abfd
->xvec
->byteorder_big_p
== true)
3755 case ELFDATANONE
: /* No data encoding specified */
3756 default: /* Unknown data encoding specified */
3760 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3761 the tdata pointer in the bfd. */
3764 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3765 if (elf_tdata (abfd
) == NULL
)
3767 bfd_set_error (bfd_error_no_memory
);
3771 /* FIXME, `wrong' returns from this point onward, leak memory. */
3773 /* Now that we know the byte order, swap in the rest of the header */
3774 i_ehdrp
= elf_elfheader (abfd
);
3775 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3777 elf_debug_file (i_ehdrp
);
3780 ebd
= get_elf_backend_data (abfd
);
3782 /* Check that the ELF e_machine field matches what this particular
3783 BFD format expects. */
3784 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3786 bfd_target
**target_ptr
;
3788 if (ebd
->elf_machine_code
!= EM_NONE
)
3791 /* This is the generic ELF target. Let it match any ELF target
3792 for which we do not have a specific backend. */
3793 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3795 struct elf_backend_data
*back
;
3797 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3799 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3800 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3802 /* target_ptr is an ELF backend which matches this
3803 object file, so reject the generic ELF target. */
3809 /* If there is no program header, or the type is not a core file, then
3811 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3814 /* Allocate space for a copy of the program header table in
3815 internal form, seek to the program header table in the file,
3816 read it in, and convert it to internal form. As a simple sanity
3817 check, verify that the what BFD thinks is the size of each program
3818 header table entry actually matches the size recorded in the file. */
3820 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3822 i_phdrp
= (Elf_Internal_Phdr
*)
3823 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3826 bfd_set_error (bfd_error_no_memory
);
3829 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3831 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3833 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3836 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3839 /* Once all of the program headers have been read and converted, we
3840 can start processing them. */
3842 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3844 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3845 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3847 if (! elf_corefile_note (abfd
, i_phdrp
+ phindex
))
3852 /* Remember the entry point specified in the ELF file header. */
3854 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
3859 /* ELF linker code. */
3861 static boolean elf_link_add_object_symbols
3862 PARAMS ((bfd
*, struct bfd_link_info
*));
3863 static boolean elf_link_add_archive_symbols
3864 PARAMS ((bfd
*, struct bfd_link_info
*));
3865 static INLINE boolean elf_link_record_dynamic_symbol
3866 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
3867 static boolean elf_link_create_dynamic_sections
3868 PARAMS ((bfd
*, struct bfd_link_info
*));
3869 static boolean elf_adjust_dynamic_symbol
3870 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3872 /* Given an ELF BFD, add symbols to the global hash table as
3876 elf_bfd_link_add_symbols (abfd
, info
)
3878 struct bfd_link_info
*info
;
3880 switch (bfd_get_format (abfd
))
3883 return elf_link_add_object_symbols (abfd
, info
);
3885 return elf_link_add_archive_symbols (abfd
, info
);
3887 bfd_set_error (bfd_error_wrong_format
);
3892 /* Add symbols from an ELF archive file to the linker hash table. We
3893 don't use _bfd_generic_link_add_archive_symbols because of a
3894 problem which arises on UnixWare. The UnixWare libc.so is an
3895 archive which includes an entry libc.so.1 which defines a bunch of
3896 symbols. The libc.so archive also includes a number of other
3897 object files, which also define symbols, some of which are the same
3898 as those defined in libc.so.1. Correct linking requires that we
3899 consider each object file in turn, and include it if it defines any
3900 symbols we need. _bfd_generic_link_add_archive_symbols does not do
3901 this; it looks through the list of undefined symbols, and includes
3902 any object file which defines them. When this algorithm is used on
3903 UnixWare, it winds up pulling in libc.so.1 early and defining a
3904 bunch of symbols. This means that some of the other objects in the
3905 archive are not included in the link, which is incorrect since they
3906 precede libc.so.1 in the archive.
3908 Fortunately, ELF archive handling is simpler than that done by
3909 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3910 oddities. In ELF, if we find a symbol in the archive map, and the
3911 symbol is currently undefined, we know that we must pull in that
3914 Unfortunately, we do have to make multiple passes over the symbol
3915 table until nothing further is resolved. */
3918 elf_link_add_archive_symbols (abfd
, info
)
3920 struct bfd_link_info
*info
;
3923 boolean
*defined
= NULL
;
3924 boolean
*included
= NULL
;
3928 if (! bfd_has_map (abfd
))
3930 bfd_set_error (bfd_error_no_symbols
);
3934 /* Keep track of all symbols we know to be already defined, and all
3935 files we know to be already included. This is to speed up the
3936 second and subsequent passes. */
3937 c
= bfd_ardata (abfd
)->symdef_count
;
3940 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
3941 included
= (boolean
*) malloc (c
* sizeof (boolean
));
3942 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
3944 bfd_set_error (bfd_error_no_memory
);
3947 memset (defined
, 0, c
* sizeof (boolean
));
3948 memset (included
, 0, c
* sizeof (boolean
));
3950 symdefs
= bfd_ardata (abfd
)->symdefs
;
3963 symdefend
= symdef
+ c
;
3964 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
3966 struct elf_link_hash_entry
*h
;
3968 struct bfd_link_hash_entry
*undefs_tail
;
3971 if (defined
[i
] || included
[i
])
3973 if (symdef
->file_offset
== last
)
3979 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
3980 false, false, false);
3981 if (h
== (struct elf_link_hash_entry
*) NULL
)
3983 if (h
->root
.type
!= bfd_link_hash_undefined
)
3989 /* We need to include this archive member. */
3991 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3992 if (element
== (bfd
*) NULL
)
3995 if (! bfd_check_format (element
, bfd_object
))
3998 /* Doublecheck that we have not included this object
3999 already--it should be impossible, but there may be
4000 something wrong with the archive. */
4001 if (element
->archive_pass
!= 0)
4003 bfd_set_error (bfd_error_bad_value
);
4006 element
->archive_pass
= 1;
4008 undefs_tail
= info
->hash
->undefs_tail
;
4010 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4013 if (! elf_link_add_object_symbols (element
, info
))
4016 /* If there are any new undefined symbols, we need to make
4017 another pass through the archive in order to see whether
4018 they can be defined. FIXME: This isn't perfect, because
4019 common symbols wind up on undefs_tail and because an
4020 undefined symbol which is defined later on in this pass
4021 does not require another pass. This isn't a bug, but it
4022 does make the code less efficient than it could be. */
4023 if (undefs_tail
!= info
->hash
->undefs_tail
)
4026 /* Look backward to mark all symbols from this object file
4027 which we have already seen in this pass. */
4031 included
[mark
] = true;
4036 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4038 /* We mark subsequent symbols from this object file as we go
4039 on through the loop. */
4040 last
= symdef
->file_offset
;
4051 if (defined
!= (boolean
*) NULL
)
4053 if (included
!= (boolean
*) NULL
)
4058 /* Record a new dynamic symbol. We record the dynamic symbols as we
4059 read the input files, since we need to have a list of all of them
4060 before we can determine the final sizes of the output sections. */
4062 static INLINE boolean
4063 elf_link_record_dynamic_symbol (info
, h
)
4064 struct bfd_link_info
*info
;
4065 struct elf_link_hash_entry
*h
;
4067 if (h
->dynindx
== -1)
4069 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
4070 ++elf_hash_table (info
)->dynsymcount
;
4071 h
->dynstr_index
= bfd_add_to_strtab (elf_hash_table (info
)->dynobj
,
4072 elf_hash_table (info
)->dynstr
,
4073 h
->root
.root
.string
);
4074 if (h
->dynstr_index
== (unsigned long) -1)
4081 /* Add symbols from an ELF object file to the linker hash table. */
4084 elf_link_add_object_symbols (abfd
, info
)
4086 struct bfd_link_info
*info
;
4088 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
4089 const Elf_Internal_Sym
*,
4090 const char **, flagword
*,
4091 asection
**, bfd_vma
*));
4093 Elf_Internal_Shdr
*hdr
;
4097 Elf_External_Sym
*buf
= NULL
;
4098 struct elf_link_hash_entry
**sym_hash
;
4100 Elf_External_Dyn
*dynbuf
= NULL
;
4101 struct elf_link_hash_entry
*weaks
;
4102 Elf_External_Sym
*esym
;
4103 Elf_External_Sym
*esymend
;
4105 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
4106 collect
= get_elf_backend_data (abfd
)->collect
;
4108 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4109 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4111 /* The sh_info field of the symtab header tells us where the
4112 external symbols start. We don't care about the local symbols at
4114 if (elf_bad_symtab (abfd
))
4116 extsymcount
= symcount
;
4121 extsymcount
= symcount
- hdr
->sh_info
;
4122 extsymoff
= hdr
->sh_info
;
4125 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
4126 if (buf
== NULL
&& extsymcount
!= 0)
4128 bfd_set_error (bfd_error_no_memory
);
4132 /* We store a pointer to the hash table entry for each external
4134 sym_hash
= ((struct elf_link_hash_entry
**)
4136 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
4137 if (sym_hash
== NULL
)
4139 bfd_set_error (bfd_error_no_memory
);
4142 elf_sym_hashes (abfd
) = sym_hash
;
4144 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
4150 unsigned long strindex
;
4154 /* You can't use -r against a dynamic object. There's no hope
4155 of using a dynamic object which does not exactly match the
4156 format of the output file. */
4157 if (info
->relocateable
4158 || info
->hash
->creator
!= abfd
->xvec
)
4160 bfd_set_error (bfd_error_invalid_operation
);
4164 /* Find the name to use in a DT_NEEDED entry that refers to this
4165 object. If the object has a DT_SONAME entry, we use it.
4166 Otherwise, if the generic linker stuck something in
4167 elf_dt_needed_name, we use that. Otherwise, we just use the
4169 name
= bfd_get_filename (abfd
);
4170 if (elf_dt_needed_name (abfd
) != NULL
)
4171 name
= elf_dt_needed_name (abfd
);
4172 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4175 Elf_External_Dyn
*extdyn
;
4176 Elf_External_Dyn
*extdynend
;
4178 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
4181 bfd_set_error (bfd_error_no_memory
);
4185 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
4186 (file_ptr
) 0, s
->_raw_size
))
4190 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
4191 for (; extdyn
< extdynend
; extdyn
++)
4193 Elf_Internal_Dyn dyn
;
4195 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
4196 if (dyn
.d_tag
== DT_SONAME
)
4201 elfsec
= elf_section_from_bfd_section (abfd
, s
);
4204 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4205 name
= elf_string_from_elf_section (abfd
, link
,
4218 /* We do not want to include any of the sections in a dynamic
4219 object in the output file. We hack by simply clobbering the
4220 list of sections in the BFD. This could be handled more
4221 cleanly by, say, a new section flag; the existing
4222 SEC_NEVER_LOAD flag is not the one we want, because that one
4223 still implies that the section takes up space in the output
4225 abfd
->sections
= NULL
;
4227 /* If this is the first dynamic object found in the link, create
4228 the special sections required for dynamic linking. We need
4229 to put them somewhere, and attaching them to the first
4230 dynamic object is as good place as any. */
4231 if (elf_hash_table (info
)->dynobj
== NULL
)
4233 if (! elf_link_create_dynamic_sections (abfd
, info
))
4235 elf_hash_table (info
)->dynobj
= abfd
;
4238 /* Add a DT_NEEDED entry for this dynamic object. */
4239 strindex
= bfd_add_to_strtab (abfd
,
4240 elf_hash_table (info
)->dynstr
,
4243 if (strindex
== (unsigned long) -1)
4245 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
4250 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
4252 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
4253 != extsymcount
* sizeof (Elf_External_Sym
)))
4258 esymend
= buf
+ extsymcount
;
4259 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
4261 Elf_Internal_Sym sym
;
4267 struct elf_link_hash_entry
*h
= NULL
;
4270 elf_swap_symbol_in (abfd
, esym
, &sym
);
4272 flags
= BSF_NO_FLAGS
;
4274 value
= sym
.st_value
;
4277 bind
= ELF_ST_BIND (sym
.st_info
);
4278 if (bind
== STB_LOCAL
)
4280 /* This should be impossible, since ELF requires that all
4281 global symbols follow all local symbols, and that sh_info
4282 point to the first global symbol. Unfortunatealy, Irix 5
4286 else if (bind
== STB_GLOBAL
)
4288 else if (bind
== STB_WEAK
)
4292 /* Leave it up to the processor backend. */
4295 if (sym
.st_shndx
== SHN_UNDEF
)
4296 sec
= &bfd_und_section
;
4297 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
4299 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
4304 else if (sym
.st_shndx
== SHN_ABS
)
4305 sec
= &bfd_abs_section
;
4306 else if (sym
.st_shndx
== SHN_COMMON
)
4308 sec
= &bfd_com_section
;
4309 /* What ELF calls the size we call the value. What ELF
4310 calls the value we call the alignment. */
4311 value
= sym
.st_size
;
4315 /* Leave it up to the processor backend. */
4318 name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
4319 if (name
== (const char *) NULL
)
4322 if (add_symbol_hook
)
4324 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
4328 /* The hook function sets the name to NULL if this symbol
4329 should be skipped for some reason. */
4330 if (name
== (const char *) NULL
)
4334 /* Sanity check that all possibilities were handled. */
4335 if (flags
== BSF_NO_FLAGS
|| sec
== (asection
*) NULL
)
4337 bfd_set_error (bfd_error_bad_value
);
4341 if (sec
== &bfd_und_section
4342 || bfd_is_com_section (sec
))
4347 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4349 /* We need to look up the symbol now in order to get some of
4350 the dynamic object handling right. We pass the hash
4351 table entry in to _bfd_generic_link_add_one_symbol so
4352 that it does not have to look it up again. */
4353 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4354 true, false, false);
4359 /* If we are looking at a dynamic object, and this is a
4360 definition, we need to see if it has already been defined
4361 by some other object. If it has, we want to use the
4362 existing definition, and we do not want to report a
4363 multiple symbol definition error; we do this by
4364 clobbering sec to be bfd_und_section. */
4365 if (dynamic
&& definition
)
4367 if (h
->root
.type
== bfd_link_hash_defined
)
4368 sec
= &bfd_und_section
;
4371 /* Similarly, if we are not looking at a dynamic object, and
4372 we have a definition, we want to override any definition
4373 we may have from a dynamic object. Symbols from regular
4374 files always take precedence over symbols from dynamic
4375 objects, even if they are defined after the dynamic
4376 object in the link. */
4379 && h
->root
.type
== bfd_link_hash_defined
4380 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4381 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
4382 == bfd_target_elf_flavour
)
4383 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
4386 /* Change the hash table entry to undefined, and let
4387 _bfd_generic_link_add_one_symbol do the right thing
4388 with the new definition. */
4389 h
->root
.type
= bfd_link_hash_undefined
;
4390 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
4394 if (! (_bfd_generic_link_add_one_symbol
4395 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
4396 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
4401 && (flags
& BSF_WEAK
) != 0
4402 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
4403 && (*sym_hash
)->weakdef
== NULL
)
4405 /* Keep a list of all weak defined non function symbols from
4406 a dynamic object, using the weakdef field. Later in this
4407 function we will set the weakdef field to the correct
4408 value. We only put non-function symbols from dynamic
4409 objects on this list, because that happens to be the only
4410 time we need to know the normal symbol corresponding to a
4411 weak symbol, and the information is time consuming to
4412 figure out. If the weakdef field is not already NULL,
4413 then this symbol was already defined by some previous
4414 dynamic object, and we will be using that previous
4415 definition anyhow. */
4417 (*sym_hash
)->weakdef
= weaks
;
4421 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
4427 /* Remember the symbol size, type and alignment. */
4428 if (sym
.st_size
!= 0)
4430 /* FIXME: We should probably somehow give a warning if
4431 the symbol size changes. */
4432 h
->size
= sym
.st_size
;
4434 if (sym
.st_shndx
== SHN_COMMON
4435 && sym
.st_value
> h
->align
)
4436 h
->align
= sym
.st_value
;
4437 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
4439 /* FIXME: We should probably somehow give a warning if
4440 the symbol type changes. */
4441 h
->type
= ELF_ST_TYPE (sym
.st_info
);
4444 /* Set a flag in the hash table entry indicating the type of
4445 reference or definition we just found. Keep a count of
4446 the number of dynamic symbols we find. A dynamic symbol
4447 is one which is referenced or defined by both a regular
4448 object and a shared object, or one which is referenced or
4449 defined by more than one shared object. */
4450 old_flags
= h
->elf_link_hash_flags
;
4455 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
4457 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
4458 if ((old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4459 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
4465 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
4467 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
4468 if ((old_flags
& new_flag
) != 0)
4471 new_flag
= ELF_LINK_HASH_REF_DYNAMIC_MULTIPLE
;
4473 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC_MULTIPLE
;
4478 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
4479 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
4484 h
->elf_link_hash_flags
|= new_flag
;
4485 if (dynsym
&& h
->dynindx
== -1)
4487 if (! elf_link_record_dynamic_symbol (info
, h
))
4493 /* Now set the weakdefs field correctly for all the weak defined
4494 symbols we found. The only way to do this is to search all the
4495 symbols. Since we only need the information for non functions in
4496 dynamic objects, that's the only time we actually put anything on
4497 the list WEAKS. We need this information so that if a regular
4498 object refers to a symbol defined weakly in a dynamic object, the
4499 real symbol in the dynamic object is also put in the dynamic
4500 symbols; we also must arrange for both symbols to point to the
4501 same memory location. We could handle the general case of symbol
4502 aliasing, but a general symbol alias can only be generated in
4503 assembler code, handling it correctly would be very time
4504 consuming, and other ELF linkers don't handle general aliasing
4506 while (weaks
!= NULL
)
4508 struct elf_link_hash_entry
*hlook
;
4511 struct elf_link_hash_entry
**hpp
;
4512 struct elf_link_hash_entry
**hppend
;
4515 weaks
= hlook
->weakdef
;
4516 hlook
->weakdef
= NULL
;
4518 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
);
4519 slook
= hlook
->root
.u
.def
.section
;
4520 vlook
= hlook
->root
.u
.def
.value
;
4522 hpp
= elf_sym_hashes (abfd
);
4523 hppend
= hpp
+ extsymcount
;
4524 for (; hpp
< hppend
; hpp
++)
4526 struct elf_link_hash_entry
*h
;
4530 && h
->root
.type
== bfd_link_hash_defined
4531 && h
->root
.u
.def
.section
== slook
4532 && h
->root
.u
.def
.value
== vlook
)
4536 /* If the weak definition is in the list of dynamic
4537 symbols, make sure the real definition is put there
4539 if (hlook
->dynindx
!= -1
4540 && h
->dynindx
== -1)
4542 if (! elf_link_record_dynamic_symbol (info
, h
))
4564 /* Create some sections which will be filled in with dynamic linking
4565 information. The ABFD argument is an input file which is a dynamic
4566 object. The dynamic sections take up virtual memory space when the
4567 final executable is run, so we need to create them before addresses
4568 are assigned to the output sections. We work out the actual
4569 contents and size of these sections later. */
4572 elf_link_create_dynamic_sections (abfd
, info
)
4574 struct bfd_link_info
*info
;
4577 register asection
*s
;
4578 struct elf_link_hash_entry
*h
;
4579 struct elf_backend_data
*bed
;
4581 /* Note that we set the SEC_IN_MEMORY flag for all of these
4583 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4585 s
= bfd_make_section (abfd
, ".interp");
4587 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4590 s
= bfd_make_section (abfd
, ".dynamic");
4592 || ! bfd_set_section_flags (abfd
, s
, flags
)
4593 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4596 /* The special symbol _DYNAMIC is always set to the start of the
4597 .dynamic section. This call occurs before we have processed the
4598 symbols for any dynamic object, so we don't have to worry about
4599 overriding a dynamic definition. We could set _DYNAMIC in a
4600 linker script, but we only want to define it if we are, in fact,
4601 creating a .dynamic section. We don't want to define it if there
4602 is no .dynamic section, since on some ELF platforms the start up
4603 code examines it to decide how to initialize the process. */
4605 if (! (_bfd_generic_link_add_one_symbol
4606 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
4607 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
4608 (struct bfd_link_hash_entry
**) &h
)))
4610 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4612 s
= bfd_make_section (abfd
, ".dynsym");
4614 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4615 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4618 /* The first .dynsym symbol is a dummy. */
4619 elf_hash_table (info
)->dynsymcount
= 1;
4621 s
= bfd_make_section (abfd
, ".dynstr");
4623 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
4626 /* Create a strtab to hold the dynamic symbol names. */
4627 elf_hash_table (info
)->dynstr
= bfd_new_strtab (abfd
);
4628 if (elf_hash_table (info
)->dynstr
== NULL
)
4631 s
= bfd_make_section (abfd
, ".hash");
4633 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
4634 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
4637 /* Let the backend create the rest of the sections. This lets the
4638 backend set the right flags. The backend will normally create
4639 the .got and .plt sections. */
4640 bed
= get_elf_backend_data (abfd
);
4641 return (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
);
4644 /* Add an entry to the .dynamic table. */
4647 elf_add_dynamic_entry (info
, tag
, val
)
4648 struct bfd_link_info
*info
;
4652 Elf_Internal_Dyn dyn
;
4656 bfd_byte
*newcontents
;
4658 dynobj
= elf_hash_table (info
)->dynobj
;
4660 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
4661 BFD_ASSERT (s
!= NULL
);
4663 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
4664 if (s
->contents
== NULL
)
4665 newcontents
= (bfd_byte
*) malloc (newsize
);
4667 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
4668 if (newcontents
== NULL
)
4670 bfd_set_error (bfd_error_no_memory
);
4675 dyn
.d_un
.d_val
= val
;
4676 elf_swap_dyn_out (dynobj
, &dyn
,
4677 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
4679 s
->_raw_size
= newsize
;
4680 s
->contents
= newcontents
;
4685 /* Record an assignment to a symbol made by a linker script. We need
4686 this in case some dynamic object refers to this symbol. */
4690 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
)
4692 struct bfd_link_info
*info
;
4695 struct elf_link_hash_entry
*h
;
4697 /* This is called after we have examined all the input objects. If
4698 the symbol does not exist, it merely means that no object refers
4699 to it, and we can just ignore it at this point. */
4700 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4701 false, false, false);
4705 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4707 if ((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
4708 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
4709 && h
->dynindx
== -1)
4711 if (! elf_link_record_dynamic_symbol (info
, h
))
4714 /* If this is a weak defined symbol, and we know a corresponding
4715 real symbol from the same dynamic object, make sure the real
4716 symbol is also made into a dynamic symbol. */
4717 if (h
->weakdef
!= NULL
4718 && h
->weakdef
->dynindx
== -1)
4720 if (! elf_link_record_dynamic_symbol (info
, h
->weakdef
))
4728 /* Array used to determine the number of hash table buckets to use
4729 based on the number of symbols there are. If there are fewer than
4730 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4731 fewer than 37 we use 17 buckets, and so forth. We never use more
4732 than 521 buckets. */
4734 static const size_t elf_buckets
[] =
4736 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4739 /* Set up the sizes and contents of the ELF dynamic sections. This is
4740 called by the ELF linker emulation before_allocation routine. We
4741 must set the sizes of the sections before the linker sets the
4742 addresses of the various sections. */
4745 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, info
, sinterpptr
)
4747 struct bfd_link_info
*info
;
4748 asection
**sinterpptr
;
4753 Elf_Internal_Sym isym
;
4756 struct elf_backend_data
*bed
;
4760 dynobj
= elf_hash_table (info
)->dynobj
;
4761 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
4763 /* If there were no dynamic objects in the link, there is nothing to
4768 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
4769 BFD_ASSERT (*sinterpptr
!= NULL
);
4771 /* Set the size of the .dynsym and .hash sections. We counted the
4772 number of dynamic symbols in elf_link_add_object_symbols. We
4773 will build the contents of .dynsym and .hash when we build the
4774 final symbol table, because until then we do not know the correct
4775 value to give the symbols. We built the .dynstr section as we
4776 went along in elf_link_add_object_symbols. */
4777 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
4778 BFD_ASSERT (s
!= NULL
);
4779 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
4780 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4781 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4783 bfd_set_error (bfd_error_no_memory
);
4787 /* The first entry in .dynsym is a dummy symbol. */
4794 elf_swap_symbol_out (output_bfd
, &isym
,
4795 (Elf_External_Sym
*) s
->contents
);
4797 for (i
= 0; elf_buckets
[i
] != 0; i
++)
4799 bucketcount
= elf_buckets
[i
];
4800 if (dynsymcount
< elf_buckets
[i
+ 1])
4804 s
= bfd_get_section_by_name (dynobj
, ".hash");
4805 BFD_ASSERT (s
!= NULL
);
4806 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
4807 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
4808 if (s
->contents
== NULL
)
4810 bfd_set_error (bfd_error_no_memory
);
4813 memset (s
->contents
, 0, s
->_raw_size
);
4815 put_word (output_bfd
, bucketcount
, s
->contents
);
4816 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
4818 elf_hash_table (info
)->bucketcount
= bucketcount
;
4820 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
4821 BFD_ASSERT (s
!= NULL
);
4822 s
->_raw_size
= elf_hash_table (info
)->dynstr
->length
;
4823 s
->contents
= (unsigned char *) elf_hash_table (info
)->dynstr
->tab
;
4825 /* Find all symbols which were defined in a dynamic object and make
4826 the backend pick a reasonable value for them. */
4827 elf_link_hash_traverse (elf_hash_table (info
),
4828 elf_adjust_dynamic_symbol
,
4831 /* Add some entries to the .dynamic section. We fill in some of the
4832 values later, in elf_bfd_final_link, but we must add the entries
4833 now so that we know the final size of the .dynamic section. */
4834 if (bfd_get_section_by_name (output_bfd
, ".init") != NULL
)
4836 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
4839 if (bfd_get_section_by_name (output_bfd
, ".fini") != NULL
)
4841 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
4844 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
4845 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
4846 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
4847 || ! elf_add_dynamic_entry (info
, DT_STRSZ
,
4848 elf_hash_table (info
)->dynstr
->length
)
4849 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
4850 sizeof (Elf_External_Sym
)))
4853 /* The backend must work out the sizes of all the other dynamic
4855 bed
= get_elf_backend_data (output_bfd
);
4856 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
4859 return elf_add_dynamic_entry (info
, DT_NULL
, 0);
4862 /* Make the backend pick a good value for a dynamic symbol. This is
4863 called via elf_link_hash_traverse, and also calls itself
4867 elf_adjust_dynamic_symbol (h
, data
)
4868 struct elf_link_hash_entry
*h
;
4871 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
4873 struct elf_backend_data
*bed
;
4875 /* If this symbol is not defined by a dynamic object, or is not
4876 referenced by a regular object, ignore it. FIXME: Do we need to
4877 worry about symbols which are defined by one dynamic object and
4878 referenced by another one? */
4879 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4880 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
4881 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4884 /* If we've already adjusted this symbol, don't do it again. This
4885 can happen via a recursive call. */
4886 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
4889 /* Don't look at this symbol again. Note that we must set this
4890 after checking the above conditions, because we may look at a
4891 symbol once, decide not to do anything, and then get called
4892 recursively later after REF_REGULAR is set below. */
4893 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
4895 /* If this is a weak definition, and we know a real definition, and
4896 the real symbol is not itself defined by a regular object file,
4897 then get a good value for the real definition. We handle the
4898 real symbol first, for the convenience of the backend routine.
4900 Note that there is a confusing case here. If the real definition
4901 is defined by a regular object file, we don't get the real symbol
4902 from the dynamic object, but we do get the weak symbol. If the
4903 processor backend uses a COPY reloc, then if some routine in the
4904 dynamic object changes the real symbol, we will not see that
4905 change in the corresponding weak symbol. This is the way other
4906 ELF linkers work as well, and seems to be a result of the shared
4909 I will clarify this issue. Most SVR4 shared libraries define the
4910 variable _timezone and define timezone as a weak synonym. The
4911 tzset call changes _timezone. If you write
4912 extern int timezone;
4914 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4915 you might expect that, since timezone is a synonym for _timezone,
4916 the same number will print both times. However, if the processor
4917 backend uses a COPY reloc, then actually timezone will be copied
4918 into your process image, and, since you define _timezone
4919 yourself, _timezone will not. Thus timezone and _timezone will
4920 wind up at different memory locations. The tzset call will set
4921 _timezone, leaving timezone unchanged. */
4923 if (h
->weakdef
!= NULL
)
4925 struct elf_link_hash_entry
*weakdef
;
4927 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4928 weakdef
= h
->weakdef
;
4929 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
);
4930 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
4931 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
4932 || (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4934 /* This symbol is defined or referenced by a regular object
4935 file, so we will not do anything special. Clear weakdef
4936 for the convenience of the processor backend. */
4941 /* There is an implicit reference by a regular object file
4942 via the weak symbol. */
4943 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
4944 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) info
))
4949 dynobj
= elf_hash_table (info
)->dynobj
;
4950 bed
= get_elf_backend_data (dynobj
);
4951 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (info
, h
))
4953 /* FIXME: No way to return error. */
4960 /* Final phase of ELF linker. */
4962 /* A structure we use to avoid passing large numbers of arguments. */
4964 struct elf_final_link_info
4966 /* General link information. */
4967 struct bfd_link_info
*info
;
4970 /* Symbol string table. */
4971 struct strtab
*symstrtab
;
4972 /* .dynsym section. */
4973 asection
*dynsym_sec
;
4974 /* .hash section. */
4976 /* Buffer large enough to hold contents of any section. */
4978 /* Buffer large enough to hold external relocs of any section. */
4979 PTR external_relocs
;
4980 /* Buffer large enough to hold internal relocs of any section. */
4981 Elf_Internal_Rela
*internal_relocs
;
4982 /* Buffer large enough to hold external local symbols of any input
4984 Elf_External_Sym
*external_syms
;
4985 /* Buffer large enough to hold internal local symbols of any input
4987 Elf_Internal_Sym
*internal_syms
;
4988 /* Array large enough to hold a symbol index for each local symbol
4989 of any input BFD. */
4991 /* Array large enough to hold a section pointer for each local
4992 symbol of any input BFD. */
4993 asection
**sections
;
4994 /* Buffer to hold swapped out symbols. */
4995 Elf_External_Sym
*symbuf
;
4996 /* Number of swapped out symbols in buffer. */
4997 size_t symbuf_count
;
4998 /* Number of symbols which fit in symbuf. */
5002 static boolean elf_link_output_sym
5003 PARAMS ((struct elf_final_link_info
*, const char *, Elf_Internal_Sym
*));
5004 static boolean elf_link_flush_output_syms
5005 PARAMS ((struct elf_final_link_info
*));
5006 static boolean elf_link_output_extsym
5007 PARAMS ((struct elf_link_hash_entry
*, PTR
));
5008 static boolean elf_link_input_bfd
5009 PARAMS ((struct elf_final_link_info
*, bfd
*));
5010 static boolean elf_reloc_link_order
5011 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
5012 struct bfd_link_order
*));
5014 /* Do the final step of an ELF link. */
5017 elf_bfd_final_link (abfd
, info
)
5019 struct bfd_link_info
*info
;
5022 struct elf_final_link_info finfo
;
5023 register asection
*o
;
5024 register struct bfd_link_order
*p
;
5026 size_t max_contents_size
;
5027 size_t max_external_reloc_size
;
5028 size_t max_internal_reloc_count
;
5029 size_t max_sym_count
;
5031 Elf_Internal_Sym elfsym
;
5033 Elf_Internal_Shdr
*symtab_hdr
;
5034 Elf_Internal_Shdr
*symstrtab_hdr
;
5036 dynobj
= elf_hash_table (info
)->dynobj
;
5039 finfo
.output_bfd
= abfd
;
5040 finfo
.symstrtab
= bfd_new_strtab (abfd
);
5041 if (finfo
.symstrtab
== NULL
)
5045 finfo
.dynsym_sec
= NULL
;
5046 finfo
.hash_sec
= NULL
;
5050 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
5051 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
5052 if (finfo
.dynsym_sec
== NULL
5053 || finfo
.hash_sec
== NULL
)
5056 finfo
.contents
= NULL
;
5057 finfo
.external_relocs
= NULL
;
5058 finfo
.internal_relocs
= NULL
;
5059 finfo
.external_syms
= NULL
;
5060 finfo
.internal_syms
= NULL
;
5061 finfo
.indices
= NULL
;
5062 finfo
.sections
= NULL
;
5063 finfo
.symbuf
= NULL
;
5064 finfo
.symbuf_count
= 0;
5066 /* Count up the number of relocations we will output for each output
5067 section, so that we know the sizes of the reloc sections. We
5068 also figure out some maximum sizes. */
5069 max_contents_size
= 0;
5070 max_external_reloc_size
= 0;
5071 max_internal_reloc_count
= 0;
5073 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5077 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5079 if (p
->type
== bfd_section_reloc_link_order
5080 || p
->type
== bfd_symbol_reloc_link_order
)
5082 else if (p
->type
== bfd_indirect_link_order
)
5086 sec
= p
->u
.indirect
.section
;
5088 if (info
->relocateable
)
5089 o
->reloc_count
+= sec
->reloc_count
;
5091 if (sec
->_raw_size
> max_contents_size
)
5092 max_contents_size
= sec
->_raw_size
;
5093 if (sec
->_cooked_size
> max_contents_size
)
5094 max_contents_size
= sec
->_cooked_size
;
5096 /* We are interested in just local symbols, not all
5098 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
5102 if (elf_bad_symtab (sec
->owner
))
5103 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
5104 / sizeof (Elf_External_Sym
));
5106 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
5108 if (sym_count
> max_sym_count
)
5109 max_sym_count
= sym_count
;
5112 if ((sec
->flags
& SEC_RELOC
) != 0)
5116 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
5117 if (ext_size
> max_external_reloc_size
)
5118 max_external_reloc_size
= ext_size
;
5119 if (sec
->reloc_count
> max_internal_reloc_count
)
5120 max_internal_reloc_count
= sec
->reloc_count
;
5125 if (o
->reloc_count
> 0)
5126 o
->flags
|= SEC_RELOC
;
5129 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5130 set it (this is probably a bug) and if it is set
5131 assign_section_numbers will create a reloc section. */
5132 o
->flags
&=~ SEC_RELOC
;
5136 /* Figure out the file positions for everything but the symbol table
5137 and the relocs. We set symcount to force assign_section_numbers
5138 to create a symbol table. */
5139 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
5140 BFD_ASSERT (! abfd
->output_has_begun
);
5141 if (! elf_compute_section_file_positions (abfd
, info
))
5144 /* That created the reloc sections. Set their sizes, and assign
5145 them file positions, and allocate some buffers. */
5146 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5148 if ((o
->flags
& SEC_RELOC
) != 0)
5150 Elf_Internal_Shdr
*rel_hdr
;
5151 register struct elf_link_hash_entry
**p
, **pend
;
5153 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5155 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
5157 /* The contents field must last into write_object_contents,
5158 so we allocate it with bfd_alloc rather than malloc. */
5159 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
5160 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
5162 bfd_set_error (bfd_error_no_memory
);
5166 p
= ((struct elf_link_hash_entry
**)
5167 malloc (o
->reloc_count
5168 * sizeof (struct elf_link_hash_entry
*)));
5169 if (p
== NULL
&& o
->reloc_count
!= 0)
5171 bfd_set_error (bfd_error_no_memory
);
5174 elf_section_data (o
)->rel_hashes
= p
;
5175 pend
= p
+ o
->reloc_count
;
5176 for (; p
< pend
; p
++)
5179 /* Use the reloc_count field as an index when outputting the
5185 assign_file_positions_for_relocs (abfd
);
5187 /* We have now assigned file positions for all the sections except
5188 .symtab and .strtab. We start the .symtab section at the current
5189 file position, and write directly to it. We build the .strtab
5190 section in memory. When we add .dynsym support, we will build
5191 that in memory as well (.dynsym is smaller than .symtab). */
5193 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5194 /* sh_name is set in prep_headers. */
5195 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5196 symtab_hdr
->sh_flags
= 0;
5197 symtab_hdr
->sh_addr
= 0;
5198 symtab_hdr
->sh_size
= 0;
5199 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
5200 /* sh_link is set in assign_section_numbers. */
5201 /* sh_info is set below. */
5202 /* sh_offset is set just below. */
5203 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
5205 off
= elf_tdata (abfd
)->next_file_pos
;
5206 off
= assign_file_position_for_section (symtab_hdr
, off
, true);
5208 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5209 incorrect. We do not yet know the size of the .symtab section.
5210 We correct next_file_pos below, after we do know the size. */
5212 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5213 continuously seeking to the right position in the file. */
5214 if (! info
->keep_memory
|| max_sym_count
< 20)
5215 finfo
.symbuf_size
= 20;
5217 finfo
.symbuf_size
= max_sym_count
;
5218 finfo
.symbuf
= ((Elf_External_Sym
*)
5219 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
5220 if (finfo
.symbuf
== NULL
)
5222 bfd_set_error (bfd_error_no_memory
);
5226 /* Start writing out the symbol table. The first symbol is always a
5228 elfsym
.st_value
= 0;
5231 elfsym
.st_other
= 0;
5232 elfsym
.st_shndx
= SHN_UNDEF
;
5233 if (! elf_link_output_sym (&finfo
, (const char *) NULL
, &elfsym
))
5237 /* Some standard ELF linkers do this, but we don't because it causes
5238 bootstrap comparison failures. */
5239 /* Output a file symbol for the output file as the second symbol.
5240 We output this even if we are discarding local symbols, although
5241 I'm not sure if this is correct. */
5242 elfsym
.st_value
= 0;
5244 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5245 elfsym
.st_other
= 0;
5246 elfsym
.st_shndx
= SHN_ABS
;
5247 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
), &elfsym
))
5251 /* Output a symbol for each section. We output these even if we are
5252 discarding local symbols, since they are used for relocs. These
5253 symbols have no names. We store the index of each one in the
5254 index field of the section, so that we can find it again when
5255 outputting relocs. */
5256 elfsym
.st_value
= 0;
5258 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5259 elfsym
.st_other
= 0;
5260 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5262 o
= section_from_elf_index (abfd
, i
);
5263 if (o
!= &bfd_abs_section
)
5264 o
->target_index
= abfd
->symcount
;
5265 elfsym
.st_shndx
= i
;
5266 if (! elf_link_output_sym (&finfo
, (const char *) NULL
, &elfsym
))
5270 /* Allocate some memory to hold information read in from the input
5272 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
5273 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
5274 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
5275 malloc (max_internal_reloc_count
5276 * sizeof (Elf_Internal_Rela
)));
5277 finfo
.external_syms
= ((Elf_External_Sym
*)
5278 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
5279 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
5280 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
5281 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
5282 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
5283 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
5284 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
5285 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
5286 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
5287 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
5288 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
5289 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
5291 bfd_set_error (bfd_error_no_memory
);
5295 /* Since ELF permits relocations to be against local symbols, we
5296 must have the local symbols available when we do the relocations.
5297 Since we would rather only read the local symbols once, and we
5298 would rather not keep them in memory, we handle all the
5299 relocations for a single input file at the same time.
5301 Unfortunately, there is no way to know the total number of local
5302 symbols until we have seen all of them, and the local symbol
5303 indices precede the global symbol indices. This means that when
5304 we are generating relocateable output, and we see a reloc against
5305 a global symbol, we can not know the symbol index until we have
5306 finished examining all the local symbols to see which ones we are
5307 going to output. To deal with this, we keep the relocations in
5308 memory, and don't output them until the end of the link. This is
5309 an unfortunate waste of memory, but I don't see a good way around
5310 it. Fortunately, it only happens when performing a relocateable
5311 link, which is not the common case. FIXME: If keep_memory is set
5312 we could write the relocs out and then read them again; I don't
5313 know how bad the memory loss will be. */
5315 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
5316 sub
->output_has_begun
= false;
5317 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5319 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
5321 if (p
->type
== bfd_indirect_link_order
5322 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5323 == bfd_target_elf_flavour
))
5325 sub
= p
->u
.indirect
.section
->owner
;
5326 if (! sub
->output_has_begun
)
5328 if (! elf_link_input_bfd (&finfo
, sub
))
5330 sub
->output_has_begun
= true;
5333 else if (p
->type
== bfd_section_reloc_link_order
5334 || p
->type
== bfd_symbol_reloc_link_order
)
5336 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
5341 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5347 /* That wrote out all the local symbols. Finish up the symbol table
5348 with the global symbols. */
5350 /* The sh_info field records the index of the first non local
5352 symtab_hdr
->sh_info
= abfd
->symcount
;
5354 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
5356 /* We get the global symbols from the hash table. */
5357 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
5360 /* Flush all symbols to the file. */
5361 if (! elf_link_flush_output_syms (&finfo
))
5364 /* Now we know the size of the symtab section. */
5365 off
+= symtab_hdr
->sh_size
;
5367 /* Finish up the symbol string table (.strtab) section. */
5368 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5369 /* sh_name was set in prep_headers. */
5370 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5371 symstrtab_hdr
->sh_flags
= 0;
5372 symstrtab_hdr
->sh_addr
= 0;
5373 symstrtab_hdr
->sh_size
= finfo
.symstrtab
->length
;
5374 symstrtab_hdr
->sh_entsize
= 0;
5375 symstrtab_hdr
->sh_link
= 0;
5376 symstrtab_hdr
->sh_info
= 0;
5377 /* sh_offset is set just below. */
5378 symstrtab_hdr
->sh_addralign
= 1;
5379 symstrtab_hdr
->contents
= (PTR
) finfo
.symstrtab
->tab
;
5381 off
= assign_file_position_for_section (symstrtab_hdr
, off
, true);
5382 elf_tdata (abfd
)->next_file_pos
= off
;
5384 /* Adjust the relocs to have the correct symbol indices. */
5385 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5387 struct elf_link_hash_entry
**rel_hash
;
5388 Elf_Internal_Shdr
*rel_hdr
;
5390 if ((o
->flags
& SEC_RELOC
) == 0)
5393 rel_hash
= elf_section_data (o
)->rel_hashes
;
5394 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5395 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
5397 if (*rel_hash
== NULL
)
5400 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
5402 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5404 Elf_External_Rel
*erel
;
5405 Elf_Internal_Rel irel
;
5407 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
5408 elf_swap_reloc_in (abfd
, erel
, &irel
);
5409 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5410 ELF_R_TYPE (irel
.r_info
));
5411 elf_swap_reloc_out (abfd
, &irel
, erel
);
5415 Elf_External_Rela
*erela
;
5416 Elf_Internal_Rela irela
;
5418 BFD_ASSERT (rel_hdr
->sh_entsize
5419 == sizeof (Elf_External_Rela
));
5421 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
5422 elf_swap_reloca_in (abfd
, erela
, &irela
);
5423 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
5424 ELF_R_TYPE (irela
.r_info
));
5425 elf_swap_reloca_out (abfd
, &irela
, erela
);
5429 /* Set the reloc_count field to 0 to prevent write_relocs from
5430 trying to swap the relocs out itself. */
5434 /* If we are linking against a dynamic object, finish up the dynamic
5435 linking information. */
5438 Elf_External_Dyn
*dyncon
, *dynconend
;
5439 struct elf_backend_data
*bed
;
5441 /* Fix up .dynamic entries. */
5442 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
5443 BFD_ASSERT (o
!= NULL
);
5445 dyncon
= (Elf_External_Dyn
*) o
->contents
;
5446 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
5447 for (; dyncon
< dynconend
; dyncon
++)
5449 Elf_Internal_Dyn dyn
;
5453 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5475 o
= bfd_get_section_by_name (abfd
, name
);
5476 BFD_ASSERT (o
!= NULL
);
5477 dyn
.d_un
.d_ptr
= o
->vma
;
5478 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5485 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
5490 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
5492 Elf_Internal_Shdr
*hdr
;
5494 hdr
= elf_elfsections (abfd
)[i
];
5495 if (hdr
->sh_type
== type
5496 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
5498 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
5499 dyn
.d_un
.d_val
+= hdr
->sh_size
;
5502 if (dyn
.d_un
.d_val
== 0
5503 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
5504 dyn
.d_un
.d_val
= hdr
->sh_addr
;
5508 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
5513 bed
= get_elf_backend_data (abfd
);
5514 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
5517 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
5519 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5521 BFD_ASSERT ((o
->flags
& SEC_IN_MEMORY
) != 0);
5522 if (! bfd_set_section_contents (abfd
, o
->output_section
,
5523 o
->contents
, o
->output_offset
,
5529 if (finfo
.contents
!= NULL
)
5530 free (finfo
.contents
);
5531 if (finfo
.external_relocs
!= NULL
)
5532 free (finfo
.external_relocs
);
5533 if (finfo
.internal_relocs
!= NULL
)
5534 free (finfo
.internal_relocs
);
5535 if (finfo
.external_syms
!= NULL
)
5536 free (finfo
.external_syms
);
5537 if (finfo
.internal_syms
!= NULL
)
5538 free (finfo
.internal_syms
);
5539 if (finfo
.indices
!= NULL
)
5540 free (finfo
.indices
);
5541 if (finfo
.sections
!= NULL
)
5542 free (finfo
.sections
);
5543 if (finfo
.symbuf
!= NULL
)
5544 free (finfo
.symbuf
);
5545 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5547 if ((o
->flags
& SEC_RELOC
) != 0
5548 && elf_section_data (o
)->rel_hashes
!= NULL
)
5549 free (elf_section_data (o
)->rel_hashes
);
5555 if (finfo
.contents
!= NULL
)
5556 free (finfo
.contents
);
5557 if (finfo
.external_relocs
!= NULL
)
5558 free (finfo
.external_relocs
);
5559 if (finfo
.internal_relocs
!= NULL
)
5560 free (finfo
.internal_relocs
);
5561 if (finfo
.external_syms
!= NULL
)
5562 free (finfo
.external_syms
);
5563 if (finfo
.internal_syms
!= NULL
)
5564 free (finfo
.internal_syms
);
5565 if (finfo
.indices
!= NULL
)
5566 free (finfo
.indices
);
5567 if (finfo
.sections
!= NULL
)
5568 free (finfo
.sections
);
5569 if (finfo
.symbuf
!= NULL
)
5570 free (finfo
.symbuf
);
5571 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5573 if ((o
->flags
& SEC_RELOC
) != 0
5574 && elf_section_data (o
)->rel_hashes
!= NULL
)
5575 free (elf_section_data (o
)->rel_hashes
);
5581 /* Add a symbol to the output symbol table. */
5584 elf_link_output_sym (finfo
, name
, elfsym
)
5585 struct elf_final_link_info
*finfo
;
5587 Elf_Internal_Sym
*elfsym
;
5589 if (name
== (const char *) NULL
|| *name
== '\0')
5590 elfsym
->st_name
= 0;
5593 elfsym
->st_name
= bfd_add_to_strtab (finfo
->output_bfd
,
5594 finfo
->symstrtab
, name
);
5595 if (elfsym
->st_name
== (unsigned long) -1)
5599 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
5601 if (! elf_link_flush_output_syms (finfo
))
5605 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
5606 finfo
->symbuf
+ finfo
->symbuf_count
);
5607 ++finfo
->symbuf_count
;
5609 ++finfo
->output_bfd
->symcount
;
5614 /* Flush the output symbols to the file. */
5617 elf_link_flush_output_syms (finfo
)
5618 struct elf_final_link_info
*finfo
;
5620 Elf_Internal_Shdr
*symtab
;
5622 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
5624 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
5626 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
5627 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
5628 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
5631 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
5633 finfo
->symbuf_count
= 0;
5638 /* Add an external symbol to the symbol table. This is called from
5639 the hash table traversal routine. */
5642 elf_link_output_extsym (h
, data
)
5643 struct elf_link_hash_entry
*h
;
5646 struct elf_final_link_info
*finfo
= (struct elf_final_link_info
*) data
;
5648 Elf_Internal_Sym sym
;
5650 /* We don't want to output symbols that have never been mentioned by
5651 a regular file, or that we have been told to strip. However, if
5652 h->indx is set to -2, the symbol is used by a reloc and we must
5656 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5657 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
5658 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
5659 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
5661 else if (finfo
->info
->strip
== strip_all
5662 || (finfo
->info
->strip
== strip_some
5663 && bfd_hash_lookup (finfo
->info
->keep_hash
,
5664 h
->root
.root
.string
,
5665 false, false) == NULL
))
5670 /* If we're stripping it, and it's not a dynamic symbol, there's
5671 nothing else to do. */
5672 if (strip
&& h
->dynindx
== -1)
5676 sym
.st_size
= h
->size
;
5677 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
5680 switch (h
->root
.type
)
5683 case bfd_link_hash_new
:
5687 case bfd_link_hash_undefined
:
5688 sym
.st_shndx
= SHN_UNDEF
;
5691 case bfd_link_hash_weak
:
5692 sym
.st_shndx
= SHN_UNDEF
;
5693 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
5696 case bfd_link_hash_defined
:
5700 sec
= h
->root
.u
.def
.section
;
5701 if (sec
->output_section
!= NULL
)
5703 sym
.st_shndx
= elf_section_from_bfd_section (finfo
->output_bfd
,
5704 sec
->output_section
);
5705 if (sym
.st_shndx
== (unsigned short) -1)
5707 /* FIXME: No way to handle errors. */
5711 /* ELF symbols in relocateable files are section relative,
5712 but in nonrelocateable files they are virtual
5714 sym
.st_value
= h
->root
.u
.def
.value
+ sec
->output_offset
;
5715 if (! finfo
->info
->relocateable
)
5716 sym
.st_value
+= sec
->output_section
->vma
;
5720 BFD_ASSERT (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
5721 && elf_elfheader (sec
->owner
)->e_type
== ET_DYN
);
5722 sym
.st_shndx
= SHN_UNDEF
;
5727 case bfd_link_hash_common
:
5728 sym
.st_shndx
= SHN_COMMON
;
5732 sym
.st_value
= h
->align
;
5735 case bfd_link_hash_indirect
:
5736 case bfd_link_hash_warning
:
5737 /* I have no idea how these should be handled. */
5741 /* If this symbol should be put in the .dynsym section, then put it
5742 there now. We have already know the symbol index. We also fill
5743 in the entry in the .hash section. */
5744 if (h
->dynindx
!= -1)
5746 struct elf_backend_data
*bed
;
5749 bfd_byte
*bucketpos
;
5752 sym
.st_name
= h
->dynstr_index
;
5754 /* Give the processor backend a chance to tweak the symbol
5755 value, and also to finish up anything that needs to be done
5757 bed
= get_elf_backend_data (finfo
->output_bfd
);
5758 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
5759 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
5761 /* FIXME: No way to return error. */
5765 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
5766 ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
5769 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
5770 bucket
= bfd_elf_hash (h
->root
.root
.string
) % bucketcount
;
5771 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
5772 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
5773 chain
= get_word (finfo
->output_bfd
, bucketpos
);
5774 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
5775 put_word (finfo
->output_bfd
, chain
,
5776 ((bfd_byte
*) finfo
->hash_sec
->contents
5777 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
5780 /* If we're stripping it, then it was just a dynamic symbol, and
5781 there's nothing else to do. */
5785 h
->indx
= finfo
->output_bfd
->symcount
;
5787 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
))
5789 /* FIXME: No way to return error. */
5796 /* Link an input file into the linker output file. This function
5797 handles all the sections and relocations of the input file at once.
5798 This is so that we only have to read the local symbols once, and
5799 don't have to keep them in memory. */
5802 elf_link_input_bfd (finfo
, input_bfd
)
5803 struct elf_final_link_info
*finfo
;
5806 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
5807 bfd
*, asection
*, bfd_byte
*,
5808 Elf_Internal_Rela
*,
5812 Elf_Internal_Shdr
*symtab_hdr
;
5815 Elf_External_Sym
*esym
;
5816 Elf_External_Sym
*esymend
;
5817 Elf_Internal_Sym
*isym
;
5819 asection
**ppsection
;
5822 output_bfd
= finfo
->output_bfd
;
5824 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
5826 /* If this is a dynamic object, we don't want to do anything here:
5827 we don't want the local symbols, and we don't want the section
5829 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
5832 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5833 if (elf_bad_symtab (input_bfd
))
5835 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5840 locsymcount
= symtab_hdr
->sh_info
;
5841 extsymoff
= symtab_hdr
->sh_info
;
5844 /* Read the local symbols. */
5845 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5846 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
5847 locsymcount
, input_bfd
)
5848 != locsymcount
* sizeof (Elf_External_Sym
)))
5851 /* Swap in the local symbols and write out the ones which we know
5852 are going into the output file. */
5853 esym
= finfo
->external_syms
;
5854 esymend
= esym
+ locsymcount
;
5855 isym
= finfo
->internal_syms
;
5856 pindex
= finfo
->indices
;
5857 ppsection
= finfo
->sections
;
5858 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5864 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5867 if (elf_bad_symtab (input_bfd
))
5869 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5876 if (isym
->st_shndx
== SHN_UNDEF
)
5877 isec
= &bfd_und_section
;
5878 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5880 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5884 else if (isym
->st_shndx
== SHN_ABS
)
5885 isec
= &bfd_abs_section
;
5886 else if (isym
->st_shndx
== SHN_COMMON
)
5887 isec
= &bfd_com_section
;
5896 /* Don't output the first, undefined, symbol. */
5897 if (esym
== finfo
->external_syms
)
5900 /* If we are stripping all symbols, we don't want to output this
5902 if (finfo
->info
->strip
== strip_all
)
5905 /* We never output section symbols. Instead, we use the section
5906 symbol of the corresponding section in the output file. */
5907 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5910 /* If we are discarding all local symbols, we don't want to
5911 output this one. If we are generating a relocateable output
5912 file, then some of the local symbols may be required by
5913 relocs; we output them below as we discover that they are
5915 if (finfo
->info
->discard
== discard_all
)
5918 /* Get the name of the symbol. */
5919 name
= elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5924 /* See if we are discarding symbols with this name. */
5925 if ((finfo
->info
->strip
== strip_some
5926 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5928 || (finfo
->info
->discard
== discard_l
5929 && strncmp (name
, finfo
->info
->lprefix
,
5930 finfo
->info
->lprefix_len
) == 0))
5933 /* If we get here, we are going to output this symbol. */
5935 /* Adjust the section index for the output file. */
5936 isym
->st_shndx
= elf_section_from_bfd_section (output_bfd
,
5937 isec
->output_section
);
5938 if (isym
->st_shndx
== (unsigned short) -1)
5941 *pindex
= output_bfd
->symcount
;
5943 /* ELF symbols in relocateable files are section relative, but
5944 in executable files they are virtual addresses. Note that
5945 this code assumes that all ELF sections have an associated
5946 BFD section with a reasonable value for output_offset; below
5947 we assume that they also have a reasonable value for
5948 output_section. Any special sections must be set up to meet
5949 these requirements. */
5950 oldval
= isym
->st_value
;
5951 isym
->st_value
+= isec
->output_offset
;
5952 if (! finfo
->info
->relocateable
)
5953 isym
->st_value
+= isec
->output_section
->vma
;
5955 if (! elf_link_output_sym (finfo
, name
, isym
))
5958 /* Restore the old value for reloc handling. */
5959 isym
->st_value
= oldval
;
5962 /* Relocate the contents of each section. */
5963 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5965 Elf_Internal_Shdr
*input_rel_hdr
;
5967 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
5970 /* Read the contents of the section. */
5971 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5972 (file_ptr
) 0, o
->_raw_size
))
5975 if ((o
->flags
& SEC_RELOC
) != 0)
5977 /* Read in the relocs. */
5978 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5979 if (bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
) != 0
5980 || bfd_read (finfo
->external_relocs
, 1, input_rel_hdr
->sh_size
,
5981 input_bfd
) != input_rel_hdr
->sh_size
)
5984 /* Swap in the relocs. For convenience, we always produce
5985 an Elf_Internal_Rela array; if the relocs are Rel, we set
5987 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
5989 Elf_External_Rel
*erel
;
5990 Elf_External_Rel
*erelend
;
5991 Elf_Internal_Rela
*irela
;
5993 erel
= (Elf_External_Rel
*) finfo
->external_relocs
;
5994 erelend
= erel
+ o
->reloc_count
;
5995 irela
= finfo
->internal_relocs
;
5996 for (; erel
< erelend
; erel
++, irela
++)
5998 Elf_Internal_Rel irel
;
6000 elf_swap_reloc_in (input_bfd
, erel
, &irel
);
6001 irela
->r_offset
= irel
.r_offset
;
6002 irela
->r_info
= irel
.r_info
;
6003 irela
->r_addend
= 0;
6008 Elf_External_Rela
*erela
;
6009 Elf_External_Rela
*erelaend
;
6010 Elf_Internal_Rela
*irela
;
6012 BFD_ASSERT (input_rel_hdr
->sh_entsize
6013 == sizeof (Elf_External_Rela
));
6015 erela
= (Elf_External_Rela
*) finfo
->external_relocs
;
6016 erelaend
= erela
+ o
->reloc_count
;
6017 irela
= finfo
->internal_relocs
;
6018 for (; erela
< erelaend
; erela
++, irela
++)
6019 elf_swap_reloca_in (input_bfd
, erela
, irela
);
6022 /* Relocate the section by invoking a back end routine.
6024 The back end routine is responsible for adjusting the
6025 section contents as necessary, and (if using Rela relocs
6026 and generating a relocateable output file) adjusting the
6027 reloc addend as necessary.
6029 The back end routine does not have to worry about setting
6030 the reloc address or the reloc symbol index.
6032 The back end routine is given a pointer to the swapped in
6033 internal symbols, and can access the hash table entries
6034 for the external symbols via elf_sym_hashes (input_bfd).
6036 When generating relocateable output, the back end routine
6037 must handle STB_LOCAL/STT_SECTION symbols specially. The
6038 output symbol is going to be a section symbol
6039 corresponding to the output section, which will require
6040 the addend to be adjusted. */
6042 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6045 finfo
->internal_relocs
,
6046 finfo
->internal_syms
,
6050 if (finfo
->info
->relocateable
)
6052 Elf_Internal_Rela
*irela
;
6053 Elf_Internal_Rela
*irelaend
;
6054 struct elf_link_hash_entry
**rel_hash
;
6055 Elf_Internal_Shdr
*output_rel_hdr
;
6057 /* Adjust the reloc addresses and symbol indices. */
6059 irela
= finfo
->internal_relocs
;
6060 irelaend
= irela
+ o
->reloc_count
;
6061 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6062 + o
->output_section
->reloc_count
);
6063 for (; irela
< irelaend
; irela
++, rel_hash
++)
6066 Elf_Internal_Sym
*isym
;
6069 irela
->r_offset
+= o
->output_offset
;
6071 r_symndx
= ELF_R_SYM (irela
->r_info
);
6076 if (r_symndx
>= locsymcount
6077 || (elf_bad_symtab (input_bfd
)
6078 && finfo
->sections
[r_symndx
] == NULL
))
6082 /* This is a reloc against a global symbol. We
6083 have not yet output all the local symbols, so
6084 we do not know the symbol index of any global
6085 symbol. We set the rel_hash entry for this
6086 reloc to point to the global hash table entry
6087 for this symbol. The symbol index is then
6088 set at the end of elf_bfd_final_link. */
6089 indx
= r_symndx
- extsymoff
;
6090 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
6092 /* Setting the index to -2 tells
6093 elf_link_output_extsym that this symbol is
6095 BFD_ASSERT ((*rel_hash
)->indx
< 0);
6096 (*rel_hash
)->indx
= -2;
6101 /* This is a reloc against a local symbol. */
6104 isym
= finfo
->internal_syms
+ r_symndx
;
6105 sec
= finfo
->sections
[r_symndx
];
6106 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6108 /* I suppose the backend ought to fill in the
6109 section of any STT_SECTION symbol against a
6110 processor specific section. */
6112 || sec
== &bfd_und_section
6113 || sec
== &bfd_com_section
)
6115 bfd_set_error (bfd_error_bad_value
);
6118 else if (sec
== &bfd_abs_section
)
6122 r_symndx
= sec
->output_section
->target_index
;
6129 if (finfo
->indices
[r_symndx
] == -1)
6135 if (finfo
->info
->strip
== strip_all
)
6137 /* You can't do ld -r -s. */
6138 bfd_set_error (bfd_error_invalid_operation
);
6142 /* This symbol was skipped earlier, but
6143 since it is needed by a reloc, we
6144 must output it now. */
6145 link
= symtab_hdr
->sh_link
;
6146 name
= elf_string_from_elf_section (input_bfd
,
6152 osec
= sec
->output_section
;
6154 elf_section_from_bfd_section (output_bfd
,
6156 if (isym
->st_shndx
== (unsigned short) -1)
6159 isym
->st_value
+= sec
->output_offset
;
6160 if (! finfo
->info
->relocateable
)
6161 isym
->st_value
+= osec
->vma
;
6163 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
6165 if (! elf_link_output_sym (finfo
, name
, isym
))
6169 r_symndx
= finfo
->indices
[r_symndx
];
6172 irela
->r_info
= ELF_R_INFO (r_symndx
,
6173 ELF_R_TYPE (irela
->r_info
));
6176 /* Swap out the relocs. */
6177 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
6178 BFD_ASSERT (output_rel_hdr
->sh_entsize
6179 == input_rel_hdr
->sh_entsize
);
6180 irela
= finfo
->internal_relocs
;
6181 irelaend
= irela
+ o
->reloc_count
;
6182 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6184 Elf_External_Rel
*erel
;
6186 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
6187 + o
->output_section
->reloc_count
);
6188 for (; irela
< irelaend
; irela
++, erel
++)
6190 Elf_Internal_Rel irel
;
6192 irel
.r_offset
= irela
->r_offset
;
6193 irel
.r_info
= irela
->r_info
;
6194 BFD_ASSERT (irela
->r_addend
== 0);
6195 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6200 Elf_External_Rela
*erela
;
6202 BFD_ASSERT (input_rel_hdr
->sh_entsize
6203 == sizeof (Elf_External_Rela
));
6204 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
6205 + o
->output_section
->reloc_count
);
6206 for (; irela
< irelaend
; irela
++, erela
++)
6207 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6210 o
->output_section
->reloc_count
+= o
->reloc_count
;
6214 /* Write out the modified section contents. */
6215 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6216 finfo
->contents
, o
->output_offset
,
6217 (o
->_cooked_size
!= 0
6226 /* Generate a reloc when linking an ELF file. This is a reloc
6227 requested by the linker, and does come from any input file. This
6228 is used to build constructor and destructor tables when linking
6232 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
6234 struct bfd_link_info
*info
;
6235 asection
*output_section
;
6236 struct bfd_link_order
*link_order
;
6238 const reloc_howto_type
*howto
;
6241 struct elf_link_hash_entry
**rel_hash_ptr
;
6242 Elf_Internal_Shdr
*rel_hdr
;
6244 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6247 bfd_set_error (bfd_error_bad_value
);
6251 /* If this is an inplace reloc, we must write the addend into the
6253 if (howto
->partial_inplace
6254 && link_order
->u
.reloc
.p
->addend
!= 0)
6257 bfd_reloc_status_type rstat
;
6261 size
= bfd_get_reloc_size (howto
);
6262 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6263 if (buf
== (bfd_byte
*) NULL
)
6265 bfd_set_error (bfd_error_no_memory
);
6268 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
6269 link_order
->u
.reloc
.p
->addend
, buf
);
6275 case bfd_reloc_outofrange
:
6277 case bfd_reloc_overflow
:
6278 if (! ((*info
->callbacks
->reloc_overflow
)
6280 (link_order
->type
== bfd_section_reloc_link_order
6281 ? bfd_section_name (output_bfd
,
6282 link_order
->u
.reloc
.p
->u
.section
)
6283 : link_order
->u
.reloc
.p
->u
.name
),
6284 howto
->name
, link_order
->u
.reloc
.p
->addend
,
6285 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
6292 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6293 (file_ptr
) link_order
->offset
, size
);
6299 /* Figure out the symbol index. */
6300 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
6301 + output_section
->reloc_count
);
6302 if (link_order
->type
== bfd_section_reloc_link_order
)
6304 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
6307 *rel_hash_ptr
= NULL
;
6311 struct elf_link_hash_entry
*h
;
6313 h
= elf_link_hash_lookup (elf_hash_table (info
),
6314 link_order
->u
.reloc
.p
->u
.name
,
6315 false, false, true);
6318 /* Setting the index to -2 tells elf_link_output_extsym that
6319 this symbol is used by a reloc. */
6326 if (! ((*info
->callbacks
->unattached_reloc
)
6327 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6328 (asection
*) NULL
, (bfd_vma
) 0)))
6334 /* The address of a reloc is relative to the section in a
6335 relocateable file, and is a virtual address in an executable
6337 offset
= link_order
->offset
;
6338 if (! info
->relocateable
)
6339 offset
+= output_section
->vma
;
6341 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6343 if (rel_hdr
->sh_type
== SHT_REL
)
6345 Elf_Internal_Rel irel
;
6346 Elf_External_Rel
*erel
;
6348 irel
.r_offset
= offset
;
6349 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6350 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
6351 + output_section
->reloc_count
);
6352 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
6356 Elf_Internal_Rela irela
;
6357 Elf_External_Rela
*erela
;
6359 irela
.r_offset
= offset
;
6360 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
6361 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
6362 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
6363 + output_section
->reloc_count
);
6364 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
6367 ++output_section
->reloc_count
;