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
**));
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
->type
= STT_NOTYPE
;
849 /* Assume that we have been called by a non-ELF symbol reader.
850 This flag is then reset by the code which reads an ELF input
851 file. This ensures that a symbol created by a non-ELF symbol
852 reader will have the flag set correctly. */
853 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
856 return (struct bfd_hash_entry
*) ret
;
859 /* Initialize an ELF linker hash table. */
862 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
863 struct elf_link_hash_table
*table
;
865 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
866 struct bfd_hash_table
*,
869 table
->dynamic_sections_created
= false;
870 table
->dynobj
= NULL
;
871 /* The first dynamic symbol is a dummy. */
872 table
->dynsymcount
= 1;
873 table
->dynstr
= NULL
;
874 table
->bucketcount
= 0;
875 table
->needed
= NULL
;
877 table
->stab_info
= NULL
;
878 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
881 /* Create an ELF linker hash table. */
883 struct bfd_link_hash_table
*
884 _bfd_elf_link_hash_table_create (abfd
)
887 struct elf_link_hash_table
*ret
;
889 ret
= ((struct elf_link_hash_table
*)
890 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
891 if (ret
== (struct elf_link_hash_table
*) NULL
)
894 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
896 bfd_release (abfd
, ret
);
903 /* This is a hook for the ELF emulation code in the generic linker to
904 tell the backend linker what file name to use for the DT_NEEDED
905 entry for a dynamic object. The generic linker passes name as an
906 empty string to indicate that no DT_NEEDED entry should be made. */
909 bfd_elf_set_dt_needed_name (abfd
, name
)
913 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
914 && bfd_get_format (abfd
) == bfd_object
)
915 elf_dt_name (abfd
) = name
;
918 /* Get the list of DT_NEEDED entries for a link. This is a hook for
919 the linker ELF emulation code. */
921 struct bfd_link_needed_list
*
922 bfd_elf_get_needed_list (abfd
, info
)
924 struct bfd_link_info
*info
;
926 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
928 return elf_hash_table (info
)->needed
;
931 /* Get the name actually used for a dynamic object for a link. This
932 is the SONAME entry if there is one. Otherwise, it is the string
933 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
936 bfd_elf_get_dt_soname (abfd
)
939 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
940 && bfd_get_format (abfd
) == bfd_object
)
941 return elf_dt_name (abfd
);
945 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
946 the ELF linker emulation code. */
949 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
951 struct bfd_link_needed_list
**pneeded
;
954 bfd_byte
*dynbuf
= NULL
;
957 bfd_byte
*extdyn
, *extdynend
;
959 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
963 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
964 || bfd_get_format (abfd
) != bfd_object
)
967 s
= bfd_get_section_by_name (abfd
, ".dynamic");
968 if (s
== NULL
|| s
->_raw_size
== 0)
971 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
975 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
979 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
983 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
985 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
986 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
989 extdynend
= extdyn
+ s
->_raw_size
;
990 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
992 Elf_Internal_Dyn dyn
;
994 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
996 if (dyn
.d_tag
== DT_NULL
)
999 if (dyn
.d_tag
== DT_NEEDED
)
1002 struct bfd_link_needed_list
*l
;
1004 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1009 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1030 /* Allocate an ELF string table--force the first byte to be zero. */
1032 struct bfd_strtab_hash
*
1033 _bfd_elf_stringtab_init ()
1035 struct bfd_strtab_hash
*ret
;
1037 ret
= _bfd_stringtab_init ();
1042 loc
= _bfd_stringtab_add (ret
, "", true, false);
1043 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1044 if (loc
== (bfd_size_type
) -1)
1046 _bfd_stringtab_free (ret
);
1053 /* ELF .o/exec file reading */
1055 /* Create a new bfd section from an ELF section header. */
1058 bfd_section_from_shdr (abfd
, shindex
)
1060 unsigned int shindex
;
1062 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1063 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1064 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1067 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1069 switch (hdr
->sh_type
)
1072 /* Inactive section. Throw it away. */
1075 case SHT_PROGBITS
: /* Normal section with contents. */
1076 case SHT_DYNAMIC
: /* Dynamic linking information. */
1077 case SHT_NOBITS
: /* .bss section. */
1078 case SHT_HASH
: /* .hash section. */
1079 case SHT_NOTE
: /* .note section. */
1080 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1082 case SHT_SYMTAB
: /* A symbol table */
1083 if (elf_onesymtab (abfd
) == shindex
)
1086 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1087 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1088 elf_onesymtab (abfd
) = shindex
;
1089 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1090 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1091 abfd
->flags
|= HAS_SYMS
;
1093 /* Sometimes a shared object will map in the symbol table. If
1094 SHF_ALLOC is set, and this is a shared object, then we also
1095 treat this section as a BFD section. We can not base the
1096 decision purely on SHF_ALLOC, because that flag is sometimes
1097 set in a relocateable object file, which would confuse the
1099 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1100 && (abfd
->flags
& DYNAMIC
) != 0
1101 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1106 case SHT_DYNSYM
: /* A dynamic symbol table */
1107 if (elf_dynsymtab (abfd
) == shindex
)
1110 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1111 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1112 elf_dynsymtab (abfd
) = shindex
;
1113 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1114 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1115 abfd
->flags
|= HAS_SYMS
;
1117 /* Besides being a symbol table, we also treat this as a regular
1118 section, so that objcopy can handle it. */
1119 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1121 case SHT_STRTAB
: /* A string table */
1122 if (hdr
->bfd_section
!= NULL
)
1124 if (ehdr
->e_shstrndx
== shindex
)
1126 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1127 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1133 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1135 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1136 if (hdr2
->sh_link
== shindex
)
1138 if (! bfd_section_from_shdr (abfd
, i
))
1140 if (elf_onesymtab (abfd
) == i
)
1142 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1143 elf_elfsections (abfd
)[shindex
] =
1144 &elf_tdata (abfd
)->strtab_hdr
;
1147 if (elf_dynsymtab (abfd
) == i
)
1149 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1150 elf_elfsections (abfd
)[shindex
] = hdr
=
1151 &elf_tdata (abfd
)->dynstrtab_hdr
;
1152 /* We also treat this as a regular section, so
1153 that objcopy can handle it. */
1156 #if 0 /* Not handling other string tables specially right now. */
1157 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1158 /* We have a strtab for some random other section. */
1159 newsect
= (asection
*) hdr2
->bfd_section
;
1162 hdr
->bfd_section
= newsect
;
1163 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1165 elf_elfsections (abfd
)[shindex
] = hdr2
;
1171 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1175 /* *These* do a lot of work -- but build no sections! */
1177 asection
*target_sect
;
1178 Elf_Internal_Shdr
*hdr2
;
1180 /* For some incomprehensible reason Oracle distributes
1181 libraries for Solaris in which some of the objects have
1182 bogus sh_link fields. It would be nice if we could just
1183 reject them, but, unfortunately, some people need to use
1184 them. We scan through the section headers; if we find only
1185 one suitable symbol table, we clobber the sh_link to point
1186 to it. I hope this doesn't break anything. */
1187 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1188 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1194 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1196 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1197 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1208 hdr
->sh_link
= found
;
1211 /* Get the symbol table. */
1212 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1213 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1216 /* If this reloc section does not use the main symbol table we
1217 don't treat it as a reloc section. BFD can't adequately
1218 represent such a section, so at least for now, we don't
1219 try. We just present it as a normal section. */
1220 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1221 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1223 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1225 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1226 if (target_sect
== NULL
)
1229 if ((target_sect
->flags
& SEC_RELOC
) == 0
1230 || target_sect
->reloc_count
== 0)
1231 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1234 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1235 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1236 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1239 elf_elfsections (abfd
)[shindex
] = hdr2
;
1240 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1241 target_sect
->flags
|= SEC_RELOC
;
1242 target_sect
->relocation
= NULL
;
1243 target_sect
->rel_filepos
= hdr
->sh_offset
;
1244 abfd
->flags
|= HAS_RELOC
;
1249 case SHT_GNU_verdef
:
1250 elf_dynverdef (abfd
) = shindex
;
1251 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1252 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1255 case SHT_GNU_versym
:
1256 elf_dynversym (abfd
) = shindex
;
1257 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1258 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1261 case SHT_GNU_verneed
:
1262 elf_dynverref (abfd
) = shindex
;
1263 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1264 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1271 /* Check for any processor-specific section types. */
1273 if (bed
->elf_backend_section_from_shdr
)
1274 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1282 /* Given an ELF section number, retrieve the corresponding BFD
1286 bfd_section_from_elf_index (abfd
, index
)
1290 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1291 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1293 return elf_elfsections (abfd
)[index
]->bfd_section
;
1297 _bfd_elf_new_section_hook (abfd
, sec
)
1301 struct bfd_elf_section_data
*sdata
;
1303 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
1306 sec
->used_by_bfd
= (PTR
) sdata
;
1307 memset (sdata
, 0, sizeof (*sdata
));
1311 /* Create a new bfd section from an ELF program header.
1313 Since program segments have no names, we generate a synthetic name
1314 of the form segment<NUM>, where NUM is generally the index in the
1315 program header table. For segments that are split (see below) we
1316 generate the names segment<NUM>a and segment<NUM>b.
1318 Note that some program segments may have a file size that is different than
1319 (less than) the memory size. All this means is that at execution the
1320 system must allocate the amount of memory specified by the memory size,
1321 but only initialize it with the first "file size" bytes read from the
1322 file. This would occur for example, with program segments consisting
1323 of combined data+bss.
1325 To handle the above situation, this routine generates TWO bfd sections
1326 for the single program segment. The first has the length specified by
1327 the file size of the segment, and the second has the length specified
1328 by the difference between the two sizes. In effect, the segment is split
1329 into it's initialized and uninitialized parts.
1334 bfd_section_from_phdr (abfd
, hdr
, index
)
1336 Elf_Internal_Phdr
*hdr
;
1344 split
= ((hdr
->p_memsz
> 0) &&
1345 (hdr
->p_filesz
> 0) &&
1346 (hdr
->p_memsz
> hdr
->p_filesz
));
1347 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
1348 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1351 strcpy (name
, namebuf
);
1352 newsect
= bfd_make_section (abfd
, name
);
1353 if (newsect
== NULL
)
1355 newsect
->vma
= hdr
->p_vaddr
;
1356 newsect
->lma
= hdr
->p_paddr
;
1357 newsect
->_raw_size
= hdr
->p_filesz
;
1358 newsect
->filepos
= hdr
->p_offset
;
1359 newsect
->flags
|= SEC_HAS_CONTENTS
;
1360 if (hdr
->p_type
== PT_LOAD
)
1362 newsect
->flags
|= SEC_ALLOC
;
1363 newsect
->flags
|= SEC_LOAD
;
1364 if (hdr
->p_flags
& PF_X
)
1366 /* FIXME: all we known is that it has execute PERMISSION,
1368 newsect
->flags
|= SEC_CODE
;
1371 if (!(hdr
->p_flags
& PF_W
))
1373 newsect
->flags
|= SEC_READONLY
;
1378 sprintf (namebuf
, "segment%db", index
);
1379 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1382 strcpy (name
, namebuf
);
1383 newsect
= bfd_make_section (abfd
, name
);
1384 if (newsect
== NULL
)
1386 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1387 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1388 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1389 if (hdr
->p_type
== PT_LOAD
)
1391 newsect
->flags
|= SEC_ALLOC
;
1392 if (hdr
->p_flags
& PF_X
)
1393 newsect
->flags
|= SEC_CODE
;
1395 if (!(hdr
->p_flags
& PF_W
))
1396 newsect
->flags
|= SEC_READONLY
;
1402 /* Set up an ELF internal section header for a section. */
1406 elf_fake_sections (abfd
, asect
, failedptrarg
)
1411 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1412 boolean
*failedptr
= (boolean
*) failedptrarg
;
1413 Elf_Internal_Shdr
*this_hdr
;
1417 /* We already failed; just get out of the bfd_map_over_sections
1422 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1424 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1427 if (this_hdr
->sh_name
== (unsigned long) -1)
1433 this_hdr
->sh_flags
= 0;
1435 if ((asect
->flags
& SEC_ALLOC
) != 0
1436 || asect
->user_set_vma
)
1437 this_hdr
->sh_addr
= asect
->vma
;
1439 this_hdr
->sh_addr
= 0;
1441 this_hdr
->sh_offset
= 0;
1442 this_hdr
->sh_size
= asect
->_raw_size
;
1443 this_hdr
->sh_link
= 0;
1444 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1445 /* The sh_entsize and sh_info fields may have been set already by
1446 copy_private_section_data. */
1448 this_hdr
->bfd_section
= asect
;
1449 this_hdr
->contents
= NULL
;
1451 /* FIXME: This should not be based on section names. */
1452 if (strcmp (asect
->name
, ".dynstr") == 0)
1453 this_hdr
->sh_type
= SHT_STRTAB
;
1454 else if (strcmp (asect
->name
, ".hash") == 0)
1456 this_hdr
->sh_type
= SHT_HASH
;
1457 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1459 else if (strcmp (asect
->name
, ".dynsym") == 0)
1461 this_hdr
->sh_type
= SHT_DYNSYM
;
1462 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1464 else if (strcmp (asect
->name
, ".dynamic") == 0)
1466 this_hdr
->sh_type
= SHT_DYNAMIC
;
1467 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1469 else if (strncmp (asect
->name
, ".rela", 5) == 0
1470 && get_elf_backend_data (abfd
)->use_rela_p
)
1472 this_hdr
->sh_type
= SHT_RELA
;
1473 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1475 else if (strncmp (asect
->name
, ".rel", 4) == 0
1476 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1478 this_hdr
->sh_type
= SHT_REL
;
1479 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1481 else if (strncmp (asect
->name
, ".note", 5) == 0)
1482 this_hdr
->sh_type
= SHT_NOTE
;
1483 else if (strncmp (asect
->name
, ".stab", 5) == 0
1484 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1485 this_hdr
->sh_type
= SHT_STRTAB
;
1486 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1488 this_hdr
->sh_type
= SHT_GNU_versym
;
1489 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1491 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1493 this_hdr
->sh_type
= SHT_GNU_verdef
;
1494 this_hdr
->sh_entsize
= 0;
1495 /* objcopy or strip will copy over sh_info, but may not set
1496 cverdefs. The linker will set cverdefs, but sh_info will be
1498 if (this_hdr
->sh_info
== 0)
1499 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1501 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1502 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1504 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1506 this_hdr
->sh_type
= SHT_GNU_verneed
;
1507 this_hdr
->sh_entsize
= 0;
1508 /* objcopy or strip will copy over sh_info, but may not set
1509 cverrefs. The linker will set cverrefs, but sh_info will be
1511 if (this_hdr
->sh_info
== 0)
1512 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1514 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1515 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1517 else if ((asect
->flags
& SEC_ALLOC
) != 0
1518 && (asect
->flags
& SEC_LOAD
) != 0)
1519 this_hdr
->sh_type
= SHT_PROGBITS
;
1520 else if ((asect
->flags
& SEC_ALLOC
) != 0
1521 && ((asect
->flags
& SEC_LOAD
) == 0))
1522 this_hdr
->sh_type
= SHT_NOBITS
;
1526 this_hdr
->sh_type
= SHT_PROGBITS
;
1529 if ((asect
->flags
& SEC_ALLOC
) != 0)
1530 this_hdr
->sh_flags
|= SHF_ALLOC
;
1531 if ((asect
->flags
& SEC_READONLY
) == 0)
1532 this_hdr
->sh_flags
|= SHF_WRITE
;
1533 if ((asect
->flags
& SEC_CODE
) != 0)
1534 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1536 /* Check for processor-specific section types. */
1538 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1540 if (bed
->elf_backend_fake_sections
)
1541 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1544 /* If the section has relocs, set up a section header for the
1545 SHT_REL[A] section. */
1546 if ((asect
->flags
& SEC_RELOC
) != 0)
1548 Elf_Internal_Shdr
*rela_hdr
;
1549 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1552 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1553 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1559 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1561 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1563 if (rela_hdr
->sh_name
== (unsigned int) -1)
1568 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1569 rela_hdr
->sh_entsize
= (use_rela_p
1570 ? bed
->s
->sizeof_rela
1571 : bed
->s
->sizeof_rel
);
1572 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1573 rela_hdr
->sh_flags
= 0;
1574 rela_hdr
->sh_addr
= 0;
1575 rela_hdr
->sh_size
= 0;
1576 rela_hdr
->sh_offset
= 0;
1580 /* Assign all ELF section numbers. The dummy first section is handled here
1581 too. The link/info pointers for the standard section types are filled
1582 in here too, while we're at it. */
1585 assign_section_numbers (abfd
)
1588 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1590 unsigned int section_number
;
1591 Elf_Internal_Shdr
**i_shdrp
;
1592 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1596 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1598 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1600 d
->this_idx
= section_number
++;
1601 if ((sec
->flags
& SEC_RELOC
) == 0)
1604 d
->rel_idx
= section_number
++;
1607 t
->shstrtab_section
= section_number
++;
1608 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1609 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1611 if (abfd
->symcount
> 0)
1613 t
->symtab_section
= section_number
++;
1614 t
->strtab_section
= section_number
++;
1617 elf_elfheader (abfd
)->e_shnum
= section_number
;
1619 /* Set up the list of section header pointers, in agreement with the
1621 i_shdrp
= ((Elf_Internal_Shdr
**)
1622 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1623 if (i_shdrp
== NULL
)
1626 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1627 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1628 if (i_shdrp
[0] == NULL
)
1630 bfd_release (abfd
, i_shdrp
);
1633 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1635 elf_elfsections (abfd
) = i_shdrp
;
1637 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1638 if (abfd
->symcount
> 0)
1640 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1641 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1642 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1644 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1646 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1650 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1651 if (d
->rel_idx
!= 0)
1652 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1654 /* Fill in the sh_link and sh_info fields while we're at it. */
1656 /* sh_link of a reloc section is the section index of the symbol
1657 table. sh_info is the section index of the section to which
1658 the relocation entries apply. */
1659 if (d
->rel_idx
!= 0)
1661 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1662 d
->rel_hdr
.sh_info
= d
->this_idx
;
1665 switch (d
->this_hdr
.sh_type
)
1669 /* A reloc section which we are treating as a normal BFD
1670 section. sh_link is the section index of the symbol
1671 table. sh_info is the section index of the section to
1672 which the relocation entries apply. We assume that an
1673 allocated reloc section uses the dynamic symbol table.
1674 FIXME: How can we be sure? */
1675 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1677 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1679 /* We look up the section the relocs apply to by name. */
1681 if (d
->this_hdr
.sh_type
== SHT_REL
)
1685 s
= bfd_get_section_by_name (abfd
, name
);
1687 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1691 /* We assume that a section named .stab*str is a stabs
1692 string section. We look for a section with the same name
1693 but without the trailing ``str'', and set its sh_link
1694 field to point to this section. */
1695 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1696 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1701 len
= strlen (sec
->name
);
1702 alc
= (char *) bfd_malloc (len
- 2);
1705 strncpy (alc
, sec
->name
, len
- 3);
1706 alc
[len
- 3] = '\0';
1707 s
= bfd_get_section_by_name (abfd
, alc
);
1711 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1713 /* This is a .stab section. */
1714 elf_section_data (s
)->this_hdr
.sh_entsize
=
1715 4 + 2 * (bed
->s
->arch_size
/ 8);
1722 case SHT_GNU_verneed
:
1723 case SHT_GNU_verdef
:
1724 /* sh_link is the section header index of the string table
1725 used for the dynamic entries, or the symbol table, or the
1727 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1729 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1733 case SHT_GNU_versym
:
1734 /* sh_link is the section header index of the symbol table
1735 this hash table or version table is for. */
1736 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1738 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1746 /* Map symbol from it's internal number to the external number, moving
1747 all local symbols to be at the head of the list. */
1750 sym_is_global (abfd
, sym
)
1754 /* If the backend has a special mapping, use it. */
1755 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1756 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1759 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1760 || bfd_is_und_section (bfd_get_section (sym
))
1761 || bfd_is_com_section (bfd_get_section (sym
)));
1765 elf_map_symbols (abfd
)
1768 int symcount
= bfd_get_symcount (abfd
);
1769 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1770 asymbol
**sect_syms
;
1772 int num_globals
= 0;
1773 int num_locals2
= 0;
1774 int num_globals2
= 0;
1776 int num_sections
= 0;
1782 fprintf (stderr
, "elf_map_symbols\n");
1786 /* Add a section symbol for each BFD section. FIXME: Is this really
1788 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1790 if (max_index
< asect
->index
)
1791 max_index
= asect
->index
;
1795 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1796 if (sect_syms
== NULL
)
1798 elf_section_syms (abfd
) = sect_syms
;
1800 for (idx
= 0; idx
< symcount
; idx
++)
1802 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1803 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1807 sec
= syms
[idx
]->section
;
1808 if (sec
->owner
!= NULL
)
1810 if (sec
->owner
!= abfd
)
1812 if (sec
->output_offset
!= 0)
1814 sec
= sec
->output_section
;
1815 BFD_ASSERT (sec
->owner
== abfd
);
1817 sect_syms
[sec
->index
] = syms
[idx
];
1822 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1826 if (sect_syms
[asect
->index
] != NULL
)
1829 sym
= bfd_make_empty_symbol (abfd
);
1832 sym
->the_bfd
= abfd
;
1833 sym
->name
= asect
->name
;
1835 /* Set the flags to 0 to indicate that this one was newly added. */
1837 sym
->section
= asect
;
1838 sect_syms
[asect
->index
] = sym
;
1842 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1843 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1847 /* Classify all of the symbols. */
1848 for (idx
= 0; idx
< symcount
; idx
++)
1850 if (!sym_is_global (abfd
, syms
[idx
]))
1855 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1857 if (sect_syms
[asect
->index
] != NULL
1858 && sect_syms
[asect
->index
]->flags
== 0)
1860 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1861 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1865 sect_syms
[asect
->index
]->flags
= 0;
1869 /* Now sort the symbols so the local symbols are first. */
1870 new_syms
= ((asymbol
**)
1872 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1873 if (new_syms
== NULL
)
1876 for (idx
= 0; idx
< symcount
; idx
++)
1878 asymbol
*sym
= syms
[idx
];
1881 if (!sym_is_global (abfd
, sym
))
1884 i
= num_locals
+ num_globals2
++;
1886 sym
->udata
.i
= i
+ 1;
1888 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1890 if (sect_syms
[asect
->index
] != NULL
1891 && sect_syms
[asect
->index
]->flags
== 0)
1893 asymbol
*sym
= sect_syms
[asect
->index
];
1896 sym
->flags
= BSF_SECTION_SYM
;
1897 if (!sym_is_global (abfd
, sym
))
1900 i
= num_locals
+ num_globals2
++;
1902 sym
->udata
.i
= i
+ 1;
1906 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1908 elf_num_locals (abfd
) = num_locals
;
1909 elf_num_globals (abfd
) = num_globals
;
1913 /* Align to the maximum file alignment that could be required for any
1914 ELF data structure. */
1916 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1917 static INLINE file_ptr
1918 align_file_position (off
, align
)
1922 return (off
+ align
- 1) & ~(align
- 1);
1925 /* Assign a file position to a section, optionally aligning to the
1926 required section alignment. */
1929 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1930 Elf_Internal_Shdr
*i_shdrp
;
1938 al
= i_shdrp
->sh_addralign
;
1940 offset
= BFD_ALIGN (offset
, al
);
1942 i_shdrp
->sh_offset
= offset
;
1943 if (i_shdrp
->bfd_section
!= NULL
)
1944 i_shdrp
->bfd_section
->filepos
= offset
;
1945 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1946 offset
+= i_shdrp
->sh_size
;
1950 /* Compute the file positions we are going to put the sections at, and
1951 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1952 is not NULL, this is being called by the ELF backend linker. */
1955 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1957 struct bfd_link_info
*link_info
;
1959 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1961 struct bfd_strtab_hash
*strtab
;
1962 Elf_Internal_Shdr
*shstrtab_hdr
;
1964 if (abfd
->output_has_begun
)
1967 /* Do any elf backend specific processing first. */
1968 if (bed
->elf_backend_begin_write_processing
)
1969 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1971 if (! prep_headers (abfd
))
1975 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1979 if (!assign_section_numbers (abfd
))
1982 /* The backend linker builds symbol table information itself. */
1983 if (link_info
== NULL
&& abfd
->symcount
> 0)
1985 if (! swap_out_syms (abfd
, &strtab
))
1989 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1990 /* sh_name was set in prep_headers. */
1991 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1992 shstrtab_hdr
->sh_flags
= 0;
1993 shstrtab_hdr
->sh_addr
= 0;
1994 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1995 shstrtab_hdr
->sh_entsize
= 0;
1996 shstrtab_hdr
->sh_link
= 0;
1997 shstrtab_hdr
->sh_info
= 0;
1998 /* sh_offset is set in assign_file_positions_except_relocs. */
1999 shstrtab_hdr
->sh_addralign
= 1;
2001 if (!assign_file_positions_except_relocs (abfd
))
2004 if (link_info
== NULL
&& abfd
->symcount
> 0)
2007 Elf_Internal_Shdr
*hdr
;
2009 off
= elf_tdata (abfd
)->next_file_pos
;
2011 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2012 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2014 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2015 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2017 elf_tdata (abfd
)->next_file_pos
= off
;
2019 /* Now that we know where the .strtab section goes, write it
2021 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2022 || ! _bfd_stringtab_emit (abfd
, strtab
))
2024 _bfd_stringtab_free (strtab
);
2027 abfd
->output_has_begun
= true;
2032 /* Create a mapping from a set of sections to a program segment. */
2034 static INLINE
struct elf_segment_map
*
2035 make_mapping (abfd
, sections
, from
, to
, phdr
)
2037 asection
**sections
;
2042 struct elf_segment_map
*m
;
2046 m
= ((struct elf_segment_map
*)
2048 (sizeof (struct elf_segment_map
)
2049 + (to
- from
- 1) * sizeof (asection
*))));
2053 m
->p_type
= PT_LOAD
;
2054 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2055 m
->sections
[i
- from
] = *hdrpp
;
2056 m
->count
= to
- from
;
2058 if (from
== 0 && phdr
)
2060 /* Include the headers in the first PT_LOAD segment. */
2061 m
->includes_filehdr
= 1;
2062 m
->includes_phdrs
= 1;
2068 /* Set up a mapping from BFD sections to program segments. */
2071 map_sections_to_segments (abfd
)
2074 asection
**sections
= NULL
;
2078 struct elf_segment_map
*mfirst
;
2079 struct elf_segment_map
**pm
;
2080 struct elf_segment_map
*m
;
2082 unsigned int phdr_index
;
2083 bfd_vma maxpagesize
;
2085 boolean phdr_in_section
= true;
2089 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2092 if (bfd_count_sections (abfd
) == 0)
2095 /* Select the allocated sections, and sort them. */
2097 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2098 * sizeof (asection
*));
2099 if (sections
== NULL
)
2103 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2105 if ((s
->flags
& SEC_ALLOC
) != 0)
2111 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2114 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2116 /* Build the mapping. */
2121 /* If we have a .interp section, then create a PT_PHDR segment for
2122 the program headers and a PT_INTERP segment for the .interp
2124 s
= bfd_get_section_by_name (abfd
, ".interp");
2125 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2127 m
= ((struct elf_segment_map
*)
2128 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2132 m
->p_type
= PT_PHDR
;
2133 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2134 m
->p_flags
= PF_R
| PF_X
;
2135 m
->p_flags_valid
= 1;
2136 m
->includes_phdrs
= 1;
2141 m
= ((struct elf_segment_map
*)
2142 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2146 m
->p_type
= PT_INTERP
;
2154 /* Look through the sections. We put sections in the same program
2155 segment when the start of the second section can be placed within
2156 a few bytes of the end of the first section. */
2159 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2161 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2163 && (dynsec
->flags
& SEC_LOAD
) == 0)
2166 /* Deal with -Ttext or something similar such that the first section
2167 is not adjacent to the program headers. This is an
2168 approximation, since at this point we don't know exactly how many
2169 program headers we will need. */
2172 bfd_size_type phdr_size
;
2174 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2176 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2177 if ((abfd
->flags
& D_PAGED
) == 0
2178 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2179 phdr_in_section
= false;
2182 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2185 boolean new_segment
;
2189 /* See if this section and the last one will fit in the same
2192 if (last_hdr
== NULL
)
2194 /* If we don't have a segment yet, then we don't need a new
2195 one (we build the last one after this loop). */
2196 new_segment
= false;
2198 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2200 /* If this section has a different relation between the
2201 virtual address and the load address, then we need a new
2205 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2206 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2208 /* If putting this section in this segment would force us to
2209 skip a page in the segment, then we need a new segment. */
2212 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2213 && (hdr
->flags
& SEC_LOAD
) != 0)
2215 /* We don't want to put a loadable section after a
2216 nonloadable section in the same segment. */
2219 else if ((abfd
->flags
& D_PAGED
) == 0)
2221 /* If the file is not demand paged, which means that we
2222 don't require the sections to be correctly aligned in the
2223 file, then there is no other reason for a new segment. */
2224 new_segment
= false;
2227 && (hdr
->flags
& SEC_READONLY
) == 0
2228 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2231 /* We don't want to put a writable section in a read only
2232 segment, unless they are on the same page in memory
2233 anyhow. We already know that the last section does not
2234 bring us past the current section on the page, so the
2235 only case in which the new section is not on the same
2236 page as the previous section is when the previous section
2237 ends precisely on a page boundary. */
2242 /* Otherwise, we can use the same segment. */
2243 new_segment
= false;
2248 if ((hdr
->flags
& SEC_READONLY
) == 0)
2254 /* We need a new program segment. We must create a new program
2255 header holding all the sections from phdr_index until hdr. */
2257 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2264 if ((hdr
->flags
& SEC_READONLY
) == 0)
2271 phdr_in_section
= false;
2274 /* Create a final PT_LOAD program segment. */
2275 if (last_hdr
!= NULL
)
2277 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2285 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2288 m
= ((struct elf_segment_map
*)
2289 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2293 m
->p_type
= PT_DYNAMIC
;
2295 m
->sections
[0] = dynsec
;
2301 /* For each loadable .note section, add a PT_NOTE segment. We don't
2302 use bfd_get_section_by_name, because if we link together
2303 nonloadable .note sections and loadable .note sections, we will
2304 generate two .note sections in the output file. FIXME: Using
2305 names for section types is bogus anyhow. */
2306 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2308 if ((s
->flags
& SEC_LOAD
) != 0
2309 && strncmp (s
->name
, ".note", 5) == 0)
2311 m
= ((struct elf_segment_map
*)
2312 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2316 m
->p_type
= PT_NOTE
;
2328 elf_tdata (abfd
)->segment_map
= mfirst
;
2332 if (sections
!= NULL
)
2337 /* Sort sections by VMA. */
2340 elf_sort_sections (arg1
, arg2
)
2344 const asection
*sec1
= *(const asection
**) arg1
;
2345 const asection
*sec2
= *(const asection
**) arg2
;
2347 if (sec1
->vma
< sec2
->vma
)
2349 else if (sec1
->vma
> sec2
->vma
)
2352 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
2353 this will do nothing. */
2354 if (sec1
->lma
< sec2
->lma
)
2356 else if (sec1
->lma
> sec2
->lma
)
2359 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2361 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2366 return sec1
->target_index
- sec2
->target_index
;
2376 /* Sort by size, to put zero sized sections before others at the
2379 if (sec1
->_raw_size
< sec2
->_raw_size
)
2381 if (sec1
->_raw_size
> sec2
->_raw_size
)
2384 return sec1
->target_index
- sec2
->target_index
;
2387 /* Assign file positions to the sections based on the mapping from
2388 sections to segments. This function also sets up some fields in
2389 the file header, and writes out the program headers. */
2392 assign_file_positions_for_segments (abfd
)
2395 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2397 struct elf_segment_map
*m
;
2399 Elf_Internal_Phdr
*phdrs
;
2401 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2402 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2403 Elf_Internal_Phdr
*p
;
2405 if (elf_tdata (abfd
)->segment_map
== NULL
)
2407 if (! map_sections_to_segments (abfd
))
2411 if (bed
->elf_backend_modify_segment_map
)
2413 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2418 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2421 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2422 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2423 elf_elfheader (abfd
)->e_phnum
= count
;
2428 /* If we already counted the number of program segments, make sure
2429 that we allocated enough space. This happens when SIZEOF_HEADERS
2430 is used in a linker script. */
2431 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2432 if (alloc
!= 0 && count
> alloc
)
2434 ((*_bfd_error_handler
)
2435 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2436 bfd_get_filename (abfd
), alloc
, count
));
2437 bfd_set_error (bfd_error_bad_value
);
2444 phdrs
= ((Elf_Internal_Phdr
*)
2445 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2449 off
= bed
->s
->sizeof_ehdr
;
2450 off
+= alloc
* bed
->s
->sizeof_phdr
;
2456 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2463 /* If elf_segment_map is not from map_sections_to_segments, the
2464 sections may not be correctly ordered. */
2466 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2469 p
->p_type
= m
->p_type
;
2471 if (m
->p_flags_valid
)
2472 p
->p_flags
= m
->p_flags
;
2476 if (p
->p_type
== PT_LOAD
2478 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2480 if ((abfd
->flags
& D_PAGED
) != 0)
2481 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2483 off
+= ((m
->sections
[0]->vma
- off
)
2484 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2490 p
->p_vaddr
= m
->sections
[0]->vma
;
2492 if (m
->p_paddr_valid
)
2493 p
->p_paddr
= m
->p_paddr
;
2494 else if (m
->count
== 0)
2497 p
->p_paddr
= m
->sections
[0]->lma
;
2499 if (p
->p_type
== PT_LOAD
2500 && (abfd
->flags
& D_PAGED
) != 0)
2501 p
->p_align
= bed
->maxpagesize
;
2502 else if (m
->count
== 0)
2503 p
->p_align
= bed
->s
->file_align
;
2511 if (m
->includes_filehdr
)
2513 if (! m
->p_flags_valid
)
2516 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2517 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2520 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2522 if (p
->p_vaddr
< (bfd_vma
) off
)
2524 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2525 bfd_get_filename (abfd
));
2526 bfd_set_error (bfd_error_bad_value
);
2531 if (! m
->p_paddr_valid
)
2534 if (p
->p_type
== PT_LOAD
)
2536 filehdr_vaddr
= p
->p_vaddr
;
2537 filehdr_paddr
= p
->p_paddr
;
2541 if (m
->includes_phdrs
)
2543 if (! m
->p_flags_valid
)
2545 if (m
->includes_filehdr
)
2547 if (p
->p_type
== PT_LOAD
)
2549 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2550 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2555 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2558 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2559 p
->p_vaddr
-= off
- p
->p_offset
;
2560 if (! m
->p_paddr_valid
)
2561 p
->p_paddr
-= off
- p
->p_offset
;
2563 if (p
->p_type
== PT_LOAD
)
2565 phdrs_vaddr
= p
->p_vaddr
;
2566 phdrs_paddr
= p
->p_paddr
;
2569 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2570 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2573 if (p
->p_type
== PT_LOAD
)
2575 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2581 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2582 p
->p_filesz
+= adjust
;
2583 p
->p_memsz
+= adjust
;
2588 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2592 bfd_size_type align
;
2596 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2598 if (p
->p_type
== PT_LOAD
)
2602 if ((flags
& SEC_LOAD
) != 0)
2603 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2604 else if ((flags
& SEC_ALLOC
) != 0)
2606 /* The section VMA must equal the file position
2607 modulo the page size. FIXME: I'm not sure if
2608 this adjustment is really necessary. We used to
2609 not have the SEC_LOAD case just above, and then
2610 this was necessary, but now I'm not sure. */
2611 if ((abfd
->flags
& D_PAGED
) != 0)
2612 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2614 adjust
= (sec
->vma
- voff
) % align
;
2623 p
->p_memsz
+= adjust
;
2626 if ((flags
& SEC_LOAD
) != 0)
2627 p
->p_filesz
+= adjust
;
2632 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2633 used in a linker script we may have a section with
2634 SEC_LOAD clear but which is supposed to have
2636 if ((flags
& SEC_LOAD
) != 0
2637 || (flags
& SEC_HAS_CONTENTS
) != 0)
2638 off
+= sec
->_raw_size
;
2639 if ((flags
& SEC_ALLOC
) != 0)
2640 voff
+= sec
->_raw_size
;
2643 p
->p_memsz
+= sec
->_raw_size
;
2645 if ((flags
& SEC_LOAD
) != 0)
2646 p
->p_filesz
+= sec
->_raw_size
;
2648 if (align
> p
->p_align
)
2651 if (! m
->p_flags_valid
)
2654 if ((flags
& SEC_CODE
) != 0)
2656 if ((flags
& SEC_READONLY
) == 0)
2662 /* Now that we have set the section file positions, we can set up
2663 the file positions for the non PT_LOAD segments. */
2664 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2668 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2670 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2671 p
->p_offset
= m
->sections
[0]->filepos
;
2675 if (m
->includes_filehdr
)
2677 p
->p_vaddr
= filehdr_vaddr
;
2678 if (! m
->p_paddr_valid
)
2679 p
->p_paddr
= filehdr_paddr
;
2681 else if (m
->includes_phdrs
)
2683 p
->p_vaddr
= phdrs_vaddr
;
2684 if (! m
->p_paddr_valid
)
2685 p
->p_paddr
= phdrs_paddr
;
2690 /* Clear out any program headers we allocated but did not use. */
2691 for (; count
< alloc
; count
++, p
++)
2693 memset (p
, 0, sizeof *p
);
2694 p
->p_type
= PT_NULL
;
2697 elf_tdata (abfd
)->phdr
= phdrs
;
2699 elf_tdata (abfd
)->next_file_pos
= off
;
2701 /* Write out the program headers. */
2702 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2703 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2709 /* Get the size of the program header.
2711 If this is called by the linker before any of the section VMA's are set, it
2712 can't calculate the correct value for a strange memory layout. This only
2713 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2714 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2715 data segment (exclusive of .interp and .dynamic).
2717 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2718 will be two segments. */
2720 static bfd_size_type
2721 get_program_header_size (abfd
)
2726 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2728 /* We can't return a different result each time we're called. */
2729 if (elf_tdata (abfd
)->program_header_size
!= 0)
2730 return elf_tdata (abfd
)->program_header_size
;
2732 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2734 struct elf_segment_map
*m
;
2737 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2739 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2740 return elf_tdata (abfd
)->program_header_size
;
2743 /* Assume we will need exactly two PT_LOAD segments: one for text
2744 and one for data. */
2747 s
= bfd_get_section_by_name (abfd
, ".interp");
2748 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2750 /* If we have a loadable interpreter section, we need a
2751 PT_INTERP segment. In this case, assume we also need a
2752 PT_PHDR segment, although that may not be true for all
2757 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2759 /* We need a PT_DYNAMIC segment. */
2763 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2765 if ((s
->flags
& SEC_LOAD
) != 0
2766 && strncmp (s
->name
, ".note", 5) == 0)
2768 /* We need a PT_NOTE segment. */
2773 /* Let the backend count up any program headers it might need. */
2774 if (bed
->elf_backend_additional_program_headers
)
2778 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2784 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2785 return elf_tdata (abfd
)->program_header_size
;
2788 /* Work out the file positions of all the sections. This is called by
2789 _bfd_elf_compute_section_file_positions. All the section sizes and
2790 VMAs must be known before this is called.
2792 We do not consider reloc sections at this point, unless they form
2793 part of the loadable image. Reloc sections are assigned file
2794 positions in assign_file_positions_for_relocs, which is called by
2795 write_object_contents and final_link.
2797 We also don't set the positions of the .symtab and .strtab here. */
2800 assign_file_positions_except_relocs (abfd
)
2803 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2804 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2805 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2807 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2809 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2811 Elf_Internal_Shdr
**hdrpp
;
2814 /* Start after the ELF header. */
2815 off
= i_ehdrp
->e_ehsize
;
2817 /* We are not creating an executable, which means that we are
2818 not creating a program header, and that the actual order of
2819 the sections in the file is unimportant. */
2820 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2822 Elf_Internal_Shdr
*hdr
;
2825 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2827 hdr
->sh_offset
= -1;
2830 if (i
== tdata
->symtab_section
2831 || i
== tdata
->strtab_section
)
2833 hdr
->sh_offset
= -1;
2837 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2843 Elf_Internal_Shdr
**hdrpp
;
2845 /* Assign file positions for the loaded sections based on the
2846 assignment of sections to segments. */
2847 if (! assign_file_positions_for_segments (abfd
))
2850 /* Assign file positions for the other sections. */
2852 off
= elf_tdata (abfd
)->next_file_pos
;
2853 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2855 Elf_Internal_Shdr
*hdr
;
2858 if (hdr
->bfd_section
!= NULL
2859 && hdr
->bfd_section
->filepos
!= 0)
2860 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2861 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2863 ((*_bfd_error_handler
)
2864 (_("%s: warning: allocated section `%s' not in segment"),
2865 bfd_get_filename (abfd
),
2866 (hdr
->bfd_section
== NULL
2868 : hdr
->bfd_section
->name
)));
2869 if ((abfd
->flags
& D_PAGED
) != 0)
2870 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2872 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2873 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2876 else if (hdr
->sh_type
== SHT_REL
2877 || hdr
->sh_type
== SHT_RELA
2878 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2879 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2880 hdr
->sh_offset
= -1;
2882 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2886 /* Place the section headers. */
2887 off
= align_file_position (off
, bed
->s
->file_align
);
2888 i_ehdrp
->e_shoff
= off
;
2889 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2891 elf_tdata (abfd
)->next_file_pos
= off
;
2900 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2901 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2902 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2904 struct bfd_strtab_hash
*shstrtab
;
2905 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2907 i_ehdrp
= elf_elfheader (abfd
);
2908 i_shdrp
= elf_elfsections (abfd
);
2910 shstrtab
= _bfd_elf_stringtab_init ();
2911 if (shstrtab
== NULL
)
2914 elf_shstrtab (abfd
) = shstrtab
;
2916 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2917 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2918 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2919 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2921 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2922 i_ehdrp
->e_ident
[EI_DATA
] =
2923 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2924 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2926 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2927 i_ehdrp
->e_ident
[count
] = 0;
2929 if ((abfd
->flags
& DYNAMIC
) != 0)
2930 i_ehdrp
->e_type
= ET_DYN
;
2931 else if ((abfd
->flags
& EXEC_P
) != 0)
2932 i_ehdrp
->e_type
= ET_EXEC
;
2934 i_ehdrp
->e_type
= ET_REL
;
2936 switch (bfd_get_arch (abfd
))
2938 case bfd_arch_unknown
:
2939 i_ehdrp
->e_machine
= EM_NONE
;
2941 case bfd_arch_sparc
:
2942 if (bed
->s
->arch_size
== 64)
2943 i_ehdrp
->e_machine
= EM_SPARCV9
;
2945 i_ehdrp
->e_machine
= EM_SPARC
;
2948 i_ehdrp
->e_machine
= EM_386
;
2951 i_ehdrp
->e_machine
= EM_68K
;
2954 i_ehdrp
->e_machine
= EM_88K
;
2957 i_ehdrp
->e_machine
= EM_860
;
2959 case bfd_arch_mips
: /* MIPS Rxxxx */
2960 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2963 i_ehdrp
->e_machine
= EM_PARISC
;
2965 case bfd_arch_powerpc
:
2966 i_ehdrp
->e_machine
= EM_PPC
;
2968 case bfd_arch_alpha
:
2969 i_ehdrp
->e_machine
= EM_ALPHA
;
2972 i_ehdrp
->e_machine
= EM_SH
;
2975 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2977 /* start-sanitize-d30v */
2979 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
2981 /* end-sanitize-d30v */
2983 switch (bfd_get_mach (abfd
))
2986 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
2990 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2993 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
2995 case bfd_arch_mn10200
:
2996 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
2998 case bfd_arch_mn10300
:
2999 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3001 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3003 i_ehdrp
->e_machine
= EM_NONE
;
3005 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3006 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3008 /* no program header, for now. */
3009 i_ehdrp
->e_phoff
= 0;
3010 i_ehdrp
->e_phentsize
= 0;
3011 i_ehdrp
->e_phnum
= 0;
3013 /* each bfd section is section header entry */
3014 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3015 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3017 /* if we're building an executable, we'll need a program header table */
3018 if (abfd
->flags
& EXEC_P
)
3020 /* it all happens later */
3022 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3024 /* elf_build_phdrs() returns a (NULL-terminated) array of
3025 Elf_Internal_Phdrs */
3026 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3027 i_ehdrp
->e_phoff
= outbase
;
3028 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3033 i_ehdrp
->e_phentsize
= 0;
3035 i_ehdrp
->e_phoff
= 0;
3038 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3039 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3040 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3041 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3042 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3043 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3044 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3045 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3046 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3052 /* Assign file positions for all the reloc sections which are not part
3053 of the loadable file image. */
3056 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3061 Elf_Internal_Shdr
**shdrpp
;
3063 off
= elf_tdata (abfd
)->next_file_pos
;
3065 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3066 i
< elf_elfheader (abfd
)->e_shnum
;
3069 Elf_Internal_Shdr
*shdrp
;
3072 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3073 && shdrp
->sh_offset
== -1)
3074 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3077 elf_tdata (abfd
)->next_file_pos
= off
;
3081 _bfd_elf_write_object_contents (abfd
)
3084 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3085 Elf_Internal_Ehdr
*i_ehdrp
;
3086 Elf_Internal_Shdr
**i_shdrp
;
3090 if (! abfd
->output_has_begun
3091 && ! _bfd_elf_compute_section_file_positions (abfd
,
3092 (struct bfd_link_info
*) NULL
))
3095 i_shdrp
= elf_elfsections (abfd
);
3096 i_ehdrp
= elf_elfheader (abfd
);
3099 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3102 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3104 /* After writing the headers, we need to write the sections too... */
3105 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3107 if (bed
->elf_backend_section_processing
)
3108 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3109 if (i_shdrp
[count
]->contents
)
3111 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3112 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3114 != i_shdrp
[count
]->sh_size
))
3119 /* Write out the section header names. */
3120 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3121 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3124 if (bed
->elf_backend_final_write_processing
)
3125 (*bed
->elf_backend_final_write_processing
) (abfd
,
3126 elf_tdata (abfd
)->linker
);
3128 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3131 /* given a section, search the header to find them... */
3133 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3137 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3138 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3140 Elf_Internal_Shdr
*hdr
;
3141 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3143 for (index
= 0; index
< maxindex
; index
++)
3145 hdr
= i_shdrp
[index
];
3146 if (hdr
->bfd_section
== asect
)
3150 if (bed
->elf_backend_section_from_bfd_section
)
3152 for (index
= 0; index
< maxindex
; index
++)
3156 hdr
= i_shdrp
[index
];
3158 if ((*bed
->elf_backend_section_from_bfd_section
)
3159 (abfd
, hdr
, asect
, &retval
))
3164 if (bfd_is_abs_section (asect
))
3166 if (bfd_is_com_section (asect
))
3168 if (bfd_is_und_section (asect
))
3174 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3178 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3180 asymbol
**asym_ptr_ptr
;
3182 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3184 flagword flags
= asym_ptr
->flags
;
3186 /* When gas creates relocations against local labels, it creates its
3187 own symbol for the section, but does put the symbol into the
3188 symbol chain, so udata is 0. When the linker is generating
3189 relocatable output, this section symbol may be for one of the
3190 input sections rather than the output section. */
3191 if (asym_ptr
->udata
.i
== 0
3192 && (flags
& BSF_SECTION_SYM
)
3193 && asym_ptr
->section
)
3197 if (asym_ptr
->section
->output_section
!= NULL
)
3198 indx
= asym_ptr
->section
->output_section
->index
;
3200 indx
= asym_ptr
->section
->index
;
3201 if (elf_section_syms (abfd
)[indx
])
3202 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3205 idx
= asym_ptr
->udata
.i
;
3209 /* This case can occur when using --strip-symbol on a symbol
3210 which is used in a relocation entry. */
3211 (*_bfd_error_handler
)
3212 (_("%s: symbol `%s' required but not present"),
3213 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3214 bfd_set_error (bfd_error_no_symbols
);
3221 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3222 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3223 elf_symbol_flags (flags
));
3231 /* Copy private BFD data. This copies any program header information. */
3234 copy_private_bfd_data (ibfd
, obfd
)
3238 Elf_Internal_Ehdr
*iehdr
;
3239 struct elf_segment_map
*mfirst
;
3240 struct elf_segment_map
**pm
;
3241 struct elf_segment_map
*m
;
3242 Elf_Internal_Phdr
*p
;
3245 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3246 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3249 if (elf_tdata (ibfd
)->phdr
== NULL
)
3252 iehdr
= elf_elfheader (ibfd
);
3257 c
= elf_elfheader (ibfd
)->e_phnum
;
3258 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
3266 /* The complicated case when p_vaddr is 0 is to handle the
3267 Solaris linker, which generates a PT_INTERP section with
3268 p_vaddr and p_memsz set to 0. */
3269 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3270 if (((s
->vma
>= p
->p_vaddr
3271 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3272 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3275 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3276 && (bfd_vma
) s
->filepos
>= p
->p_offset
3277 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3278 <= p
->p_offset
+ p
->p_filesz
)))
3279 && (s
->flags
& SEC_ALLOC
) != 0
3280 && s
->output_section
!= NULL
)
3283 m
= ((struct elf_segment_map
*)
3285 (sizeof (struct elf_segment_map
)
3286 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3291 m
->p_type
= p
->p_type
;
3292 m
->p_flags
= p
->p_flags
;
3293 m
->p_flags_valid
= 1;
3294 m
->p_paddr
= p
->p_paddr
;
3295 m
->p_paddr_valid
= 1;
3297 m
->includes_filehdr
= (p
->p_offset
== 0
3298 && p
->p_filesz
>= iehdr
->e_ehsize
);
3300 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3301 && (p
->p_offset
+ p
->p_filesz
3302 >= ((bfd_vma
) iehdr
->e_phoff
3303 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3306 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3308 if (((s
->vma
>= p
->p_vaddr
3309 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3310 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3313 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3314 && (bfd_vma
) s
->filepos
>= p
->p_offset
3315 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3316 <= p
->p_offset
+ p
->p_filesz
)))
3317 && (s
->flags
& SEC_ALLOC
) != 0
3318 && s
->output_section
!= NULL
)
3320 m
->sections
[isec
] = s
->output_section
;
3324 BFD_ASSERT (isec
== csecs
);
3331 /* The Solaris linker creates program headers in which all the
3332 p_paddr fields are zero. When we try to objcopy or strip such a
3333 file, we get confused. Check for this case, and if we find it
3334 reset the p_paddr_valid fields. */
3335 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3336 if (m
->p_paddr
!= 0)
3340 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3341 m
->p_paddr_valid
= 0;
3344 elf_tdata (obfd
)->segment_map
= mfirst
;
3349 /* Copy private section information. This copies over the entsize
3350 field, and sometimes the info field. */
3353 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3359 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3361 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3362 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3365 /* Copy over private BFD data if it has not already been copied.
3366 This must be done here, rather than in the copy_private_bfd_data
3367 entry point, because the latter is called after the section
3368 contents have been set, which means that the program headers have
3369 already been worked out. */
3370 if (elf_tdata (obfd
)->segment_map
== NULL
3371 && elf_tdata (ibfd
)->phdr
!= NULL
)
3375 /* Only set up the segments if there are no more SEC_ALLOC
3376 sections. FIXME: This won't do the right thing if objcopy is
3377 used to remove the last SEC_ALLOC section, since objcopy
3378 won't call this routine in that case. */
3379 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3380 if ((s
->flags
& SEC_ALLOC
) != 0)
3384 if (! copy_private_bfd_data (ibfd
, obfd
))
3389 ihdr
= &elf_section_data (isec
)->this_hdr
;
3390 ohdr
= &elf_section_data (osec
)->this_hdr
;
3392 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3394 if (ihdr
->sh_type
== SHT_SYMTAB
3395 || ihdr
->sh_type
== SHT_DYNSYM
3396 || ihdr
->sh_type
== SHT_GNU_verneed
3397 || ihdr
->sh_type
== SHT_GNU_verdef
)
3398 ohdr
->sh_info
= ihdr
->sh_info
;
3403 /* Copy private symbol information. If this symbol is in a section
3404 which we did not map into a BFD section, try to map the section
3405 index correctly. We use special macro definitions for the mapped
3406 section indices; these definitions are interpreted by the
3407 swap_out_syms function. */
3409 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3410 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3411 #define MAP_STRTAB (SHN_LORESERVE - 3)
3412 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3415 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3421 elf_symbol_type
*isym
, *osym
;
3423 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3424 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3427 isym
= elf_symbol_from (ibfd
, isymarg
);
3428 osym
= elf_symbol_from (obfd
, osymarg
);
3432 && bfd_is_abs_section (isym
->symbol
.section
))
3436 shndx
= isym
->internal_elf_sym
.st_shndx
;
3437 if (shndx
== elf_onesymtab (ibfd
))
3438 shndx
= MAP_ONESYMTAB
;
3439 else if (shndx
== elf_dynsymtab (ibfd
))
3440 shndx
= MAP_DYNSYMTAB
;
3441 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3443 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3444 shndx
= MAP_SHSTRTAB
;
3445 osym
->internal_elf_sym
.st_shndx
= shndx
;
3451 /* Swap out the symbols. */
3454 swap_out_syms (abfd
, sttp
)
3456 struct bfd_strtab_hash
**sttp
;
3458 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3460 if (!elf_map_symbols (abfd
))
3463 /* Dump out the symtabs. */
3465 int symcount
= bfd_get_symcount (abfd
);
3466 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3467 struct bfd_strtab_hash
*stt
;
3468 Elf_Internal_Shdr
*symtab_hdr
;
3469 Elf_Internal_Shdr
*symstrtab_hdr
;
3470 char *outbound_syms
;
3473 stt
= _bfd_elf_stringtab_init ();
3477 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3478 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3479 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3480 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3481 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3482 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3484 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3485 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3487 outbound_syms
= bfd_alloc (abfd
,
3488 (1 + symcount
) * bed
->s
->sizeof_sym
);
3489 if (outbound_syms
== NULL
)
3491 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3493 /* now generate the data (for "contents") */
3495 /* Fill in zeroth symbol and swap it out. */
3496 Elf_Internal_Sym sym
;
3502 sym
.st_shndx
= SHN_UNDEF
;
3503 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3504 outbound_syms
+= bed
->s
->sizeof_sym
;
3506 for (idx
= 0; idx
< symcount
; idx
++)
3508 Elf_Internal_Sym sym
;
3509 bfd_vma value
= syms
[idx
]->value
;
3510 elf_symbol_type
*type_ptr
;
3511 flagword flags
= syms
[idx
]->flags
;
3514 if (flags
& BSF_SECTION_SYM
)
3515 /* Section symbols have no names. */
3519 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3522 if (sym
.st_name
== (unsigned long) -1)
3526 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3528 if (bfd_is_com_section (syms
[idx
]->section
))
3530 /* ELF common symbols put the alignment into the `value' field,
3531 and the size into the `size' field. This is backwards from
3532 how BFD handles it, so reverse it here. */
3533 sym
.st_size
= value
;
3534 if (type_ptr
== NULL
3535 || type_ptr
->internal_elf_sym
.st_value
== 0)
3536 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3538 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3539 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3540 syms
[idx
]->section
);
3544 asection
*sec
= syms
[idx
]->section
;
3547 if (sec
->output_section
)
3549 value
+= sec
->output_offset
;
3550 sec
= sec
->output_section
;
3553 sym
.st_value
= value
;
3554 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3556 if (bfd_is_abs_section (sec
)
3558 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3560 /* This symbol is in a real ELF section which we did
3561 not create as a BFD section. Undo the mapping done
3562 by copy_private_symbol_data. */
3563 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3567 shndx
= elf_onesymtab (abfd
);
3570 shndx
= elf_dynsymtab (abfd
);
3573 shndx
= elf_tdata (abfd
)->strtab_section
;
3576 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3584 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3590 /* Writing this would be a hell of a lot easier if
3591 we had some decent documentation on bfd, and
3592 knew what to expect of the library, and what to
3593 demand of applications. For example, it
3594 appears that `objcopy' might not set the
3595 section of a symbol to be a section that is
3596 actually in the output file. */
3597 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3598 BFD_ASSERT (sec2
!= 0);
3599 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3600 BFD_ASSERT (shndx
!= -1);
3604 sym
.st_shndx
= shndx
;
3607 if ((flags
& BSF_FUNCTION
) != 0)
3609 else if ((flags
& BSF_OBJECT
) != 0)
3614 if (bfd_is_com_section (syms
[idx
]->section
))
3615 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3616 else if (bfd_is_und_section (syms
[idx
]->section
))
3617 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3621 else if (flags
& BSF_SECTION_SYM
)
3622 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3623 else if (flags
& BSF_FILE
)
3624 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3627 int bind
= STB_LOCAL
;
3629 if (flags
& BSF_LOCAL
)
3631 else if (flags
& BSF_WEAK
)
3633 else if (flags
& BSF_GLOBAL
)
3636 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3639 if (type_ptr
!= NULL
)
3640 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3644 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3645 outbound_syms
+= bed
->s
->sizeof_sym
;
3649 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3650 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3652 symstrtab_hdr
->sh_flags
= 0;
3653 symstrtab_hdr
->sh_addr
= 0;
3654 symstrtab_hdr
->sh_entsize
= 0;
3655 symstrtab_hdr
->sh_link
= 0;
3656 symstrtab_hdr
->sh_info
= 0;
3657 symstrtab_hdr
->sh_addralign
= 1;
3663 /* Return the number of bytes required to hold the symtab vector.
3665 Note that we base it on the count plus 1, since we will null terminate
3666 the vector allocated based on this size. However, the ELF symbol table
3667 always has a dummy entry as symbol #0, so it ends up even. */
3670 _bfd_elf_get_symtab_upper_bound (abfd
)
3675 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3677 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3678 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3684 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3689 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3691 if (elf_dynsymtab (abfd
) == 0)
3693 bfd_set_error (bfd_error_invalid_operation
);
3697 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3698 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3704 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3708 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3711 /* Canonicalize the relocs. */
3714 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3723 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3729 tblptr
= section
->relocation
;
3730 for (i
= 0; i
< section
->reloc_count
; i
++)
3731 *relptr
++ = tblptr
++;
3735 return section
->reloc_count
;
3739 _bfd_elf_get_symtab (abfd
, alocation
)
3741 asymbol
**alocation
;
3743 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3746 bfd_get_symcount (abfd
) = symcount
;
3751 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3753 asymbol
**alocation
;
3755 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3758 /* Return the size required for the dynamic reloc entries. Any
3759 section that was actually installed in the BFD, and has type
3760 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3761 considered to be a dynamic reloc section. */
3764 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3770 if (elf_dynsymtab (abfd
) == 0)
3772 bfd_set_error (bfd_error_invalid_operation
);
3776 ret
= sizeof (arelent
*);
3777 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3778 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3779 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3780 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3781 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3782 * sizeof (arelent
*));
3787 /* Canonicalize the dynamic relocation entries. Note that we return
3788 the dynamic relocations as a single block, although they are
3789 actually associated with particular sections; the interface, which
3790 was designed for SunOS style shared libraries, expects that there
3791 is only one set of dynamic relocs. Any section that was actually
3792 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3793 the dynamic symbol table, is considered to be a dynamic reloc
3797 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3802 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3806 if (elf_dynsymtab (abfd
) == 0)
3808 bfd_set_error (bfd_error_invalid_operation
);
3812 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3814 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3816 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3817 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3818 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3823 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3825 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3827 for (i
= 0; i
< count
; i
++)
3838 /* Read in the version information. */
3841 _bfd_elf_slurp_version_tables (abfd
)
3844 bfd_byte
*contents
= NULL
;
3846 if (elf_dynverdef (abfd
) != 0)
3848 Elf_Internal_Shdr
*hdr
;
3849 Elf_External_Verdef
*everdef
;
3850 Elf_Internal_Verdef
*iverdef
;
3853 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
3855 elf_tdata (abfd
)->verdef
=
3856 ((Elf_Internal_Verdef
*)
3857 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
3858 if (elf_tdata (abfd
)->verdef
== NULL
)
3861 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
3863 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3864 if (contents
== NULL
)
3866 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3867 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3870 everdef
= (Elf_External_Verdef
*) contents
;
3871 iverdef
= elf_tdata (abfd
)->verdef
;
3872 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
3874 Elf_External_Verdaux
*everdaux
;
3875 Elf_Internal_Verdaux
*iverdaux
;
3878 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
3880 iverdef
->vd_bfd
= abfd
;
3882 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
3885 * sizeof (Elf_Internal_Verdaux
))));
3886 if (iverdef
->vd_auxptr
== NULL
)
3889 everdaux
= ((Elf_External_Verdaux
*)
3890 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
3891 iverdaux
= iverdef
->vd_auxptr
;
3892 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
3894 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
3896 iverdaux
->vda_nodename
=
3897 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3898 iverdaux
->vda_name
);
3899 if (iverdaux
->vda_nodename
== NULL
)
3902 if (j
+ 1 < iverdef
->vd_cnt
)
3903 iverdaux
->vda_nextptr
= iverdaux
+ 1;
3905 iverdaux
->vda_nextptr
= NULL
;
3907 everdaux
= ((Elf_External_Verdaux
*)
3908 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
3911 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
3913 if (i
+ 1 < hdr
->sh_info
)
3914 iverdef
->vd_nextdef
= iverdef
+ 1;
3916 iverdef
->vd_nextdef
= NULL
;
3918 everdef
= ((Elf_External_Verdef
*)
3919 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
3926 if (elf_dynverref (abfd
) != 0)
3928 Elf_Internal_Shdr
*hdr
;
3929 Elf_External_Verneed
*everneed
;
3930 Elf_Internal_Verneed
*iverneed
;
3933 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
3935 elf_tdata (abfd
)->verref
=
3936 ((Elf_Internal_Verneed
*)
3937 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
3938 if (elf_tdata (abfd
)->verref
== NULL
)
3941 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
3943 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3944 if (contents
== NULL
)
3946 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3947 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3950 everneed
= (Elf_External_Verneed
*) contents
;
3951 iverneed
= elf_tdata (abfd
)->verref
;
3952 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
3954 Elf_External_Vernaux
*evernaux
;
3955 Elf_Internal_Vernaux
*ivernaux
;
3958 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
3960 iverneed
->vn_bfd
= abfd
;
3962 iverneed
->vn_filename
=
3963 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3965 if (iverneed
->vn_filename
== NULL
)
3968 iverneed
->vn_auxptr
=
3969 ((Elf_Internal_Vernaux
*)
3971 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
3973 evernaux
= ((Elf_External_Vernaux
*)
3974 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
3975 ivernaux
= iverneed
->vn_auxptr
;
3976 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
3978 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
3980 ivernaux
->vna_nodename
=
3981 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3982 ivernaux
->vna_name
);
3983 if (ivernaux
->vna_nodename
== NULL
)
3986 if (j
+ 1 < iverneed
->vn_cnt
)
3987 ivernaux
->vna_nextptr
= ivernaux
+ 1;
3989 ivernaux
->vna_nextptr
= NULL
;
3991 evernaux
= ((Elf_External_Vernaux
*)
3992 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
3995 if (i
+ 1 < hdr
->sh_info
)
3996 iverneed
->vn_nextref
= iverneed
+ 1;
3998 iverneed
->vn_nextref
= NULL
;
4000 everneed
= ((Elf_External_Verneed
*)
4001 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4011 if (contents
== NULL
)
4017 _bfd_elf_make_empty_symbol (abfd
)
4020 elf_symbol_type
*newsym
;
4022 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4027 newsym
->symbol
.the_bfd
= abfd
;
4028 return &newsym
->symbol
;
4033 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4038 bfd_symbol_info (symbol
, ret
);
4041 /* Return whether a symbol name implies a local symbol. Most targets
4042 use this function for the is_local_label_name entry point, but some
4046 _bfd_elf_is_local_label_name (abfd
, name
)
4050 /* Normal local symbols start with ``.L''. */
4051 if (name
[0] == '.' && name
[1] == 'L')
4054 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4055 DWARF debugging symbols starting with ``..''. */
4056 if (name
[0] == '.' && name
[1] == '.')
4059 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4060 emitting DWARF debugging output. I suspect this is actually a
4061 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4062 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4063 underscore to be emitted on some ELF targets). For ease of use,
4064 we treat such symbols as local. */
4065 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4072 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4081 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4083 enum bfd_architecture arch
;
4084 unsigned long machine
;
4086 /* If this isn't the right architecture for this backend, and this
4087 isn't the generic backend, fail. */
4088 if (arch
!= get_elf_backend_data (abfd
)->arch
4089 && arch
!= bfd_arch_unknown
4090 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4093 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4096 /* Find the nearest line to a particular section and offset, for error
4100 _bfd_elf_find_nearest_line (abfd
,
4111 CONST
char **filename_ptr
;
4112 CONST
char **functionname_ptr
;
4113 unsigned int *line_ptr
;
4116 const char *filename
;
4121 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4122 filename_ptr
, functionname_ptr
,
4126 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4127 &found
, filename_ptr
,
4128 functionname_ptr
, line_ptr
,
4129 &elf_tdata (abfd
)->line_info
))
4134 if (symbols
== NULL
)
4141 for (p
= symbols
; *p
!= NULL
; p
++)
4145 q
= (elf_symbol_type
*) *p
;
4147 if (bfd_get_section (&q
->symbol
) != section
)
4150 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4155 filename
= bfd_asymbol_name (&q
->symbol
);
4158 if (q
->symbol
.section
== section
4159 && q
->symbol
.value
>= low_func
4160 && q
->symbol
.value
<= offset
)
4162 func
= (asymbol
*) q
;
4163 low_func
= q
->symbol
.value
;
4172 *filename_ptr
= filename
;
4173 *functionname_ptr
= bfd_asymbol_name (func
);
4179 _bfd_elf_sizeof_headers (abfd
, reloc
)
4185 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4187 ret
+= get_program_header_size (abfd
);
4192 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4197 bfd_size_type count
;
4199 Elf_Internal_Shdr
*hdr
;
4201 if (! abfd
->output_has_begun
4202 && ! _bfd_elf_compute_section_file_positions (abfd
,
4203 (struct bfd_link_info
*) NULL
))
4206 hdr
= &elf_section_data (section
)->this_hdr
;
4208 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4210 if (bfd_write (location
, 1, count
, abfd
) != count
)
4217 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4220 Elf_Internal_Rela
*dst
;
4227 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4230 Elf_Internal_Rel
*dst
;
4236 /* Try to convert a non-ELF reloc into an ELF one. */
4239 _bfd_elf_validate_reloc (abfd
, areloc
)
4243 /* Check whether we really have an ELF howto. */
4245 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4247 bfd_reloc_code_real_type code
;
4248 reloc_howto_type
*howto
;
4250 /* Alien reloc: Try to determine its type to replace it with an
4251 equivalent ELF reloc. */
4253 if (areloc
->howto
->pc_relative
)
4255 switch (areloc
->howto
->bitsize
)
4258 code
= BFD_RELOC_8_PCREL
;
4261 code
= BFD_RELOC_12_PCREL
;
4264 code
= BFD_RELOC_16_PCREL
;
4267 code
= BFD_RELOC_24_PCREL
;
4270 code
= BFD_RELOC_32_PCREL
;
4273 code
= BFD_RELOC_64_PCREL
;
4279 howto
= bfd_reloc_type_lookup (abfd
, code
);
4281 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4283 if (howto
->pcrel_offset
)
4284 areloc
->addend
+= areloc
->address
;
4286 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4291 switch (areloc
->howto
->bitsize
)
4297 code
= BFD_RELOC_14
;
4300 code
= BFD_RELOC_16
;
4303 code
= BFD_RELOC_26
;
4306 code
= BFD_RELOC_32
;
4309 code
= BFD_RELOC_64
;
4315 howto
= bfd_reloc_type_lookup (abfd
, code
);
4319 areloc
->howto
= howto
;
4327 (*_bfd_error_handler
)
4328 (_("%s: unsupported relocation type %s"),
4329 bfd_get_filename (abfd
), areloc
->howto
->name
);
4330 bfd_set_error (bfd_error_bad_value
);
4335 _bfd_elf_close_and_cleanup (abfd
)
4338 if (bfd_get_format (abfd
) == bfd_object
)
4340 if (elf_shstrtab (abfd
) != NULL
)
4341 _bfd_stringtab_free (elf_shstrtab (abfd
));
4344 return _bfd_generic_close_and_cleanup (abfd
);