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
))
3190 bfd_set_error (bfd_error_nonrepresentable_section
);
3195 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3199 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3201 asymbol
**asym_ptr_ptr
;
3203 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3205 flagword flags
= asym_ptr
->flags
;
3207 /* When gas creates relocations against local labels, it creates its
3208 own symbol for the section, but does put the symbol into the
3209 symbol chain, so udata is 0. When the linker is generating
3210 relocatable output, this section symbol may be for one of the
3211 input sections rather than the output section. */
3212 if (asym_ptr
->udata
.i
== 0
3213 && (flags
& BSF_SECTION_SYM
)
3214 && asym_ptr
->section
)
3218 if (asym_ptr
->section
->output_section
!= NULL
)
3219 indx
= asym_ptr
->section
->output_section
->index
;
3221 indx
= asym_ptr
->section
->index
;
3222 if (elf_section_syms (abfd
)[indx
])
3223 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3226 idx
= asym_ptr
->udata
.i
;
3230 /* This case can occur when using --strip-symbol on a symbol
3231 which is used in a relocation entry. */
3232 (*_bfd_error_handler
)
3233 (_("%s: symbol `%s' required but not present"),
3234 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3235 bfd_set_error (bfd_error_no_symbols
);
3242 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3243 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3244 elf_symbol_flags (flags
));
3252 /* Copy private BFD data. This copies any program header information. */
3255 copy_private_bfd_data (ibfd
, obfd
)
3259 Elf_Internal_Ehdr
*iehdr
;
3260 struct elf_segment_map
*mfirst
;
3261 struct elf_segment_map
**pm
;
3262 struct elf_segment_map
*m
;
3263 Elf_Internal_Phdr
*p
;
3266 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3267 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3270 if (elf_tdata (ibfd
)->phdr
== NULL
)
3273 iehdr
= elf_elfheader (ibfd
);
3278 c
= elf_elfheader (ibfd
)->e_phnum
;
3279 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
3287 /* The complicated case when p_vaddr is 0 is to handle the
3288 Solaris linker, which generates a PT_INTERP section with
3289 p_vaddr and p_memsz set to 0. */
3290 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3291 if (((s
->vma
>= p
->p_vaddr
3292 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3293 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3296 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3298 && (bfd_vma
) s
->filepos
>= p
->p_offset
3299 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3300 <= p
->p_offset
+ p
->p_filesz
)))
3301 && (s
->flags
& SEC_ALLOC
) != 0
3302 && s
->output_section
!= NULL
)
3305 m
= ((struct elf_segment_map
*)
3307 (sizeof (struct elf_segment_map
)
3308 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3313 m
->p_type
= p
->p_type
;
3314 m
->p_flags
= p
->p_flags
;
3315 m
->p_flags_valid
= 1;
3316 /* Default to using the physical address of the segment
3317 in the input BFD. */
3318 m
->p_paddr
= p
->p_paddr
;
3319 m
->p_paddr_valid
= 1;
3321 m
->includes_filehdr
= (p
->p_offset
== 0
3322 && p
->p_filesz
>= iehdr
->e_ehsize
);
3324 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3325 && (p
->p_offset
+ p
->p_filesz
3326 >= ((bfd_vma
) iehdr
->e_phoff
3327 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3330 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3332 boolean matching_lma
= false;
3333 boolean lma_conflict
= false;
3334 bfd_vma suggested_lma
= 0;
3337 #define is_contained_by(addr, len, bottom, phdr) \
3338 ((addr) >= (bottom) \
3339 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3340 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3342 os
= s
->output_section
;
3344 if ((is_contained_by (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3347 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3349 && (bfd_vma
) s
->filepos
>= p
->p_offset
3350 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3351 <= p
->p_offset
+ p
->p_filesz
)))
3352 && (s
->flags
& SEC_ALLOC
) != 0
3355 /* The Solaris native linker always sets p_paddr to 0.
3356 We try to catch that case here, and set it to the
3362 && (os
->vma
== (p
->p_vaddr
3363 + (m
->includes_filehdr
3366 + (m
->includes_phdrs
3367 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3369 m
->p_paddr
= p
->p_vaddr
;
3371 m
->sections
[isec
] = os
;
3374 /* Match up the physical address of the segment with the
3375 LMA addresses of its sections. */
3377 if (is_contained_by (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
))
3378 matching_lma
= true;
3379 else if (suggested_lma
== 0)
3380 suggested_lma
= os
->lma
;
3381 else if (! is_contained_by (os
->lma
, os
->_raw_size
,
3383 lma_conflict
= true;
3389 (*_bfd_error_handler
)
3390 (_("Warning: Some sections' LMAs lie outside their segment's physical address\n"));
3392 else if (lma_conflict
)
3394 (*_bfd_error_handler
)
3395 (_("Warning: Cannot change segment's physical address to contain all of its sections' LMAs\n"));
3397 else if (suggested_lma
)
3399 m
->p_paddr
= suggested_lma
;
3402 BFD_ASSERT (isec
== csecs
);
3409 /* The Solaris linker creates program headers in which all the
3410 p_paddr fields are zero. When we try to objcopy or strip such a
3411 file, we get confused. Check for this case, and if we find it
3412 reset the p_paddr_valid fields. */
3413 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3414 if (m
->p_paddr
!= 0)
3418 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3419 m
->p_paddr_valid
= 0;
3422 elf_tdata (obfd
)->segment_map
= mfirst
;
3427 /* Copy private section information. This copies over the entsize
3428 field, and sometimes the info field. */
3431 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3437 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3439 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3440 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3443 /* Copy over private BFD data if it has not already been copied.
3444 This must be done here, rather than in the copy_private_bfd_data
3445 entry point, because the latter is called after the section
3446 contents have been set, which means that the program headers have
3447 already been worked out. */
3448 if (elf_tdata (obfd
)->segment_map
== NULL
3449 && elf_tdata (ibfd
)->phdr
!= NULL
)
3453 /* Only set up the segments if there are no more SEC_ALLOC
3454 sections. FIXME: This won't do the right thing if objcopy is
3455 used to remove the last SEC_ALLOC section, since objcopy
3456 won't call this routine in that case. */
3457 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3458 if ((s
->flags
& SEC_ALLOC
) != 0)
3462 if (! copy_private_bfd_data (ibfd
, obfd
))
3467 ihdr
= &elf_section_data (isec
)->this_hdr
;
3468 ohdr
= &elf_section_data (osec
)->this_hdr
;
3470 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3472 if (ihdr
->sh_type
== SHT_SYMTAB
3473 || ihdr
->sh_type
== SHT_DYNSYM
3474 || ihdr
->sh_type
== SHT_GNU_verneed
3475 || ihdr
->sh_type
== SHT_GNU_verdef
)
3476 ohdr
->sh_info
= ihdr
->sh_info
;
3481 /* Copy private symbol information. If this symbol is in a section
3482 which we did not map into a BFD section, try to map the section
3483 index correctly. We use special macro definitions for the mapped
3484 section indices; these definitions are interpreted by the
3485 swap_out_syms function. */
3487 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3488 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3489 #define MAP_STRTAB (SHN_LORESERVE - 3)
3490 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3493 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3499 elf_symbol_type
*isym
, *osym
;
3501 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3502 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3505 isym
= elf_symbol_from (ibfd
, isymarg
);
3506 osym
= elf_symbol_from (obfd
, osymarg
);
3510 && bfd_is_abs_section (isym
->symbol
.section
))
3514 shndx
= isym
->internal_elf_sym
.st_shndx
;
3515 if (shndx
== elf_onesymtab (ibfd
))
3516 shndx
= MAP_ONESYMTAB
;
3517 else if (shndx
== elf_dynsymtab (ibfd
))
3518 shndx
= MAP_DYNSYMTAB
;
3519 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3521 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3522 shndx
= MAP_SHSTRTAB
;
3523 osym
->internal_elf_sym
.st_shndx
= shndx
;
3529 /* Swap out the symbols. */
3532 swap_out_syms (abfd
, sttp
, relocatable_p
)
3534 struct bfd_strtab_hash
**sttp
;
3537 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3539 if (!elf_map_symbols (abfd
))
3542 /* Dump out the symtabs. */
3544 int symcount
= bfd_get_symcount (abfd
);
3545 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3546 struct bfd_strtab_hash
*stt
;
3547 Elf_Internal_Shdr
*symtab_hdr
;
3548 Elf_Internal_Shdr
*symstrtab_hdr
;
3549 char *outbound_syms
;
3552 stt
= _bfd_elf_stringtab_init ();
3556 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3557 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3558 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3559 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3560 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3561 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3563 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3564 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3566 outbound_syms
= bfd_alloc (abfd
,
3567 (1 + symcount
) * bed
->s
->sizeof_sym
);
3568 if (outbound_syms
== NULL
)
3570 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3572 /* now generate the data (for "contents") */
3574 /* Fill in zeroth symbol and swap it out. */
3575 Elf_Internal_Sym sym
;
3581 sym
.st_shndx
= SHN_UNDEF
;
3582 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3583 outbound_syms
+= bed
->s
->sizeof_sym
;
3585 for (idx
= 0; idx
< symcount
; idx
++)
3587 Elf_Internal_Sym sym
;
3588 bfd_vma value
= syms
[idx
]->value
;
3589 elf_symbol_type
*type_ptr
;
3590 flagword flags
= syms
[idx
]->flags
;
3593 if (flags
& BSF_SECTION_SYM
)
3594 /* Section symbols have no names. */
3598 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3601 if (sym
.st_name
== (unsigned long) -1)
3605 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3607 if (bfd_is_com_section (syms
[idx
]->section
))
3609 /* ELF common symbols put the alignment into the `value' field,
3610 and the size into the `size' field. This is backwards from
3611 how BFD handles it, so reverse it here. */
3612 sym
.st_size
= value
;
3613 if (type_ptr
== NULL
3614 || type_ptr
->internal_elf_sym
.st_value
== 0)
3615 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3617 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3618 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3619 syms
[idx
]->section
);
3623 asection
*sec
= syms
[idx
]->section
;
3626 if (sec
->output_section
)
3628 value
+= sec
->output_offset
;
3629 sec
= sec
->output_section
;
3631 /* Don't add in the section vma for relocatable output. */
3632 if (! relocatable_p
)
3634 sym
.st_value
= value
;
3635 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3637 if (bfd_is_abs_section (sec
)
3639 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3641 /* This symbol is in a real ELF section which we did
3642 not create as a BFD section. Undo the mapping done
3643 by copy_private_symbol_data. */
3644 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3648 shndx
= elf_onesymtab (abfd
);
3651 shndx
= elf_dynsymtab (abfd
);
3654 shndx
= elf_tdata (abfd
)->strtab_section
;
3657 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3665 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3671 /* Writing this would be a hell of a lot easier if
3672 we had some decent documentation on bfd, and
3673 knew what to expect of the library, and what to
3674 demand of applications. For example, it
3675 appears that `objcopy' might not set the
3676 section of a symbol to be a section that is
3677 actually in the output file. */
3678 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3679 BFD_ASSERT (sec2
!= 0);
3680 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3681 BFD_ASSERT (shndx
!= -1);
3685 sym
.st_shndx
= shndx
;
3688 if ((flags
& BSF_FUNCTION
) != 0)
3690 else if ((flags
& BSF_OBJECT
) != 0)
3695 if (bfd_is_com_section (syms
[idx
]->section
))
3696 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3697 else if (bfd_is_und_section (syms
[idx
]->section
))
3698 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3702 else if (flags
& BSF_SECTION_SYM
)
3703 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3704 else if (flags
& BSF_FILE
)
3705 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3708 int bind
= STB_LOCAL
;
3710 if (flags
& BSF_LOCAL
)
3712 else if (flags
& BSF_WEAK
)
3714 else if (flags
& BSF_GLOBAL
)
3717 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3720 if (type_ptr
!= NULL
)
3721 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3725 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3726 outbound_syms
+= bed
->s
->sizeof_sym
;
3730 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3731 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3733 symstrtab_hdr
->sh_flags
= 0;
3734 symstrtab_hdr
->sh_addr
= 0;
3735 symstrtab_hdr
->sh_entsize
= 0;
3736 symstrtab_hdr
->sh_link
= 0;
3737 symstrtab_hdr
->sh_info
= 0;
3738 symstrtab_hdr
->sh_addralign
= 1;
3744 /* Return the number of bytes required to hold the symtab vector.
3746 Note that we base it on the count plus 1, since we will null terminate
3747 the vector allocated based on this size. However, the ELF symbol table
3748 always has a dummy entry as symbol #0, so it ends up even. */
3751 _bfd_elf_get_symtab_upper_bound (abfd
)
3756 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
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_dynamic_symtab_upper_bound (abfd
)
3770 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3772 if (elf_dynsymtab (abfd
) == 0)
3774 bfd_set_error (bfd_error_invalid_operation
);
3778 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3779 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3785 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3789 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3792 /* Canonicalize the relocs. */
3795 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3804 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3810 tblptr
= section
->relocation
;
3811 for (i
= 0; i
< section
->reloc_count
; i
++)
3812 *relptr
++ = tblptr
++;
3816 return section
->reloc_count
;
3820 _bfd_elf_get_symtab (abfd
, alocation
)
3822 asymbol
**alocation
;
3824 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3827 bfd_get_symcount (abfd
) = symcount
;
3832 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3834 asymbol
**alocation
;
3836 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3839 /* Return the size required for the dynamic reloc entries. Any
3840 section that was actually installed in the BFD, and has type
3841 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3842 considered to be a dynamic reloc section. */
3845 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3851 if (elf_dynsymtab (abfd
) == 0)
3853 bfd_set_error (bfd_error_invalid_operation
);
3857 ret
= sizeof (arelent
*);
3858 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3859 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3860 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3861 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3862 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3863 * sizeof (arelent
*));
3868 /* Canonicalize the dynamic relocation entries. Note that we return
3869 the dynamic relocations as a single block, although they are
3870 actually associated with particular sections; the interface, which
3871 was designed for SunOS style shared libraries, expects that there
3872 is only one set of dynamic relocs. Any section that was actually
3873 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3874 the dynamic symbol table, is considered to be a dynamic reloc
3878 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3883 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3887 if (elf_dynsymtab (abfd
) == 0)
3889 bfd_set_error (bfd_error_invalid_operation
);
3893 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3895 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3897 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3898 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3899 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3904 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3906 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3908 for (i
= 0; i
< count
; i
++)
3919 /* Read in the version information. */
3922 _bfd_elf_slurp_version_tables (abfd
)
3925 bfd_byte
*contents
= NULL
;
3927 if (elf_dynverdef (abfd
) != 0)
3929 Elf_Internal_Shdr
*hdr
;
3930 Elf_External_Verdef
*everdef
;
3931 Elf_Internal_Verdef
*iverdef
;
3934 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
3936 elf_tdata (abfd
)->verdef
=
3937 ((Elf_Internal_Verdef
*)
3938 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
3939 if (elf_tdata (abfd
)->verdef
== NULL
)
3942 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
3944 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3945 if (contents
== NULL
)
3947 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3948 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3951 everdef
= (Elf_External_Verdef
*) contents
;
3952 iverdef
= elf_tdata (abfd
)->verdef
;
3953 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
3955 Elf_External_Verdaux
*everdaux
;
3956 Elf_Internal_Verdaux
*iverdaux
;
3959 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
3961 iverdef
->vd_bfd
= abfd
;
3963 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
3966 * sizeof (Elf_Internal_Verdaux
))));
3967 if (iverdef
->vd_auxptr
== NULL
)
3970 everdaux
= ((Elf_External_Verdaux
*)
3971 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
3972 iverdaux
= iverdef
->vd_auxptr
;
3973 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
3975 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
3977 iverdaux
->vda_nodename
=
3978 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3979 iverdaux
->vda_name
);
3980 if (iverdaux
->vda_nodename
== NULL
)
3983 if (j
+ 1 < iverdef
->vd_cnt
)
3984 iverdaux
->vda_nextptr
= iverdaux
+ 1;
3986 iverdaux
->vda_nextptr
= NULL
;
3988 everdaux
= ((Elf_External_Verdaux
*)
3989 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
3992 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
3994 if (i
+ 1 < hdr
->sh_info
)
3995 iverdef
->vd_nextdef
= iverdef
+ 1;
3997 iverdef
->vd_nextdef
= NULL
;
3999 everdef
= ((Elf_External_Verdef
*)
4000 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4007 if (elf_dynverref (abfd
) != 0)
4009 Elf_Internal_Shdr
*hdr
;
4010 Elf_External_Verneed
*everneed
;
4011 Elf_Internal_Verneed
*iverneed
;
4014 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4016 elf_tdata (abfd
)->verref
=
4017 ((Elf_Internal_Verneed
*)
4018 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4019 if (elf_tdata (abfd
)->verref
== NULL
)
4022 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4024 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4025 if (contents
== NULL
)
4027 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4028 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4031 everneed
= (Elf_External_Verneed
*) contents
;
4032 iverneed
= elf_tdata (abfd
)->verref
;
4033 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4035 Elf_External_Vernaux
*evernaux
;
4036 Elf_Internal_Vernaux
*ivernaux
;
4039 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4041 iverneed
->vn_bfd
= abfd
;
4043 iverneed
->vn_filename
=
4044 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4046 if (iverneed
->vn_filename
== NULL
)
4049 iverneed
->vn_auxptr
=
4050 ((Elf_Internal_Vernaux
*)
4052 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4054 evernaux
= ((Elf_External_Vernaux
*)
4055 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4056 ivernaux
= iverneed
->vn_auxptr
;
4057 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4059 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4061 ivernaux
->vna_nodename
=
4062 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4063 ivernaux
->vna_name
);
4064 if (ivernaux
->vna_nodename
== NULL
)
4067 if (j
+ 1 < iverneed
->vn_cnt
)
4068 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4070 ivernaux
->vna_nextptr
= NULL
;
4072 evernaux
= ((Elf_External_Vernaux
*)
4073 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4076 if (i
+ 1 < hdr
->sh_info
)
4077 iverneed
->vn_nextref
= iverneed
+ 1;
4079 iverneed
->vn_nextref
= NULL
;
4081 everneed
= ((Elf_External_Verneed
*)
4082 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4092 if (contents
== NULL
)
4098 _bfd_elf_make_empty_symbol (abfd
)
4101 elf_symbol_type
*newsym
;
4103 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4108 newsym
->symbol
.the_bfd
= abfd
;
4109 return &newsym
->symbol
;
4114 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4119 bfd_symbol_info (symbol
, ret
);
4122 /* Return whether a symbol name implies a local symbol. Most targets
4123 use this function for the is_local_label_name entry point, but some
4127 _bfd_elf_is_local_label_name (abfd
, name
)
4131 /* Normal local symbols start with ``.L''. */
4132 if (name
[0] == '.' && name
[1] == 'L')
4135 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4136 DWARF debugging symbols starting with ``..''. */
4137 if (name
[0] == '.' && name
[1] == '.')
4140 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4141 emitting DWARF debugging output. I suspect this is actually a
4142 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4143 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4144 underscore to be emitted on some ELF targets). For ease of use,
4145 we treat such symbols as local. */
4146 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4153 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4162 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4164 enum bfd_architecture arch
;
4165 unsigned long machine
;
4167 /* If this isn't the right architecture for this backend, and this
4168 isn't the generic backend, fail. */
4169 if (arch
!= get_elf_backend_data (abfd
)->arch
4170 && arch
!= bfd_arch_unknown
4171 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4174 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4177 /* Find the nearest line to a particular section and offset, for error
4181 _bfd_elf_find_nearest_line (abfd
,
4192 CONST
char **filename_ptr
;
4193 CONST
char **functionname_ptr
;
4194 unsigned int *line_ptr
;
4197 const char *filename
;
4202 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4203 filename_ptr
, functionname_ptr
,
4207 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4208 &found
, filename_ptr
,
4209 functionname_ptr
, line_ptr
,
4210 &elf_tdata (abfd
)->line_info
))
4215 if (symbols
== NULL
)
4222 for (p
= symbols
; *p
!= NULL
; p
++)
4226 q
= (elf_symbol_type
*) *p
;
4228 if (bfd_get_section (&q
->symbol
) != section
)
4231 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4236 filename
= bfd_asymbol_name (&q
->symbol
);
4239 if (q
->symbol
.section
== section
4240 && q
->symbol
.value
>= low_func
4241 && q
->symbol
.value
<= offset
)
4243 func
= (asymbol
*) q
;
4244 low_func
= q
->symbol
.value
;
4253 *filename_ptr
= filename
;
4254 *functionname_ptr
= bfd_asymbol_name (func
);
4260 _bfd_elf_sizeof_headers (abfd
, reloc
)
4266 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4268 ret
+= get_program_header_size (abfd
);
4273 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4278 bfd_size_type count
;
4280 Elf_Internal_Shdr
*hdr
;
4282 if (! abfd
->output_has_begun
4283 && ! _bfd_elf_compute_section_file_positions (abfd
,
4284 (struct bfd_link_info
*) NULL
))
4287 hdr
= &elf_section_data (section
)->this_hdr
;
4289 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4291 if (bfd_write (location
, 1, count
, abfd
) != count
)
4298 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4301 Elf_Internal_Rela
*dst
;
4308 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4311 Elf_Internal_Rel
*dst
;
4317 /* Try to convert a non-ELF reloc into an ELF one. */
4320 _bfd_elf_validate_reloc (abfd
, areloc
)
4324 /* Check whether we really have an ELF howto. */
4326 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4328 bfd_reloc_code_real_type code
;
4329 reloc_howto_type
*howto
;
4331 /* Alien reloc: Try to determine its type to replace it with an
4332 equivalent ELF reloc. */
4334 if (areloc
->howto
->pc_relative
)
4336 switch (areloc
->howto
->bitsize
)
4339 code
= BFD_RELOC_8_PCREL
;
4342 code
= BFD_RELOC_12_PCREL
;
4345 code
= BFD_RELOC_16_PCREL
;
4348 code
= BFD_RELOC_24_PCREL
;
4351 code
= BFD_RELOC_32_PCREL
;
4354 code
= BFD_RELOC_64_PCREL
;
4360 howto
= bfd_reloc_type_lookup (abfd
, code
);
4362 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4364 if (howto
->pcrel_offset
)
4365 areloc
->addend
+= areloc
->address
;
4367 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4372 switch (areloc
->howto
->bitsize
)
4378 code
= BFD_RELOC_14
;
4381 code
= BFD_RELOC_16
;
4384 code
= BFD_RELOC_26
;
4387 code
= BFD_RELOC_32
;
4390 code
= BFD_RELOC_64
;
4396 howto
= bfd_reloc_type_lookup (abfd
, code
);
4400 areloc
->howto
= howto
;
4408 (*_bfd_error_handler
)
4409 (_("%s: unsupported relocation type %s"),
4410 bfd_get_filename (abfd
), areloc
->howto
->name
);
4411 bfd_set_error (bfd_error_bad_value
);
4416 _bfd_elf_close_and_cleanup (abfd
)
4419 if (bfd_get_format (abfd
) == bfd_object
)
4421 if (elf_shstrtab (abfd
) != NULL
)
4422 _bfd_stringtab_free (elf_shstrtab (abfd
));
4425 return _bfd_generic_close_and_cleanup (abfd
);