1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
41 static INLINE
struct elf_segment_map
*make_mapping
42 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
43 static boolean map_sections_to_segments
PARAMS ((bfd
*));
44 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
45 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
46 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
47 static boolean prep_headers
PARAMS ((bfd
*));
48 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
49 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
50 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
51 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
52 static boolean assign_section_numbers
PARAMS ((bfd
*));
53 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
54 static boolean elf_map_symbols
PARAMS ((bfd
*));
55 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
57 /* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
61 /* Swap in a Verdef structure. */
64 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
66 const Elf_External_Verdef
*src
;
67 Elf_Internal_Verdef
*dst
;
69 dst
->vd_version
= bfd_h_get_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= bfd_h_get_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= bfd_h_get_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= bfd_h_get_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= bfd_h_get_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= bfd_h_get_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= bfd_h_get_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
83 const Elf_Internal_Verdef
*src
;
84 Elf_External_Verdef
*dst
;
86 bfd_h_put_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 bfd_h_put_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 bfd_h_put_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 bfd_h_put_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 bfd_h_put_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 bfd_h_put_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 bfd_h_put_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
100 const Elf_External_Verdaux
*src
;
101 Elf_Internal_Verdaux
*dst
;
103 dst
->vda_name
= bfd_h_get_32 (abfd
, src
->vda_name
);
104 dst
->vda_next
= bfd_h_get_32 (abfd
, src
->vda_next
);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
112 const Elf_Internal_Verdaux
*src
;
113 Elf_External_Verdaux
*dst
;
115 bfd_h_put_32 (abfd
, src
->vda_name
, dst
->vda_name
);
116 bfd_h_put_32 (abfd
, src
->vda_next
, dst
->vda_next
);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
124 const Elf_External_Verneed
*src
;
125 Elf_Internal_Verneed
*dst
;
127 dst
->vn_version
= bfd_h_get_16 (abfd
, src
->vn_version
);
128 dst
->vn_cnt
= bfd_h_get_16 (abfd
, src
->vn_cnt
);
129 dst
->vn_file
= bfd_h_get_32 (abfd
, src
->vn_file
);
130 dst
->vn_aux
= bfd_h_get_32 (abfd
, src
->vn_aux
);
131 dst
->vn_next
= bfd_h_get_32 (abfd
, src
->vn_next
);
134 /* Swap out a Verneed structure. */
137 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
139 const Elf_Internal_Verneed
*src
;
140 Elf_External_Verneed
*dst
;
142 bfd_h_put_16 (abfd
, src
->vn_version
, dst
->vn_version
);
143 bfd_h_put_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
144 bfd_h_put_32 (abfd
, src
->vn_file
, dst
->vn_file
);
145 bfd_h_put_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
146 bfd_h_put_32 (abfd
, src
->vn_next
, dst
->vn_next
);
149 /* Swap in a Vernaux structure. */
152 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
154 const Elf_External_Vernaux
*src
;
155 Elf_Internal_Vernaux
*dst
;
157 dst
->vna_hash
= bfd_h_get_32 (abfd
, src
->vna_hash
);
158 dst
->vna_flags
= bfd_h_get_16 (abfd
, src
->vna_flags
);
159 dst
->vna_other
= bfd_h_get_16 (abfd
, src
->vna_other
);
160 dst
->vna_name
= bfd_h_get_32 (abfd
, src
->vna_name
);
161 dst
->vna_next
= bfd_h_get_32 (abfd
, src
->vna_next
);
164 /* Swap out a Vernaux structure. */
167 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
169 const Elf_Internal_Vernaux
*src
;
170 Elf_External_Vernaux
*dst
;
172 bfd_h_put_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
173 bfd_h_put_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
174 bfd_h_put_16 (abfd
, src
->vna_other
, dst
->vna_other
);
175 bfd_h_put_32 (abfd
, src
->vna_name
, dst
->vna_name
);
176 bfd_h_put_32 (abfd
, src
->vna_next
, dst
->vna_next
);
179 /* Swap in a Versym structure. */
182 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
184 const Elf_External_Versym
*src
;
185 Elf_Internal_Versym
*dst
;
187 dst
->vs_vers
= bfd_h_get_16 (abfd
, src
->vs_vers
);
190 /* Swap out a Versym structure. */
193 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
195 const Elf_Internal_Versym
*src
;
196 Elf_External_Versym
*dst
;
198 bfd_h_put_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
201 /* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. (Well, you would if this
203 were being used yet.) */
206 CONST
unsigned char *name
;
212 while ((ch
= *name
++) != '\0')
215 if ((g
= (h
& 0xf0000000)) != 0)
224 /* Read a specified number of bytes at a specified offset in an ELF
225 file, into a newly allocated buffer, and return a pointer to the
229 elf_read (abfd
, offset
, size
)
236 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
238 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
240 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
242 if (bfd_get_error () != bfd_error_system_call
)
243 bfd_set_error (bfd_error_file_truncated
);
250 bfd_elf_mkobject (abfd
)
253 /* this just does initialization */
254 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
255 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
256 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
257 if (elf_tdata (abfd
) == 0)
259 /* since everything is done at close time, do we need any
266 bfd_elf_get_str_section (abfd
, shindex
)
268 unsigned int shindex
;
270 Elf_Internal_Shdr
**i_shdrp
;
271 char *shstrtab
= NULL
;
273 unsigned int shstrtabsize
;
275 i_shdrp
= elf_elfsections (abfd
);
276 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
279 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
280 if (shstrtab
== NULL
)
282 /* No cached one, attempt to read, and cache what we read. */
283 offset
= i_shdrp
[shindex
]->sh_offset
;
284 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
285 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
286 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
292 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
294 unsigned int shindex
;
295 unsigned int strindex
;
297 Elf_Internal_Shdr
*hdr
;
302 hdr
= elf_elfsections (abfd
)[shindex
];
304 if (hdr
->contents
== NULL
305 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
308 return ((char *) hdr
->contents
) + strindex
;
311 /* Make a BFD section from an ELF section. We store a pointer to the
312 BFD section in the bfd_section field of the header. */
315 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
317 Elf_Internal_Shdr
*hdr
;
323 if (hdr
->bfd_section
!= NULL
)
325 BFD_ASSERT (strcmp (name
,
326 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
330 newsect
= bfd_make_section_anyway (abfd
, name
);
334 newsect
->filepos
= hdr
->sh_offset
;
336 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
337 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
338 || ! bfd_set_section_alignment (abfd
, newsect
,
339 bfd_log2 (hdr
->sh_addralign
)))
342 flags
= SEC_NO_FLAGS
;
343 if (hdr
->sh_type
!= SHT_NOBITS
)
344 flags
|= SEC_HAS_CONTENTS
;
345 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
348 if (hdr
->sh_type
!= SHT_NOBITS
)
351 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
352 flags
|= SEC_READONLY
;
353 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
355 else if ((flags
& SEC_LOAD
) != 0)
358 /* The debugging sections appear to be recognized only by name, not
360 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
361 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
362 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
363 flags
|= SEC_DEBUGGING
;
365 /* As a GNU extension, if the name begins with .gnu.linkonce, we
366 only link a single copy of the section. This is used to support
367 g++. g++ will emit each template expansion in its own section.
368 The symbols will be defined as weak, so that multiple definitions
369 are permitted. The GNU linker extension is to actually discard
370 all but one of the sections. */
371 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
372 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
374 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
377 if ((flags
& SEC_ALLOC
) != 0)
379 Elf_Internal_Phdr
*phdr
;
382 /* Look through the phdrs to see if we need to adjust the lma. */
383 phdr
= elf_tdata (abfd
)->phdr
;
384 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
386 if (phdr
->p_type
== PT_LOAD
387 && phdr
->p_paddr
!= 0
388 && phdr
->p_vaddr
!= phdr
->p_paddr
389 && phdr
->p_vaddr
<= hdr
->sh_addr
390 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
391 && ((flags
& SEC_LOAD
) == 0
392 || (phdr
->p_offset
<= hdr
->sh_offset
393 && (phdr
->p_offset
+ phdr
->p_filesz
394 >= hdr
->sh_offset
+ hdr
->sh_size
))))
396 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
402 hdr
->bfd_section
= newsect
;
403 elf_section_data (newsect
)->this_hdr
= *hdr
;
413 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
416 Helper functions for GDB to locate the string tables.
417 Since BFD hides string tables from callers, GDB needs to use an
418 internal hook to find them. Sun's .stabstr, in particular,
419 isn't even pointed to by the .stab section, so ordinary
420 mechanisms wouldn't work to find it, even if we had some.
423 struct elf_internal_shdr
*
424 bfd_elf_find_section (abfd
, name
)
428 Elf_Internal_Shdr
**i_shdrp
;
433 i_shdrp
= elf_elfsections (abfd
);
436 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
437 if (shstrtab
!= NULL
)
439 max
= elf_elfheader (abfd
)->e_shnum
;
440 for (i
= 1; i
< max
; i
++)
441 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
448 const char *const bfd_elf_section_type_names
[] = {
449 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
450 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
451 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
454 /* ELF relocs are against symbols. If we are producing relocateable
455 output, and the reloc is against an external symbol, and nothing
456 has given us any additional addend, the resulting reloc will also
457 be against the same symbol. In such a case, we don't want to
458 change anything about the way the reloc is handled, since it will
459 all be done at final link time. Rather than put special case code
460 into bfd_perform_relocation, all the reloc types use this howto
461 function. It just short circuits the reloc if producing
462 relocateable output against an external symbol. */
465 bfd_reloc_status_type
466 bfd_elf_generic_reloc (abfd
,
474 arelent
*reloc_entry
;
477 asection
*input_section
;
479 char **error_message
;
481 if (output_bfd
!= (bfd
*) NULL
482 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
483 && (! reloc_entry
->howto
->partial_inplace
484 || reloc_entry
->addend
== 0))
486 reloc_entry
->address
+= input_section
->output_offset
;
490 return bfd_reloc_continue
;
493 /* Print out the program headers. */
496 _bfd_elf_print_private_bfd_data (abfd
, farg
)
500 FILE *f
= (FILE *) farg
;
501 Elf_Internal_Phdr
*p
;
503 bfd_byte
*dynbuf
= NULL
;
505 p
= elf_tdata (abfd
)->phdr
;
510 fprintf (f
, "\nProgram Header:\n");
511 c
= elf_elfheader (abfd
)->e_phnum
;
512 for (i
= 0; i
< c
; i
++, p
++)
519 case PT_NULL
: s
= "NULL"; break;
520 case PT_LOAD
: s
= "LOAD"; break;
521 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
522 case PT_INTERP
: s
= "INTERP"; break;
523 case PT_NOTE
: s
= "NOTE"; break;
524 case PT_SHLIB
: s
= "SHLIB"; break;
525 case PT_PHDR
: s
= "PHDR"; break;
526 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
528 fprintf (f
, "%8s off 0x", s
);
529 fprintf_vma (f
, p
->p_offset
);
530 fprintf (f
, " vaddr 0x");
531 fprintf_vma (f
, p
->p_vaddr
);
532 fprintf (f
, " paddr 0x");
533 fprintf_vma (f
, p
->p_paddr
);
534 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
535 fprintf (f
, " filesz 0x");
536 fprintf_vma (f
, p
->p_filesz
);
537 fprintf (f
, " memsz 0x");
538 fprintf_vma (f
, p
->p_memsz
);
539 fprintf (f
, " flags %c%c%c",
540 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
541 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
542 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
543 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
544 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
549 s
= bfd_get_section_by_name (abfd
, ".dynamic");
554 bfd_byte
*extdyn
, *extdynend
;
556 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
558 fprintf (f
, "\nDynamic Section:\n");
560 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
563 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
567 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
570 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
572 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
573 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
576 extdynend
= extdyn
+ s
->_raw_size
;
577 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
579 Elf_Internal_Dyn dyn
;
584 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
586 if (dyn
.d_tag
== DT_NULL
)
593 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
597 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
598 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
599 case DT_PLTGOT
: name
= "PLTGOT"; break;
600 case DT_HASH
: name
= "HASH"; break;
601 case DT_STRTAB
: name
= "STRTAB"; break;
602 case DT_SYMTAB
: name
= "SYMTAB"; break;
603 case DT_RELA
: name
= "RELA"; break;
604 case DT_RELASZ
: name
= "RELASZ"; break;
605 case DT_RELAENT
: name
= "RELAENT"; break;
606 case DT_STRSZ
: name
= "STRSZ"; break;
607 case DT_SYMENT
: name
= "SYMENT"; break;
608 case DT_INIT
: name
= "INIT"; break;
609 case DT_FINI
: name
= "FINI"; break;
610 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
611 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
612 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
613 case DT_REL
: name
= "REL"; break;
614 case DT_RELSZ
: name
= "RELSZ"; break;
615 case DT_RELENT
: name
= "RELENT"; break;
616 case DT_PLTREL
: name
= "PLTREL"; break;
617 case DT_DEBUG
: name
= "DEBUG"; break;
618 case DT_TEXTREL
: name
= "TEXTREL"; break;
619 case DT_JMPREL
: name
= "JMPREL"; break;
620 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
621 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
622 case DT_VERSYM
: name
= "VERSYM"; break;
623 case DT_VERDEF
: name
= "VERDEF"; break;
624 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
625 case DT_VERNEED
: name
= "VERNEED"; break;
626 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
629 fprintf (f
, " %-11s ", name
);
631 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
636 string
= bfd_elf_string_from_elf_section (abfd
, link
,
640 fprintf (f
, "%s", string
);
649 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
650 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
652 if (! _bfd_elf_slurp_version_tables (abfd
))
656 if (elf_dynverdef (abfd
) != 0)
658 Elf_Internal_Verdef
*t
;
660 fprintf (f
, "\nVersion definitions:\n");
661 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
663 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
664 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
665 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
667 Elf_Internal_Verdaux
*a
;
670 for (a
= t
->vd_auxptr
->vda_nextptr
;
673 fprintf (f
, "%s ", a
->vda_nodename
);
679 if (elf_dynverref (abfd
) != 0)
681 Elf_Internal_Verneed
*t
;
683 fprintf (f
, "\nVersion References:\n");
684 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
686 Elf_Internal_Vernaux
*a
;
688 fprintf (f
, " required from %s:\n", t
->vn_filename
);
689 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
690 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
691 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
703 /* Display ELF-specific fields of a symbol. */
705 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
709 bfd_print_symbol_type how
;
711 FILE *file
= (FILE *) filep
;
714 case bfd_print_symbol_name
:
715 fprintf (file
, "%s", symbol
->name
);
717 case bfd_print_symbol_more
:
718 fprintf (file
, "elf ");
719 fprintf_vma (file
, symbol
->value
);
720 fprintf (file
, " %lx", (long) symbol
->flags
);
722 case bfd_print_symbol_all
:
724 CONST
char *section_name
;
725 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
726 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
727 fprintf (file
, " %s\t", section_name
);
728 /* Print the "other" value for a symbol. For common symbols,
729 we've already printed the size; now print the alignment.
730 For other symbols, we have no specified alignment, and
731 we've printed the address; now print the size. */
733 (bfd_is_com_section (symbol
->section
)
734 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
735 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
736 /* If the st_other field is not zero, print it. */
737 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
738 fprintf (file
, " 0x%02x",
740 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
741 fprintf (file
, " %s", symbol
->name
);
747 /* Create an entry in an ELF linker hash table. */
749 struct bfd_hash_entry
*
750 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
751 struct bfd_hash_entry
*entry
;
752 struct bfd_hash_table
*table
;
755 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
757 /* Allocate the structure if it has not already been allocated by a
759 if (ret
== (struct elf_link_hash_entry
*) NULL
)
760 ret
= ((struct elf_link_hash_entry
*)
761 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
762 if (ret
== (struct elf_link_hash_entry
*) NULL
)
763 return (struct bfd_hash_entry
*) ret
;
765 /* Call the allocation method of the superclass. */
766 ret
= ((struct elf_link_hash_entry
*)
767 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
769 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
771 /* Set local fields. */
775 ret
->dynstr_index
= 0;
777 ret
->got_offset
= (bfd_vma
) -1;
778 ret
->plt_offset
= (bfd_vma
) -1;
779 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
780 ret
->verinfo
.verdef
= NULL
;
781 ret
->type
= STT_NOTYPE
;
783 /* Assume that we have been called by a non-ELF symbol reader.
784 This flag is then reset by the code which reads an ELF input
785 file. This ensures that a symbol created by a non-ELF symbol
786 reader will have the flag set correctly. */
787 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
790 return (struct bfd_hash_entry
*) ret
;
793 /* Initialize an ELF linker hash table. */
796 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
797 struct elf_link_hash_table
*table
;
799 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
800 struct bfd_hash_table
*,
803 table
->dynamic_sections_created
= false;
804 table
->dynobj
= NULL
;
805 /* The first dynamic symbol is a dummy. */
806 table
->dynsymcount
= 1;
807 table
->dynstr
= NULL
;
808 table
->bucketcount
= 0;
809 table
->needed
= NULL
;
811 table
->stab_info
= NULL
;
812 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
815 /* Create an ELF linker hash table. */
817 struct bfd_link_hash_table
*
818 _bfd_elf_link_hash_table_create (abfd
)
821 struct elf_link_hash_table
*ret
;
823 ret
= ((struct elf_link_hash_table
*)
824 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
825 if (ret
== (struct elf_link_hash_table
*) NULL
)
828 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
830 bfd_release (abfd
, ret
);
837 /* This is a hook for the ELF emulation code in the generic linker to
838 tell the backend linker what file name to use for the DT_NEEDED
839 entry for a dynamic object. The generic linker passes name as an
840 empty string to indicate that no DT_NEEDED entry should be made. */
843 bfd_elf_set_dt_needed_name (abfd
, name
)
847 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
848 && bfd_get_format (abfd
) == bfd_object
)
849 elf_dt_name (abfd
) = name
;
852 /* Get the list of DT_NEEDED entries for a link. This is a hook for
853 the ELF emulation code. */
855 struct bfd_link_needed_list
*
856 bfd_elf_get_needed_list (abfd
, info
)
858 struct bfd_link_info
*info
;
860 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
862 return elf_hash_table (info
)->needed
;
865 /* Get the name actually used for a dynamic object for a link. This
866 is the SONAME entry if there is one. Otherwise, it is the string
867 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
870 bfd_elf_get_dt_soname (abfd
)
873 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
874 && bfd_get_format (abfd
) == bfd_object
)
875 return elf_dt_name (abfd
);
879 /* Allocate an ELF string table--force the first byte to be zero. */
881 struct bfd_strtab_hash
*
882 _bfd_elf_stringtab_init ()
884 struct bfd_strtab_hash
*ret
;
886 ret
= _bfd_stringtab_init ();
891 loc
= _bfd_stringtab_add (ret
, "", true, false);
892 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
893 if (loc
== (bfd_size_type
) -1)
895 _bfd_stringtab_free (ret
);
902 /* ELF .o/exec file reading */
904 /* Create a new bfd section from an ELF section header. */
907 bfd_section_from_shdr (abfd
, shindex
)
909 unsigned int shindex
;
911 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
912 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
913 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
916 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
918 switch (hdr
->sh_type
)
921 /* Inactive section. Throw it away. */
924 case SHT_PROGBITS
: /* Normal section with contents. */
925 case SHT_DYNAMIC
: /* Dynamic linking information. */
926 case SHT_NOBITS
: /* .bss section. */
927 case SHT_HASH
: /* .hash section. */
928 case SHT_NOTE
: /* .note section. */
929 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
931 case SHT_SYMTAB
: /* A symbol table */
932 if (elf_onesymtab (abfd
) == shindex
)
935 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
936 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
937 elf_onesymtab (abfd
) = shindex
;
938 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
939 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
940 abfd
->flags
|= HAS_SYMS
;
942 /* Sometimes a shared object will map in the symbol table. If
943 SHF_ALLOC is set, and this is a shared object, then we also
944 treat this section as a BFD section. We can not base the
945 decision purely on SHF_ALLOC, because that flag is sometimes
946 set in a relocateable object file, which would confuse the
948 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
949 && (abfd
->flags
& DYNAMIC
) != 0
950 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
955 case SHT_DYNSYM
: /* A dynamic symbol table */
956 if (elf_dynsymtab (abfd
) == shindex
)
959 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
960 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
961 elf_dynsymtab (abfd
) = shindex
;
962 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
963 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
964 abfd
->flags
|= HAS_SYMS
;
966 /* Besides being a symbol table, we also treat this as a regular
967 section, so that objcopy can handle it. */
968 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
970 case SHT_STRTAB
: /* A string table */
971 if (hdr
->bfd_section
!= NULL
)
973 if (ehdr
->e_shstrndx
== shindex
)
975 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
976 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
982 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
984 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
985 if (hdr2
->sh_link
== shindex
)
987 if (! bfd_section_from_shdr (abfd
, i
))
989 if (elf_onesymtab (abfd
) == i
)
991 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
992 elf_elfsections (abfd
)[shindex
] =
993 &elf_tdata (abfd
)->strtab_hdr
;
996 if (elf_dynsymtab (abfd
) == i
)
998 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
999 elf_elfsections (abfd
)[shindex
] = hdr
=
1000 &elf_tdata (abfd
)->dynstrtab_hdr
;
1001 /* We also treat this as a regular section, so
1002 that objcopy can handle it. */
1005 #if 0 /* Not handling other string tables specially right now. */
1006 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1007 /* We have a strtab for some random other section. */
1008 newsect
= (asection
*) hdr2
->bfd_section
;
1011 hdr
->bfd_section
= newsect
;
1012 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1014 elf_elfsections (abfd
)[shindex
] = hdr2
;
1020 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1024 /* *These* do a lot of work -- but build no sections! */
1026 asection
*target_sect
;
1027 Elf_Internal_Shdr
*hdr2
;
1029 /* For some incomprehensible reason Oracle distributes
1030 libraries for Solaris in which some of the objects have
1031 bogus sh_link fields. It would be nice if we could just
1032 reject them, but, unfortunately, some people need to use
1033 them. We scan through the section headers; if we find only
1034 one suitable symbol table, we clobber the sh_link to point
1035 to it. I hope this doesn't break anything. */
1036 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1037 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1043 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1045 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1046 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1057 hdr
->sh_link
= found
;
1060 /* Get the symbol table. */
1061 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1062 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1065 /* If this reloc section does not use the main symbol table we
1066 don't treat it as a reloc section. BFD can't adequately
1067 represent such a section, so at least for now, we don't
1068 try. We just present it as a normal section. */
1069 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1070 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1072 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1074 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1075 if (target_sect
== NULL
)
1078 if ((target_sect
->flags
& SEC_RELOC
) == 0
1079 || target_sect
->reloc_count
== 0)
1080 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1083 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1084 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1085 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1088 elf_elfsections (abfd
)[shindex
] = hdr2
;
1089 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1090 target_sect
->flags
|= SEC_RELOC
;
1091 target_sect
->relocation
= NULL
;
1092 target_sect
->rel_filepos
= hdr
->sh_offset
;
1093 abfd
->flags
|= HAS_RELOC
;
1098 case SHT_GNU_verdef
:
1099 elf_dynverdef (abfd
) = shindex
;
1100 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1103 case SHT_GNU_versym
:
1104 elf_dynversym (abfd
) = shindex
;
1105 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1108 case SHT_GNU_verneed
:
1109 elf_dynverref (abfd
) = shindex
;
1110 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1117 /* Check for any processor-specific section types. */
1119 if (bed
->elf_backend_section_from_shdr
)
1120 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1128 /* Given an ELF section number, retrieve the corresponding BFD
1132 bfd_section_from_elf_index (abfd
, index
)
1136 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1137 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1139 return elf_elfsections (abfd
)[index
]->bfd_section
;
1143 _bfd_elf_new_section_hook (abfd
, sec
)
1147 struct bfd_elf_section_data
*sdata
;
1149 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
1152 sec
->used_by_bfd
= (PTR
) sdata
;
1153 memset (sdata
, 0, sizeof (*sdata
));
1157 /* Create a new bfd section from an ELF program header.
1159 Since program segments have no names, we generate a synthetic name
1160 of the form segment<NUM>, where NUM is generally the index in the
1161 program header table. For segments that are split (see below) we
1162 generate the names segment<NUM>a and segment<NUM>b.
1164 Note that some program segments may have a file size that is different than
1165 (less than) the memory size. All this means is that at execution the
1166 system must allocate the amount of memory specified by the memory size,
1167 but only initialize it with the first "file size" bytes read from the
1168 file. This would occur for example, with program segments consisting
1169 of combined data+bss.
1171 To handle the above situation, this routine generates TWO bfd sections
1172 for the single program segment. The first has the length specified by
1173 the file size of the segment, and the second has the length specified
1174 by the difference between the two sizes. In effect, the segment is split
1175 into it's initialized and uninitialized parts.
1180 bfd_section_from_phdr (abfd
, hdr
, index
)
1182 Elf_Internal_Phdr
*hdr
;
1190 split
= ((hdr
->p_memsz
> 0) &&
1191 (hdr
->p_filesz
> 0) &&
1192 (hdr
->p_memsz
> hdr
->p_filesz
));
1193 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
1194 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1197 strcpy (name
, namebuf
);
1198 newsect
= bfd_make_section (abfd
, name
);
1199 if (newsect
== NULL
)
1201 newsect
->vma
= hdr
->p_vaddr
;
1202 newsect
->lma
= hdr
->p_paddr
;
1203 newsect
->_raw_size
= hdr
->p_filesz
;
1204 newsect
->filepos
= hdr
->p_offset
;
1205 newsect
->flags
|= SEC_HAS_CONTENTS
;
1206 if (hdr
->p_type
== PT_LOAD
)
1208 newsect
->flags
|= SEC_ALLOC
;
1209 newsect
->flags
|= SEC_LOAD
;
1210 if (hdr
->p_flags
& PF_X
)
1212 /* FIXME: all we known is that it has execute PERMISSION,
1214 newsect
->flags
|= SEC_CODE
;
1217 if (!(hdr
->p_flags
& PF_W
))
1219 newsect
->flags
|= SEC_READONLY
;
1224 sprintf (namebuf
, "segment%db", index
);
1225 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1228 strcpy (name
, namebuf
);
1229 newsect
= bfd_make_section (abfd
, name
);
1230 if (newsect
== NULL
)
1232 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1233 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1234 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1235 if (hdr
->p_type
== PT_LOAD
)
1237 newsect
->flags
|= SEC_ALLOC
;
1238 if (hdr
->p_flags
& PF_X
)
1239 newsect
->flags
|= SEC_CODE
;
1241 if (!(hdr
->p_flags
& PF_W
))
1242 newsect
->flags
|= SEC_READONLY
;
1248 /* Set up an ELF internal section header for a section. */
1252 elf_fake_sections (abfd
, asect
, failedptrarg
)
1257 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1258 boolean
*failedptr
= (boolean
*) failedptrarg
;
1259 Elf_Internal_Shdr
*this_hdr
;
1263 /* We already failed; just get out of the bfd_map_over_sections
1268 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1270 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1273 if (this_hdr
->sh_name
== (unsigned long) -1)
1279 this_hdr
->sh_flags
= 0;
1281 if ((asect
->flags
& SEC_ALLOC
) != 0
1282 || asect
->user_set_vma
)
1283 this_hdr
->sh_addr
= asect
->vma
;
1285 this_hdr
->sh_addr
= 0;
1287 this_hdr
->sh_offset
= 0;
1288 this_hdr
->sh_size
= asect
->_raw_size
;
1289 this_hdr
->sh_link
= 0;
1290 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1291 /* The sh_entsize and sh_info fields may have been set already by
1292 copy_private_section_data. */
1294 this_hdr
->bfd_section
= asect
;
1295 this_hdr
->contents
= NULL
;
1297 /* FIXME: This should not be based on section names. */
1298 if (strcmp (asect
->name
, ".dynstr") == 0)
1299 this_hdr
->sh_type
= SHT_STRTAB
;
1300 else if (strcmp (asect
->name
, ".hash") == 0)
1302 this_hdr
->sh_type
= SHT_HASH
;
1303 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1305 else if (strcmp (asect
->name
, ".dynsym") == 0)
1307 this_hdr
->sh_type
= SHT_DYNSYM
;
1308 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1310 else if (strcmp (asect
->name
, ".dynamic") == 0)
1312 this_hdr
->sh_type
= SHT_DYNAMIC
;
1313 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1315 else if (strncmp (asect
->name
, ".rela", 5) == 0
1316 && get_elf_backend_data (abfd
)->use_rela_p
)
1318 this_hdr
->sh_type
= SHT_RELA
;
1319 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1321 else if (strncmp (asect
->name
, ".rel", 4) == 0
1322 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1324 this_hdr
->sh_type
= SHT_REL
;
1325 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1327 else if (strncmp (asect
->name
, ".note", 5) == 0)
1328 this_hdr
->sh_type
= SHT_NOTE
;
1329 else if (strncmp (asect
->name
, ".stab", 5) == 0
1330 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1331 this_hdr
->sh_type
= SHT_STRTAB
;
1332 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1334 this_hdr
->sh_type
= SHT_GNU_versym
;
1335 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1337 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1339 this_hdr
->sh_type
= SHT_GNU_verdef
;
1340 this_hdr
->sh_entsize
= 0;
1341 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1343 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1345 this_hdr
->sh_type
= SHT_GNU_verneed
;
1346 this_hdr
->sh_entsize
= 0;
1347 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1349 else if ((asect
->flags
& SEC_ALLOC
) != 0
1350 && (asect
->flags
& SEC_LOAD
) != 0)
1351 this_hdr
->sh_type
= SHT_PROGBITS
;
1352 else if ((asect
->flags
& SEC_ALLOC
) != 0
1353 && ((asect
->flags
& SEC_LOAD
) == 0))
1354 this_hdr
->sh_type
= SHT_NOBITS
;
1358 this_hdr
->sh_type
= SHT_PROGBITS
;
1361 if ((asect
->flags
& SEC_ALLOC
) != 0)
1362 this_hdr
->sh_flags
|= SHF_ALLOC
;
1363 if ((asect
->flags
& SEC_READONLY
) == 0)
1364 this_hdr
->sh_flags
|= SHF_WRITE
;
1365 if ((asect
->flags
& SEC_CODE
) != 0)
1366 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1368 /* Check for processor-specific section types. */
1370 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1372 if (bed
->elf_backend_fake_sections
)
1373 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1376 /* If the section has relocs, set up a section header for the
1377 SHT_REL[A] section. */
1378 if ((asect
->flags
& SEC_RELOC
) != 0)
1380 Elf_Internal_Shdr
*rela_hdr
;
1381 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1384 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1385 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1391 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1393 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1395 if (rela_hdr
->sh_name
== (unsigned int) -1)
1400 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1401 rela_hdr
->sh_entsize
= (use_rela_p
1402 ? bed
->s
->sizeof_rela
1403 : bed
->s
->sizeof_rel
);
1404 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1405 rela_hdr
->sh_flags
= 0;
1406 rela_hdr
->sh_addr
= 0;
1407 rela_hdr
->sh_size
= 0;
1408 rela_hdr
->sh_offset
= 0;
1412 /* Assign all ELF section numbers. The dummy first section is handled here
1413 too. The link/info pointers for the standard section types are filled
1414 in here too, while we're at it. */
1417 assign_section_numbers (abfd
)
1420 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1422 unsigned int section_number
;
1423 Elf_Internal_Shdr
**i_shdrp
;
1424 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1428 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1430 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1432 d
->this_idx
= section_number
++;
1433 if ((sec
->flags
& SEC_RELOC
) == 0)
1436 d
->rel_idx
= section_number
++;
1439 t
->shstrtab_section
= section_number
++;
1440 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1441 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1443 if (abfd
->symcount
> 0)
1445 t
->symtab_section
= section_number
++;
1446 t
->strtab_section
= section_number
++;
1449 elf_elfheader (abfd
)->e_shnum
= section_number
;
1451 /* Set up the list of section header pointers, in agreement with the
1453 i_shdrp
= ((Elf_Internal_Shdr
**)
1454 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1455 if (i_shdrp
== NULL
)
1458 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1459 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1460 if (i_shdrp
[0] == NULL
)
1462 bfd_release (abfd
, i_shdrp
);
1465 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1467 elf_elfsections (abfd
) = i_shdrp
;
1469 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1470 if (abfd
->symcount
> 0)
1472 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1473 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1474 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1476 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1478 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1482 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1483 if (d
->rel_idx
!= 0)
1484 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1486 /* Fill in the sh_link and sh_info fields while we're at it. */
1488 /* sh_link of a reloc section is the section index of the symbol
1489 table. sh_info is the section index of the section to which
1490 the relocation entries apply. */
1491 if (d
->rel_idx
!= 0)
1493 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1494 d
->rel_hdr
.sh_info
= d
->this_idx
;
1497 switch (d
->this_hdr
.sh_type
)
1501 /* A reloc section which we are treating as a normal BFD
1502 section. sh_link is the section index of the symbol
1503 table. sh_info is the section index of the section to
1504 which the relocation entries apply. We assume that an
1505 allocated reloc section uses the dynamic symbol table.
1506 FIXME: How can we be sure? */
1507 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1509 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1511 /* We look up the section the relocs apply to by name. */
1513 if (d
->this_hdr
.sh_type
== SHT_REL
)
1517 s
= bfd_get_section_by_name (abfd
, name
);
1519 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1523 /* We assume that a section named .stab*str is a stabs
1524 string section. We look for a section with the same name
1525 but without the trailing ``str'', and set its sh_link
1526 field to point to this section. */
1527 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1528 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1533 len
= strlen (sec
->name
);
1534 alc
= (char *) bfd_malloc (len
- 2);
1537 strncpy (alc
, sec
->name
, len
- 3);
1538 alc
[len
- 3] = '\0';
1539 s
= bfd_get_section_by_name (abfd
, alc
);
1543 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1545 /* This is a .stab section. */
1546 elf_section_data (s
)->this_hdr
.sh_entsize
=
1547 4 + 2 * (bed
->s
->arch_size
/ 8);
1554 case SHT_GNU_verneed
:
1555 case SHT_GNU_verdef
:
1556 /* sh_link is the section header index of the string table
1557 used for the dynamic entries, or the symbol table, or the
1559 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1561 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1565 case SHT_GNU_versym
:
1566 /* sh_link is the section header index of the symbol table
1567 this hash table or version table is for. */
1568 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1570 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1578 /* Map symbol from it's internal number to the external number, moving
1579 all local symbols to be at the head of the list. */
1582 sym_is_global (abfd
, sym
)
1586 /* If the backend has a special mapping, use it. */
1587 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1588 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1591 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1592 || bfd_is_und_section (bfd_get_section (sym
))
1593 || bfd_is_com_section (bfd_get_section (sym
)));
1597 elf_map_symbols (abfd
)
1600 int symcount
= bfd_get_symcount (abfd
);
1601 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1602 asymbol
**sect_syms
;
1604 int num_globals
= 0;
1605 int num_locals2
= 0;
1606 int num_globals2
= 0;
1608 int num_sections
= 0;
1614 fprintf (stderr
, "elf_map_symbols\n");
1618 /* Add a section symbol for each BFD section. FIXME: Is this really
1620 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1622 if (max_index
< asect
->index
)
1623 max_index
= asect
->index
;
1627 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1628 if (sect_syms
== NULL
)
1630 elf_section_syms (abfd
) = sect_syms
;
1632 for (idx
= 0; idx
< symcount
; idx
++)
1634 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1635 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1639 sec
= syms
[idx
]->section
;
1640 if (sec
->owner
!= NULL
)
1642 if (sec
->owner
!= abfd
)
1644 if (sec
->output_offset
!= 0)
1646 sec
= sec
->output_section
;
1647 BFD_ASSERT (sec
->owner
== abfd
);
1649 sect_syms
[sec
->index
] = syms
[idx
];
1654 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1658 if (sect_syms
[asect
->index
] != NULL
)
1661 sym
= bfd_make_empty_symbol (abfd
);
1664 sym
->the_bfd
= abfd
;
1665 sym
->name
= asect
->name
;
1667 /* Set the flags to 0 to indicate that this one was newly added. */
1669 sym
->section
= asect
;
1670 sect_syms
[asect
->index
] = sym
;
1674 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1675 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1679 /* Classify all of the symbols. */
1680 for (idx
= 0; idx
< symcount
; idx
++)
1682 if (!sym_is_global (abfd
, syms
[idx
]))
1687 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1689 if (sect_syms
[asect
->index
] != NULL
1690 && sect_syms
[asect
->index
]->flags
== 0)
1692 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1693 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1697 sect_syms
[asect
->index
]->flags
= 0;
1701 /* Now sort the symbols so the local symbols are first. */
1702 new_syms
= ((asymbol
**)
1704 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1705 if (new_syms
== NULL
)
1708 for (idx
= 0; idx
< symcount
; idx
++)
1710 asymbol
*sym
= syms
[idx
];
1713 if (!sym_is_global (abfd
, sym
))
1716 i
= num_locals
+ num_globals2
++;
1718 sym
->udata
.i
= i
+ 1;
1720 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1722 if (sect_syms
[asect
->index
] != NULL
1723 && sect_syms
[asect
->index
]->flags
== 0)
1725 asymbol
*sym
= sect_syms
[asect
->index
];
1728 sym
->flags
= BSF_SECTION_SYM
;
1729 if (!sym_is_global (abfd
, sym
))
1732 i
= num_locals
+ num_globals2
++;
1734 sym
->udata
.i
= i
+ 1;
1738 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1740 elf_num_locals (abfd
) = num_locals
;
1741 elf_num_globals (abfd
) = num_globals
;
1745 /* Align to the maximum file alignment that could be required for any
1746 ELF data structure. */
1748 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1749 static INLINE file_ptr
1750 align_file_position (off
, align
)
1754 return (off
+ align
- 1) & ~(align
- 1);
1757 /* Assign a file position to a section, optionally aligning to the
1758 required section alignment. */
1761 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1762 Elf_Internal_Shdr
*i_shdrp
;
1770 al
= i_shdrp
->sh_addralign
;
1772 offset
= BFD_ALIGN (offset
, al
);
1774 i_shdrp
->sh_offset
= offset
;
1775 if (i_shdrp
->bfd_section
!= NULL
)
1776 i_shdrp
->bfd_section
->filepos
= offset
;
1777 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1778 offset
+= i_shdrp
->sh_size
;
1782 /* Compute the file positions we are going to put the sections at, and
1783 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1784 is not NULL, this is being called by the ELF backend linker. */
1787 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1789 struct bfd_link_info
*link_info
;
1791 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1793 struct bfd_strtab_hash
*strtab
;
1794 Elf_Internal_Shdr
*shstrtab_hdr
;
1796 if (abfd
->output_has_begun
)
1799 /* Do any elf backend specific processing first. */
1800 if (bed
->elf_backend_begin_write_processing
)
1801 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1803 if (! prep_headers (abfd
))
1807 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1811 if (!assign_section_numbers (abfd
))
1814 /* The backend linker builds symbol table information itself. */
1815 if (link_info
== NULL
&& abfd
->symcount
> 0)
1817 if (! swap_out_syms (abfd
, &strtab
))
1821 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1822 /* sh_name was set in prep_headers. */
1823 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1824 shstrtab_hdr
->sh_flags
= 0;
1825 shstrtab_hdr
->sh_addr
= 0;
1826 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1827 shstrtab_hdr
->sh_entsize
= 0;
1828 shstrtab_hdr
->sh_link
= 0;
1829 shstrtab_hdr
->sh_info
= 0;
1830 /* sh_offset is set in assign_file_positions_except_relocs. */
1831 shstrtab_hdr
->sh_addralign
= 1;
1833 if (!assign_file_positions_except_relocs (abfd
))
1836 if (link_info
== NULL
&& abfd
->symcount
> 0)
1839 Elf_Internal_Shdr
*hdr
;
1841 off
= elf_tdata (abfd
)->next_file_pos
;
1843 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1844 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1846 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1847 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1849 elf_tdata (abfd
)->next_file_pos
= off
;
1851 /* Now that we know where the .strtab section goes, write it
1853 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1854 || ! _bfd_stringtab_emit (abfd
, strtab
))
1856 _bfd_stringtab_free (strtab
);
1859 abfd
->output_has_begun
= true;
1864 /* Create a mapping from a set of sections to a program segment. */
1866 static INLINE
struct elf_segment_map
*
1867 make_mapping (abfd
, sections
, from
, to
, phdr
)
1869 asection
**sections
;
1874 struct elf_segment_map
*m
;
1878 m
= ((struct elf_segment_map
*)
1880 (sizeof (struct elf_segment_map
)
1881 + (to
- from
- 1) * sizeof (asection
*))));
1885 m
->p_type
= PT_LOAD
;
1886 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1887 m
->sections
[i
- from
] = *hdrpp
;
1888 m
->count
= to
- from
;
1890 if (from
== 0 && phdr
)
1892 /* Include the headers in the first PT_LOAD segment. */
1893 m
->includes_filehdr
= 1;
1894 m
->includes_phdrs
= 1;
1900 /* Set up a mapping from BFD sections to program segments. */
1903 map_sections_to_segments (abfd
)
1906 asection
**sections
= NULL
;
1910 struct elf_segment_map
*mfirst
;
1911 struct elf_segment_map
**pm
;
1912 struct elf_segment_map
*m
;
1914 unsigned int phdr_index
;
1915 bfd_vma maxpagesize
;
1917 boolean phdr_in_section
= true;
1921 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1924 if (bfd_count_sections (abfd
) == 0)
1927 /* Select the allocated sections, and sort them. */
1929 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1930 * sizeof (asection
*));
1931 if (sections
== NULL
)
1935 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1937 if ((s
->flags
& SEC_ALLOC
) != 0)
1943 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1946 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1948 /* Build the mapping. */
1953 /* If we have a .interp section, then create a PT_PHDR segment for
1954 the program headers and a PT_INTERP segment for the .interp
1956 s
= bfd_get_section_by_name (abfd
, ".interp");
1957 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1959 m
= ((struct elf_segment_map
*)
1960 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1964 m
->p_type
= PT_PHDR
;
1965 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1966 m
->p_flags
= PF_R
| PF_X
;
1967 m
->p_flags_valid
= 1;
1968 m
->includes_phdrs
= 1;
1973 m
= ((struct elf_segment_map
*)
1974 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1978 m
->p_type
= PT_INTERP
;
1986 /* Look through the sections. We put sections in the same program
1987 segment when the start of the second section can be placed within
1988 a few bytes of the end of the first section. */
1991 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1993 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
1995 && (dynsec
->flags
& SEC_LOAD
) == 0)
1998 /* Deal with -Ttext or something similar such that the first section
1999 is not adjacent to the program headers. This is an
2000 approximation, since at this point we don't know exactly how many
2001 program headers we will need. */
2004 bfd_size_type phdr_size
;
2006 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2008 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2009 if ((abfd
->flags
& D_PAGED
) == 0
2010 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2011 phdr_in_section
= false;
2014 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2017 boolean new_segment
;
2021 /* See if this section and the last one will fit in the same
2024 if (last_hdr
== NULL
)
2026 /* If we don't have a segment yet, then we don't need a new
2027 one (we build the last one after this loop). */
2028 new_segment
= false;
2030 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2032 /* If this section has a different relation between the
2033 virtual address and the load address, then we need a new
2037 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2040 /* If putting this section in this segment would force us to
2041 skip a page in the segment, then we need a new segment. */
2044 else if ((abfd
->flags
& D_PAGED
) == 0)
2046 /* If the file is not demand paged, which means that we
2047 don't require the sections to be correctly aligned in the
2048 file, then there is no other reason for a new segment. */
2049 new_segment
= false;
2051 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2052 && (hdr
->flags
& SEC_LOAD
) != 0)
2054 /* We don't want to put a loadable section after a
2055 nonloadable section in the same segment. */
2059 && (hdr
->flags
& SEC_READONLY
) == 0
2060 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2063 /* We don't want to put a writable section in a read only
2064 segment, unless they are on the same page in memory
2065 anyhow. We already know that the last section does not
2066 bring us past the current section on the page, so the
2067 only case in which the new section is not on the same
2068 page as the previous section is when the previous section
2069 ends precisely on a page boundary. */
2074 /* Otherwise, we can use the same segment. */
2075 new_segment
= false;
2080 if ((hdr
->flags
& SEC_READONLY
) == 0)
2086 /* We need a new program segment. We must create a new program
2087 header holding all the sections from phdr_index until hdr. */
2089 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2096 if ((hdr
->flags
& SEC_READONLY
) == 0)
2103 phdr_in_section
= false;
2106 /* Create a final PT_LOAD program segment. */
2107 if (last_hdr
!= NULL
)
2109 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
2117 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2120 m
= ((struct elf_segment_map
*)
2121 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2125 m
->p_type
= PT_DYNAMIC
;
2127 m
->sections
[0] = dynsec
;
2133 /* For each loadable .note section, add a PT_NOTE segment. We don't
2134 use bfd_get_section_by_name, because if we link together
2135 nonloadable .note sections and loadable .note sections, we will
2136 generate two .note sections in the output file. FIXME: Using
2137 names for section types is bogus anyhow. */
2138 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2140 if ((s
->flags
& SEC_LOAD
) != 0
2141 && strncmp (s
->name
, ".note", 5) == 0)
2143 m
= ((struct elf_segment_map
*)
2144 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2148 m
->p_type
= PT_NOTE
;
2160 elf_tdata (abfd
)->segment_map
= mfirst
;
2164 if (sections
!= NULL
)
2169 /* Sort sections by VMA. */
2172 elf_sort_sections (arg1
, arg2
)
2176 const asection
*sec1
= *(const asection
**) arg1
;
2177 const asection
*sec2
= *(const asection
**) arg2
;
2179 if (sec1
->vma
< sec2
->vma
)
2181 else if (sec1
->vma
> sec2
->vma
)
2184 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
2185 this will do nothing. */
2186 if (sec1
->lma
< sec2
->lma
)
2188 else if (sec1
->lma
> sec2
->lma
)
2191 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2193 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2197 return sec1
->target_index
- sec2
->target_index
;
2206 /* Sort by size, to put zero sized sections before others at the
2209 if (sec1
->_raw_size
< sec2
->_raw_size
)
2211 if (sec1
->_raw_size
> sec2
->_raw_size
)
2214 return sec1
->target_index
- sec2
->target_index
;
2217 /* Assign file positions to the sections based on the mapping from
2218 sections to segments. This function also sets up some fields in
2219 the file header, and writes out the program headers. */
2222 assign_file_positions_for_segments (abfd
)
2225 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2227 struct elf_segment_map
*m
;
2229 Elf_Internal_Phdr
*phdrs
;
2231 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2232 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2233 Elf_Internal_Phdr
*p
;
2235 if (elf_tdata (abfd
)->segment_map
== NULL
)
2237 if (! map_sections_to_segments (abfd
))
2241 if (bed
->elf_backend_modify_segment_map
)
2243 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2248 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2251 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2252 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2253 elf_elfheader (abfd
)->e_phnum
= count
;
2258 /* If we already counted the number of program segments, make sure
2259 that we allocated enough space. This happens when SIZEOF_HEADERS
2260 is used in a linker script. */
2261 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2262 if (alloc
!= 0 && count
> alloc
)
2264 ((*_bfd_error_handler
)
2265 ("%s: Not enough room for program headers (allocated %u, need %u)",
2266 bfd_get_filename (abfd
), alloc
, count
));
2267 bfd_set_error (bfd_error_bad_value
);
2274 phdrs
= ((Elf_Internal_Phdr
*)
2275 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2279 off
= bed
->s
->sizeof_ehdr
;
2280 off
+= alloc
* bed
->s
->sizeof_phdr
;
2286 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2293 /* If elf_segment_map is not from map_sections_to_segments, the
2294 sections may not be correctly ordered. */
2296 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2299 p
->p_type
= m
->p_type
;
2301 if (m
->p_flags_valid
)
2302 p
->p_flags
= m
->p_flags
;
2306 if (p
->p_type
== PT_LOAD
2308 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2310 if ((abfd
->flags
& D_PAGED
) != 0)
2311 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2313 off
+= ((m
->sections
[0]->vma
- off
)
2314 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2320 p
->p_vaddr
= m
->sections
[0]->vma
;
2322 if (m
->p_paddr_valid
)
2323 p
->p_paddr
= m
->p_paddr
;
2324 else if (m
->count
== 0)
2327 p
->p_paddr
= m
->sections
[0]->lma
;
2329 if (p
->p_type
== PT_LOAD
2330 && (abfd
->flags
& D_PAGED
) != 0)
2331 p
->p_align
= bed
->maxpagesize
;
2332 else if (m
->count
== 0)
2333 p
->p_align
= bed
->s
->file_align
;
2341 if (m
->includes_filehdr
)
2343 if (! m
->p_flags_valid
)
2346 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2347 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2350 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2352 if (! m
->p_paddr_valid
)
2355 if (p
->p_type
== PT_LOAD
)
2357 filehdr_vaddr
= p
->p_vaddr
;
2358 filehdr_paddr
= p
->p_paddr
;
2362 if (m
->includes_phdrs
)
2364 if (! m
->p_flags_valid
)
2366 if (m
->includes_filehdr
)
2368 if (p
->p_type
== PT_LOAD
)
2370 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2371 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2376 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2379 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2380 p
->p_vaddr
-= off
- p
->p_offset
;
2381 if (! m
->p_paddr_valid
)
2382 p
->p_paddr
-= off
- p
->p_offset
;
2384 if (p
->p_type
== PT_LOAD
)
2386 phdrs_vaddr
= p
->p_vaddr
;
2387 phdrs_paddr
= p
->p_paddr
;
2390 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2391 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2394 if (p
->p_type
== PT_LOAD
)
2396 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2402 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2403 p
->p_filesz
+= adjust
;
2404 p
->p_memsz
+= adjust
;
2409 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2413 bfd_size_type align
;
2417 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2419 if (p
->p_type
== PT_LOAD
)
2423 /* The section VMA must equal the file position modulo
2425 if ((flags
& SEC_ALLOC
) != 0)
2427 if ((abfd
->flags
& D_PAGED
) != 0)
2428 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2430 adjust
= (sec
->vma
- voff
) % align
;
2435 p
->p_memsz
+= adjust
;
2438 if ((flags
& SEC_LOAD
) != 0)
2439 p
->p_filesz
+= adjust
;
2445 if ((flags
& SEC_LOAD
) != 0)
2446 off
+= sec
->_raw_size
;
2447 if ((flags
& SEC_ALLOC
) != 0)
2448 voff
+= sec
->_raw_size
;
2451 p
->p_memsz
+= sec
->_raw_size
;
2453 if ((flags
& SEC_LOAD
) != 0)
2454 p
->p_filesz
+= sec
->_raw_size
;
2456 if (align
> p
->p_align
)
2459 if (! m
->p_flags_valid
)
2462 if ((flags
& SEC_CODE
) != 0)
2464 if ((flags
& SEC_READONLY
) == 0)
2470 /* Now that we have set the section file positions, we can set up
2471 the file positions for the non PT_LOAD segments. */
2472 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2476 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2478 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2479 p
->p_offset
= m
->sections
[0]->filepos
;
2483 if (m
->includes_filehdr
)
2485 p
->p_vaddr
= filehdr_vaddr
;
2486 if (! m
->p_paddr_valid
)
2487 p
->p_paddr
= filehdr_paddr
;
2489 else if (m
->includes_phdrs
)
2491 p
->p_vaddr
= phdrs_vaddr
;
2492 if (! m
->p_paddr_valid
)
2493 p
->p_paddr
= phdrs_paddr
;
2498 /* Clear out any program headers we allocated but did not use. */
2499 for (; count
< alloc
; count
++, p
++)
2501 memset (p
, 0, sizeof *p
);
2502 p
->p_type
= PT_NULL
;
2505 elf_tdata (abfd
)->phdr
= phdrs
;
2507 elf_tdata (abfd
)->next_file_pos
= off
;
2509 /* Write out the program headers. */
2510 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2511 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2517 /* Get the size of the program header.
2519 If this is called by the linker before any of the section VMA's are set, it
2520 can't calculate the correct value for a strange memory layout. This only
2521 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2522 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2523 data segment (exclusive of .interp and .dynamic).
2525 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2526 will be two segments. */
2528 static bfd_size_type
2529 get_program_header_size (abfd
)
2534 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2536 /* We can't return a different result each time we're called. */
2537 if (elf_tdata (abfd
)->program_header_size
!= 0)
2538 return elf_tdata (abfd
)->program_header_size
;
2540 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2542 struct elf_segment_map
*m
;
2545 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2547 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2548 return elf_tdata (abfd
)->program_header_size
;
2551 /* Assume we will need exactly two PT_LOAD segments: one for text
2552 and one for data. */
2555 s
= bfd_get_section_by_name (abfd
, ".interp");
2556 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2558 /* If we have a loadable interpreter section, we need a
2559 PT_INTERP segment. In this case, assume we also need a
2560 PT_PHDR segment, although that may not be true for all
2565 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2567 /* We need a PT_DYNAMIC segment. */
2571 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2573 if ((s
->flags
& SEC_LOAD
) != 0
2574 && strncmp (s
->name
, ".note", 5) == 0)
2576 /* We need a PT_NOTE segment. */
2581 /* Let the backend count up any program headers it might need. */
2582 if (bed
->elf_backend_additional_program_headers
)
2586 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2592 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2593 return elf_tdata (abfd
)->program_header_size
;
2596 /* Work out the file positions of all the sections. This is called by
2597 _bfd_elf_compute_section_file_positions. All the section sizes and
2598 VMAs must be known before this is called.
2600 We do not consider reloc sections at this point, unless they form
2601 part of the loadable image. Reloc sections are assigned file
2602 positions in assign_file_positions_for_relocs, which is called by
2603 write_object_contents and final_link.
2605 We also don't set the positions of the .symtab and .strtab here. */
2608 assign_file_positions_except_relocs (abfd
)
2611 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2612 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2613 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2615 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2617 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2619 Elf_Internal_Shdr
**hdrpp
;
2622 /* Start after the ELF header. */
2623 off
= i_ehdrp
->e_ehsize
;
2625 /* We are not creating an executable, which means that we are
2626 not creating a program header, and that the actual order of
2627 the sections in the file is unimportant. */
2628 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2630 Elf_Internal_Shdr
*hdr
;
2633 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2635 hdr
->sh_offset
= -1;
2638 if (i
== tdata
->symtab_section
2639 || i
== tdata
->strtab_section
)
2641 hdr
->sh_offset
= -1;
2645 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2651 Elf_Internal_Shdr
**hdrpp
;
2653 /* Assign file positions for the loaded sections based on the
2654 assignment of sections to segments. */
2655 if (! assign_file_positions_for_segments (abfd
))
2658 /* Assign file positions for the other sections. */
2660 off
= elf_tdata (abfd
)->next_file_pos
;
2661 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2663 Elf_Internal_Shdr
*hdr
;
2666 if (hdr
->bfd_section
!= NULL
2667 && hdr
->bfd_section
->filepos
!= 0)
2668 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2669 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2671 ((*_bfd_error_handler
)
2672 ("%s: warning: allocated section `%s' not in segment",
2673 bfd_get_filename (abfd
),
2674 (hdr
->bfd_section
== NULL
2676 : hdr
->bfd_section
->name
)));
2677 if ((abfd
->flags
& D_PAGED
) != 0)
2678 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2680 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2681 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2684 else if (hdr
->sh_type
== SHT_REL
2685 || hdr
->sh_type
== SHT_RELA
2686 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2687 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2688 hdr
->sh_offset
= -1;
2690 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2694 /* Place the section headers. */
2695 off
= align_file_position (off
, bed
->s
->file_align
);
2696 i_ehdrp
->e_shoff
= off
;
2697 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2699 elf_tdata (abfd
)->next_file_pos
= off
;
2708 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2709 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2710 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2712 struct bfd_strtab_hash
*shstrtab
;
2713 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2715 i_ehdrp
= elf_elfheader (abfd
);
2716 i_shdrp
= elf_elfsections (abfd
);
2718 shstrtab
= _bfd_elf_stringtab_init ();
2719 if (shstrtab
== NULL
)
2722 elf_shstrtab (abfd
) = shstrtab
;
2724 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2725 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2726 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2727 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2729 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2730 i_ehdrp
->e_ident
[EI_DATA
] =
2731 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2732 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2734 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2735 i_ehdrp
->e_ident
[count
] = 0;
2737 if ((abfd
->flags
& DYNAMIC
) != 0)
2738 i_ehdrp
->e_type
= ET_DYN
;
2739 else if ((abfd
->flags
& EXEC_P
) != 0)
2740 i_ehdrp
->e_type
= ET_EXEC
;
2742 i_ehdrp
->e_type
= ET_REL
;
2744 switch (bfd_get_arch (abfd
))
2746 case bfd_arch_unknown
:
2747 i_ehdrp
->e_machine
= EM_NONE
;
2749 case bfd_arch_sparc
:
2750 if (bed
->s
->arch_size
== 64)
2751 i_ehdrp
->e_machine
= EM_SPARC64
;
2753 i_ehdrp
->e_machine
= EM_SPARC
;
2756 i_ehdrp
->e_machine
= EM_386
;
2759 i_ehdrp
->e_machine
= EM_68K
;
2762 i_ehdrp
->e_machine
= EM_88K
;
2765 i_ehdrp
->e_machine
= EM_860
;
2767 case bfd_arch_mips
: /* MIPS Rxxxx */
2768 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2771 i_ehdrp
->e_machine
= EM_PARISC
;
2773 case bfd_arch_powerpc
:
2774 i_ehdrp
->e_machine
= EM_PPC
;
2776 case bfd_arch_alpha
:
2777 i_ehdrp
->e_machine
= EM_ALPHA
;
2780 i_ehdrp
->e_machine
= EM_SH
;
2783 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2785 /* start-sanitize-d30v */
2787 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
2789 /* end-sanitize-d30v */
2790 /* start-sanitize-v850 */
2792 i_ehdrp
->e_machine
= EM_CYGNUS_V850
;
2794 /* end-sanitize-v850 */
2795 /* start-sanitize-arc */
2797 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2799 /* end-sanitize-arc */
2800 /* start-sanitize-m32r */
2802 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
2804 /* end-sanitize-m32r */
2805 case bfd_arch_mn10200
:
2806 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
2808 case bfd_arch_mn10300
:
2809 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
2811 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2813 i_ehdrp
->e_machine
= EM_NONE
;
2815 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2816 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2818 /* no program header, for now. */
2819 i_ehdrp
->e_phoff
= 0;
2820 i_ehdrp
->e_phentsize
= 0;
2821 i_ehdrp
->e_phnum
= 0;
2823 /* each bfd section is section header entry */
2824 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2825 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2827 /* if we're building an executable, we'll need a program header table */
2828 if (abfd
->flags
& EXEC_P
)
2830 /* it all happens later */
2832 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2834 /* elf_build_phdrs() returns a (NULL-terminated) array of
2835 Elf_Internal_Phdrs */
2836 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2837 i_ehdrp
->e_phoff
= outbase
;
2838 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2843 i_ehdrp
->e_phentsize
= 0;
2845 i_ehdrp
->e_phoff
= 0;
2848 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2849 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2850 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2851 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2852 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2853 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2854 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2855 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2856 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2862 /* Assign file positions for all the reloc sections which are not part
2863 of the loadable file image. */
2866 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2871 Elf_Internal_Shdr
**shdrpp
;
2873 off
= elf_tdata (abfd
)->next_file_pos
;
2875 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2876 i
< elf_elfheader (abfd
)->e_shnum
;
2879 Elf_Internal_Shdr
*shdrp
;
2882 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2883 && shdrp
->sh_offset
== -1)
2884 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2887 elf_tdata (abfd
)->next_file_pos
= off
;
2891 _bfd_elf_write_object_contents (abfd
)
2894 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2895 Elf_Internal_Ehdr
*i_ehdrp
;
2896 Elf_Internal_Shdr
**i_shdrp
;
2900 if (! abfd
->output_has_begun
2901 && ! _bfd_elf_compute_section_file_positions (abfd
,
2902 (struct bfd_link_info
*) NULL
))
2905 i_shdrp
= elf_elfsections (abfd
);
2906 i_ehdrp
= elf_elfheader (abfd
);
2909 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2912 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2914 /* After writing the headers, we need to write the sections too... */
2915 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2917 if (bed
->elf_backend_section_processing
)
2918 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2919 if (i_shdrp
[count
]->contents
)
2921 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2922 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2924 != i_shdrp
[count
]->sh_size
))
2929 /* Write out the section header names. */
2930 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2931 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2934 if (bed
->elf_backend_final_write_processing
)
2935 (*bed
->elf_backend_final_write_processing
) (abfd
,
2936 elf_tdata (abfd
)->linker
);
2938 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2941 /* given a section, search the header to find them... */
2943 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2947 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2948 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2950 Elf_Internal_Shdr
*hdr
;
2951 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2953 for (index
= 0; index
< maxindex
; index
++)
2955 hdr
= i_shdrp
[index
];
2956 if (hdr
->bfd_section
== asect
)
2960 if (bed
->elf_backend_section_from_bfd_section
)
2962 for (index
= 0; index
< maxindex
; index
++)
2966 hdr
= i_shdrp
[index
];
2968 if ((*bed
->elf_backend_section_from_bfd_section
)
2969 (abfd
, hdr
, asect
, &retval
))
2974 if (bfd_is_abs_section (asect
))
2976 if (bfd_is_com_section (asect
))
2978 if (bfd_is_und_section (asect
))
2984 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
2988 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2990 asymbol
**asym_ptr_ptr
;
2992 asymbol
*asym_ptr
= *asym_ptr_ptr
;
2994 flagword flags
= asym_ptr
->flags
;
2996 /* When gas creates relocations against local labels, it creates its
2997 own symbol for the section, but does put the symbol into the
2998 symbol chain, so udata is 0. When the linker is generating
2999 relocatable output, this section symbol may be for one of the
3000 input sections rather than the output section. */
3001 if (asym_ptr
->udata
.i
== 0
3002 && (flags
& BSF_SECTION_SYM
)
3003 && asym_ptr
->section
)
3007 if (asym_ptr
->section
->output_section
!= NULL
)
3008 indx
= asym_ptr
->section
->output_section
->index
;
3010 indx
= asym_ptr
->section
->index
;
3011 if (elf_section_syms (abfd
)[indx
])
3012 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3015 idx
= asym_ptr
->udata
.i
;
3019 /* This case can occur when using --strip-symbol on a symbol
3020 which is used in a relocation entry. */
3021 (*_bfd_error_handler
)
3022 ("%s: symbol `%s' required but not present",
3023 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3024 bfd_set_error (bfd_error_no_symbols
);
3031 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
3032 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3033 elf_symbol_flags (flags
));
3041 /* Copy private BFD data. This copies any program header information. */
3044 copy_private_bfd_data (ibfd
, obfd
)
3048 Elf_Internal_Ehdr
*iehdr
;
3049 struct elf_segment_map
*mfirst
;
3050 struct elf_segment_map
**pm
;
3051 Elf_Internal_Phdr
*p
;
3054 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3055 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3058 if (elf_tdata (ibfd
)->phdr
== NULL
)
3061 iehdr
= elf_elfheader (ibfd
);
3066 c
= elf_elfheader (ibfd
)->e_phnum
;
3067 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
3071 struct elf_segment_map
*m
;
3076 /* The complicated case when p_vaddr is 0 is to handle the
3077 Solaris linker, which generates a PT_INTERP section with
3078 p_vaddr and p_memsz set to 0. */
3079 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3080 if (((s
->vma
>= p
->p_vaddr
3081 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3082 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3085 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3086 && (bfd_vma
) s
->filepos
>= p
->p_offset
3087 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3088 <= p
->p_offset
+ p
->p_filesz
)))
3089 && (s
->flags
& SEC_ALLOC
) != 0
3090 && s
->output_section
!= NULL
)
3093 m
= ((struct elf_segment_map
*)
3095 (sizeof (struct elf_segment_map
)
3096 + (csecs
- 1) * sizeof (asection
*))));
3101 m
->p_type
= p
->p_type
;
3102 m
->p_flags
= p
->p_flags
;
3103 m
->p_flags_valid
= 1;
3104 m
->p_paddr
= p
->p_paddr
;
3105 m
->p_paddr_valid
= 1;
3107 m
->includes_filehdr
= (p
->p_offset
== 0
3108 && p
->p_filesz
>= iehdr
->e_ehsize
);
3110 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3111 && (p
->p_offset
+ p
->p_filesz
3112 >= ((bfd_vma
) iehdr
->e_phoff
3113 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3116 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3118 if (((s
->vma
>= p
->p_vaddr
3119 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
3120 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
3123 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
3124 && (bfd_vma
) s
->filepos
>= p
->p_offset
3125 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
3126 <= p
->p_offset
+ p
->p_filesz
)))
3127 && (s
->flags
& SEC_ALLOC
) != 0
3128 && s
->output_section
!= NULL
)
3130 m
->sections
[isec
] = s
->output_section
;
3134 BFD_ASSERT (isec
== csecs
);
3141 elf_tdata (obfd
)->segment_map
= mfirst
;
3146 /* Copy private section information. This copies over the entsize
3147 field, and sometimes the info field. */
3150 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3156 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3158 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3159 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3162 /* Copy over private BFD data if it has not already been copied.
3163 This must be done here, rather than in the copy_private_bfd_data
3164 entry point, because the latter is called after the section
3165 contents have been set, which means that the program headers have
3166 already been worked out. */
3167 if (elf_tdata (obfd
)->segment_map
== NULL
3168 && elf_tdata (ibfd
)->phdr
!= NULL
)
3172 /* Only set up the segments when all the sections have been set
3174 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3175 if (s
->output_section
== NULL
)
3179 if (! copy_private_bfd_data (ibfd
, obfd
))
3184 ihdr
= &elf_section_data (isec
)->this_hdr
;
3185 ohdr
= &elf_section_data (osec
)->this_hdr
;
3187 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3189 if (ihdr
->sh_type
== SHT_SYMTAB
3190 || ihdr
->sh_type
== SHT_DYNSYM
)
3191 ohdr
->sh_info
= ihdr
->sh_info
;
3196 /* Copy private symbol information. If this symbol is in a section
3197 which we did not map into a BFD section, try to map the section
3198 index correctly. We use special macro definitions for the mapped
3199 section indices; these definitions are interpreted by the
3200 swap_out_syms function. */
3202 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3203 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3204 #define MAP_STRTAB (SHN_LORESERVE - 3)
3205 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3208 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3214 elf_symbol_type
*isym
, *osym
;
3216 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3217 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3220 isym
= elf_symbol_from (ibfd
, isymarg
);
3221 osym
= elf_symbol_from (obfd
, osymarg
);
3225 && bfd_is_abs_section (isym
->symbol
.section
))
3229 shndx
= isym
->internal_elf_sym
.st_shndx
;
3230 if (shndx
== elf_onesymtab (ibfd
))
3231 shndx
= MAP_ONESYMTAB
;
3232 else if (shndx
== elf_dynsymtab (ibfd
))
3233 shndx
= MAP_DYNSYMTAB
;
3234 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3236 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3237 shndx
= MAP_SHSTRTAB
;
3238 osym
->internal_elf_sym
.st_shndx
= shndx
;
3244 /* Swap out the symbols. */
3247 swap_out_syms (abfd
, sttp
)
3249 struct bfd_strtab_hash
**sttp
;
3251 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3253 if (!elf_map_symbols (abfd
))
3256 /* Dump out the symtabs. */
3258 int symcount
= bfd_get_symcount (abfd
);
3259 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3260 struct bfd_strtab_hash
*stt
;
3261 Elf_Internal_Shdr
*symtab_hdr
;
3262 Elf_Internal_Shdr
*symstrtab_hdr
;
3263 char *outbound_syms
;
3266 stt
= _bfd_elf_stringtab_init ();
3270 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3271 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3272 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3273 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3274 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3275 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3277 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3278 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3280 outbound_syms
= bfd_alloc (abfd
,
3281 (1 + symcount
) * bed
->s
->sizeof_sym
);
3282 if (outbound_syms
== NULL
)
3284 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3286 /* now generate the data (for "contents") */
3288 /* Fill in zeroth symbol and swap it out. */
3289 Elf_Internal_Sym sym
;
3295 sym
.st_shndx
= SHN_UNDEF
;
3296 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3297 outbound_syms
+= bed
->s
->sizeof_sym
;
3299 for (idx
= 0; idx
< symcount
; idx
++)
3301 Elf_Internal_Sym sym
;
3302 bfd_vma value
= syms
[idx
]->value
;
3303 elf_symbol_type
*type_ptr
;
3304 flagword flags
= syms
[idx
]->flags
;
3307 if (flags
& BSF_SECTION_SYM
)
3308 /* Section symbols have no names. */
3312 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3315 if (sym
.st_name
== (unsigned long) -1)
3319 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3321 if (bfd_is_com_section (syms
[idx
]->section
))
3323 /* ELF common symbols put the alignment into the `value' field,
3324 and the size into the `size' field. This is backwards from
3325 how BFD handles it, so reverse it here. */
3326 sym
.st_size
= value
;
3327 if (type_ptr
== NULL
3328 || type_ptr
->internal_elf_sym
.st_value
== 0)
3329 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3331 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3332 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3333 syms
[idx
]->section
);
3337 asection
*sec
= syms
[idx
]->section
;
3340 if (sec
->output_section
)
3342 value
+= sec
->output_offset
;
3343 sec
= sec
->output_section
;
3346 sym
.st_value
= value
;
3347 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3349 if (bfd_is_abs_section (sec
)
3351 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3353 /* This symbol is in a real ELF section which we did
3354 not create as a BFD section. Undo the mapping done
3355 by copy_private_symbol_data. */
3356 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3360 shndx
= elf_onesymtab (abfd
);
3363 shndx
= elf_dynsymtab (abfd
);
3366 shndx
= elf_tdata (abfd
)->strtab_section
;
3369 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3377 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3383 /* Writing this would be a hell of a lot easier if
3384 we had some decent documentation on bfd, and
3385 knew what to expect of the library, and what to
3386 demand of applications. For example, it
3387 appears that `objcopy' might not set the
3388 section of a symbol to be a section that is
3389 actually in the output file. */
3390 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3391 BFD_ASSERT (sec2
!= 0);
3392 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3393 BFD_ASSERT (shndx
!= -1);
3397 sym
.st_shndx
= shndx
;
3400 if ((flags
& BSF_FUNCTION
) != 0)
3402 else if ((flags
& BSF_OBJECT
) != 0)
3407 if (bfd_is_com_section (syms
[idx
]->section
))
3408 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3409 else if (bfd_is_und_section (syms
[idx
]->section
))
3410 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3414 else if (flags
& BSF_SECTION_SYM
)
3415 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3416 else if (flags
& BSF_FILE
)
3417 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3420 int bind
= STB_LOCAL
;
3422 if (flags
& BSF_LOCAL
)
3424 else if (flags
& BSF_WEAK
)
3426 else if (flags
& BSF_GLOBAL
)
3429 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3432 if (type_ptr
!= NULL
)
3433 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3437 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3438 outbound_syms
+= bed
->s
->sizeof_sym
;
3442 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3443 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3445 symstrtab_hdr
->sh_flags
= 0;
3446 symstrtab_hdr
->sh_addr
= 0;
3447 symstrtab_hdr
->sh_entsize
= 0;
3448 symstrtab_hdr
->sh_link
= 0;
3449 symstrtab_hdr
->sh_info
= 0;
3450 symstrtab_hdr
->sh_addralign
= 1;
3456 /* Return the number of bytes required to hold the symtab vector.
3458 Note that we base it on the count plus 1, since we will null terminate
3459 the vector allocated based on this size. However, the ELF symbol table
3460 always has a dummy entry as symbol #0, so it ends up even. */
3463 _bfd_elf_get_symtab_upper_bound (abfd
)
3468 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3470 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3471 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3477 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3482 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3484 if (elf_dynsymtab (abfd
) == 0)
3486 bfd_set_error (bfd_error_invalid_operation
);
3490 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3491 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3497 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3501 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3504 /* Canonicalize the relocs. */
3507 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3516 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3522 tblptr
= section
->relocation
;
3523 for (i
= 0; i
< section
->reloc_count
; i
++)
3524 *relptr
++ = tblptr
++;
3528 return section
->reloc_count
;
3532 _bfd_elf_get_symtab (abfd
, alocation
)
3534 asymbol
**alocation
;
3536 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3539 bfd_get_symcount (abfd
) = symcount
;
3544 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3546 asymbol
**alocation
;
3548 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3551 /* Return the size required for the dynamic reloc entries. Any
3552 section that was actually installed in the BFD, and has type
3553 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3554 considered to be a dynamic reloc section. */
3557 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3563 if (elf_dynsymtab (abfd
) == 0)
3565 bfd_set_error (bfd_error_invalid_operation
);
3569 ret
= sizeof (arelent
*);
3570 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3571 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3572 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3573 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3574 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3575 * sizeof (arelent
*));
3580 /* Canonicalize the dynamic relocation entries. Note that we return
3581 the dynamic relocations as a single block, although they are
3582 actually associated with particular sections; the interface, which
3583 was designed for SunOS style shared libraries, expects that there
3584 is only one set of dynamic relocs. Any section that was actually
3585 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3586 the dynamic symbol table, is considered to be a dynamic reloc
3590 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3595 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3599 if (elf_dynsymtab (abfd
) == 0)
3601 bfd_set_error (bfd_error_invalid_operation
);
3605 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3607 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3609 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3610 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3611 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3616 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3618 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3620 for (i
= 0; i
< count
; i
++)
3631 /* Read in the version information. */
3634 _bfd_elf_slurp_version_tables (abfd
)
3637 bfd_byte
*contents
= NULL
;
3639 if (elf_dynverdef (abfd
) != 0)
3641 Elf_Internal_Shdr
*hdr
;
3642 Elf_External_Verdef
*everdef
;
3643 Elf_Internal_Verdef
*iverdef
;
3646 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
3648 elf_tdata (abfd
)->verdef
=
3649 ((Elf_Internal_Verdef
*)
3650 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
3651 if (elf_tdata (abfd
)->verdef
== NULL
)
3654 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
3656 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3657 if (contents
== NULL
)
3659 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3660 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3663 everdef
= (Elf_External_Verdef
*) contents
;
3664 iverdef
= elf_tdata (abfd
)->verdef
;
3665 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
3667 Elf_External_Verdaux
*everdaux
;
3668 Elf_Internal_Verdaux
*iverdaux
;
3671 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
3673 iverdef
->vd_bfd
= abfd
;
3675 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
3678 * sizeof (Elf_Internal_Verdaux
))));
3679 if (iverdef
->vd_auxptr
== NULL
)
3682 everdaux
= ((Elf_External_Verdaux
*)
3683 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
3684 iverdaux
= iverdef
->vd_auxptr
;
3685 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
3687 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
3689 iverdaux
->vda_nodename
=
3690 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3691 iverdaux
->vda_name
);
3692 if (iverdaux
->vda_nodename
== NULL
)
3695 if (j
+ 1 < iverdef
->vd_cnt
)
3696 iverdaux
->vda_nextptr
= iverdaux
+ 1;
3698 iverdaux
->vda_nextptr
= NULL
;
3700 everdaux
= ((Elf_External_Verdaux
*)
3701 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
3704 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
3706 if (i
+ 1 < hdr
->sh_info
)
3707 iverdef
->vd_nextdef
= iverdef
+ 1;
3709 iverdef
->vd_nextdef
= NULL
;
3711 everdef
= ((Elf_External_Verdef
*)
3712 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
3719 if (elf_dynverref (abfd
) != 0)
3721 Elf_Internal_Shdr
*hdr
;
3722 Elf_External_Verneed
*everneed
;
3723 Elf_Internal_Verneed
*iverneed
;
3726 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
3728 elf_tdata (abfd
)->verref
=
3729 ((Elf_Internal_Verneed
*)
3730 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
3731 if (elf_tdata (abfd
)->verref
== NULL
)
3734 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
3736 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
3737 if (contents
== NULL
)
3739 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3740 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
3743 everneed
= (Elf_External_Verneed
*) contents
;
3744 iverneed
= elf_tdata (abfd
)->verref
;
3745 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
3747 Elf_External_Vernaux
*evernaux
;
3748 Elf_Internal_Vernaux
*ivernaux
;
3751 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
3753 iverneed
->vn_bfd
= abfd
;
3755 iverneed
->vn_filename
=
3756 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3758 if (iverneed
->vn_filename
== NULL
)
3761 iverneed
->vn_auxptr
=
3762 ((Elf_Internal_Vernaux
*)
3764 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
3766 evernaux
= ((Elf_External_Vernaux
*)
3767 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
3768 ivernaux
= iverneed
->vn_auxptr
;
3769 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
3771 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
3773 ivernaux
->vna_nodename
=
3774 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3775 ivernaux
->vna_name
);
3776 if (ivernaux
->vna_nodename
== NULL
)
3779 if (j
+ 1 < iverneed
->vn_cnt
)
3780 ivernaux
->vna_nextptr
= ivernaux
+ 1;
3782 ivernaux
->vna_nextptr
= NULL
;
3784 evernaux
= ((Elf_External_Vernaux
*)
3785 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
3788 if (i
+ 1 < hdr
->sh_info
)
3789 iverneed
->vn_nextref
= iverneed
+ 1;
3791 iverneed
->vn_nextref
= NULL
;
3793 everneed
= ((Elf_External_Verneed
*)
3794 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
3804 if (contents
== NULL
)
3810 _bfd_elf_make_empty_symbol (abfd
)
3813 elf_symbol_type
*newsym
;
3815 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3820 newsym
->symbol
.the_bfd
= abfd
;
3821 return &newsym
->symbol
;
3826 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3831 bfd_symbol_info (symbol
, ret
);
3834 /* Return whether a symbol name implies a local symbol. In ELF, local
3835 symbols generally start with ``.L''. Most targets use this
3836 function for the is_local_label_name entry point, but some override
3840 _bfd_elf_is_local_label_name (abfd
, name
)
3844 return name
[0] == '.' && name
[1] == 'L';
3848 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3857 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3859 enum bfd_architecture arch
;
3860 unsigned long machine
;
3862 /* If this isn't the right architecture for this backend, and this
3863 isn't the generic backend, fail. */
3864 if (arch
!= get_elf_backend_data (abfd
)->arch
3865 && arch
!= bfd_arch_unknown
3866 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3869 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3872 /* Find the nearest line to a particular section and offset, for error
3876 _bfd_elf_find_nearest_line (abfd
,
3887 CONST
char **filename_ptr
;
3888 CONST
char **functionname_ptr
;
3889 unsigned int *line_ptr
;
3892 const char *filename
;
3897 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3898 &found
, filename_ptr
,
3899 functionname_ptr
, line_ptr
,
3900 &elf_tdata (abfd
)->line_info
))
3905 if (symbols
== NULL
)
3912 for (p
= symbols
; *p
!= NULL
; p
++)
3916 q
= (elf_symbol_type
*) *p
;
3918 if (bfd_get_section (&q
->symbol
) != section
)
3921 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3926 filename
= bfd_asymbol_name (&q
->symbol
);
3929 if (q
->symbol
.section
== section
3930 && q
->symbol
.value
>= low_func
3931 && q
->symbol
.value
<= offset
)
3933 func
= (asymbol
*) q
;
3934 low_func
= q
->symbol
.value
;
3943 *filename_ptr
= filename
;
3944 *functionname_ptr
= bfd_asymbol_name (func
);
3950 _bfd_elf_sizeof_headers (abfd
, reloc
)
3956 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3958 ret
+= get_program_header_size (abfd
);
3963 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3968 bfd_size_type count
;
3970 Elf_Internal_Shdr
*hdr
;
3972 if (! abfd
->output_has_begun
3973 && ! _bfd_elf_compute_section_file_positions (abfd
,
3974 (struct bfd_link_info
*) NULL
))
3977 hdr
= &elf_section_data (section
)->this_hdr
;
3979 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3981 if (bfd_write (location
, 1, count
, abfd
) != count
)
3988 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3991 Elf_Internal_Rela
*dst
;
3998 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4001 Elf_Internal_Rel
*dst
;
4007 /* Try to convert a non-ELF reloc into an ELF one. */
4010 _bfd_elf_validate_reloc (abfd
, areloc
)
4014 /* Check whether we really have an ELF howto. */
4016 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4018 bfd_reloc_code_real_type code
;
4019 reloc_howto_type
*howto
;
4021 /* Alien reloc: Try to determine its type to replace it with an
4022 equivalent ELF reloc. */
4024 if (areloc
->howto
->pc_relative
)
4026 switch (areloc
->howto
->bitsize
)
4029 code
= BFD_RELOC_8_PCREL
;
4032 code
= BFD_RELOC_12_PCREL
;
4035 code
= BFD_RELOC_16_PCREL
;
4038 code
= BFD_RELOC_24_PCREL
;
4041 code
= BFD_RELOC_32_PCREL
;
4044 code
= BFD_RELOC_64_PCREL
;
4050 howto
= bfd_reloc_type_lookup (abfd
, code
);
4052 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4054 if (howto
->pcrel_offset
)
4055 areloc
->addend
+= areloc
->address
;
4057 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4062 switch (areloc
->howto
->bitsize
)
4068 code
= BFD_RELOC_14
;
4071 code
= BFD_RELOC_16
;
4074 code
= BFD_RELOC_26
;
4077 code
= BFD_RELOC_32
;
4080 code
= BFD_RELOC_64
;
4086 howto
= bfd_reloc_type_lookup (abfd
, code
);
4090 areloc
->howto
= howto
;
4098 (*_bfd_error_handler
)
4099 ("%s: unsupported relocation type %s",
4100 bfd_get_filename (abfd
), areloc
->howto
->name
);
4101 bfd_set_error (bfd_error_bad_value
);