1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
41 static INLINE
struct elf_segment_map
*make_mapping
42 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
43 static boolean map_sections_to_segments
PARAMS ((bfd
*));
44 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
45 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
46 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
47 static boolean prep_headers
PARAMS ((bfd
*));
48 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
49 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
50 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
51 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
52 static boolean assign_section_numbers
PARAMS ((bfd
*));
53 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
54 static boolean elf_map_symbols
PARAMS ((bfd
*));
55 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
57 /* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
61 /* Swap in a Verdef structure. */
64 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
66 const Elf_External_Verdef
*src
;
67 Elf_Internal_Verdef
*dst
;
69 dst
->vd_version
= bfd_h_get_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= bfd_h_get_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= bfd_h_get_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= bfd_h_get_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= bfd_h_get_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= bfd_h_get_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= bfd_h_get_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
83 const Elf_Internal_Verdef
*src
;
84 Elf_External_Verdef
*dst
;
86 bfd_h_put_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 bfd_h_put_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 bfd_h_put_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 bfd_h_put_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 bfd_h_put_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 bfd_h_put_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 bfd_h_put_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
100 const Elf_External_Verdaux
*src
;
101 Elf_Internal_Verdaux
*dst
;
103 dst
->vda_name
= bfd_h_get_32 (abfd
, src
->vda_name
);
104 dst
->vda_next
= bfd_h_get_32 (abfd
, src
->vda_next
);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
112 const Elf_Internal_Verdaux
*src
;
113 Elf_External_Verdaux
*dst
;
115 bfd_h_put_32 (abfd
, src
->vda_name
, dst
->vda_name
);
116 bfd_h_put_32 (abfd
, src
->vda_next
, dst
->vda_next
);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
124 const Elf_External_Verneed
*src
;
125 Elf_Internal_Verneed
*dst
;
127 dst
->vn_version
= bfd_h_get_16 (abfd
, src
->vn_version
);
128 dst
->vn_cnt
= bfd_h_get_16 (abfd
, src
->vn_cnt
);
129 dst
->vn_file
= bfd_h_get_32 (abfd
, src
->vn_file
);
130 dst
->vn_aux
= bfd_h_get_32 (abfd
, src
->vn_aux
);
131 dst
->vn_next
= bfd_h_get_32 (abfd
, src
->vn_next
);
134 /* Swap out a Verneed structure. */
137 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
139 const Elf_Internal_Verneed
*src
;
140 Elf_External_Verneed
*dst
;
142 bfd_h_put_16 (abfd
, src
->vn_version
, dst
->vn_version
);
143 bfd_h_put_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
144 bfd_h_put_32 (abfd
, src
->vn_file
, dst
->vn_file
);
145 bfd_h_put_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
146 bfd_h_put_32 (abfd
, src
->vn_next
, dst
->vn_next
);
149 /* Swap in a Vernaux structure. */
152 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
154 const Elf_External_Vernaux
*src
;
155 Elf_Internal_Vernaux
*dst
;
157 dst
->vna_hash
= bfd_h_get_32 (abfd
, src
->vna_hash
);
158 dst
->vna_flags
= bfd_h_get_16 (abfd
, src
->vna_flags
);
159 dst
->vna_other
= bfd_h_get_16 (abfd
, src
->vna_other
);
160 dst
->vna_name
= bfd_h_get_32 (abfd
, src
->vna_name
);
161 dst
->vna_next
= bfd_h_get_32 (abfd
, src
->vna_next
);
164 /* Swap out a Vernaux structure. */
167 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
169 const Elf_Internal_Vernaux
*src
;
170 Elf_External_Vernaux
*dst
;
172 bfd_h_put_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
173 bfd_h_put_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
174 bfd_h_put_16 (abfd
, src
->vna_other
, dst
->vna_other
);
175 bfd_h_put_32 (abfd
, src
->vna_name
, dst
->vna_name
);
176 bfd_h_put_32 (abfd
, src
->vna_next
, dst
->vna_next
);
179 /* Swap in a Versym structure. */
182 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
184 const Elf_External_Versym
*src
;
185 Elf_Internal_Versym
*dst
;
187 dst
->vs_vers
= bfd_h_get_16 (abfd
, src
->vs_vers
);
190 /* Swap out a Versym structure. */
193 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
195 const Elf_Internal_Versym
*src
;
196 Elf_External_Versym
*dst
;
198 bfd_h_put_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
201 /* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. (Well, you would if this
203 were being used yet.) */
206 CONST
unsigned char *name
;
212 while ((ch
= *name
++) != '\0')
215 if ((g
= (h
& 0xf0000000)) != 0)
224 /* Read a specified number of bytes at a specified offset in an ELF
225 file, into a newly allocated buffer, and return a pointer to the
229 elf_read (abfd
, offset
, size
)
236 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
238 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
240 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
242 if (bfd_get_error () != bfd_error_system_call
)
243 bfd_set_error (bfd_error_file_truncated
);
250 bfd_elf_mkobject (abfd
)
253 /* this just does initialization */
254 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
255 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
256 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
257 if (elf_tdata (abfd
) == 0)
259 /* since everything is done at close time, do we need any
266 bfd_elf_get_str_section (abfd
, shindex
)
268 unsigned int shindex
;
270 Elf_Internal_Shdr
**i_shdrp
;
271 char *shstrtab
= NULL
;
273 unsigned int shstrtabsize
;
275 i_shdrp
= elf_elfsections (abfd
);
276 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
279 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
280 if (shstrtab
== NULL
)
282 /* No cached one, attempt to read, and cache what we read. */
283 offset
= i_shdrp
[shindex
]->sh_offset
;
284 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
285 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
286 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
292 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
294 unsigned int shindex
;
295 unsigned int strindex
;
297 Elf_Internal_Shdr
*hdr
;
302 hdr
= elf_elfsections (abfd
)[shindex
];
304 if (hdr
->contents
== NULL
305 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
308 if (strindex
>= hdr
->sh_size
)
310 (*_bfd_error_handler
)
311 (_("%s: invalid string offset %u >= %lu for section `%s'"),
312 bfd_get_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
313 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
314 && strindex
== hdr
->sh_name
)
316 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
320 return ((char *) hdr
->contents
) + strindex
;
323 /* Make a BFD section from an ELF section. We store a pointer to the
324 BFD section in the bfd_section field of the header. */
327 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
329 Elf_Internal_Shdr
*hdr
;
335 if (hdr
->bfd_section
!= NULL
)
337 BFD_ASSERT (strcmp (name
,
338 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
342 newsect
= bfd_make_section_anyway (abfd
, name
);
346 newsect
->filepos
= hdr
->sh_offset
;
348 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
349 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
350 || ! bfd_set_section_alignment (abfd
, newsect
,
351 bfd_log2 (hdr
->sh_addralign
)))
354 flags
= SEC_NO_FLAGS
;
355 if (hdr
->sh_type
!= SHT_NOBITS
)
356 flags
|= SEC_HAS_CONTENTS
;
357 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
360 if (hdr
->sh_type
!= SHT_NOBITS
)
363 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
364 flags
|= SEC_READONLY
;
365 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
367 else if ((flags
& SEC_LOAD
) != 0)
370 /* The debugging sections appear to be recognized only by name, not
372 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
373 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
374 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
375 flags
|= SEC_DEBUGGING
;
377 /* As a GNU extension, if the name begins with .gnu.linkonce, we
378 only link a single copy of the section. This is used to support
379 g++. g++ will emit each template expansion in its own section.
380 The symbols will be defined as weak, so that multiple definitions
381 are permitted. The GNU linker extension is to actually discard
382 all but one of the sections. */
383 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
384 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
386 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
389 if ((flags
& SEC_ALLOC
) != 0)
391 Elf_Internal_Phdr
*phdr
;
394 /* Look through the phdrs to see if we need to adjust the lma. */
395 phdr
= elf_tdata (abfd
)->phdr
;
396 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
398 if (phdr
->p_type
== PT_LOAD
399 && phdr
->p_paddr
!= 0
400 && phdr
->p_vaddr
!= phdr
->p_paddr
401 && phdr
->p_vaddr
<= hdr
->sh_addr
402 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
403 && ((flags
& SEC_LOAD
) == 0
404 || (phdr
->p_offset
<= (bfd_vma
) hdr
->sh_offset
405 && (phdr
->p_offset
+ phdr
->p_filesz
406 >= hdr
->sh_offset
+ hdr
->sh_size
))))
408 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
414 hdr
->bfd_section
= newsect
;
415 elf_section_data (newsect
)->this_hdr
= *hdr
;
425 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
428 Helper functions for GDB to locate the string tables.
429 Since BFD hides string tables from callers, GDB needs to use an
430 internal hook to find them. Sun's .stabstr, in particular,
431 isn't even pointed to by the .stab section, so ordinary
432 mechanisms wouldn't work to find it, even if we had some.
435 struct elf_internal_shdr
*
436 bfd_elf_find_section (abfd
, name
)
440 Elf_Internal_Shdr
**i_shdrp
;
445 i_shdrp
= elf_elfsections (abfd
);
448 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
449 if (shstrtab
!= NULL
)
451 max
= elf_elfheader (abfd
)->e_shnum
;
452 for (i
= 1; i
< max
; i
++)
453 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
460 const char *const bfd_elf_section_type_names
[] = {
461 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
462 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
463 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
466 /* ELF relocs are against symbols. If we are producing relocateable
467 output, and the reloc is against an external symbol, and nothing
468 has given us any additional addend, the resulting reloc will also
469 be against the same symbol. In such a case, we don't want to
470 change anything about the way the reloc is handled, since it will
471 all be done at final link time. Rather than put special case code
472 into bfd_perform_relocation, all the reloc types use this howto
473 function. It just short circuits the reloc if producing
474 relocateable output against an external symbol. */
477 bfd_reloc_status_type
478 bfd_elf_generic_reloc (abfd
,
486 arelent
*reloc_entry
;
489 asection
*input_section
;
491 char **error_message
;
493 if (output_bfd
!= (bfd
*) NULL
494 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
495 && (! reloc_entry
->howto
->partial_inplace
496 || reloc_entry
->addend
== 0))
498 reloc_entry
->address
+= input_section
->output_offset
;
502 return bfd_reloc_continue
;
505 /* Print out the program headers. */
508 _bfd_elf_print_private_bfd_data (abfd
, farg
)
512 FILE *f
= (FILE *) farg
;
513 Elf_Internal_Phdr
*p
;
515 bfd_byte
*dynbuf
= NULL
;
517 p
= elf_tdata (abfd
)->phdr
;
522 fprintf (f
, _("\nProgram Header:\n"));
523 c
= elf_elfheader (abfd
)->e_phnum
;
524 for (i
= 0; i
< c
; i
++, p
++)
531 case PT_NULL
: s
= "NULL"; break;
532 case PT_LOAD
: s
= "LOAD"; break;
533 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
534 case PT_INTERP
: s
= "INTERP"; break;
535 case PT_NOTE
: s
= "NOTE"; break;
536 case PT_SHLIB
: s
= "SHLIB"; break;
537 case PT_PHDR
: s
= "PHDR"; break;
538 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
540 fprintf (f
, "%8s off 0x", s
);
541 fprintf_vma (f
, p
->p_offset
);
542 fprintf (f
, " vaddr 0x");
543 fprintf_vma (f
, p
->p_vaddr
);
544 fprintf (f
, " paddr 0x");
545 fprintf_vma (f
, p
->p_paddr
);
546 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
547 fprintf (f
, " filesz 0x");
548 fprintf_vma (f
, p
->p_filesz
);
549 fprintf (f
, " memsz 0x");
550 fprintf_vma (f
, p
->p_memsz
);
551 fprintf (f
, " flags %c%c%c",
552 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
553 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
554 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
555 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
556 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
561 s
= bfd_get_section_by_name (abfd
, ".dynamic");
566 bfd_byte
*extdyn
, *extdynend
;
568 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
570 fprintf (f
, _("\nDynamic Section:\n"));
572 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
575 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
579 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
582 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
584 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
585 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
588 extdynend
= extdyn
+ s
->_raw_size
;
589 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
591 Elf_Internal_Dyn dyn
;
596 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
598 if (dyn
.d_tag
== DT_NULL
)
605 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
609 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
610 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
611 case DT_PLTGOT
: name
= "PLTGOT"; break;
612 case DT_HASH
: name
= "HASH"; break;
613 case DT_STRTAB
: name
= "STRTAB"; break;
614 case DT_SYMTAB
: name
= "SYMTAB"; break;
615 case DT_RELA
: name
= "RELA"; break;
616 case DT_RELASZ
: name
= "RELASZ"; break;
617 case DT_RELAENT
: name
= "RELAENT"; break;
618 case DT_STRSZ
: name
= "STRSZ"; break;
619 case DT_SYMENT
: name
= "SYMENT"; break;
620 case DT_INIT
: name
= "INIT"; break;
621 case DT_FINI
: name
= "FINI"; break;
622 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
623 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
624 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
625 case DT_REL
: name
= "REL"; break;
626 case DT_RELSZ
: name
= "RELSZ"; break;
627 case DT_RELENT
: name
= "RELENT"; break;
628 case DT_PLTREL
: name
= "PLTREL"; break;
629 case DT_DEBUG
: name
= "DEBUG"; break;
630 case DT_TEXTREL
: name
= "TEXTREL"; break;
631 case DT_JMPREL
: name
= "JMPREL"; break;
632 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
633 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
634 case DT_VERSYM
: name
= "VERSYM"; break;
635 case DT_VERDEF
: name
= "VERDEF"; break;
636 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
637 case DT_VERNEED
: name
= "VERNEED"; break;
638 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
641 fprintf (f
, " %-11s ", name
);
643 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
648 string
= bfd_elf_string_from_elf_section (abfd
, link
,
652 fprintf (f
, "%s", string
);
661 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
662 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
664 if (! _bfd_elf_slurp_version_tables (abfd
))
668 if (elf_dynverdef (abfd
) != 0)
670 Elf_Internal_Verdef
*t
;
672 fprintf (f
, _("\nVersion definitions:\n"));
673 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
675 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
676 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
677 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
679 Elf_Internal_Verdaux
*a
;
682 for (a
= t
->vd_auxptr
->vda_nextptr
;
685 fprintf (f
, "%s ", a
->vda_nodename
);
691 if (elf_dynverref (abfd
) != 0)
693 Elf_Internal_Verneed
*t
;
695 fprintf (f
, _("\nVersion References:\n"));
696 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
698 Elf_Internal_Vernaux
*a
;
700 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
701 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
702 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
703 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
715 /* Display ELF-specific fields of a symbol. */
718 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
722 bfd_print_symbol_type how
;
724 FILE *file
= (FILE *) filep
;
727 case bfd_print_symbol_name
:
728 fprintf (file
, "%s", symbol
->name
);
730 case bfd_print_symbol_more
:
731 fprintf (file
, "elf ");
732 fprintf_vma (file
, symbol
->value
);
733 fprintf (file
, " %lx", (long) symbol
->flags
);
735 case bfd_print_symbol_all
:
737 CONST
char *section_name
;
738 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
739 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
740 fprintf (file
, " %s\t", section_name
);
741 /* Print the "other" value for a symbol. For common symbols,
742 we've already printed the size; now print the alignment.
743 For other symbols, we have no specified alignment, and
744 we've printed the address; now print the size. */
746 (bfd_is_com_section (symbol
->section
)
747 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
748 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
750 /* If we have version information, print it. */
751 if (elf_tdata (abfd
)->dynversym_section
!= 0
752 && (elf_tdata (abfd
)->dynverdef_section
!= 0
753 || elf_tdata (abfd
)->dynverref_section
!= 0))
756 const char *version_string
;
758 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
762 else if (vernum
== 1)
763 version_string
= "Base";
764 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
766 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
769 Elf_Internal_Verneed
*t
;
772 for (t
= elf_tdata (abfd
)->verref
;
776 Elf_Internal_Vernaux
*a
;
778 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
780 if (a
->vna_other
== vernum
)
782 version_string
= a
->vna_nodename
;
789 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
790 fprintf (file
, " %-11s", version_string
);
795 fprintf (file
, " (%s)", version_string
);
796 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
801 /* If the st_other field is not zero, print it. */
802 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
803 fprintf (file
, " 0x%02x",
805 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
807 fprintf (file
, " %s", symbol
->name
);
813 /* Create an entry in an ELF linker hash table. */
815 struct bfd_hash_entry
*
816 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
817 struct bfd_hash_entry
*entry
;
818 struct bfd_hash_table
*table
;
821 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
823 /* Allocate the structure if it has not already been allocated by a
825 if (ret
== (struct elf_link_hash_entry
*) NULL
)
826 ret
= ((struct elf_link_hash_entry
*)
827 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
828 if (ret
== (struct elf_link_hash_entry
*) NULL
)
829 return (struct bfd_hash_entry
*) ret
;
831 /* Call the allocation method of the superclass. */
832 ret
= ((struct elf_link_hash_entry
*)
833 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
835 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
837 /* Set local fields. */
841 ret
->dynstr_index
= 0;
843 ret
->got_offset
= (bfd_vma
) -1;
844 ret
->plt_offset
= (bfd_vma
) -1;
845 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
846 ret
->verinfo
.verdef
= NULL
;
847 ret
->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
== 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 /* Non-zero if doing a relocatable link. */
1986 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
1988 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
1992 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1993 /* sh_name was set in prep_headers. */
1994 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1995 shstrtab_hdr
->sh_flags
= 0;
1996 shstrtab_hdr
->sh_addr
= 0;
1997 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1998 shstrtab_hdr
->sh_entsize
= 0;
1999 shstrtab_hdr
->sh_link
= 0;
2000 shstrtab_hdr
->sh_info
= 0;
2001 /* sh_offset is set in assign_file_positions_except_relocs. */
2002 shstrtab_hdr
->sh_addralign
= 1;
2004 if (!assign_file_positions_except_relocs (abfd
))
2007 if (link_info
== NULL
&& abfd
->symcount
> 0)
2010 Elf_Internal_Shdr
*hdr
;
2012 off
= elf_tdata (abfd
)->next_file_pos
;
2014 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2015 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2017 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2018 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2020 elf_tdata (abfd
)->next_file_pos
= off
;
2022 /* Now that we know where the .strtab section goes, write it
2024 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2025 || ! _bfd_stringtab_emit (abfd
, strtab
))
2027 _bfd_stringtab_free (strtab
);
2030 abfd
->output_has_begun
= true;
2035 /* Create a mapping from a set of sections to a program segment. */
2037 static INLINE
struct elf_segment_map
*
2038 make_mapping (abfd
, sections
, from
, to
, phdr
)
2040 asection
**sections
;
2045 struct elf_segment_map
*m
;
2049 m
= ((struct elf_segment_map
*)
2051 (sizeof (struct elf_segment_map
)
2052 + (to
- from
- 1) * sizeof (asection
*))));
2056 m
->p_type
= PT_LOAD
;
2057 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2058 m
->sections
[i
- from
] = *hdrpp
;
2059 m
->count
= to
- from
;
2061 if (from
== 0 && phdr
)
2063 /* Include the headers in the first PT_LOAD segment. */
2064 m
->includes_filehdr
= 1;
2065 m
->includes_phdrs
= 1;
2071 /* Set up a mapping from BFD sections to program segments. */
2074 map_sections_to_segments (abfd
)
2077 asection
**sections
= NULL
;
2081 struct elf_segment_map
*mfirst
;
2082 struct elf_segment_map
**pm
;
2083 struct elf_segment_map
*m
;
2085 unsigned int phdr_index
;
2086 bfd_vma maxpagesize
;
2088 boolean phdr_in_section
= true;
2092 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2095 if (bfd_count_sections (abfd
) == 0)
2098 /* Select the allocated sections, and sort them. */
2100 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2101 * sizeof (asection
*));
2102 if (sections
== NULL
)
2106 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2108 if ((s
->flags
& SEC_ALLOC
) != 0)
2114 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2117 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2119 /* Build the mapping. */
2124 /* If we have a .interp section, then create a PT_PHDR segment for
2125 the program headers and a PT_INTERP segment for the .interp
2127 s
= bfd_get_section_by_name (abfd
, ".interp");
2128 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2130 m
= ((struct elf_segment_map
*)
2131 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2135 m
->p_type
= PT_PHDR
;
2136 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2137 m
->p_flags
= PF_R
| PF_X
;
2138 m
->p_flags_valid
= 1;
2139 m
->includes_phdrs
= 1;
2144 m
= ((struct elf_segment_map
*)
2145 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2149 m
->p_type
= PT_INTERP
;
2157 /* Look through the sections. We put sections in the same program
2158 segment when the start of the second section can be placed within
2159 a few bytes of the end of the first section. */
2162 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2164 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2166 && (dynsec
->flags
& SEC_LOAD
) == 0)
2169 /* Deal with -Ttext or something similar such that the first section
2170 is not adjacent to the program headers. This is an
2171 approximation, since at this point we don't know exactly how many
2172 program headers we will need. */
2175 bfd_size_type phdr_size
;
2177 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2179 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2180 if ((abfd
->flags
& D_PAGED
) == 0
2181 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2182 phdr_in_section
= false;
2185 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2188 boolean new_segment
;
2192 /* See if this section and the last one will fit in the same
2195 if (last_hdr
== NULL
)
2197 /* If we don't have a segment yet, then we don't need a new
2198 one (we build the last one after this loop). */
2199 new_segment
= false;
2201 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2203 /* If this section has a different relation between the
2204 virtual address and the load address, then we need a new
2208 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2209 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2211 /* If putting this section in this segment would force us to
2212 skip a page in the segment, then we need a new segment. */
2215 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2216 && (hdr
->flags
& SEC_LOAD
) != 0)
2218 /* We don't want to put a loadable section after a
2219 nonloadable section in the same segment. */
2222 else if ((abfd
->flags
& D_PAGED
) == 0)
2224 /* If the file is not demand paged, which means that we
2225 don't require the sections to be correctly aligned in the
2226 file, then there is no other reason for a new segment. */
2227 new_segment
= false;
2230 && (hdr
->flags
& SEC_READONLY
) == 0
2231 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2234 /* We don't want to put a writable section in a read only
2235 segment, unless they are on the same page in memory
2236 anyhow. We already know that the last section does not
2237 bring us past the current section on the page, so the
2238 only case in which the new section is not on the same
2239 page as the previous section is when the previous section
2240 ends precisely on a page boundary. */
2245 /* Otherwise, we can use the same segment. */
2246 new_segment
= false;
2251 if ((hdr
->flags
& SEC_READONLY
) == 0)
2257 /* We need a new program segment. We must create a new program
2258 header holding all the sections from phdr_index until hdr. */
2260 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2267 if ((hdr
->flags
& SEC_READONLY
) == 0)
2274 phdr_in_section
= false;
2277 /* Create a final PT_LOAD program segment. */
2278 if (last_hdr
!= NULL
)
2280 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2288 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2291 m
= ((struct elf_segment_map
*)
2292 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2296 m
->p_type
= PT_DYNAMIC
;
2298 m
->sections
[0] = dynsec
;
2304 /* For each loadable .note section, add a PT_NOTE segment. We don't
2305 use bfd_get_section_by_name, because if we link together
2306 nonloadable .note sections and loadable .note sections, we will
2307 generate two .note sections in the output file. FIXME: Using
2308 names for section types is bogus anyhow. */
2309 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2311 if ((s
->flags
& SEC_LOAD
) != 0
2312 && strncmp (s
->name
, ".note", 5) == 0)
2314 m
= ((struct elf_segment_map
*)
2315 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2319 m
->p_type
= PT_NOTE
;
2331 elf_tdata (abfd
)->segment_map
= mfirst
;
2335 if (sections
!= NULL
)
2340 /* Sort sections by VMA. */
2343 elf_sort_sections (arg1
, arg2
)
2347 const asection
*sec1
= *(const asection
**) arg1
;
2348 const asection
*sec2
= *(const asection
**) arg2
;
2350 /* Sort by LMA first, since this is the address used to
2351 place the section into a segment. */
2352 if (sec1
->lma
< sec2
->lma
)
2354 else if (sec1
->lma
> sec2
->lma
)
2357 /* Sort by VMA. Normally the LMA and the VMA will be the same, and
2358 this will do nothing. */
2359 if (sec1
->vma
< sec2
->vma
)
2361 else if (sec1
->vma
> sec2
->vma
)
2364 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2366 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2371 return sec1
->target_index
- sec2
->target_index
;
2381 /* Sort by size, to put zero sized sections before others at the
2384 if (sec1
->_raw_size
< sec2
->_raw_size
)
2386 if (sec1
->_raw_size
> sec2
->_raw_size
)
2389 return sec1
->target_index
- sec2
->target_index
;
2392 /* Assign file positions to the sections based on the mapping from
2393 sections to segments. This function also sets up some fields in
2394 the file header, and writes out the program headers. */
2397 assign_file_positions_for_segments (abfd
)
2400 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2402 struct elf_segment_map
*m
;
2404 Elf_Internal_Phdr
*phdrs
;
2406 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2407 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2408 Elf_Internal_Phdr
*p
;
2410 if (elf_tdata (abfd
)->segment_map
== NULL
)
2412 if (! map_sections_to_segments (abfd
))
2416 if (bed
->elf_backend_modify_segment_map
)
2418 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2423 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2426 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2427 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2428 elf_elfheader (abfd
)->e_phnum
= count
;
2433 /* If we already counted the number of program segments, make sure
2434 that we allocated enough space. This happens when SIZEOF_HEADERS
2435 is used in a linker script. */
2436 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2437 if (alloc
!= 0 && count
> alloc
)
2439 ((*_bfd_error_handler
)
2440 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2441 bfd_get_filename (abfd
), alloc
, count
));
2442 bfd_set_error (bfd_error_bad_value
);
2449 phdrs
= ((Elf_Internal_Phdr
*)
2450 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2454 off
= bed
->s
->sizeof_ehdr
;
2455 off
+= alloc
* bed
->s
->sizeof_phdr
;
2461 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2468 /* If elf_segment_map is not from map_sections_to_segments, the
2469 sections may not be correctly ordered. */
2471 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2474 p
->p_type
= m
->p_type
;
2476 if (m
->p_flags_valid
)
2477 p
->p_flags
= m
->p_flags
;
2481 if (p
->p_type
== PT_LOAD
2483 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2485 if ((abfd
->flags
& D_PAGED
) != 0)
2486 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2488 off
+= ((m
->sections
[0]->vma
- off
)
2489 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2495 p
->p_vaddr
= m
->sections
[0]->vma
;
2497 if (m
->p_paddr_valid
)
2498 p
->p_paddr
= m
->p_paddr
;
2499 else if (m
->count
== 0)
2502 p
->p_paddr
= m
->sections
[0]->lma
;
2504 if (p
->p_type
== PT_LOAD
2505 && (abfd
->flags
& D_PAGED
) != 0)
2506 p
->p_align
= bed
->maxpagesize
;
2507 else if (m
->count
== 0)
2508 p
->p_align
= bed
->s
->file_align
;
2516 if (m
->includes_filehdr
)
2518 if (! m
->p_flags_valid
)
2521 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2522 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2525 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2527 if (p
->p_vaddr
< (bfd_vma
) off
)
2529 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2530 bfd_get_filename (abfd
));
2531 bfd_set_error (bfd_error_bad_value
);
2536 if (! m
->p_paddr_valid
)
2539 if (p
->p_type
== PT_LOAD
)
2541 filehdr_vaddr
= p
->p_vaddr
;
2542 filehdr_paddr
= p
->p_paddr
;
2546 if (m
->includes_phdrs
)
2548 if (! m
->p_flags_valid
)
2550 if (m
->includes_filehdr
)
2552 if (p
->p_type
== PT_LOAD
)
2554 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2555 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2560 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2563 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2564 p
->p_vaddr
-= off
- p
->p_offset
;
2565 if (! m
->p_paddr_valid
)
2566 p
->p_paddr
-= off
- p
->p_offset
;
2568 if (p
->p_type
== PT_LOAD
)
2570 phdrs_vaddr
= p
->p_vaddr
;
2571 phdrs_paddr
= p
->p_paddr
;
2574 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2575 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2578 if (p
->p_type
== PT_LOAD
)
2580 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2586 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2587 p
->p_filesz
+= adjust
;
2588 p
->p_memsz
+= adjust
;
2593 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2597 bfd_size_type align
;
2601 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2603 /* The section may have artificial alignment forced by a
2604 link script. Notice this case by the gap between the
2605 cumulative phdr vma and the section's vma. */
2606 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2608 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2610 p
->p_memsz
+= adjust
;
2613 if ((flags
& SEC_LOAD
) != 0)
2614 p
->p_filesz
+= adjust
;
2617 if (p
->p_type
== PT_LOAD
)
2621 if ((flags
& SEC_LOAD
) != 0)
2622 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2623 else if ((flags
& SEC_ALLOC
) != 0)
2625 /* The section VMA must equal the file position
2626 modulo the page size. FIXME: I'm not sure if
2627 this adjustment is really necessary. We used to
2628 not have the SEC_LOAD case just above, and then
2629 this was necessary, but now I'm not sure. */
2630 if ((abfd
->flags
& D_PAGED
) != 0)
2631 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2633 adjust
= (sec
->vma
- voff
) % align
;
2642 p
->p_memsz
+= adjust
;
2645 if ((flags
& SEC_LOAD
) != 0)
2646 p
->p_filesz
+= adjust
;
2651 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2652 used in a linker script we may have a section with
2653 SEC_LOAD clear but which is supposed to have
2655 if ((flags
& SEC_LOAD
) != 0
2656 || (flags
& SEC_HAS_CONTENTS
) != 0)
2657 off
+= sec
->_raw_size
;
2658 if ((flags
& SEC_ALLOC
) != 0)
2659 voff
+= sec
->_raw_size
;
2662 p
->p_memsz
+= sec
->_raw_size
;
2664 if ((flags
& SEC_LOAD
) != 0)
2665 p
->p_filesz
+= sec
->_raw_size
;
2667 if (align
> p
->p_align
)
2670 if (! m
->p_flags_valid
)
2673 if ((flags
& SEC_CODE
) != 0)
2675 if ((flags
& SEC_READONLY
) == 0)
2681 /* Now that we have set the section file positions, we can set up
2682 the file positions for the non PT_LOAD segments. */
2683 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2687 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2689 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2690 p
->p_offset
= m
->sections
[0]->filepos
;
2694 if (m
->includes_filehdr
)
2696 p
->p_vaddr
= filehdr_vaddr
;
2697 if (! m
->p_paddr_valid
)
2698 p
->p_paddr
= filehdr_paddr
;
2700 else if (m
->includes_phdrs
)
2702 p
->p_vaddr
= phdrs_vaddr
;
2703 if (! m
->p_paddr_valid
)
2704 p
->p_paddr
= phdrs_paddr
;
2709 /* Clear out any program headers we allocated but did not use. */
2710 for (; count
< alloc
; count
++, p
++)
2712 memset (p
, 0, sizeof *p
);
2713 p
->p_type
= PT_NULL
;
2716 elf_tdata (abfd
)->phdr
= phdrs
;
2718 elf_tdata (abfd
)->next_file_pos
= off
;
2720 /* Write out the program headers. */
2721 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2722 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2728 /* Get the size of the program header.
2730 If this is called by the linker before any of the section VMA's are set, it
2731 can't calculate the correct value for a strange memory layout. This only
2732 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2733 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2734 data segment (exclusive of .interp and .dynamic).
2736 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2737 will be two segments. */
2739 static bfd_size_type
2740 get_program_header_size (abfd
)
2745 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2747 /* We can't return a different result each time we're called. */
2748 if (elf_tdata (abfd
)->program_header_size
!= 0)
2749 return elf_tdata (abfd
)->program_header_size
;
2751 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2753 struct elf_segment_map
*m
;
2756 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2758 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2759 return elf_tdata (abfd
)->program_header_size
;
2762 /* Assume we will need exactly two PT_LOAD segments: one for text
2763 and one for data. */
2766 s
= bfd_get_section_by_name (abfd
, ".interp");
2767 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2769 /* If we have a loadable interpreter section, we need a
2770 PT_INTERP segment. In this case, assume we also need a
2771 PT_PHDR segment, although that may not be true for all
2776 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2778 /* We need a PT_DYNAMIC segment. */
2782 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2784 if ((s
->flags
& SEC_LOAD
) != 0
2785 && strncmp (s
->name
, ".note", 5) == 0)
2787 /* We need a PT_NOTE segment. */
2792 /* Let the backend count up any program headers it might need. */
2793 if (bed
->elf_backend_additional_program_headers
)
2797 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2803 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2804 return elf_tdata (abfd
)->program_header_size
;
2807 /* Work out the file positions of all the sections. This is called by
2808 _bfd_elf_compute_section_file_positions. All the section sizes and
2809 VMAs must be known before this is called.
2811 We do not consider reloc sections at this point, unless they form
2812 part of the loadable image. Reloc sections are assigned file
2813 positions in assign_file_positions_for_relocs, which is called by
2814 write_object_contents and final_link.
2816 We also don't set the positions of the .symtab and .strtab here. */
2819 assign_file_positions_except_relocs (abfd
)
2822 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2823 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2824 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2826 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2828 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2830 Elf_Internal_Shdr
**hdrpp
;
2833 /* Start after the ELF header. */
2834 off
= i_ehdrp
->e_ehsize
;
2836 /* We are not creating an executable, which means that we are
2837 not creating a program header, and that the actual order of
2838 the sections in the file is unimportant. */
2839 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2841 Elf_Internal_Shdr
*hdr
;
2844 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2846 hdr
->sh_offset
= -1;
2849 if (i
== tdata
->symtab_section
2850 || i
== tdata
->strtab_section
)
2852 hdr
->sh_offset
= -1;
2856 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2862 Elf_Internal_Shdr
**hdrpp
;
2864 /* Assign file positions for the loaded sections based on the
2865 assignment of sections to segments. */
2866 if (! assign_file_positions_for_segments (abfd
))
2869 /* Assign file positions for the other sections. */
2871 off
= elf_tdata (abfd
)->next_file_pos
;
2872 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2874 Elf_Internal_Shdr
*hdr
;
2877 if (hdr
->bfd_section
!= NULL
2878 && hdr
->bfd_section
->filepos
!= 0)
2879 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2880 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2882 ((*_bfd_error_handler
)
2883 (_("%s: warning: allocated section `%s' not in segment"),
2884 bfd_get_filename (abfd
),
2885 (hdr
->bfd_section
== NULL
2887 : hdr
->bfd_section
->name
)));
2888 if ((abfd
->flags
& D_PAGED
) != 0)
2889 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2891 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2892 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2895 else if (hdr
->sh_type
== SHT_REL
2896 || hdr
->sh_type
== SHT_RELA
2897 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2898 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2899 hdr
->sh_offset
= -1;
2901 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2905 /* Place the section headers. */
2906 off
= align_file_position (off
, bed
->s
->file_align
);
2907 i_ehdrp
->e_shoff
= off
;
2908 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2910 elf_tdata (abfd
)->next_file_pos
= off
;
2919 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2920 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2921 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2923 struct bfd_strtab_hash
*shstrtab
;
2924 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2926 i_ehdrp
= elf_elfheader (abfd
);
2927 i_shdrp
= elf_elfsections (abfd
);
2929 shstrtab
= _bfd_elf_stringtab_init ();
2930 if (shstrtab
== NULL
)
2933 elf_shstrtab (abfd
) = shstrtab
;
2935 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2936 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2937 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2938 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2940 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2941 i_ehdrp
->e_ident
[EI_DATA
] =
2942 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2943 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2945 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2946 i_ehdrp
->e_ident
[count
] = 0;
2948 if ((abfd
->flags
& DYNAMIC
) != 0)
2949 i_ehdrp
->e_type
= ET_DYN
;
2950 else if ((abfd
->flags
& EXEC_P
) != 0)
2951 i_ehdrp
->e_type
= ET_EXEC
;
2953 i_ehdrp
->e_type
= ET_REL
;
2955 switch (bfd_get_arch (abfd
))
2957 case bfd_arch_unknown
:
2958 i_ehdrp
->e_machine
= EM_NONE
;
2960 case bfd_arch_sparc
:
2961 if (bed
->s
->arch_size
== 64)
2962 i_ehdrp
->e_machine
= EM_SPARCV9
;
2964 i_ehdrp
->e_machine
= EM_SPARC
;
2967 i_ehdrp
->e_machine
= EM_386
;
2970 i_ehdrp
->e_machine
= EM_68K
;
2973 i_ehdrp
->e_machine
= EM_88K
;
2976 i_ehdrp
->e_machine
= EM_860
;
2978 case bfd_arch_mips
: /* MIPS Rxxxx */
2979 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2982 i_ehdrp
->e_machine
= EM_PARISC
;
2984 case bfd_arch_powerpc
:
2985 i_ehdrp
->e_machine
= EM_PPC
;
2987 case bfd_arch_alpha
:
2988 i_ehdrp
->e_machine
= EM_ALPHA
;
2991 i_ehdrp
->e_machine
= EM_SH
;
2994 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2996 /* start-sanitize-d30v */
2998 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3000 /* end-sanitize-d30v */
3002 switch (bfd_get_mach (abfd
))
3005 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3009 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3012 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3014 case bfd_arch_mn10200
:
3015 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3017 case bfd_arch_mn10300
:
3018 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3020 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3022 i_ehdrp
->e_machine
= EM_NONE
;
3024 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3025 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3027 /* no program header, for now. */
3028 i_ehdrp
->e_phoff
= 0;
3029 i_ehdrp
->e_phentsize
= 0;
3030 i_ehdrp
->e_phnum
= 0;
3032 /* each bfd section is section header entry */
3033 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3034 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3036 /* if we're building an executable, we'll need a program header table */
3037 if (abfd
->flags
& EXEC_P
)
3039 /* it all happens later */
3041 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3043 /* elf_build_phdrs() returns a (NULL-terminated) array of
3044 Elf_Internal_Phdrs */
3045 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3046 i_ehdrp
->e_phoff
= outbase
;
3047 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3052 i_ehdrp
->e_phentsize
= 0;
3054 i_ehdrp
->e_phoff
= 0;
3057 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3058 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3059 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3060 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3061 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3062 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3063 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3064 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3065 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3071 /* Assign file positions for all the reloc sections which are not part
3072 of the loadable file image. */
3075 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3080 Elf_Internal_Shdr
**shdrpp
;
3082 off
= elf_tdata (abfd
)->next_file_pos
;
3084 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3085 i
< elf_elfheader (abfd
)->e_shnum
;
3088 Elf_Internal_Shdr
*shdrp
;
3091 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3092 && shdrp
->sh_offset
== -1)
3093 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3096 elf_tdata (abfd
)->next_file_pos
= off
;
3100 _bfd_elf_write_object_contents (abfd
)
3103 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3104 Elf_Internal_Ehdr
*i_ehdrp
;
3105 Elf_Internal_Shdr
**i_shdrp
;
3109 if (! abfd
->output_has_begun
3110 && ! _bfd_elf_compute_section_file_positions (abfd
,
3111 (struct bfd_link_info
*) NULL
))
3114 i_shdrp
= elf_elfsections (abfd
);
3115 i_ehdrp
= elf_elfheader (abfd
);
3118 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3121 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3123 /* After writing the headers, we need to write the sections too... */
3124 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3126 if (bed
->elf_backend_section_processing
)
3127 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3128 if (i_shdrp
[count
]->contents
)
3130 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3131 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3133 != i_shdrp
[count
]->sh_size
))
3138 /* Write out the section header names. */
3139 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3140 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3143 if (bed
->elf_backend_final_write_processing
)
3144 (*bed
->elf_backend_final_write_processing
) (abfd
,
3145 elf_tdata (abfd
)->linker
);
3147 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3150 /* given a section, search the header to find them... */
3152 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3156 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3157 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3159 Elf_Internal_Shdr
*hdr
;
3160 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3162 for (index
= 0; index
< maxindex
; index
++)
3164 hdr
= i_shdrp
[index
];
3165 if (hdr
->bfd_section
== asect
)
3169 if (bed
->elf_backend_section_from_bfd_section
)
3171 for (index
= 0; index
< maxindex
; index
++)
3175 hdr
= i_shdrp
[index
];
3177 if ((*bed
->elf_backend_section_from_bfd_section
)
3178 (abfd
, hdr
, asect
, &retval
))
3183 if (bfd_is_abs_section (asect
))
3185 if (bfd_is_com_section (asect
))
3187 if (bfd_is_und_section (asect
))
3193 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3197 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3199 asymbol
**asym_ptr_ptr
;
3201 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3203 flagword flags
= asym_ptr
->flags
;
3205 /* When gas creates relocations against local labels, it creates its
3206 own symbol for the section, but does put the symbol into the
3207 symbol chain, so udata is 0. When the linker is generating
3208 relocatable output, this section symbol may be for one of the
3209 input sections rather than the output section. */
3210 if (asym_ptr
->udata
.i
== 0
3211 && (flags
& BSF_SECTION_SYM
)
3212 && asym_ptr
->section
)
3216 if (asym_ptr
->section
->output_section
!= NULL
)
3217 indx
= asym_ptr
->section
->output_section
->index
;
3219 indx
= asym_ptr
->section
->index
;
3220 if (elf_section_syms (abfd
)[indx
])
3221 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3224 idx
= asym_ptr
->udata
.i
;
3228 /* This case can occur when using --strip-symbol on a symbol
3229 which is used in a relocation entry. */
3230 (*_bfd_error_handler
)
3231 (_("%s: symbol `%s' required but not present"),
3232 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3233 bfd_set_error (bfd_error_no_symbols
);
3240 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3241 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3242 elf_symbol_flags (flags
));
3250 /* Copy private BFD data. This copies any program header information. */
3253 copy_private_bfd_data (ibfd
, obfd
)
3257 Elf_Internal_Ehdr
*iehdr
;
3258 struct elf_segment_map
*mfirst
;
3259 struct elf_segment_map
**pm
;
3260 struct elf_segment_map
*m
;
3261 Elf_Internal_Phdr
*p
;
3264 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3265 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3268 if (elf_tdata (ibfd
)->phdr
== NULL
)
3271 iehdr
= elf_elfheader (ibfd
);
3276 c
= elf_elfheader (ibfd
)->e_phnum
;
3277 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
3285 /* The complicated case when p_vaddr is 0 is to handle the
3286 Solaris linker, which generates a PT_INTERP section with
3287 p_vaddr and p_memsz set to 0. */
3288 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3289 if (((s
->vma
>= p
->p_vaddr
3290 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3291 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3294 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3295 && (bfd_vma
) s
->filepos
>= p
->p_offset
3296 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3297 <= p
->p_offset
+ p
->p_filesz
)))
3298 && (s
->flags
& SEC_ALLOC
) != 0
3299 && s
->output_section
!= NULL
)
3302 m
= ((struct elf_segment_map
*)
3304 (sizeof (struct elf_segment_map
)
3305 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3310 m
->p_type
= p
->p_type
;
3311 m
->p_flags
= p
->p_flags
;
3312 m
->p_flags_valid
= 1;
3313 /* Default to using the physical address of the segment
3314 in the input BFD. */
3315 m
->p_paddr
= p
->p_paddr
;
3316 m
->p_paddr_valid
= 1;
3318 m
->includes_filehdr
= (p
->p_offset
== 0
3319 && p
->p_filesz
>= iehdr
->e_ehsize
);
3321 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3322 && (p
->p_offset
+ p
->p_filesz
3323 >= ((bfd_vma
) iehdr
->e_phoff
3324 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3327 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3329 boolean matching_lma
= false;
3330 boolean lma_conflict
= false;
3331 bfd_vma suggested_lma
= 0;
3334 #define is_contained_by(addr, len, bottom, phdr) \
3335 ((addr) >= (bottom) \
3336 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3337 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3339 os
= s
->output_section
;
3341 if ((is_contained_by (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3344 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3345 && (bfd_vma
) s
->filepos
>= p
->p_offset
3346 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3347 <= p
->p_offset
+ p
->p_filesz
)))
3348 && (s
->flags
& SEC_ALLOC
) != 0
3351 m
->sections
[isec
] = os
;
3354 /* Match up the physical address of the segment with the
3355 LMA addresses of its sections. */
3357 if (is_contained_by (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
))
3358 matching_lma
= true;
3359 else if (suggested_lma
== 0)
3360 suggested_lma
= os
->lma
;
3362 (! is_contained_by (os
->lma
, os
->_raw_size
, suggested_lma
, p
))
3363 lma_conflict
= true;
3369 (*_bfd_error_handler
)
3370 (_("Warning: Some sections' LMAs lie outside their segment's physical address\n"));
3372 else if (lma_conflict
)
3374 (*_bfd_error_handler
)
3375 (_("Warning: Cannot change segment's physical address to contain all of its sections' LMAs\n"));
3377 else if (suggested_lma
)
3379 m
->p_paddr
= suggested_lma
;
3382 BFD_ASSERT (isec
== csecs
);
3389 /* The Solaris linker creates program headers in which all the
3390 p_paddr fields are zero. When we try to objcopy or strip such a
3391 file, we get confused. Check for this case, and if we find it
3392 reset the p_paddr_valid fields. */
3393 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3394 if (m
->p_paddr
!= 0)
3398 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3399 m
->p_paddr_valid
= 0;
3402 elf_tdata (obfd
)->segment_map
= mfirst
;
3407 /* Copy private section information. This copies over the entsize
3408 field, and sometimes the info field. */
3411 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3417 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3419 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3420 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3423 /* Copy over private BFD data if it has not already been copied.
3424 This must be done here, rather than in the copy_private_bfd_data
3425 entry point, because the latter is called after the section
3426 contents have been set, which means that the program headers have
3427 already been worked out. */
3428 if (elf_tdata (obfd
)->segment_map
== NULL
3429 && elf_tdata (ibfd
)->phdr
!= NULL
)
3433 /* Only set up the segments if there are no more SEC_ALLOC
3434 sections. FIXME: This won't do the right thing if objcopy is
3435 used to remove the last SEC_ALLOC section, since objcopy
3436 won't call this routine in that case. */
3437 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3438 if ((s
->flags
& SEC_ALLOC
) != 0)
3442 if (! copy_private_bfd_data (ibfd
, obfd
))
3447 ihdr
= &elf_section_data (isec
)->this_hdr
;
3448 ohdr
= &elf_section_data (osec
)->this_hdr
;
3450 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3452 if (ihdr
->sh_type
== SHT_SYMTAB
3453 || ihdr
->sh_type
== SHT_DYNSYM
3454 || ihdr
->sh_type
== SHT_GNU_verneed
3455 || ihdr
->sh_type
== SHT_GNU_verdef
)
3456 ohdr
->sh_info
= ihdr
->sh_info
;
3461 /* Copy private symbol information. If this symbol is in a section
3462 which we did not map into a BFD section, try to map the section
3463 index correctly. We use special macro definitions for the mapped
3464 section indices; these definitions are interpreted by the
3465 swap_out_syms function. */
3467 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3468 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3469 #define MAP_STRTAB (SHN_LORESERVE - 3)
3470 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3473 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3479 elf_symbol_type
*isym
, *osym
;
3481 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3482 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3485 isym
= elf_symbol_from (ibfd
, isymarg
);
3486 osym
= elf_symbol_from (obfd
, osymarg
);
3490 && bfd_is_abs_section (isym
->symbol
.section
))
3494 shndx
= isym
->internal_elf_sym
.st_shndx
;
3495 if (shndx
== elf_onesymtab (ibfd
))
3496 shndx
= MAP_ONESYMTAB
;
3497 else if (shndx
== elf_dynsymtab (ibfd
))
3498 shndx
= MAP_DYNSYMTAB
;
3499 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3501 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3502 shndx
= MAP_SHSTRTAB
;
3503 osym
->internal_elf_sym
.st_shndx
= shndx
;
3509 /* Swap out the symbols. */
3512 swap_out_syms (abfd
, sttp
, relocatable_p
)
3514 struct bfd_strtab_hash
**sttp
;
3517 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3519 if (!elf_map_symbols (abfd
))
3522 /* Dump out the symtabs. */
3524 int symcount
= bfd_get_symcount (abfd
);
3525 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3526 struct bfd_strtab_hash
*stt
;
3527 Elf_Internal_Shdr
*symtab_hdr
;
3528 Elf_Internal_Shdr
*symstrtab_hdr
;
3529 char *outbound_syms
;
3532 stt
= _bfd_elf_stringtab_init ();
3536 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3537 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3538 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3539 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3540 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3541 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3543 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3544 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3546 outbound_syms
= bfd_alloc (abfd
,
3547 (1 + symcount
) * bed
->s
->sizeof_sym
);
3548 if (outbound_syms
== NULL
)
3550 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3552 /* now generate the data (for "contents") */
3554 /* Fill in zeroth symbol and swap it out. */
3555 Elf_Internal_Sym sym
;
3561 sym
.st_shndx
= SHN_UNDEF
;
3562 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3563 outbound_syms
+= bed
->s
->sizeof_sym
;
3565 for (idx
= 0; idx
< symcount
; idx
++)
3567 Elf_Internal_Sym sym
;
3568 bfd_vma value
= syms
[idx
]->value
;
3569 elf_symbol_type
*type_ptr
;
3570 flagword flags
= syms
[idx
]->flags
;
3573 if (flags
& BSF_SECTION_SYM
)
3574 /* Section symbols have no names. */
3578 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3581 if (sym
.st_name
== (unsigned long) -1)
3585 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3587 if (bfd_is_com_section (syms
[idx
]->section
))
3589 /* ELF common symbols put the alignment into the `value' field,
3590 and the size into the `size' field. This is backwards from
3591 how BFD handles it, so reverse it here. */
3592 sym
.st_size
= value
;
3593 if (type_ptr
== NULL
3594 || type_ptr
->internal_elf_sym
.st_value
== 0)
3595 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3597 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3598 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3599 syms
[idx
]->section
);
3603 asection
*sec
= syms
[idx
]->section
;
3606 if (sec
->output_section
)
3608 value
+= sec
->output_offset
;
3609 sec
= sec
->output_section
;
3611 /* Don't add in the section vma for relocatable output. */
3612 if (! relocatable_p
)
3614 sym
.st_value
= value
;
3615 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3617 if (bfd_is_abs_section (sec
)
3619 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3621 /* This symbol is in a real ELF section which we did
3622 not create as a BFD section. Undo the mapping done
3623 by copy_private_symbol_data. */
3624 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3628 shndx
= elf_onesymtab (abfd
);
3631 shndx
= elf_dynsymtab (abfd
);
3634 shndx
= elf_tdata (abfd
)->strtab_section
;
3637 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3645 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3651 /* Writing this would be a hell of a lot easier if
3652 we had some decent documentation on bfd, and
3653 knew what to expect of the library, and what to
3654 demand of applications. For example, it
3655 appears that `objcopy' might not set the
3656 section of a symbol to be a section that is
3657 actually in the output file. */
3658 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3659 BFD_ASSERT (sec2
!= 0);
3660 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3661 BFD_ASSERT (shndx
!= -1);
3665 sym
.st_shndx
= shndx
;
3668 if ((flags
& BSF_FUNCTION
) != 0)
3670 else if ((flags
& BSF_OBJECT
) != 0)
3675 if (bfd_is_com_section (syms
[idx
]->section
))
3676 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3677 else if (bfd_is_und_section (syms
[idx
]->section
))
3678 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3682 else if (flags
& BSF_SECTION_SYM
)
3683 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3684 else if (flags
& BSF_FILE
)
3685 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3688 int bind
= STB_LOCAL
;
3690 if (flags
& BSF_LOCAL
)
3692 else if (flags
& BSF_WEAK
)
3694 else if (flags
& BSF_GLOBAL
)
3697 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3700 if (type_ptr
!= NULL
)
3701 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3705 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3706 outbound_syms
+= bed
->s
->sizeof_sym
;
3710 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3711 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3713 symstrtab_hdr
->sh_flags
= 0;
3714 symstrtab_hdr
->sh_addr
= 0;
3715 symstrtab_hdr
->sh_entsize
= 0;
3716 symstrtab_hdr
->sh_link
= 0;
3717 symstrtab_hdr
->sh_info
= 0;
3718 symstrtab_hdr
->sh_addralign
= 1;
3724 /* Return the number of bytes required to hold the symtab vector.
3726 Note that we base it on the count plus 1, since we will null terminate
3727 the vector allocated based on this size. However, the ELF symbol table
3728 always has a dummy entry as symbol #0, so it ends up even. */
3731 _bfd_elf_get_symtab_upper_bound (abfd
)
3736 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3738 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3739 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3745 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3750 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3752 if (elf_dynsymtab (abfd
) == 0)
3754 bfd_set_error (bfd_error_invalid_operation
);
3758 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3759 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3765 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3769 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3772 /* Canonicalize the relocs. */
3775 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3784 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3790 tblptr
= section
->relocation
;
3791 for (i
= 0; i
< section
->reloc_count
; i
++)
3792 *relptr
++ = tblptr
++;
3796 return section
->reloc_count
;
3800 _bfd_elf_get_symtab (abfd
, alocation
)
3802 asymbol
**alocation
;
3804 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3807 bfd_get_symcount (abfd
) = symcount
;
3812 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3814 asymbol
**alocation
;
3816 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3819 /* Return the size required for the dynamic reloc entries. Any
3820 section that was actually installed in the BFD, and has type
3821 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3822 considered to be a dynamic reloc section. */
3825 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3831 if (elf_dynsymtab (abfd
) == 0)
3833 bfd_set_error (bfd_error_invalid_operation
);
3837 ret
= sizeof (arelent
*);
3838 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3839 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3840 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3841 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3842 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3843 * sizeof (arelent
*));
3848 /* Canonicalize the dynamic relocation entries. Note that we return
3849 the dynamic relocations as a single block, although they are
3850 actually associated with particular sections; the interface, which
3851 was designed for SunOS style shared libraries, expects that there
3852 is only one set of dynamic relocs. Any section that was actually
3853 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3854 the dynamic symbol table, is considered to be a dynamic reloc
3858 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3863 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3867 if (elf_dynsymtab (abfd
) == 0)
3869 bfd_set_error (bfd_error_invalid_operation
);
3873 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3875 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3877 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3878 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3879 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3884 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3886 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3888 for (i
= 0; i
< count
; i
++)
3899 /* Read in the version information. */
3902 _bfd_elf_slurp_version_tables (abfd
)
3905 bfd_byte
*contents
= NULL
;
3907 if (elf_dynverdef (abfd
) != 0)
3909 Elf_Internal_Shdr
*hdr
;
3910 Elf_External_Verdef
*everdef
;
3911 Elf_Internal_Verdef
*iverdef
;
3914 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
3916 elf_tdata (abfd
)->verdef
=
3917 ((Elf_Internal_Verdef
*)
3918 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
3919 if (elf_tdata (abfd
)->verdef
== NULL
)
3922 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
3924 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3925 if (contents
== NULL
)
3927 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3928 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3931 everdef
= (Elf_External_Verdef
*) contents
;
3932 iverdef
= elf_tdata (abfd
)->verdef
;
3933 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
3935 Elf_External_Verdaux
*everdaux
;
3936 Elf_Internal_Verdaux
*iverdaux
;
3939 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
3941 iverdef
->vd_bfd
= abfd
;
3943 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
3946 * sizeof (Elf_Internal_Verdaux
))));
3947 if (iverdef
->vd_auxptr
== NULL
)
3950 everdaux
= ((Elf_External_Verdaux
*)
3951 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
3952 iverdaux
= iverdef
->vd_auxptr
;
3953 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
3955 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
3957 iverdaux
->vda_nodename
=
3958 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3959 iverdaux
->vda_name
);
3960 if (iverdaux
->vda_nodename
== NULL
)
3963 if (j
+ 1 < iverdef
->vd_cnt
)
3964 iverdaux
->vda_nextptr
= iverdaux
+ 1;
3966 iverdaux
->vda_nextptr
= NULL
;
3968 everdaux
= ((Elf_External_Verdaux
*)
3969 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
3972 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
3974 if (i
+ 1 < hdr
->sh_info
)
3975 iverdef
->vd_nextdef
= iverdef
+ 1;
3977 iverdef
->vd_nextdef
= NULL
;
3979 everdef
= ((Elf_External_Verdef
*)
3980 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
3987 if (elf_dynverref (abfd
) != 0)
3989 Elf_Internal_Shdr
*hdr
;
3990 Elf_External_Verneed
*everneed
;
3991 Elf_Internal_Verneed
*iverneed
;
3994 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
3996 elf_tdata (abfd
)->verref
=
3997 ((Elf_Internal_Verneed
*)
3998 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
3999 if (elf_tdata (abfd
)->verref
== NULL
)
4002 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4004 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4005 if (contents
== NULL
)
4007 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4008 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4011 everneed
= (Elf_External_Verneed
*) contents
;
4012 iverneed
= elf_tdata (abfd
)->verref
;
4013 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4015 Elf_External_Vernaux
*evernaux
;
4016 Elf_Internal_Vernaux
*ivernaux
;
4019 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4021 iverneed
->vn_bfd
= abfd
;
4023 iverneed
->vn_filename
=
4024 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4026 if (iverneed
->vn_filename
== NULL
)
4029 iverneed
->vn_auxptr
=
4030 ((Elf_Internal_Vernaux
*)
4032 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4034 evernaux
= ((Elf_External_Vernaux
*)
4035 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4036 ivernaux
= iverneed
->vn_auxptr
;
4037 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4039 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4041 ivernaux
->vna_nodename
=
4042 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4043 ivernaux
->vna_name
);
4044 if (ivernaux
->vna_nodename
== NULL
)
4047 if (j
+ 1 < iverneed
->vn_cnt
)
4048 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4050 ivernaux
->vna_nextptr
= NULL
;
4052 evernaux
= ((Elf_External_Vernaux
*)
4053 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4056 if (i
+ 1 < hdr
->sh_info
)
4057 iverneed
->vn_nextref
= iverneed
+ 1;
4059 iverneed
->vn_nextref
= NULL
;
4061 everneed
= ((Elf_External_Verneed
*)
4062 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4072 if (contents
== NULL
)
4078 _bfd_elf_make_empty_symbol (abfd
)
4081 elf_symbol_type
*newsym
;
4083 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4088 newsym
->symbol
.the_bfd
= abfd
;
4089 return &newsym
->symbol
;
4094 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4099 bfd_symbol_info (symbol
, ret
);
4102 /* Return whether a symbol name implies a local symbol. Most targets
4103 use this function for the is_local_label_name entry point, but some
4107 _bfd_elf_is_local_label_name (abfd
, name
)
4111 /* Normal local symbols start with ``.L''. */
4112 if (name
[0] == '.' && name
[1] == 'L')
4115 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4116 DWARF debugging symbols starting with ``..''. */
4117 if (name
[0] == '.' && name
[1] == '.')
4120 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4121 emitting DWARF debugging output. I suspect this is actually a
4122 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4123 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4124 underscore to be emitted on some ELF targets). For ease of use,
4125 we treat such symbols as local. */
4126 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4133 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4142 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4144 enum bfd_architecture arch
;
4145 unsigned long machine
;
4147 /* If this isn't the right architecture for this backend, and this
4148 isn't the generic backend, fail. */
4149 if (arch
!= get_elf_backend_data (abfd
)->arch
4150 && arch
!= bfd_arch_unknown
4151 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4154 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4157 /* Find the nearest line to a particular section and offset, for error
4161 _bfd_elf_find_nearest_line (abfd
,
4172 CONST
char **filename_ptr
;
4173 CONST
char **functionname_ptr
;
4174 unsigned int *line_ptr
;
4177 const char *filename
;
4182 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4183 filename_ptr
, functionname_ptr
,
4187 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4188 &found
, filename_ptr
,
4189 functionname_ptr
, line_ptr
,
4190 &elf_tdata (abfd
)->line_info
))
4195 if (symbols
== NULL
)
4202 for (p
= symbols
; *p
!= NULL
; p
++)
4206 q
= (elf_symbol_type
*) *p
;
4208 if (bfd_get_section (&q
->symbol
) != section
)
4211 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4216 filename
= bfd_asymbol_name (&q
->symbol
);
4219 if (q
->symbol
.section
== section
4220 && q
->symbol
.value
>= low_func
4221 && q
->symbol
.value
<= offset
)
4223 func
= (asymbol
*) q
;
4224 low_func
= q
->symbol
.value
;
4233 *filename_ptr
= filename
;
4234 *functionname_ptr
= bfd_asymbol_name (func
);
4240 _bfd_elf_sizeof_headers (abfd
, reloc
)
4246 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4248 ret
+= get_program_header_size (abfd
);
4253 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4258 bfd_size_type count
;
4260 Elf_Internal_Shdr
*hdr
;
4262 if (! abfd
->output_has_begun
4263 && ! _bfd_elf_compute_section_file_positions (abfd
,
4264 (struct bfd_link_info
*) NULL
))
4267 hdr
= &elf_section_data (section
)->this_hdr
;
4269 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4271 if (bfd_write (location
, 1, count
, abfd
) != count
)
4278 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4281 Elf_Internal_Rela
*dst
;
4288 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4291 Elf_Internal_Rel
*dst
;
4297 /* Try to convert a non-ELF reloc into an ELF one. */
4300 _bfd_elf_validate_reloc (abfd
, areloc
)
4304 /* Check whether we really have an ELF howto. */
4306 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4308 bfd_reloc_code_real_type code
;
4309 reloc_howto_type
*howto
;
4311 /* Alien reloc: Try to determine its type to replace it with an
4312 equivalent ELF reloc. */
4314 if (areloc
->howto
->pc_relative
)
4316 switch (areloc
->howto
->bitsize
)
4319 code
= BFD_RELOC_8_PCREL
;
4322 code
= BFD_RELOC_12_PCREL
;
4325 code
= BFD_RELOC_16_PCREL
;
4328 code
= BFD_RELOC_24_PCREL
;
4331 code
= BFD_RELOC_32_PCREL
;
4334 code
= BFD_RELOC_64_PCREL
;
4340 howto
= bfd_reloc_type_lookup (abfd
, code
);
4342 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4344 if (howto
->pcrel_offset
)
4345 areloc
->addend
+= areloc
->address
;
4347 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4352 switch (areloc
->howto
->bitsize
)
4358 code
= BFD_RELOC_14
;
4361 code
= BFD_RELOC_16
;
4364 code
= BFD_RELOC_26
;
4367 code
= BFD_RELOC_32
;
4370 code
= BFD_RELOC_64
;
4376 howto
= bfd_reloc_type_lookup (abfd
, code
);
4380 areloc
->howto
= howto
;
4388 (*_bfd_error_handler
)
4389 (_("%s: unsupported relocation type %s"),
4390 bfd_get_filename (abfd
), areloc
->howto
->name
);
4391 bfd_set_error (bfd_error_bad_value
);
4396 _bfd_elf_close_and_cleanup (abfd
)
4399 if (bfd_get_format (abfd
) == bfd_object
)
4401 if (elf_shstrtab (abfd
) != NULL
)
4402 _bfd_stringtab_free (elf_shstrtab (abfd
));
4405 return _bfd_generic_close_and_cleanup (abfd
);