1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
41 static INLINE
struct elf_segment_map
*make_mapping
42 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
43 static boolean map_sections_to_segments
PARAMS ((bfd
*));
44 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
45 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
46 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
47 static boolean prep_headers
PARAMS ((bfd
*));
48 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
49 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
50 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
51 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
52 static boolean assign_section_numbers
PARAMS ((bfd
*));
53 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
54 static boolean elf_map_symbols
PARAMS ((bfd
*));
55 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
57 /* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
61 /* Swap in a Verdef structure. */
64 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
66 const Elf_External_Verdef
*src
;
67 Elf_Internal_Verdef
*dst
;
69 dst
->vd_version
= bfd_h_get_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= bfd_h_get_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= bfd_h_get_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= bfd_h_get_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= bfd_h_get_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= bfd_h_get_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= bfd_h_get_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
83 const Elf_Internal_Verdef
*src
;
84 Elf_External_Verdef
*dst
;
86 bfd_h_put_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 bfd_h_put_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 bfd_h_put_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 bfd_h_put_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 bfd_h_put_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 bfd_h_put_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 bfd_h_put_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
100 const Elf_External_Verdaux
*src
;
101 Elf_Internal_Verdaux
*dst
;
103 dst
->vda_name
= bfd_h_get_32 (abfd
, src
->vda_name
);
104 dst
->vda_next
= bfd_h_get_32 (abfd
, src
->vda_next
);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
112 const Elf_Internal_Verdaux
*src
;
113 Elf_External_Verdaux
*dst
;
115 bfd_h_put_32 (abfd
, src
->vda_name
, dst
->vda_name
);
116 bfd_h_put_32 (abfd
, src
->vda_next
, dst
->vda_next
);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
124 const Elf_External_Verneed
*src
;
125 Elf_Internal_Verneed
*dst
;
127 dst
->vn_version
= bfd_h_get_16 (abfd
, src
->vn_version
);
128 dst
->vn_cnt
= bfd_h_get_16 (abfd
, src
->vn_cnt
);
129 dst
->vn_file
= bfd_h_get_32 (abfd
, src
->vn_file
);
130 dst
->vn_aux
= bfd_h_get_32 (abfd
, src
->vn_aux
);
131 dst
->vn_next
= bfd_h_get_32 (abfd
, src
->vn_next
);
134 /* Swap out a Verneed structure. */
137 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
139 const Elf_Internal_Verneed
*src
;
140 Elf_External_Verneed
*dst
;
142 bfd_h_put_16 (abfd
, src
->vn_version
, dst
->vn_version
);
143 bfd_h_put_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
144 bfd_h_put_32 (abfd
, src
->vn_file
, dst
->vn_file
);
145 bfd_h_put_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
146 bfd_h_put_32 (abfd
, src
->vn_next
, dst
->vn_next
);
149 /* Swap in a Vernaux structure. */
152 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
154 const Elf_External_Vernaux
*src
;
155 Elf_Internal_Vernaux
*dst
;
157 dst
->vna_hash
= bfd_h_get_32 (abfd
, src
->vna_hash
);
158 dst
->vna_flags
= bfd_h_get_16 (abfd
, src
->vna_flags
);
159 dst
->vna_other
= bfd_h_get_16 (abfd
, src
->vna_other
);
160 dst
->vna_name
= bfd_h_get_32 (abfd
, src
->vna_name
);
161 dst
->vna_next
= bfd_h_get_32 (abfd
, src
->vna_next
);
164 /* Swap out a Vernaux structure. */
167 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
169 const Elf_Internal_Vernaux
*src
;
170 Elf_External_Vernaux
*dst
;
172 bfd_h_put_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
173 bfd_h_put_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
174 bfd_h_put_16 (abfd
, src
->vna_other
, dst
->vna_other
);
175 bfd_h_put_32 (abfd
, src
->vna_name
, dst
->vna_name
);
176 bfd_h_put_32 (abfd
, src
->vna_next
, dst
->vna_next
);
179 /* Swap in a Versym structure. */
182 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
184 const Elf_External_Versym
*src
;
185 Elf_Internal_Versym
*dst
;
187 dst
->vs_vers
= bfd_h_get_16 (abfd
, src
->vs_vers
);
190 /* Swap out a Versym structure. */
193 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
195 const Elf_Internal_Versym
*src
;
196 Elf_External_Versym
*dst
;
198 bfd_h_put_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
201 /* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. (Well, you would if this
203 were being used yet.) */
206 CONST
unsigned char *name
;
212 while ((ch
= *name
++) != '\0')
215 if ((g
= (h
& 0xf0000000)) != 0)
224 /* Read a specified number of bytes at a specified offset in an ELF
225 file, into a newly allocated buffer, and return a pointer to the
229 elf_read (abfd
, offset
, size
)
236 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
238 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
240 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
242 if (bfd_get_error () != bfd_error_system_call
)
243 bfd_set_error (bfd_error_file_truncated
);
250 bfd_elf_mkobject (abfd
)
253 /* this just does initialization */
254 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
255 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
256 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
257 if (elf_tdata (abfd
) == 0)
259 /* since everything is done at close time, do we need any
266 bfd_elf_get_str_section (abfd
, shindex
)
268 unsigned int shindex
;
270 Elf_Internal_Shdr
**i_shdrp
;
271 char *shstrtab
= NULL
;
273 unsigned int shstrtabsize
;
275 i_shdrp
= elf_elfsections (abfd
);
276 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
279 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
280 if (shstrtab
== NULL
)
282 /* No cached one, attempt to read, and cache what we read. */
283 offset
= i_shdrp
[shindex
]->sh_offset
;
284 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
285 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
286 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
292 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
294 unsigned int shindex
;
295 unsigned int strindex
;
297 Elf_Internal_Shdr
*hdr
;
302 hdr
= elf_elfsections (abfd
)[shindex
];
304 if (hdr
->contents
== NULL
305 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
308 if (strindex
>= hdr
->sh_size
)
310 (*_bfd_error_handler
)
311 (_("%s: invalid string offset %u >= %lu for section `%s'"),
312 bfd_get_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
313 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
314 && strindex
== hdr
->sh_name
)
316 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
320 return ((char *) hdr
->contents
) + strindex
;
323 /* Make a BFD section from an ELF section. We store a pointer to the
324 BFD section in the bfd_section field of the header. */
327 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
329 Elf_Internal_Shdr
*hdr
;
335 if (hdr
->bfd_section
!= NULL
)
337 BFD_ASSERT (strcmp (name
,
338 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
342 newsect
= bfd_make_section_anyway (abfd
, name
);
346 newsect
->filepos
= hdr
->sh_offset
;
348 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
349 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
350 || ! bfd_set_section_alignment (abfd
, newsect
,
351 bfd_log2 (hdr
->sh_addralign
)))
354 flags
= SEC_NO_FLAGS
;
355 if (hdr
->sh_type
!= SHT_NOBITS
)
356 flags
|= SEC_HAS_CONTENTS
;
357 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
360 if (hdr
->sh_type
!= SHT_NOBITS
)
363 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
364 flags
|= SEC_READONLY
;
365 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
367 else if ((flags
& SEC_LOAD
) != 0)
370 /* The debugging sections appear to be recognized only by name, not
372 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
373 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
374 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
375 flags
|= SEC_DEBUGGING
;
377 /* As a GNU extension, if the name begins with .gnu.linkonce, we
378 only link a single copy of the section. This is used to support
379 g++. g++ will emit each template expansion in its own section.
380 The symbols will be defined as weak, so that multiple definitions
381 are permitted. The GNU linker extension is to actually discard
382 all but one of the sections. */
383 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
384 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
386 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
389 if ((flags
& SEC_ALLOC
) != 0)
391 Elf_Internal_Phdr
*phdr
;
394 /* Look through the phdrs to see if we need to adjust the lma. */
395 phdr
= elf_tdata (abfd
)->phdr
;
396 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
398 if (phdr
->p_type
== PT_LOAD
399 && phdr
->p_paddr
!= 0
400 && phdr
->p_vaddr
!= phdr
->p_paddr
401 && phdr
->p_vaddr
<= hdr
->sh_addr
402 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
403 && ((flags
& SEC_LOAD
) == 0
404 || (phdr
->p_offset
<= (bfd_vma
) hdr
->sh_offset
405 && (phdr
->p_offset
+ phdr
->p_filesz
406 >= hdr
->sh_offset
+ hdr
->sh_size
))))
408 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
414 hdr
->bfd_section
= newsect
;
415 elf_section_data (newsect
)->this_hdr
= *hdr
;
425 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
428 Helper functions for GDB to locate the string tables.
429 Since BFD hides string tables from callers, GDB needs to use an
430 internal hook to find them. Sun's .stabstr, in particular,
431 isn't even pointed to by the .stab section, so ordinary
432 mechanisms wouldn't work to find it, even if we had some.
435 struct elf_internal_shdr
*
436 bfd_elf_find_section (abfd
, name
)
440 Elf_Internal_Shdr
**i_shdrp
;
445 i_shdrp
= elf_elfsections (abfd
);
448 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
449 if (shstrtab
!= NULL
)
451 max
= elf_elfheader (abfd
)->e_shnum
;
452 for (i
= 1; i
< max
; i
++)
453 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
460 const char *const bfd_elf_section_type_names
[] = {
461 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
462 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
463 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
466 /* ELF relocs are against symbols. If we are producing relocateable
467 output, and the reloc is against an external symbol, and nothing
468 has given us any additional addend, the resulting reloc will also
469 be against the same symbol. In such a case, we don't want to
470 change anything about the way the reloc is handled, since it will
471 all be done at final link time. Rather than put special case code
472 into bfd_perform_relocation, all the reloc types use this howto
473 function. It just short circuits the reloc if producing
474 relocateable output against an external symbol. */
477 bfd_reloc_status_type
478 bfd_elf_generic_reloc (abfd
,
486 arelent
*reloc_entry
;
489 asection
*input_section
;
491 char **error_message
;
493 if (output_bfd
!= (bfd
*) NULL
494 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
495 && (! reloc_entry
->howto
->partial_inplace
496 || reloc_entry
->addend
== 0))
498 reloc_entry
->address
+= input_section
->output_offset
;
502 return bfd_reloc_continue
;
505 /* Print out the program headers. */
508 _bfd_elf_print_private_bfd_data (abfd
, farg
)
512 FILE *f
= (FILE *) farg
;
513 Elf_Internal_Phdr
*p
;
515 bfd_byte
*dynbuf
= NULL
;
517 p
= elf_tdata (abfd
)->phdr
;
522 fprintf (f
, _("\nProgram Header:\n"));
523 c
= elf_elfheader (abfd
)->e_phnum
;
524 for (i
= 0; i
< c
; i
++, p
++)
531 case PT_NULL
: s
= "NULL"; break;
532 case PT_LOAD
: s
= "LOAD"; break;
533 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
534 case PT_INTERP
: s
= "INTERP"; break;
535 case PT_NOTE
: s
= "NOTE"; break;
536 case PT_SHLIB
: s
= "SHLIB"; break;
537 case PT_PHDR
: s
= "PHDR"; break;
538 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
540 fprintf (f
, "%8s off 0x", s
);
541 fprintf_vma (f
, p
->p_offset
);
542 fprintf (f
, " vaddr 0x");
543 fprintf_vma (f
, p
->p_vaddr
);
544 fprintf (f
, " paddr 0x");
545 fprintf_vma (f
, p
->p_paddr
);
546 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
547 fprintf (f
, " filesz 0x");
548 fprintf_vma (f
, p
->p_filesz
);
549 fprintf (f
, " memsz 0x");
550 fprintf_vma (f
, p
->p_memsz
);
551 fprintf (f
, " flags %c%c%c",
552 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
553 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
554 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
555 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
556 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
561 s
= bfd_get_section_by_name (abfd
, ".dynamic");
566 bfd_byte
*extdyn
, *extdynend
;
568 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
570 fprintf (f
, _("\nDynamic Section:\n"));
572 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
575 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
579 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
582 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
584 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
585 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
588 extdynend
= extdyn
+ s
->_raw_size
;
589 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
591 Elf_Internal_Dyn dyn
;
596 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
598 if (dyn
.d_tag
== DT_NULL
)
605 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
609 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
610 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
611 case DT_PLTGOT
: name
= "PLTGOT"; break;
612 case DT_HASH
: name
= "HASH"; break;
613 case DT_STRTAB
: name
= "STRTAB"; break;
614 case DT_SYMTAB
: name
= "SYMTAB"; break;
615 case DT_RELA
: name
= "RELA"; break;
616 case DT_RELASZ
: name
= "RELASZ"; break;
617 case DT_RELAENT
: name
= "RELAENT"; break;
618 case DT_STRSZ
: name
= "STRSZ"; break;
619 case DT_SYMENT
: name
= "SYMENT"; break;
620 case DT_INIT
: name
= "INIT"; break;
621 case DT_FINI
: name
= "FINI"; break;
622 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
623 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
624 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
625 case DT_REL
: name
= "REL"; break;
626 case DT_RELSZ
: name
= "RELSZ"; break;
627 case DT_RELENT
: name
= "RELENT"; break;
628 case DT_PLTREL
: name
= "PLTREL"; break;
629 case DT_DEBUG
: name
= "DEBUG"; break;
630 case DT_TEXTREL
: name
= "TEXTREL"; break;
631 case DT_JMPREL
: name
= "JMPREL"; break;
632 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
633 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
634 case DT_VERSYM
: name
= "VERSYM"; break;
635 case DT_VERDEF
: name
= "VERDEF"; break;
636 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
637 case DT_VERNEED
: name
= "VERNEED"; break;
638 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
641 fprintf (f
, " %-11s ", name
);
643 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
648 string
= bfd_elf_string_from_elf_section (abfd
, link
,
652 fprintf (f
, "%s", string
);
661 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
662 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
664 if (! _bfd_elf_slurp_version_tables (abfd
))
668 if (elf_dynverdef (abfd
) != 0)
670 Elf_Internal_Verdef
*t
;
672 fprintf (f
, _("\nVersion definitions:\n"));
673 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
675 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
676 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
677 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
679 Elf_Internal_Verdaux
*a
;
682 for (a
= t
->vd_auxptr
->vda_nextptr
;
685 fprintf (f
, "%s ", a
->vda_nodename
);
691 if (elf_dynverref (abfd
) != 0)
693 Elf_Internal_Verneed
*t
;
695 fprintf (f
, _("\nVersion References:\n"));
696 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
698 Elf_Internal_Vernaux
*a
;
700 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
701 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
702 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
703 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
715 /* Display ELF-specific fields of a symbol. */
718 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
722 bfd_print_symbol_type how
;
724 FILE *file
= (FILE *) filep
;
727 case bfd_print_symbol_name
:
728 fprintf (file
, "%s", symbol
->name
);
730 case bfd_print_symbol_more
:
731 fprintf (file
, "elf ");
732 fprintf_vma (file
, symbol
->value
);
733 fprintf (file
, " %lx", (long) symbol
->flags
);
735 case bfd_print_symbol_all
:
737 CONST
char *section_name
;
738 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
739 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
740 fprintf (file
, " %s\t", section_name
);
741 /* Print the "other" value for a symbol. For common symbols,
742 we've already printed the size; now print the alignment.
743 For other symbols, we have no specified alignment, and
744 we've printed the address; now print the size. */
746 (bfd_is_com_section (symbol
->section
)
747 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
748 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
750 /* If we have version information, print it. */
751 if (elf_tdata (abfd
)->dynversym_section
!= 0
752 && (elf_tdata (abfd
)->dynverdef_section
!= 0
753 || elf_tdata (abfd
)->dynverref_section
!= 0))
756 const char *version_string
;
758 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
762 else if (vernum
== 1)
763 version_string
= "Base";
764 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
766 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
769 Elf_Internal_Verneed
*t
;
772 for (t
= elf_tdata (abfd
)->verref
;
776 Elf_Internal_Vernaux
*a
;
778 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
780 if (a
->vna_other
== vernum
)
782 version_string
= a
->vna_nodename
;
789 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
790 fprintf (file
, " %-11s", version_string
);
795 fprintf (file
, " (%s)", version_string
);
796 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
801 /* If the st_other field is not zero, print it. */
802 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
803 fprintf (file
, " 0x%02x",
805 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
807 fprintf (file
, " %s", symbol
->name
);
813 /* Create an entry in an ELF linker hash table. */
815 struct bfd_hash_entry
*
816 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
817 struct bfd_hash_entry
*entry
;
818 struct bfd_hash_table
*table
;
821 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
823 /* Allocate the structure if it has not already been allocated by a
825 if (ret
== (struct elf_link_hash_entry
*) NULL
)
826 ret
= ((struct elf_link_hash_entry
*)
827 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
828 if (ret
== (struct elf_link_hash_entry
*) NULL
)
829 return (struct bfd_hash_entry
*) ret
;
831 /* Call the allocation method of the superclass. */
832 ret
= ((struct elf_link_hash_entry
*)
833 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
835 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
837 /* Set local fields. */
841 ret
->dynstr_index
= 0;
843 ret
->got
.offset
= (bfd_vma
) -1;
844 ret
->plt
.offset
= (bfd_vma
) -1;
845 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
846 ret
->verinfo
.verdef
= NULL
;
847 ret
->vtable_entries_used
= NULL
;
848 ret
->vtable_parent
= NULL
;
849 ret
->type
= STT_NOTYPE
;
851 /* Assume that we have been called by a non-ELF symbol reader.
852 This flag is then reset by the code which reads an ELF input
853 file. This ensures that a symbol created by a non-ELF symbol
854 reader will have the flag set correctly. */
855 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
858 return (struct bfd_hash_entry
*) ret
;
861 /* Initialize an ELF linker hash table. */
864 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
865 struct elf_link_hash_table
*table
;
867 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
868 struct bfd_hash_table
*,
871 table
->dynamic_sections_created
= false;
872 table
->dynobj
= NULL
;
873 /* The first dynamic symbol is a dummy. */
874 table
->dynsymcount
= 1;
875 table
->dynstr
= NULL
;
876 table
->bucketcount
= 0;
877 table
->needed
= NULL
;
879 table
->stab_info
= NULL
;
880 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
883 /* Create an ELF linker hash table. */
885 struct bfd_link_hash_table
*
886 _bfd_elf_link_hash_table_create (abfd
)
889 struct elf_link_hash_table
*ret
;
891 ret
= ((struct elf_link_hash_table
*)
892 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
893 if (ret
== (struct elf_link_hash_table
*) NULL
)
896 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
898 bfd_release (abfd
, ret
);
905 /* This is a hook for the ELF emulation code in the generic linker to
906 tell the backend linker what file name to use for the DT_NEEDED
907 entry for a dynamic object. The generic linker passes name as an
908 empty string to indicate that no DT_NEEDED entry should be made. */
911 bfd_elf_set_dt_needed_name (abfd
, name
)
915 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
916 && bfd_get_format (abfd
) == bfd_object
)
917 elf_dt_name (abfd
) = name
;
920 /* Get the list of DT_NEEDED entries for a link. This is a hook for
921 the linker ELF emulation code. */
923 struct bfd_link_needed_list
*
924 bfd_elf_get_needed_list (abfd
, info
)
926 struct bfd_link_info
*info
;
928 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
930 return elf_hash_table (info
)->needed
;
933 /* Get the name actually used for a dynamic object for a link. This
934 is the SONAME entry if there is one. Otherwise, it is the string
935 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
938 bfd_elf_get_dt_soname (abfd
)
941 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
942 && bfd_get_format (abfd
) == bfd_object
)
943 return elf_dt_name (abfd
);
947 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
948 the ELF linker emulation code. */
951 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
953 struct bfd_link_needed_list
**pneeded
;
956 bfd_byte
*dynbuf
= NULL
;
959 bfd_byte
*extdyn
, *extdynend
;
961 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
965 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
966 || bfd_get_format (abfd
) != bfd_object
)
969 s
= bfd_get_section_by_name (abfd
, ".dynamic");
970 if (s
== NULL
|| s
->_raw_size
== 0)
973 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
977 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
981 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
985 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
987 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
988 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
991 extdynend
= extdyn
+ s
->_raw_size
;
992 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
994 Elf_Internal_Dyn dyn
;
996 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
998 if (dyn
.d_tag
== DT_NULL
)
1001 if (dyn
.d_tag
== DT_NEEDED
)
1004 struct bfd_link_needed_list
*l
;
1006 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1011 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1032 /* Allocate an ELF string table--force the first byte to be zero. */
1034 struct bfd_strtab_hash
*
1035 _bfd_elf_stringtab_init ()
1037 struct bfd_strtab_hash
*ret
;
1039 ret
= _bfd_stringtab_init ();
1044 loc
= _bfd_stringtab_add (ret
, "", true, false);
1045 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1046 if (loc
== (bfd_size_type
) -1)
1048 _bfd_stringtab_free (ret
);
1055 /* ELF .o/exec file reading */
1057 /* Create a new bfd section from an ELF section header. */
1060 bfd_section_from_shdr (abfd
, shindex
)
1062 unsigned int shindex
;
1064 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1065 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1066 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1069 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1071 switch (hdr
->sh_type
)
1074 /* Inactive section. Throw it away. */
1077 case SHT_PROGBITS
: /* Normal section with contents. */
1078 case SHT_DYNAMIC
: /* Dynamic linking information. */
1079 case SHT_NOBITS
: /* .bss section. */
1080 case SHT_HASH
: /* .hash section. */
1081 case SHT_NOTE
: /* .note section. */
1082 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1084 case SHT_SYMTAB
: /* A symbol table */
1085 if (elf_onesymtab (abfd
) == shindex
)
1088 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1089 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1090 elf_onesymtab (abfd
) = shindex
;
1091 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1092 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1093 abfd
->flags
|= HAS_SYMS
;
1095 /* Sometimes a shared object will map in the symbol table. If
1096 SHF_ALLOC is set, and this is a shared object, then we also
1097 treat this section as a BFD section. We can not base the
1098 decision purely on SHF_ALLOC, because that flag is sometimes
1099 set in a relocateable object file, which would confuse the
1101 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1102 && (abfd
->flags
& DYNAMIC
) != 0
1103 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1108 case SHT_DYNSYM
: /* A dynamic symbol table */
1109 if (elf_dynsymtab (abfd
) == shindex
)
1112 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1113 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1114 elf_dynsymtab (abfd
) = shindex
;
1115 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1116 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1117 abfd
->flags
|= HAS_SYMS
;
1119 /* Besides being a symbol table, we also treat this as a regular
1120 section, so that objcopy can handle it. */
1121 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1123 case SHT_STRTAB
: /* A string table */
1124 if (hdr
->bfd_section
!= NULL
)
1126 if (ehdr
->e_shstrndx
== shindex
)
1128 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1129 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1135 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1137 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1138 if (hdr2
->sh_link
== shindex
)
1140 if (! bfd_section_from_shdr (abfd
, i
))
1142 if (elf_onesymtab (abfd
) == i
)
1144 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1145 elf_elfsections (abfd
)[shindex
] =
1146 &elf_tdata (abfd
)->strtab_hdr
;
1149 if (elf_dynsymtab (abfd
) == i
)
1151 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1152 elf_elfsections (abfd
)[shindex
] = hdr
=
1153 &elf_tdata (abfd
)->dynstrtab_hdr
;
1154 /* We also treat this as a regular section, so
1155 that objcopy can handle it. */
1158 #if 0 /* Not handling other string tables specially right now. */
1159 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1160 /* We have a strtab for some random other section. */
1161 newsect
= (asection
*) hdr2
->bfd_section
;
1164 hdr
->bfd_section
= newsect
;
1165 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1167 elf_elfsections (abfd
)[shindex
] = hdr2
;
1173 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1177 /* *These* do a lot of work -- but build no sections! */
1179 asection
*target_sect
;
1180 Elf_Internal_Shdr
*hdr2
;
1182 /* For some incomprehensible reason Oracle distributes
1183 libraries for Solaris in which some of the objects have
1184 bogus sh_link fields. It would be nice if we could just
1185 reject them, but, unfortunately, some people need to use
1186 them. We scan through the section headers; if we find only
1187 one suitable symbol table, we clobber the sh_link to point
1188 to it. I hope this doesn't break anything. */
1189 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1190 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1196 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1198 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1199 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1210 hdr
->sh_link
= found
;
1213 /* Get the symbol table. */
1214 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1215 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1218 /* If this reloc section does not use the main symbol table we
1219 don't treat it as a reloc section. BFD can't adequately
1220 represent such a section, so at least for now, we don't
1221 try. We just present it as a normal section. */
1222 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1223 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1225 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1227 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1228 if (target_sect
== NULL
)
1231 if ((target_sect
->flags
& SEC_RELOC
) == 0
1232 || target_sect
->reloc_count
== 0)
1233 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1236 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1237 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1238 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1241 elf_elfsections (abfd
)[shindex
] = hdr2
;
1242 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1243 target_sect
->flags
|= SEC_RELOC
;
1244 target_sect
->relocation
= NULL
;
1245 target_sect
->rel_filepos
= hdr
->sh_offset
;
1246 abfd
->flags
|= HAS_RELOC
;
1251 case SHT_GNU_verdef
:
1252 elf_dynverdef (abfd
) = shindex
;
1253 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1254 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1257 case SHT_GNU_versym
:
1258 elf_dynversym (abfd
) = shindex
;
1259 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1260 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1263 case SHT_GNU_verneed
:
1264 elf_dynverref (abfd
) = shindex
;
1265 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1266 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1273 /* Check for any processor-specific section types. */
1275 if (bed
->elf_backend_section_from_shdr
)
1276 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1284 /* Given an ELF section number, retrieve the corresponding BFD
1288 bfd_section_from_elf_index (abfd
, index
)
1292 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1293 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1295 return elf_elfsections (abfd
)[index
]->bfd_section
;
1299 _bfd_elf_new_section_hook (abfd
, sec
)
1303 struct bfd_elf_section_data
*sdata
;
1305 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
1308 sec
->used_by_bfd
= (PTR
) sdata
;
1309 memset (sdata
, 0, sizeof (*sdata
));
1313 /* Create a new bfd section from an ELF program header.
1315 Since program segments have no names, we generate a synthetic name
1316 of the form segment<NUM>, where NUM is generally the index in the
1317 program header table. For segments that are split (see below) we
1318 generate the names segment<NUM>a and segment<NUM>b.
1320 Note that some program segments may have a file size that is different than
1321 (less than) the memory size. All this means is that at execution the
1322 system must allocate the amount of memory specified by the memory size,
1323 but only initialize it with the first "file size" bytes read from the
1324 file. This would occur for example, with program segments consisting
1325 of combined data+bss.
1327 To handle the above situation, this routine generates TWO bfd sections
1328 for the single program segment. The first has the length specified by
1329 the file size of the segment, and the second has the length specified
1330 by the difference between the two sizes. In effect, the segment is split
1331 into it's initialized and uninitialized parts.
1336 bfd_section_from_phdr (abfd
, hdr
, index
)
1338 Elf_Internal_Phdr
*hdr
;
1346 split
= ((hdr
->p_memsz
> 0) &&
1347 (hdr
->p_filesz
> 0) &&
1348 (hdr
->p_memsz
> hdr
->p_filesz
));
1349 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
1350 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1353 strcpy (name
, namebuf
);
1354 newsect
= bfd_make_section (abfd
, name
);
1355 if (newsect
== NULL
)
1357 newsect
->vma
= hdr
->p_vaddr
;
1358 newsect
->lma
= hdr
->p_paddr
;
1359 newsect
->_raw_size
= hdr
->p_filesz
;
1360 newsect
->filepos
= hdr
->p_offset
;
1361 newsect
->flags
|= SEC_HAS_CONTENTS
;
1362 if (hdr
->p_type
== PT_LOAD
)
1364 newsect
->flags
|= SEC_ALLOC
;
1365 newsect
->flags
|= SEC_LOAD
;
1366 if (hdr
->p_flags
& PF_X
)
1368 /* FIXME: all we known is that it has execute PERMISSION,
1370 newsect
->flags
|= SEC_CODE
;
1373 if (!(hdr
->p_flags
& PF_W
))
1375 newsect
->flags
|= SEC_READONLY
;
1380 sprintf (namebuf
, "segment%db", index
);
1381 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1384 strcpy (name
, namebuf
);
1385 newsect
= bfd_make_section (abfd
, name
);
1386 if (newsect
== NULL
)
1388 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1389 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1390 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1391 if (hdr
->p_type
== PT_LOAD
)
1393 newsect
->flags
|= SEC_ALLOC
;
1394 if (hdr
->p_flags
& PF_X
)
1395 newsect
->flags
|= SEC_CODE
;
1397 if (!(hdr
->p_flags
& PF_W
))
1398 newsect
->flags
|= SEC_READONLY
;
1404 /* Set up an ELF internal section header for a section. */
1408 elf_fake_sections (abfd
, asect
, failedptrarg
)
1413 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1414 boolean
*failedptr
= (boolean
*) failedptrarg
;
1415 Elf_Internal_Shdr
*this_hdr
;
1419 /* We already failed; just get out of the bfd_map_over_sections
1424 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1426 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1429 if (this_hdr
->sh_name
== (unsigned long) -1)
1435 this_hdr
->sh_flags
= 0;
1437 if ((asect
->flags
& SEC_ALLOC
) != 0
1438 || asect
->user_set_vma
)
1439 this_hdr
->sh_addr
= asect
->vma
;
1441 this_hdr
->sh_addr
= 0;
1443 this_hdr
->sh_offset
= 0;
1444 this_hdr
->sh_size
= asect
->_raw_size
;
1445 this_hdr
->sh_link
= 0;
1446 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1447 /* The sh_entsize and sh_info fields may have been set already by
1448 copy_private_section_data. */
1450 this_hdr
->bfd_section
= asect
;
1451 this_hdr
->contents
= NULL
;
1453 /* FIXME: This should not be based on section names. */
1454 if (strcmp (asect
->name
, ".dynstr") == 0)
1455 this_hdr
->sh_type
= SHT_STRTAB
;
1456 else if (strcmp (asect
->name
, ".hash") == 0)
1458 this_hdr
->sh_type
= SHT_HASH
;
1459 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1461 else if (strcmp (asect
->name
, ".dynsym") == 0)
1463 this_hdr
->sh_type
= SHT_DYNSYM
;
1464 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1466 else if (strcmp (asect
->name
, ".dynamic") == 0)
1468 this_hdr
->sh_type
= SHT_DYNAMIC
;
1469 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1471 else if (strncmp (asect
->name
, ".rela", 5) == 0
1472 && get_elf_backend_data (abfd
)->use_rela_p
)
1474 this_hdr
->sh_type
= SHT_RELA
;
1475 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1477 else if (strncmp (asect
->name
, ".rel", 4) == 0
1478 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1480 this_hdr
->sh_type
= SHT_REL
;
1481 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1483 else if (strncmp (asect
->name
, ".note", 5) == 0)
1484 this_hdr
->sh_type
= SHT_NOTE
;
1485 else if (strncmp (asect
->name
, ".stab", 5) == 0
1486 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1487 this_hdr
->sh_type
= SHT_STRTAB
;
1488 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1490 this_hdr
->sh_type
= SHT_GNU_versym
;
1491 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1493 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1495 this_hdr
->sh_type
= SHT_GNU_verdef
;
1496 this_hdr
->sh_entsize
= 0;
1497 /* objcopy or strip will copy over sh_info, but may not set
1498 cverdefs. The linker will set cverdefs, but sh_info will be
1500 if (this_hdr
->sh_info
== 0)
1501 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1503 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1504 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1506 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1508 this_hdr
->sh_type
= SHT_GNU_verneed
;
1509 this_hdr
->sh_entsize
= 0;
1510 /* objcopy or strip will copy over sh_info, but may not set
1511 cverrefs. The linker will set cverrefs, but sh_info will be
1513 if (this_hdr
->sh_info
== 0)
1514 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1516 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1517 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1519 else if ((asect
->flags
& SEC_ALLOC
) != 0
1520 && (asect
->flags
& SEC_LOAD
) != 0)
1521 this_hdr
->sh_type
= SHT_PROGBITS
;
1522 else if ((asect
->flags
& SEC_ALLOC
) != 0
1523 && ((asect
->flags
& SEC_LOAD
) == 0))
1524 this_hdr
->sh_type
= SHT_NOBITS
;
1528 this_hdr
->sh_type
= SHT_PROGBITS
;
1531 if ((asect
->flags
& SEC_ALLOC
) != 0)
1532 this_hdr
->sh_flags
|= SHF_ALLOC
;
1533 if ((asect
->flags
& SEC_READONLY
) == 0)
1534 this_hdr
->sh_flags
|= SHF_WRITE
;
1535 if ((asect
->flags
& SEC_CODE
) != 0)
1536 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1538 /* Check for processor-specific section types. */
1540 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1542 if (bed
->elf_backend_fake_sections
)
1543 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1546 /* If the section has relocs, set up a section header for the
1547 SHT_REL[A] section. */
1548 if ((asect
->flags
& SEC_RELOC
) != 0)
1550 Elf_Internal_Shdr
*rela_hdr
;
1551 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1554 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1555 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1561 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1563 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1565 if (rela_hdr
->sh_name
== (unsigned int) -1)
1570 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1571 rela_hdr
->sh_entsize
= (use_rela_p
1572 ? bed
->s
->sizeof_rela
1573 : bed
->s
->sizeof_rel
);
1574 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1575 rela_hdr
->sh_flags
= 0;
1576 rela_hdr
->sh_addr
= 0;
1577 rela_hdr
->sh_size
= 0;
1578 rela_hdr
->sh_offset
= 0;
1582 /* Assign all ELF section numbers. The dummy first section is handled here
1583 too. The link/info pointers for the standard section types are filled
1584 in here too, while we're at it. */
1587 assign_section_numbers (abfd
)
1590 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1592 unsigned int section_number
;
1593 Elf_Internal_Shdr
**i_shdrp
;
1594 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1598 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1600 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1602 d
->this_idx
= section_number
++;
1603 if ((sec
->flags
& SEC_RELOC
) == 0)
1606 d
->rel_idx
= section_number
++;
1609 t
->shstrtab_section
= section_number
++;
1610 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1611 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1613 if (abfd
->symcount
> 0)
1615 t
->symtab_section
= section_number
++;
1616 t
->strtab_section
= section_number
++;
1619 elf_elfheader (abfd
)->e_shnum
= section_number
;
1621 /* Set up the list of section header pointers, in agreement with the
1623 i_shdrp
= ((Elf_Internal_Shdr
**)
1624 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1625 if (i_shdrp
== NULL
)
1628 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1629 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1630 if (i_shdrp
[0] == NULL
)
1632 bfd_release (abfd
, i_shdrp
);
1635 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1637 elf_elfsections (abfd
) = i_shdrp
;
1639 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1640 if (abfd
->symcount
> 0)
1642 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1643 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1644 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1646 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1648 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1652 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1653 if (d
->rel_idx
!= 0)
1654 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1656 /* Fill in the sh_link and sh_info fields while we're at it. */
1658 /* sh_link of a reloc section is the section index of the symbol
1659 table. sh_info is the section index of the section to which
1660 the relocation entries apply. */
1661 if (d
->rel_idx
!= 0)
1663 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1664 d
->rel_hdr
.sh_info
= d
->this_idx
;
1667 switch (d
->this_hdr
.sh_type
)
1671 /* A reloc section which we are treating as a normal BFD
1672 section. sh_link is the section index of the symbol
1673 table. sh_info is the section index of the section to
1674 which the relocation entries apply. We assume that an
1675 allocated reloc section uses the dynamic symbol table.
1676 FIXME: How can we be sure? */
1677 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1679 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1681 /* We look up the section the relocs apply to by name. */
1683 if (d
->this_hdr
.sh_type
== SHT_REL
)
1687 s
= bfd_get_section_by_name (abfd
, name
);
1689 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1693 /* We assume that a section named .stab*str is a stabs
1694 string section. We look for a section with the same name
1695 but without the trailing ``str'', and set its sh_link
1696 field to point to this section. */
1697 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1698 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1703 len
= strlen (sec
->name
);
1704 alc
= (char *) bfd_malloc (len
- 2);
1707 strncpy (alc
, sec
->name
, len
- 3);
1708 alc
[len
- 3] = '\0';
1709 s
= bfd_get_section_by_name (abfd
, alc
);
1713 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1715 /* This is a .stab section. */
1716 elf_section_data (s
)->this_hdr
.sh_entsize
=
1717 4 + 2 * (bed
->s
->arch_size
/ 8);
1724 case SHT_GNU_verneed
:
1725 case SHT_GNU_verdef
:
1726 /* sh_link is the section header index of the string table
1727 used for the dynamic entries, or the symbol table, or the
1729 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1731 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1735 case SHT_GNU_versym
:
1736 /* sh_link is the section header index of the symbol table
1737 this hash table or version table is for. */
1738 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1740 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1748 /* Map symbol from it's internal number to the external number, moving
1749 all local symbols to be at the head of the list. */
1752 sym_is_global (abfd
, sym
)
1756 /* If the backend has a special mapping, use it. */
1757 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1758 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1761 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1762 || bfd_is_und_section (bfd_get_section (sym
))
1763 || bfd_is_com_section (bfd_get_section (sym
)));
1767 elf_map_symbols (abfd
)
1770 int symcount
= bfd_get_symcount (abfd
);
1771 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1772 asymbol
**sect_syms
;
1774 int num_globals
= 0;
1775 int num_locals2
= 0;
1776 int num_globals2
= 0;
1778 int num_sections
= 0;
1784 fprintf (stderr
, "elf_map_symbols\n");
1788 /* Add a section symbol for each BFD section. FIXME: Is this really
1790 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1792 if (max_index
< asect
->index
)
1793 max_index
= asect
->index
;
1797 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1798 if (sect_syms
== NULL
)
1800 elf_section_syms (abfd
) = sect_syms
;
1802 for (idx
= 0; idx
< symcount
; idx
++)
1804 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1805 && syms
[idx
]->value
== 0)
1809 sec
= syms
[idx
]->section
;
1810 if (sec
->owner
!= NULL
)
1812 if (sec
->owner
!= abfd
)
1814 if (sec
->output_offset
!= 0)
1816 sec
= sec
->output_section
;
1817 BFD_ASSERT (sec
->owner
== abfd
);
1819 sect_syms
[sec
->index
] = syms
[idx
];
1824 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1828 if (sect_syms
[asect
->index
] != NULL
)
1831 sym
= bfd_make_empty_symbol (abfd
);
1834 sym
->the_bfd
= abfd
;
1835 sym
->name
= asect
->name
;
1837 /* Set the flags to 0 to indicate that this one was newly added. */
1839 sym
->section
= asect
;
1840 sect_syms
[asect
->index
] = sym
;
1844 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1845 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1849 /* Classify all of the symbols. */
1850 for (idx
= 0; idx
< symcount
; idx
++)
1852 if (!sym_is_global (abfd
, syms
[idx
]))
1857 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1859 if (sect_syms
[asect
->index
] != NULL
1860 && sect_syms
[asect
->index
]->flags
== 0)
1862 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1863 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1867 sect_syms
[asect
->index
]->flags
= 0;
1871 /* Now sort the symbols so the local symbols are first. */
1872 new_syms
= ((asymbol
**)
1874 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1875 if (new_syms
== NULL
)
1878 for (idx
= 0; idx
< symcount
; idx
++)
1880 asymbol
*sym
= syms
[idx
];
1883 if (!sym_is_global (abfd
, sym
))
1886 i
= num_locals
+ num_globals2
++;
1888 sym
->udata
.i
= i
+ 1;
1890 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1892 if (sect_syms
[asect
->index
] != NULL
1893 && sect_syms
[asect
->index
]->flags
== 0)
1895 asymbol
*sym
= sect_syms
[asect
->index
];
1898 sym
->flags
= BSF_SECTION_SYM
;
1899 if (!sym_is_global (abfd
, sym
))
1902 i
= num_locals
+ num_globals2
++;
1904 sym
->udata
.i
= i
+ 1;
1908 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1910 elf_num_locals (abfd
) = num_locals
;
1911 elf_num_globals (abfd
) = num_globals
;
1915 /* Align to the maximum file alignment that could be required for any
1916 ELF data structure. */
1918 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1919 static INLINE file_ptr
1920 align_file_position (off
, align
)
1924 return (off
+ align
- 1) & ~(align
- 1);
1927 /* Assign a file position to a section, optionally aligning to the
1928 required section alignment. */
1931 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1932 Elf_Internal_Shdr
*i_shdrp
;
1940 al
= i_shdrp
->sh_addralign
;
1942 offset
= BFD_ALIGN (offset
, al
);
1944 i_shdrp
->sh_offset
= offset
;
1945 if (i_shdrp
->bfd_section
!= NULL
)
1946 i_shdrp
->bfd_section
->filepos
= offset
;
1947 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1948 offset
+= i_shdrp
->sh_size
;
1952 /* Compute the file positions we are going to put the sections at, and
1953 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1954 is not NULL, this is being called by the ELF backend linker. */
1957 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1959 struct bfd_link_info
*link_info
;
1961 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1963 struct bfd_strtab_hash
*strtab
;
1964 Elf_Internal_Shdr
*shstrtab_hdr
;
1966 if (abfd
->output_has_begun
)
1969 /* Do any elf backend specific processing first. */
1970 if (bed
->elf_backend_begin_write_processing
)
1971 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1973 if (! prep_headers (abfd
))
1977 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1981 if (!assign_section_numbers (abfd
))
1984 /* The backend linker builds symbol table information itself. */
1985 if (link_info
== NULL
&& abfd
->symcount
> 0)
1987 /* Non-zero if doing a relocatable link. */
1988 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
1990 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
1994 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1995 /* sh_name was set in prep_headers. */
1996 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1997 shstrtab_hdr
->sh_flags
= 0;
1998 shstrtab_hdr
->sh_addr
= 0;
1999 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
2000 shstrtab_hdr
->sh_entsize
= 0;
2001 shstrtab_hdr
->sh_link
= 0;
2002 shstrtab_hdr
->sh_info
= 0;
2003 /* sh_offset is set in assign_file_positions_except_relocs. */
2004 shstrtab_hdr
->sh_addralign
= 1;
2006 if (!assign_file_positions_except_relocs (abfd
))
2009 if (link_info
== NULL
&& abfd
->symcount
> 0)
2012 Elf_Internal_Shdr
*hdr
;
2014 off
= elf_tdata (abfd
)->next_file_pos
;
2016 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2017 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2019 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2020 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2022 elf_tdata (abfd
)->next_file_pos
= off
;
2024 /* Now that we know where the .strtab section goes, write it
2026 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2027 || ! _bfd_stringtab_emit (abfd
, strtab
))
2029 _bfd_stringtab_free (strtab
);
2032 abfd
->output_has_begun
= true;
2037 /* Create a mapping from a set of sections to a program segment. */
2039 static INLINE
struct elf_segment_map
*
2040 make_mapping (abfd
, sections
, from
, to
, phdr
)
2042 asection
**sections
;
2047 struct elf_segment_map
*m
;
2051 m
= ((struct elf_segment_map
*)
2053 (sizeof (struct elf_segment_map
)
2054 + (to
- from
- 1) * sizeof (asection
*))));
2058 m
->p_type
= PT_LOAD
;
2059 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2060 m
->sections
[i
- from
] = *hdrpp
;
2061 m
->count
= to
- from
;
2063 if (from
== 0 && phdr
)
2065 /* Include the headers in the first PT_LOAD segment. */
2066 m
->includes_filehdr
= 1;
2067 m
->includes_phdrs
= 1;
2073 /* Set up a mapping from BFD sections to program segments. */
2076 map_sections_to_segments (abfd
)
2079 asection
**sections
= NULL
;
2083 struct elf_segment_map
*mfirst
;
2084 struct elf_segment_map
**pm
;
2085 struct elf_segment_map
*m
;
2087 unsigned int phdr_index
;
2088 bfd_vma maxpagesize
;
2090 boolean phdr_in_section
= true;
2094 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2097 if (bfd_count_sections (abfd
) == 0)
2100 /* Select the allocated sections, and sort them. */
2102 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2103 * sizeof (asection
*));
2104 if (sections
== NULL
)
2108 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2110 if ((s
->flags
& SEC_ALLOC
) != 0)
2116 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2119 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2121 /* Build the mapping. */
2126 /* If we have a .interp section, then create a PT_PHDR segment for
2127 the program headers and a PT_INTERP segment for the .interp
2129 s
= bfd_get_section_by_name (abfd
, ".interp");
2130 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2132 m
= ((struct elf_segment_map
*)
2133 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2137 m
->p_type
= PT_PHDR
;
2138 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2139 m
->p_flags
= PF_R
| PF_X
;
2140 m
->p_flags_valid
= 1;
2141 m
->includes_phdrs
= 1;
2146 m
= ((struct elf_segment_map
*)
2147 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2151 m
->p_type
= PT_INTERP
;
2159 /* Look through the sections. We put sections in the same program
2160 segment when the start of the second section can be placed within
2161 a few bytes of the end of the first section. */
2164 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2166 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2168 && (dynsec
->flags
& SEC_LOAD
) == 0)
2171 /* Deal with -Ttext or something similar such that the first section
2172 is not adjacent to the program headers. This is an
2173 approximation, since at this point we don't know exactly how many
2174 program headers we will need. */
2177 bfd_size_type phdr_size
;
2179 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2181 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2182 if ((abfd
->flags
& D_PAGED
) == 0
2183 || sections
[0]->lma
< phdr_size
2184 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2185 phdr_in_section
= false;
2188 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2191 boolean new_segment
;
2195 /* See if this section and the last one will fit in the same
2198 if (last_hdr
== NULL
)
2200 /* If we don't have a segment yet, then we don't need a new
2201 one (we build the last one after this loop). */
2202 new_segment
= false;
2204 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2206 /* If this section has a different relation between the
2207 virtual address and the load address, then we need a new
2211 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2212 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2214 /* If putting this section in this segment would force us to
2215 skip a page in the segment, then we need a new segment. */
2218 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2219 && (hdr
->flags
& SEC_LOAD
) != 0)
2221 /* We don't want to put a loadable section after a
2222 nonloadable section in the same segment. */
2225 else if ((abfd
->flags
& D_PAGED
) == 0)
2227 /* If the file is not demand paged, which means that we
2228 don't require the sections to be correctly aligned in the
2229 file, then there is no other reason for a new segment. */
2230 new_segment
= false;
2233 && (hdr
->flags
& SEC_READONLY
) == 0
2234 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2237 /* We don't want to put a writable section in a read only
2238 segment, unless they are on the same page in memory
2239 anyhow. We already know that the last section does not
2240 bring us past the current section on the page, so the
2241 only case in which the new section is not on the same
2242 page as the previous section is when the previous section
2243 ends precisely on a page boundary. */
2248 /* Otherwise, we can use the same segment. */
2249 new_segment
= false;
2254 if ((hdr
->flags
& SEC_READONLY
) == 0)
2260 /* We need a new program segment. We must create a new program
2261 header holding all the sections from phdr_index until hdr. */
2263 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2270 if ((hdr
->flags
& SEC_READONLY
) == 0)
2277 phdr_in_section
= false;
2280 /* Create a final PT_LOAD program segment. */
2281 if (last_hdr
!= NULL
)
2283 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2291 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2294 m
= ((struct elf_segment_map
*)
2295 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2299 m
->p_type
= PT_DYNAMIC
;
2301 m
->sections
[0] = dynsec
;
2307 /* For each loadable .note section, add a PT_NOTE segment. We don't
2308 use bfd_get_section_by_name, because if we link together
2309 nonloadable .note sections and loadable .note sections, we will
2310 generate two .note sections in the output file. FIXME: Using
2311 names for section types is bogus anyhow. */
2312 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2314 if ((s
->flags
& SEC_LOAD
) != 0
2315 && strncmp (s
->name
, ".note", 5) == 0)
2317 m
= ((struct elf_segment_map
*)
2318 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2322 m
->p_type
= PT_NOTE
;
2334 elf_tdata (abfd
)->segment_map
= mfirst
;
2338 if (sections
!= NULL
)
2343 /* Sort sections by VMA. */
2346 elf_sort_sections (arg1
, arg2
)
2350 const asection
*sec1
= *(const asection
**) arg1
;
2351 const asection
*sec2
= *(const asection
**) arg2
;
2353 /* Sort by LMA first, since this is the address used to
2354 place the section into a segment. */
2355 if (sec1
->lma
< sec2
->lma
)
2357 else if (sec1
->lma
> sec2
->lma
)
2360 /* Sort by VMA. Normally the LMA and the VMA will be the same, and
2361 this will do nothing. */
2362 if (sec1
->vma
< sec2
->vma
)
2364 else if (sec1
->vma
> sec2
->vma
)
2367 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2369 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2374 return sec1
->target_index
- sec2
->target_index
;
2384 /* Sort by size, to put zero sized sections before others at the
2387 if (sec1
->_raw_size
< sec2
->_raw_size
)
2389 if (sec1
->_raw_size
> sec2
->_raw_size
)
2392 return sec1
->target_index
- sec2
->target_index
;
2395 /* Assign file positions to the sections based on the mapping from
2396 sections to segments. This function also sets up some fields in
2397 the file header, and writes out the program headers. */
2400 assign_file_positions_for_segments (abfd
)
2403 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2405 struct elf_segment_map
*m
;
2407 Elf_Internal_Phdr
*phdrs
;
2409 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2410 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2411 Elf_Internal_Phdr
*p
;
2413 if (elf_tdata (abfd
)->segment_map
== NULL
)
2415 if (! map_sections_to_segments (abfd
))
2419 if (bed
->elf_backend_modify_segment_map
)
2421 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2426 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2429 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2430 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2431 elf_elfheader (abfd
)->e_phnum
= count
;
2436 /* If we already counted the number of program segments, make sure
2437 that we allocated enough space. This happens when SIZEOF_HEADERS
2438 is used in a linker script. */
2439 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2440 if (alloc
!= 0 && count
> alloc
)
2442 ((*_bfd_error_handler
)
2443 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2444 bfd_get_filename (abfd
), alloc
, count
));
2445 bfd_set_error (bfd_error_bad_value
);
2452 phdrs
= ((Elf_Internal_Phdr
*)
2453 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2457 off
= bed
->s
->sizeof_ehdr
;
2458 off
+= alloc
* bed
->s
->sizeof_phdr
;
2464 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2471 /* If elf_segment_map is not from map_sections_to_segments, the
2472 sections may not be correctly ordered. */
2474 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2477 p
->p_type
= m
->p_type
;
2479 if (m
->p_flags_valid
)
2480 p
->p_flags
= m
->p_flags
;
2484 if (p
->p_type
== PT_LOAD
2486 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2488 if ((abfd
->flags
& D_PAGED
) != 0)
2489 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2491 off
+= ((m
->sections
[0]->vma
- off
)
2492 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2498 p
->p_vaddr
= m
->sections
[0]->vma
;
2500 if (m
->p_paddr_valid
)
2501 p
->p_paddr
= m
->p_paddr
;
2502 else if (m
->count
== 0)
2505 p
->p_paddr
= m
->sections
[0]->lma
;
2507 if (p
->p_type
== PT_LOAD
2508 && (abfd
->flags
& D_PAGED
) != 0)
2509 p
->p_align
= bed
->maxpagesize
;
2510 else if (m
->count
== 0)
2511 p
->p_align
= bed
->s
->file_align
;
2519 if (m
->includes_filehdr
)
2521 if (! m
->p_flags_valid
)
2524 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2525 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2528 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2530 if (p
->p_vaddr
< (bfd_vma
) off
)
2532 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2533 bfd_get_filename (abfd
));
2534 bfd_set_error (bfd_error_bad_value
);
2539 if (! m
->p_paddr_valid
)
2542 if (p
->p_type
== PT_LOAD
)
2544 filehdr_vaddr
= p
->p_vaddr
;
2545 filehdr_paddr
= p
->p_paddr
;
2549 if (m
->includes_phdrs
)
2551 if (! m
->p_flags_valid
)
2553 if (m
->includes_filehdr
)
2555 if (p
->p_type
== PT_LOAD
)
2557 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2558 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2563 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2566 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2567 p
->p_vaddr
-= off
- p
->p_offset
;
2568 if (! m
->p_paddr_valid
)
2569 p
->p_paddr
-= off
- p
->p_offset
;
2571 if (p
->p_type
== PT_LOAD
)
2573 phdrs_vaddr
= p
->p_vaddr
;
2574 phdrs_paddr
= p
->p_paddr
;
2577 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2578 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2581 if (p
->p_type
== PT_LOAD
)
2583 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2589 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2590 p
->p_filesz
+= adjust
;
2591 p
->p_memsz
+= adjust
;
2596 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2600 bfd_size_type align
;
2604 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2606 /* The section may have artificial alignment forced by a
2607 link script. Notice this case by the gap between the
2608 cumulative phdr vma and the section's vma. */
2609 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2611 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2613 p
->p_memsz
+= adjust
;
2616 if ((flags
& SEC_LOAD
) != 0)
2617 p
->p_filesz
+= adjust
;
2620 if (p
->p_type
== PT_LOAD
)
2624 if ((flags
& SEC_LOAD
) != 0)
2625 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2626 else if ((flags
& SEC_ALLOC
) != 0)
2628 /* The section VMA must equal the file position
2629 modulo the page size. FIXME: I'm not sure if
2630 this adjustment is really necessary. We used to
2631 not have the SEC_LOAD case just above, and then
2632 this was necessary, but now I'm not sure. */
2633 if ((abfd
->flags
& D_PAGED
) != 0)
2634 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2636 adjust
= (sec
->vma
- voff
) % align
;
2645 p
->p_memsz
+= adjust
;
2648 if ((flags
& SEC_LOAD
) != 0)
2649 p
->p_filesz
+= adjust
;
2654 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2655 used in a linker script we may have a section with
2656 SEC_LOAD clear but which is supposed to have
2658 if ((flags
& SEC_LOAD
) != 0
2659 || (flags
& SEC_HAS_CONTENTS
) != 0)
2660 off
+= sec
->_raw_size
;
2661 if ((flags
& SEC_ALLOC
) != 0)
2662 voff
+= sec
->_raw_size
;
2665 p
->p_memsz
+= sec
->_raw_size
;
2667 if ((flags
& SEC_LOAD
) != 0)
2668 p
->p_filesz
+= sec
->_raw_size
;
2670 if (align
> p
->p_align
)
2673 if (! m
->p_flags_valid
)
2676 if ((flags
& SEC_CODE
) != 0)
2678 if ((flags
& SEC_READONLY
) == 0)
2684 /* Now that we have set the section file positions, we can set up
2685 the file positions for the non PT_LOAD segments. */
2686 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2690 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2692 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2693 p
->p_offset
= m
->sections
[0]->filepos
;
2697 if (m
->includes_filehdr
)
2699 p
->p_vaddr
= filehdr_vaddr
;
2700 if (! m
->p_paddr_valid
)
2701 p
->p_paddr
= filehdr_paddr
;
2703 else if (m
->includes_phdrs
)
2705 p
->p_vaddr
= phdrs_vaddr
;
2706 if (! m
->p_paddr_valid
)
2707 p
->p_paddr
= phdrs_paddr
;
2712 /* Clear out any program headers we allocated but did not use. */
2713 for (; count
< alloc
; count
++, p
++)
2715 memset (p
, 0, sizeof *p
);
2716 p
->p_type
= PT_NULL
;
2719 elf_tdata (abfd
)->phdr
= phdrs
;
2721 elf_tdata (abfd
)->next_file_pos
= off
;
2723 /* Write out the program headers. */
2724 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2725 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2731 /* Get the size of the program header.
2733 If this is called by the linker before any of the section VMA's are set, it
2734 can't calculate the correct value for a strange memory layout. This only
2735 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2736 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2737 data segment (exclusive of .interp and .dynamic).
2739 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2740 will be two segments. */
2742 static bfd_size_type
2743 get_program_header_size (abfd
)
2748 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2750 /* We can't return a different result each time we're called. */
2751 if (elf_tdata (abfd
)->program_header_size
!= 0)
2752 return elf_tdata (abfd
)->program_header_size
;
2754 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2756 struct elf_segment_map
*m
;
2759 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2761 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2762 return elf_tdata (abfd
)->program_header_size
;
2765 /* Assume we will need exactly two PT_LOAD segments: one for text
2766 and one for data. */
2769 s
= bfd_get_section_by_name (abfd
, ".interp");
2770 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2772 /* If we have a loadable interpreter section, we need a
2773 PT_INTERP segment. In this case, assume we also need a
2774 PT_PHDR segment, although that may not be true for all
2779 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2781 /* We need a PT_DYNAMIC segment. */
2785 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2787 if ((s
->flags
& SEC_LOAD
) != 0
2788 && strncmp (s
->name
, ".note", 5) == 0)
2790 /* We need a PT_NOTE segment. */
2795 /* Let the backend count up any program headers it might need. */
2796 if (bed
->elf_backend_additional_program_headers
)
2800 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2806 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2807 return elf_tdata (abfd
)->program_header_size
;
2810 /* Work out the file positions of all the sections. This is called by
2811 _bfd_elf_compute_section_file_positions. All the section sizes and
2812 VMAs must be known before this is called.
2814 We do not consider reloc sections at this point, unless they form
2815 part of the loadable image. Reloc sections are assigned file
2816 positions in assign_file_positions_for_relocs, which is called by
2817 write_object_contents and final_link.
2819 We also don't set the positions of the .symtab and .strtab here. */
2822 assign_file_positions_except_relocs (abfd
)
2825 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2826 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2827 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2829 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2831 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2833 Elf_Internal_Shdr
**hdrpp
;
2836 /* Start after the ELF header. */
2837 off
= i_ehdrp
->e_ehsize
;
2839 /* We are not creating an executable, which means that we are
2840 not creating a program header, and that the actual order of
2841 the sections in the file is unimportant. */
2842 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2844 Elf_Internal_Shdr
*hdr
;
2847 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2849 hdr
->sh_offset
= -1;
2852 if (i
== tdata
->symtab_section
2853 || i
== tdata
->strtab_section
)
2855 hdr
->sh_offset
= -1;
2859 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2865 Elf_Internal_Shdr
**hdrpp
;
2867 /* Assign file positions for the loaded sections based on the
2868 assignment of sections to segments. */
2869 if (! assign_file_positions_for_segments (abfd
))
2872 /* Assign file positions for the other sections. */
2874 off
= elf_tdata (abfd
)->next_file_pos
;
2875 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2877 Elf_Internal_Shdr
*hdr
;
2880 if (hdr
->bfd_section
!= NULL
2881 && hdr
->bfd_section
->filepos
!= 0)
2882 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2883 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2885 ((*_bfd_error_handler
)
2886 (_("%s: warning: allocated section `%s' not in segment"),
2887 bfd_get_filename (abfd
),
2888 (hdr
->bfd_section
== NULL
2890 : hdr
->bfd_section
->name
)));
2891 if ((abfd
->flags
& D_PAGED
) != 0)
2892 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2894 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2895 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2898 else if (hdr
->sh_type
== SHT_REL
2899 || hdr
->sh_type
== SHT_RELA
2900 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2901 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2902 hdr
->sh_offset
= -1;
2904 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2908 /* Place the section headers. */
2909 off
= align_file_position (off
, bed
->s
->file_align
);
2910 i_ehdrp
->e_shoff
= off
;
2911 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2913 elf_tdata (abfd
)->next_file_pos
= off
;
2922 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2923 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2924 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2926 struct bfd_strtab_hash
*shstrtab
;
2927 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2929 i_ehdrp
= elf_elfheader (abfd
);
2930 i_shdrp
= elf_elfsections (abfd
);
2932 shstrtab
= _bfd_elf_stringtab_init ();
2933 if (shstrtab
== NULL
)
2936 elf_shstrtab (abfd
) = shstrtab
;
2938 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2939 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2940 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2941 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2943 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2944 i_ehdrp
->e_ident
[EI_DATA
] =
2945 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2946 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2948 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2949 i_ehdrp
->e_ident
[count
] = 0;
2951 if ((abfd
->flags
& DYNAMIC
) != 0)
2952 i_ehdrp
->e_type
= ET_DYN
;
2953 else if ((abfd
->flags
& EXEC_P
) != 0)
2954 i_ehdrp
->e_type
= ET_EXEC
;
2956 i_ehdrp
->e_type
= ET_REL
;
2958 switch (bfd_get_arch (abfd
))
2960 case bfd_arch_unknown
:
2961 i_ehdrp
->e_machine
= EM_NONE
;
2963 case bfd_arch_sparc
:
2964 if (bed
->s
->arch_size
== 64)
2965 i_ehdrp
->e_machine
= EM_SPARCV9
;
2967 i_ehdrp
->e_machine
= EM_SPARC
;
2970 i_ehdrp
->e_machine
= EM_386
;
2973 i_ehdrp
->e_machine
= EM_68K
;
2976 i_ehdrp
->e_machine
= EM_88K
;
2979 i_ehdrp
->e_machine
= EM_860
;
2981 case bfd_arch_mips
: /* MIPS Rxxxx */
2982 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2985 i_ehdrp
->e_machine
= EM_PARISC
;
2987 case bfd_arch_powerpc
:
2988 i_ehdrp
->e_machine
= EM_PPC
;
2990 case bfd_arch_alpha
:
2991 i_ehdrp
->e_machine
= EM_ALPHA
;
2994 i_ehdrp
->e_machine
= EM_SH
;
2997 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2999 /* start-sanitize-d30v */
3001 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3003 /* end-sanitize-d30v */
3005 switch (bfd_get_mach (abfd
))
3008 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3012 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3015 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3017 case bfd_arch_mn10200
:
3018 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3020 case bfd_arch_mn10300
:
3021 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3023 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3025 i_ehdrp
->e_machine
= EM_NONE
;
3027 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3028 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3030 /* no program header, for now. */
3031 i_ehdrp
->e_phoff
= 0;
3032 i_ehdrp
->e_phentsize
= 0;
3033 i_ehdrp
->e_phnum
= 0;
3035 /* each bfd section is section header entry */
3036 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3037 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3039 /* if we're building an executable, we'll need a program header table */
3040 if (abfd
->flags
& EXEC_P
)
3042 /* it all happens later */
3044 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3046 /* elf_build_phdrs() returns a (NULL-terminated) array of
3047 Elf_Internal_Phdrs */
3048 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3049 i_ehdrp
->e_phoff
= outbase
;
3050 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3055 i_ehdrp
->e_phentsize
= 0;
3057 i_ehdrp
->e_phoff
= 0;
3060 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3061 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3062 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3063 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3064 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3065 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3066 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3067 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3068 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3074 /* Assign file positions for all the reloc sections which are not part
3075 of the loadable file image. */
3078 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3083 Elf_Internal_Shdr
**shdrpp
;
3085 off
= elf_tdata (abfd
)->next_file_pos
;
3087 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3088 i
< elf_elfheader (abfd
)->e_shnum
;
3091 Elf_Internal_Shdr
*shdrp
;
3094 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3095 && shdrp
->sh_offset
== -1)
3096 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3099 elf_tdata (abfd
)->next_file_pos
= off
;
3103 _bfd_elf_write_object_contents (abfd
)
3106 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3107 Elf_Internal_Ehdr
*i_ehdrp
;
3108 Elf_Internal_Shdr
**i_shdrp
;
3112 if (! abfd
->output_has_begun
3113 && ! _bfd_elf_compute_section_file_positions (abfd
,
3114 (struct bfd_link_info
*) NULL
))
3117 i_shdrp
= elf_elfsections (abfd
);
3118 i_ehdrp
= elf_elfheader (abfd
);
3121 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3124 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3126 /* After writing the headers, we need to write the sections too... */
3127 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3129 if (bed
->elf_backend_section_processing
)
3130 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3131 if (i_shdrp
[count
]->contents
)
3133 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3134 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3136 != i_shdrp
[count
]->sh_size
))
3141 /* Write out the section header names. */
3142 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3143 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3146 if (bed
->elf_backend_final_write_processing
)
3147 (*bed
->elf_backend_final_write_processing
) (abfd
,
3148 elf_tdata (abfd
)->linker
);
3150 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3153 /* given a section, search the header to find them... */
3155 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3159 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3160 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3162 Elf_Internal_Shdr
*hdr
;
3163 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3165 for (index
= 0; index
< maxindex
; index
++)
3167 hdr
= i_shdrp
[index
];
3168 if (hdr
->bfd_section
== asect
)
3172 if (bed
->elf_backend_section_from_bfd_section
)
3174 for (index
= 0; index
< maxindex
; index
++)
3178 hdr
= i_shdrp
[index
];
3180 if ((*bed
->elf_backend_section_from_bfd_section
)
3181 (abfd
, hdr
, asect
, &retval
))
3186 if (bfd_is_abs_section (asect
))
3188 if (bfd_is_com_section (asect
))
3190 if (bfd_is_und_section (asect
))
3193 bfd_set_error (bfd_error_nonrepresentable_section
);
3198 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3202 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3204 asymbol
**asym_ptr_ptr
;
3206 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3208 flagword flags
= asym_ptr
->flags
;
3210 /* When gas creates relocations against local labels, it creates its
3211 own symbol for the section, but does put the symbol into the
3212 symbol chain, so udata is 0. When the linker is generating
3213 relocatable output, this section symbol may be for one of the
3214 input sections rather than the output section. */
3215 if (asym_ptr
->udata
.i
== 0
3216 && (flags
& BSF_SECTION_SYM
)
3217 && asym_ptr
->section
)
3221 if (asym_ptr
->section
->output_section
!= NULL
)
3222 indx
= asym_ptr
->section
->output_section
->index
;
3224 indx
= asym_ptr
->section
->index
;
3225 if (elf_section_syms (abfd
)[indx
])
3226 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3229 idx
= asym_ptr
->udata
.i
;
3233 /* This case can occur when using --strip-symbol on a symbol
3234 which is used in a relocation entry. */
3235 (*_bfd_error_handler
)
3236 (_("%s: symbol `%s' required but not present"),
3237 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3238 bfd_set_error (bfd_error_no_symbols
);
3245 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3246 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3247 elf_symbol_flags (flags
));
3255 /* Copy private BFD data. This copies any program header information. */
3258 copy_private_bfd_data (ibfd
, obfd
)
3262 Elf_Internal_Ehdr
*iehdr
;
3263 struct elf_segment_map
*mfirst
;
3264 struct elf_segment_map
**pm
;
3265 struct elf_segment_map
*m
;
3266 Elf_Internal_Phdr
*p
;
3269 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3270 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3273 if (elf_tdata (ibfd
)->phdr
== NULL
)
3276 iehdr
= elf_elfheader (ibfd
);
3281 c
= elf_elfheader (ibfd
)->e_phnum
;
3282 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
3290 /* The complicated case when p_vaddr is 0 is to handle the
3291 Solaris linker, which generates a PT_INTERP section with
3292 p_vaddr and p_memsz set to 0. */
3293 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3294 if (((s
->vma
>= p
->p_vaddr
3295 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3296 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3299 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3301 && (bfd_vma
) s
->filepos
>= p
->p_offset
3302 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3303 <= p
->p_offset
+ p
->p_filesz
)))
3304 && (s
->flags
& SEC_ALLOC
) != 0
3305 && s
->output_section
!= NULL
)
3308 m
= ((struct elf_segment_map
*)
3310 (sizeof (struct elf_segment_map
)
3311 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3316 m
->p_type
= p
->p_type
;
3317 m
->p_flags
= p
->p_flags
;
3318 m
->p_flags_valid
= 1;
3319 /* Default to using the physical address of the segment
3320 in the input BFD. */
3321 m
->p_paddr
= p
->p_paddr
;
3322 m
->p_paddr_valid
= 1;
3324 m
->includes_filehdr
= (p
->p_offset
== 0
3325 && p
->p_filesz
>= iehdr
->e_ehsize
);
3327 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3328 && (p
->p_offset
+ p
->p_filesz
3329 >= ((bfd_vma
) iehdr
->e_phoff
3330 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3333 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3335 boolean matching_lma
= false;
3336 boolean lma_conflict
= false;
3337 bfd_vma suggested_lma
= 0;
3340 #define is_contained_by(addr, len, bottom, phdr) \
3341 ((addr) >= (bottom) \
3342 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3343 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3345 os
= s
->output_section
;
3347 if ((is_contained_by (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3350 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3352 && (bfd_vma
) s
->filepos
>= p
->p_offset
3353 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3354 <= p
->p_offset
+ p
->p_filesz
)))
3355 && (s
->flags
& SEC_ALLOC
) != 0
3358 /* The Solaris native linker always sets p_paddr to 0.
3359 We try to catch that case here, and set it to the
3365 && (os
->vma
== (p
->p_vaddr
3366 + (m
->includes_filehdr
3369 + (m
->includes_phdrs
3370 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3372 m
->p_paddr
= p
->p_vaddr
;
3374 m
->sections
[isec
] = os
;
3377 /* Match up the physical address of the segment with the
3378 LMA addresses of its sections. */
3380 if (is_contained_by (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
))
3381 matching_lma
= true;
3382 else if (suggested_lma
== 0)
3383 suggested_lma
= os
->lma
;
3384 else if (! is_contained_by (os
->lma
, os
->_raw_size
,
3386 lma_conflict
= true;
3392 (*_bfd_error_handler
)
3393 (_("Warning: Some sections' LMAs lie outside their segment's physical address\n"));
3395 else if (lma_conflict
)
3397 (*_bfd_error_handler
)
3398 (_("Warning: Cannot change segment's physical address to contain all of its sections' LMAs\n"));
3400 else if (suggested_lma
)
3402 m
->p_paddr
= suggested_lma
;
3405 BFD_ASSERT (isec
== csecs
);
3412 /* The Solaris linker creates program headers in which all the
3413 p_paddr fields are zero. When we try to objcopy or strip such a
3414 file, we get confused. Check for this case, and if we find it
3415 reset the p_paddr_valid fields. */
3416 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3417 if (m
->p_paddr
!= 0)
3421 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3422 m
->p_paddr_valid
= 0;
3425 elf_tdata (obfd
)->segment_map
= mfirst
;
3430 /* Copy private section information. This copies over the entsize
3431 field, and sometimes the info field. */
3434 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3440 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3442 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3443 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3446 /* Copy over private BFD data if it has not already been copied.
3447 This must be done here, rather than in the copy_private_bfd_data
3448 entry point, because the latter is called after the section
3449 contents have been set, which means that the program headers have
3450 already been worked out. */
3451 if (elf_tdata (obfd
)->segment_map
== NULL
3452 && elf_tdata (ibfd
)->phdr
!= NULL
)
3456 /* Only set up the segments if there are no more SEC_ALLOC
3457 sections. FIXME: This won't do the right thing if objcopy is
3458 used to remove the last SEC_ALLOC section, since objcopy
3459 won't call this routine in that case. */
3460 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3461 if ((s
->flags
& SEC_ALLOC
) != 0)
3465 if (! copy_private_bfd_data (ibfd
, obfd
))
3470 ihdr
= &elf_section_data (isec
)->this_hdr
;
3471 ohdr
= &elf_section_data (osec
)->this_hdr
;
3473 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3475 if (ihdr
->sh_type
== SHT_SYMTAB
3476 || ihdr
->sh_type
== SHT_DYNSYM
3477 || ihdr
->sh_type
== SHT_GNU_verneed
3478 || ihdr
->sh_type
== SHT_GNU_verdef
)
3479 ohdr
->sh_info
= ihdr
->sh_info
;
3484 /* Copy private symbol information. If this symbol is in a section
3485 which we did not map into a BFD section, try to map the section
3486 index correctly. We use special macro definitions for the mapped
3487 section indices; these definitions are interpreted by the
3488 swap_out_syms function. */
3490 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3491 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3492 #define MAP_STRTAB (SHN_LORESERVE - 3)
3493 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3496 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3502 elf_symbol_type
*isym
, *osym
;
3504 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3505 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3508 isym
= elf_symbol_from (ibfd
, isymarg
);
3509 osym
= elf_symbol_from (obfd
, osymarg
);
3513 && bfd_is_abs_section (isym
->symbol
.section
))
3517 shndx
= isym
->internal_elf_sym
.st_shndx
;
3518 if (shndx
== elf_onesymtab (ibfd
))
3519 shndx
= MAP_ONESYMTAB
;
3520 else if (shndx
== elf_dynsymtab (ibfd
))
3521 shndx
= MAP_DYNSYMTAB
;
3522 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3524 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3525 shndx
= MAP_SHSTRTAB
;
3526 osym
->internal_elf_sym
.st_shndx
= shndx
;
3532 /* Swap out the symbols. */
3535 swap_out_syms (abfd
, sttp
, relocatable_p
)
3537 struct bfd_strtab_hash
**sttp
;
3540 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3542 if (!elf_map_symbols (abfd
))
3545 /* Dump out the symtabs. */
3547 int symcount
= bfd_get_symcount (abfd
);
3548 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3549 struct bfd_strtab_hash
*stt
;
3550 Elf_Internal_Shdr
*symtab_hdr
;
3551 Elf_Internal_Shdr
*symstrtab_hdr
;
3552 char *outbound_syms
;
3555 stt
= _bfd_elf_stringtab_init ();
3559 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3560 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3561 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3562 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3563 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3564 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3566 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3567 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3569 outbound_syms
= bfd_alloc (abfd
,
3570 (1 + symcount
) * bed
->s
->sizeof_sym
);
3571 if (outbound_syms
== NULL
)
3573 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3575 /* now generate the data (for "contents") */
3577 /* Fill in zeroth symbol and swap it out. */
3578 Elf_Internal_Sym sym
;
3584 sym
.st_shndx
= SHN_UNDEF
;
3585 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3586 outbound_syms
+= bed
->s
->sizeof_sym
;
3588 for (idx
= 0; idx
< symcount
; idx
++)
3590 Elf_Internal_Sym sym
;
3591 bfd_vma value
= syms
[idx
]->value
;
3592 elf_symbol_type
*type_ptr
;
3593 flagword flags
= syms
[idx
]->flags
;
3596 if (flags
& BSF_SECTION_SYM
)
3597 /* Section symbols have no names. */
3601 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3604 if (sym
.st_name
== (unsigned long) -1)
3608 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3610 if (bfd_is_com_section (syms
[idx
]->section
))
3612 /* ELF common symbols put the alignment into the `value' field,
3613 and the size into the `size' field. This is backwards from
3614 how BFD handles it, so reverse it here. */
3615 sym
.st_size
= value
;
3616 if (type_ptr
== NULL
3617 || type_ptr
->internal_elf_sym
.st_value
== 0)
3618 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3620 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3621 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3622 syms
[idx
]->section
);
3626 asection
*sec
= syms
[idx
]->section
;
3629 if (sec
->output_section
)
3631 value
+= sec
->output_offset
;
3632 sec
= sec
->output_section
;
3634 /* Don't add in the section vma for relocatable output. */
3635 if (! relocatable_p
)
3637 sym
.st_value
= value
;
3638 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3640 if (bfd_is_abs_section (sec
)
3642 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3644 /* This symbol is in a real ELF section which we did
3645 not create as a BFD section. Undo the mapping done
3646 by copy_private_symbol_data. */
3647 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3651 shndx
= elf_onesymtab (abfd
);
3654 shndx
= elf_dynsymtab (abfd
);
3657 shndx
= elf_tdata (abfd
)->strtab_section
;
3660 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3668 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3674 /* Writing this would be a hell of a lot easier if
3675 we had some decent documentation on bfd, and
3676 knew what to expect of the library, and what to
3677 demand of applications. For example, it
3678 appears that `objcopy' might not set the
3679 section of a symbol to be a section that is
3680 actually in the output file. */
3681 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3682 BFD_ASSERT (sec2
!= 0);
3683 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3684 BFD_ASSERT (shndx
!= -1);
3688 sym
.st_shndx
= shndx
;
3691 if ((flags
& BSF_FUNCTION
) != 0)
3693 else if ((flags
& BSF_OBJECT
) != 0)
3698 if (bfd_is_com_section (syms
[idx
]->section
))
3699 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3700 else if (bfd_is_und_section (syms
[idx
]->section
))
3701 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3705 else if (flags
& BSF_SECTION_SYM
)
3706 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3707 else if (flags
& BSF_FILE
)
3708 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3711 int bind
= STB_LOCAL
;
3713 if (flags
& BSF_LOCAL
)
3715 else if (flags
& BSF_WEAK
)
3717 else if (flags
& BSF_GLOBAL
)
3720 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3723 if (type_ptr
!= NULL
)
3724 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3728 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3729 outbound_syms
+= bed
->s
->sizeof_sym
;
3733 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3734 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3736 symstrtab_hdr
->sh_flags
= 0;
3737 symstrtab_hdr
->sh_addr
= 0;
3738 symstrtab_hdr
->sh_entsize
= 0;
3739 symstrtab_hdr
->sh_link
= 0;
3740 symstrtab_hdr
->sh_info
= 0;
3741 symstrtab_hdr
->sh_addralign
= 1;
3747 /* Return the number of bytes required to hold the symtab vector.
3749 Note that we base it on the count plus 1, since we will null terminate
3750 the vector allocated based on this size. However, the ELF symbol table
3751 always has a dummy entry as symbol #0, so it ends up even. */
3754 _bfd_elf_get_symtab_upper_bound (abfd
)
3759 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3761 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3762 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3768 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3773 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3775 if (elf_dynsymtab (abfd
) == 0)
3777 bfd_set_error (bfd_error_invalid_operation
);
3781 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3782 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3788 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3792 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3795 /* Canonicalize the relocs. */
3798 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3807 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3813 tblptr
= section
->relocation
;
3814 for (i
= 0; i
< section
->reloc_count
; i
++)
3815 *relptr
++ = tblptr
++;
3819 return section
->reloc_count
;
3823 _bfd_elf_get_symtab (abfd
, alocation
)
3825 asymbol
**alocation
;
3827 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3830 bfd_get_symcount (abfd
) = symcount
;
3835 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3837 asymbol
**alocation
;
3839 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3842 /* Return the size required for the dynamic reloc entries. Any
3843 section that was actually installed in the BFD, and has type
3844 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3845 considered to be a dynamic reloc section. */
3848 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3854 if (elf_dynsymtab (abfd
) == 0)
3856 bfd_set_error (bfd_error_invalid_operation
);
3860 ret
= sizeof (arelent
*);
3861 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3862 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3863 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3864 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3865 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3866 * sizeof (arelent
*));
3871 /* Canonicalize the dynamic relocation entries. Note that we return
3872 the dynamic relocations as a single block, although they are
3873 actually associated with particular sections; the interface, which
3874 was designed for SunOS style shared libraries, expects that there
3875 is only one set of dynamic relocs. Any section that was actually
3876 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3877 the dynamic symbol table, is considered to be a dynamic reloc
3881 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3886 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3890 if (elf_dynsymtab (abfd
) == 0)
3892 bfd_set_error (bfd_error_invalid_operation
);
3896 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3898 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3900 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3901 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3902 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3907 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3909 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3911 for (i
= 0; i
< count
; i
++)
3922 /* Read in the version information. */
3925 _bfd_elf_slurp_version_tables (abfd
)
3928 bfd_byte
*contents
= NULL
;
3930 if (elf_dynverdef (abfd
) != 0)
3932 Elf_Internal_Shdr
*hdr
;
3933 Elf_External_Verdef
*everdef
;
3934 Elf_Internal_Verdef
*iverdef
;
3937 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
3939 elf_tdata (abfd
)->verdef
=
3940 ((Elf_Internal_Verdef
*)
3941 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
3942 if (elf_tdata (abfd
)->verdef
== NULL
)
3945 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
3947 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3948 if (contents
== NULL
)
3950 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3951 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3954 everdef
= (Elf_External_Verdef
*) contents
;
3955 iverdef
= elf_tdata (abfd
)->verdef
;
3956 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
3958 Elf_External_Verdaux
*everdaux
;
3959 Elf_Internal_Verdaux
*iverdaux
;
3962 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
3964 iverdef
->vd_bfd
= abfd
;
3966 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
3969 * sizeof (Elf_Internal_Verdaux
))));
3970 if (iverdef
->vd_auxptr
== NULL
)
3973 everdaux
= ((Elf_External_Verdaux
*)
3974 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
3975 iverdaux
= iverdef
->vd_auxptr
;
3976 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
3978 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
3980 iverdaux
->vda_nodename
=
3981 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3982 iverdaux
->vda_name
);
3983 if (iverdaux
->vda_nodename
== NULL
)
3986 if (j
+ 1 < iverdef
->vd_cnt
)
3987 iverdaux
->vda_nextptr
= iverdaux
+ 1;
3989 iverdaux
->vda_nextptr
= NULL
;
3991 everdaux
= ((Elf_External_Verdaux
*)
3992 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
3995 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
3997 if (i
+ 1 < hdr
->sh_info
)
3998 iverdef
->vd_nextdef
= iverdef
+ 1;
4000 iverdef
->vd_nextdef
= NULL
;
4002 everdef
= ((Elf_External_Verdef
*)
4003 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4010 if (elf_dynverref (abfd
) != 0)
4012 Elf_Internal_Shdr
*hdr
;
4013 Elf_External_Verneed
*everneed
;
4014 Elf_Internal_Verneed
*iverneed
;
4017 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4019 elf_tdata (abfd
)->verref
=
4020 ((Elf_Internal_Verneed
*)
4021 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4022 if (elf_tdata (abfd
)->verref
== NULL
)
4025 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4027 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4028 if (contents
== NULL
)
4030 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4031 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4034 everneed
= (Elf_External_Verneed
*) contents
;
4035 iverneed
= elf_tdata (abfd
)->verref
;
4036 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4038 Elf_External_Vernaux
*evernaux
;
4039 Elf_Internal_Vernaux
*ivernaux
;
4042 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4044 iverneed
->vn_bfd
= abfd
;
4046 iverneed
->vn_filename
=
4047 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4049 if (iverneed
->vn_filename
== NULL
)
4052 iverneed
->vn_auxptr
=
4053 ((Elf_Internal_Vernaux
*)
4055 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4057 evernaux
= ((Elf_External_Vernaux
*)
4058 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4059 ivernaux
= iverneed
->vn_auxptr
;
4060 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4062 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4064 ivernaux
->vna_nodename
=
4065 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4066 ivernaux
->vna_name
);
4067 if (ivernaux
->vna_nodename
== NULL
)
4070 if (j
+ 1 < iverneed
->vn_cnt
)
4071 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4073 ivernaux
->vna_nextptr
= NULL
;
4075 evernaux
= ((Elf_External_Vernaux
*)
4076 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4079 if (i
+ 1 < hdr
->sh_info
)
4080 iverneed
->vn_nextref
= iverneed
+ 1;
4082 iverneed
->vn_nextref
= NULL
;
4084 everneed
= ((Elf_External_Verneed
*)
4085 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4095 if (contents
== NULL
)
4101 _bfd_elf_make_empty_symbol (abfd
)
4104 elf_symbol_type
*newsym
;
4106 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4111 newsym
->symbol
.the_bfd
= abfd
;
4112 return &newsym
->symbol
;
4117 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4122 bfd_symbol_info (symbol
, ret
);
4125 /* Return whether a symbol name implies a local symbol. Most targets
4126 use this function for the is_local_label_name entry point, but some
4130 _bfd_elf_is_local_label_name (abfd
, name
)
4134 /* Normal local symbols start with ``.L''. */
4135 if (name
[0] == '.' && name
[1] == 'L')
4138 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4139 DWARF debugging symbols starting with ``..''. */
4140 if (name
[0] == '.' && name
[1] == '.')
4143 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4144 emitting DWARF debugging output. I suspect this is actually a
4145 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4146 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4147 underscore to be emitted on some ELF targets). For ease of use,
4148 we treat such symbols as local. */
4149 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4156 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4165 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4167 enum bfd_architecture arch
;
4168 unsigned long machine
;
4170 /* If this isn't the right architecture for this backend, and this
4171 isn't the generic backend, fail. */
4172 if (arch
!= get_elf_backend_data (abfd
)->arch
4173 && arch
!= bfd_arch_unknown
4174 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4177 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4180 /* Find the nearest line to a particular section and offset, for error
4184 _bfd_elf_find_nearest_line (abfd
,
4195 CONST
char **filename_ptr
;
4196 CONST
char **functionname_ptr
;
4197 unsigned int *line_ptr
;
4200 const char *filename
;
4205 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4206 filename_ptr
, functionname_ptr
,
4210 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4211 &found
, filename_ptr
,
4212 functionname_ptr
, line_ptr
,
4213 &elf_tdata (abfd
)->line_info
))
4218 if (symbols
== NULL
)
4225 for (p
= symbols
; *p
!= NULL
; p
++)
4229 q
= (elf_symbol_type
*) *p
;
4231 if (bfd_get_section (&q
->symbol
) != section
)
4234 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4239 filename
= bfd_asymbol_name (&q
->symbol
);
4242 if (q
->symbol
.section
== section
4243 && q
->symbol
.value
>= low_func
4244 && q
->symbol
.value
<= offset
)
4246 func
= (asymbol
*) q
;
4247 low_func
= q
->symbol
.value
;
4256 *filename_ptr
= filename
;
4257 *functionname_ptr
= bfd_asymbol_name (func
);
4263 _bfd_elf_sizeof_headers (abfd
, reloc
)
4269 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4271 ret
+= get_program_header_size (abfd
);
4276 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4281 bfd_size_type count
;
4283 Elf_Internal_Shdr
*hdr
;
4285 if (! abfd
->output_has_begun
4286 && ! _bfd_elf_compute_section_file_positions (abfd
,
4287 (struct bfd_link_info
*) NULL
))
4290 hdr
= &elf_section_data (section
)->this_hdr
;
4292 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4294 if (bfd_write (location
, 1, count
, abfd
) != count
)
4301 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4304 Elf_Internal_Rela
*dst
;
4311 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4314 Elf_Internal_Rel
*dst
;
4320 /* Try to convert a non-ELF reloc into an ELF one. */
4323 _bfd_elf_validate_reloc (abfd
, areloc
)
4327 /* Check whether we really have an ELF howto. */
4329 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4331 bfd_reloc_code_real_type code
;
4332 reloc_howto_type
*howto
;
4334 /* Alien reloc: Try to determine its type to replace it with an
4335 equivalent ELF reloc. */
4337 if (areloc
->howto
->pc_relative
)
4339 switch (areloc
->howto
->bitsize
)
4342 code
= BFD_RELOC_8_PCREL
;
4345 code
= BFD_RELOC_12_PCREL
;
4348 code
= BFD_RELOC_16_PCREL
;
4351 code
= BFD_RELOC_24_PCREL
;
4354 code
= BFD_RELOC_32_PCREL
;
4357 code
= BFD_RELOC_64_PCREL
;
4363 howto
= bfd_reloc_type_lookup (abfd
, code
);
4365 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4367 if (howto
->pcrel_offset
)
4368 areloc
->addend
+= areloc
->address
;
4370 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4375 switch (areloc
->howto
->bitsize
)
4381 code
= BFD_RELOC_14
;
4384 code
= BFD_RELOC_16
;
4387 code
= BFD_RELOC_26
;
4390 code
= BFD_RELOC_32
;
4393 code
= BFD_RELOC_64
;
4399 howto
= bfd_reloc_type_lookup (abfd
, code
);
4403 areloc
->howto
= howto
;
4411 (*_bfd_error_handler
)
4412 (_("%s: unsupported relocation type %s"),
4413 bfd_get_filename (abfd
), areloc
->howto
->name
);
4414 bfd_set_error (bfd_error_bad_value
);
4419 _bfd_elf_close_and_cleanup (abfd
)
4422 if (bfd_get_format (abfd
) == bfd_object
)
4424 if (elf_shstrtab (abfd
) != NULL
)
4425 _bfd_stringtab_free (elf_shstrtab (abfd
));
4428 return _bfd_generic_close_and_cleanup (abfd
);