1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000 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
35 #define _SYSCALL32 /* For Sparc64-cross-32 */
45 static INLINE
struct elf_segment_map
*make_mapping
46 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
47 static boolean map_sections_to_segments
PARAMS ((bfd
*));
48 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
49 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
50 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
51 static boolean prep_headers
PARAMS ((bfd
*));
52 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
53 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
54 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
55 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
56 static boolean assign_section_numbers
PARAMS ((bfd
*));
57 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
58 static boolean elf_map_symbols
PARAMS ((bfd
*));
59 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
60 static boolean elfcore_read_notes
PARAMS ((bfd
*, bfd_vma
, bfd_vma
));
62 /* Swap version information in and out. The version information is
63 currently size independent. If that ever changes, this code will
64 need to move into elfcode.h. */
66 /* Swap in a Verdef structure. */
69 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
71 const Elf_External_Verdef
*src
;
72 Elf_Internal_Verdef
*dst
;
74 dst
->vd_version
= bfd_h_get_16 (abfd
, src
->vd_version
);
75 dst
->vd_flags
= bfd_h_get_16 (abfd
, src
->vd_flags
);
76 dst
->vd_ndx
= bfd_h_get_16 (abfd
, src
->vd_ndx
);
77 dst
->vd_cnt
= bfd_h_get_16 (abfd
, src
->vd_cnt
);
78 dst
->vd_hash
= bfd_h_get_32 (abfd
, src
->vd_hash
);
79 dst
->vd_aux
= bfd_h_get_32 (abfd
, src
->vd_aux
);
80 dst
->vd_next
= bfd_h_get_32 (abfd
, src
->vd_next
);
83 /* Swap out a Verdef structure. */
86 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
88 const Elf_Internal_Verdef
*src
;
89 Elf_External_Verdef
*dst
;
91 bfd_h_put_16 (abfd
, src
->vd_version
, dst
->vd_version
);
92 bfd_h_put_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
93 bfd_h_put_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
94 bfd_h_put_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
95 bfd_h_put_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
96 bfd_h_put_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
97 bfd_h_put_32 (abfd
, src
->vd_next
, dst
->vd_next
);
100 /* Swap in a Verdaux structure. */
103 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
105 const Elf_External_Verdaux
*src
;
106 Elf_Internal_Verdaux
*dst
;
108 dst
->vda_name
= bfd_h_get_32 (abfd
, src
->vda_name
);
109 dst
->vda_next
= bfd_h_get_32 (abfd
, src
->vda_next
);
112 /* Swap out a Verdaux structure. */
115 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
117 const Elf_Internal_Verdaux
*src
;
118 Elf_External_Verdaux
*dst
;
120 bfd_h_put_32 (abfd
, src
->vda_name
, dst
->vda_name
);
121 bfd_h_put_32 (abfd
, src
->vda_next
, dst
->vda_next
);
124 /* Swap in a Verneed structure. */
127 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
129 const Elf_External_Verneed
*src
;
130 Elf_Internal_Verneed
*dst
;
132 dst
->vn_version
= bfd_h_get_16 (abfd
, src
->vn_version
);
133 dst
->vn_cnt
= bfd_h_get_16 (abfd
, src
->vn_cnt
);
134 dst
->vn_file
= bfd_h_get_32 (abfd
, src
->vn_file
);
135 dst
->vn_aux
= bfd_h_get_32 (abfd
, src
->vn_aux
);
136 dst
->vn_next
= bfd_h_get_32 (abfd
, src
->vn_next
);
139 /* Swap out a Verneed structure. */
142 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
144 const Elf_Internal_Verneed
*src
;
145 Elf_External_Verneed
*dst
;
147 bfd_h_put_16 (abfd
, src
->vn_version
, dst
->vn_version
);
148 bfd_h_put_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
149 bfd_h_put_32 (abfd
, src
->vn_file
, dst
->vn_file
);
150 bfd_h_put_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
151 bfd_h_put_32 (abfd
, src
->vn_next
, dst
->vn_next
);
154 /* Swap in a Vernaux structure. */
157 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
159 const Elf_External_Vernaux
*src
;
160 Elf_Internal_Vernaux
*dst
;
162 dst
->vna_hash
= bfd_h_get_32 (abfd
, src
->vna_hash
);
163 dst
->vna_flags
= bfd_h_get_16 (abfd
, src
->vna_flags
);
164 dst
->vna_other
= bfd_h_get_16 (abfd
, src
->vna_other
);
165 dst
->vna_name
= bfd_h_get_32 (abfd
, src
->vna_name
);
166 dst
->vna_next
= bfd_h_get_32 (abfd
, src
->vna_next
);
169 /* Swap out a Vernaux structure. */
172 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
174 const Elf_Internal_Vernaux
*src
;
175 Elf_External_Vernaux
*dst
;
177 bfd_h_put_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
178 bfd_h_put_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
179 bfd_h_put_16 (abfd
, src
->vna_other
, dst
->vna_other
);
180 bfd_h_put_32 (abfd
, src
->vna_name
, dst
->vna_name
);
181 bfd_h_put_32 (abfd
, src
->vna_next
, dst
->vna_next
);
184 /* Swap in a Versym structure. */
187 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
189 const Elf_External_Versym
*src
;
190 Elf_Internal_Versym
*dst
;
192 dst
->vs_vers
= bfd_h_get_16 (abfd
, src
->vs_vers
);
195 /* Swap out a Versym structure. */
198 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
200 const Elf_Internal_Versym
*src
;
201 Elf_External_Versym
*dst
;
203 bfd_h_put_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
206 /* Standard ELF hash function. Do not change this function; you will
207 cause invalid hash tables to be generated. */
210 bfd_elf_hash (namearg
)
213 const unsigned char *name
= (const unsigned char *) namearg
;
218 while ((ch
= *name
++) != '\0')
221 if ((g
= (h
& 0xf0000000)) != 0)
224 /* The ELF ABI says `h &= ~g', but this is equivalent in
225 this case and on some machines one insn instead of two. */
232 /* Read a specified number of bytes at a specified offset in an ELF
233 file, into a newly allocated buffer, and return a pointer to the
237 elf_read (abfd
, offset
, size
)
244 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
246 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
248 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
250 if (bfd_get_error () != bfd_error_system_call
)
251 bfd_set_error (bfd_error_file_truncated
);
258 bfd_elf_mkobject (abfd
)
261 /* this just does initialization */
262 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
263 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
264 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
265 if (elf_tdata (abfd
) == 0)
267 /* since everything is done at close time, do we need any
274 bfd_elf_mkcorefile (abfd
)
277 /* I think this can be done just like an object file. */
278 return bfd_elf_mkobject (abfd
);
282 bfd_elf_get_str_section (abfd
, shindex
)
284 unsigned int shindex
;
286 Elf_Internal_Shdr
**i_shdrp
;
287 char *shstrtab
= NULL
;
289 unsigned int shstrtabsize
;
291 i_shdrp
= elf_elfsections (abfd
);
292 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
295 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
296 if (shstrtab
== NULL
)
298 /* No cached one, attempt to read, and cache what we read. */
299 offset
= i_shdrp
[shindex
]->sh_offset
;
300 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
301 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
302 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
308 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
310 unsigned int shindex
;
311 unsigned int strindex
;
313 Elf_Internal_Shdr
*hdr
;
318 hdr
= elf_elfsections (abfd
)[shindex
];
320 if (hdr
->contents
== NULL
321 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
324 if (strindex
>= hdr
->sh_size
)
326 (*_bfd_error_handler
)
327 (_("%s: invalid string offset %u >= %lu for section `%s'"),
328 bfd_get_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
329 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
330 && strindex
== hdr
->sh_name
)
332 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
336 return ((char *) hdr
->contents
) + strindex
;
339 /* Make a BFD section from an ELF section. We store a pointer to the
340 BFD section in the bfd_section field of the header. */
343 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
345 Elf_Internal_Shdr
*hdr
;
351 if (hdr
->bfd_section
!= NULL
)
353 BFD_ASSERT (strcmp (name
,
354 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
358 newsect
= bfd_make_section_anyway (abfd
, name
);
362 newsect
->filepos
= hdr
->sh_offset
;
364 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
365 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
366 || ! bfd_set_section_alignment (abfd
, newsect
,
367 bfd_log2 (hdr
->sh_addralign
)))
370 flags
= SEC_NO_FLAGS
;
371 if (hdr
->sh_type
!= SHT_NOBITS
)
372 flags
|= SEC_HAS_CONTENTS
;
373 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
376 if (hdr
->sh_type
!= SHT_NOBITS
)
379 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
380 flags
|= SEC_READONLY
;
381 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
383 else if ((flags
& SEC_LOAD
) != 0)
386 /* The debugging sections appear to be recognized only by name, not
388 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
389 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
390 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
391 flags
|= SEC_DEBUGGING
;
393 /* As a GNU extension, if the name begins with .gnu.linkonce, we
394 only link a single copy of the section. This is used to support
395 g++. g++ will emit each template expansion in its own section.
396 The symbols will be defined as weak, so that multiple definitions
397 are permitted. The GNU linker extension is to actually discard
398 all but one of the sections. */
399 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
400 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
402 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
405 if ((flags
& SEC_ALLOC
) != 0)
407 Elf_Internal_Phdr
*phdr
;
410 /* Look through the phdrs to see if we need to adjust the lma.
411 If all the p_paddr fields are zero, we ignore them, since
412 some ELF linkers produce such output. */
413 phdr
= elf_tdata (abfd
)->phdr
;
414 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
416 if (phdr
->p_paddr
!= 0)
419 if (i
< elf_elfheader (abfd
)->e_phnum
)
421 phdr
= elf_tdata (abfd
)->phdr
;
422 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
424 if (phdr
->p_type
== PT_LOAD
425 && phdr
->p_vaddr
!= phdr
->p_paddr
426 && phdr
->p_vaddr
<= hdr
->sh_addr
427 && (phdr
->p_vaddr
+ phdr
->p_memsz
428 >= hdr
->sh_addr
+ hdr
->sh_size
)
429 && ((flags
& SEC_LOAD
) == 0
430 || (phdr
->p_offset
<= (bfd_vma
) hdr
->sh_offset
431 && (phdr
->p_offset
+ phdr
->p_filesz
432 >= hdr
->sh_offset
+ hdr
->sh_size
))))
434 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
441 hdr
->bfd_section
= newsect
;
442 elf_section_data (newsect
)->this_hdr
= *hdr
;
452 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
455 Helper functions for GDB to locate the string tables.
456 Since BFD hides string tables from callers, GDB needs to use an
457 internal hook to find them. Sun's .stabstr, in particular,
458 isn't even pointed to by the .stab section, so ordinary
459 mechanisms wouldn't work to find it, even if we had some.
462 struct elf_internal_shdr
*
463 bfd_elf_find_section (abfd
, name
)
467 Elf_Internal_Shdr
**i_shdrp
;
472 i_shdrp
= elf_elfsections (abfd
);
475 shstrtab
= bfd_elf_get_str_section
476 (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
477 if (shstrtab
!= NULL
)
479 max
= elf_elfheader (abfd
)->e_shnum
;
480 for (i
= 1; i
< max
; i
++)
481 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
488 const char *const bfd_elf_section_type_names
[] = {
489 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
490 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
491 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
494 /* ELF relocs are against symbols. If we are producing relocateable
495 output, and the reloc is against an external symbol, and nothing
496 has given us any additional addend, the resulting reloc will also
497 be against the same symbol. In such a case, we don't want to
498 change anything about the way the reloc is handled, since it will
499 all be done at final link time. Rather than put special case code
500 into bfd_perform_relocation, all the reloc types use this howto
501 function. It just short circuits the reloc if producing
502 relocateable output against an external symbol. */
505 bfd_reloc_status_type
506 bfd_elf_generic_reloc (abfd
,
513 bfd
*abfd ATTRIBUTE_UNUSED
;
514 arelent
*reloc_entry
;
516 PTR data ATTRIBUTE_UNUSED
;
517 asection
*input_section
;
519 char **error_message ATTRIBUTE_UNUSED
;
521 if (output_bfd
!= (bfd
*) NULL
522 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
523 && (! reloc_entry
->howto
->partial_inplace
524 || reloc_entry
->addend
== 0))
526 reloc_entry
->address
+= input_section
->output_offset
;
530 return bfd_reloc_continue
;
533 /* Print out the program headers. */
536 _bfd_elf_print_private_bfd_data (abfd
, farg
)
540 FILE *f
= (FILE *) farg
;
541 Elf_Internal_Phdr
*p
;
543 bfd_byte
*dynbuf
= NULL
;
545 p
= elf_tdata (abfd
)->phdr
;
550 fprintf (f
, _("\nProgram Header:\n"));
551 c
= elf_elfheader (abfd
)->e_phnum
;
552 for (i
= 0; i
< c
; i
++, p
++)
559 case PT_NULL
: s
= "NULL"; break;
560 case PT_LOAD
: s
= "LOAD"; break;
561 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
562 case PT_INTERP
: s
= "INTERP"; break;
563 case PT_NOTE
: s
= "NOTE"; break;
564 case PT_SHLIB
: s
= "SHLIB"; break;
565 case PT_PHDR
: s
= "PHDR"; break;
566 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
568 fprintf (f
, "%8s off 0x", s
);
569 fprintf_vma (f
, p
->p_offset
);
570 fprintf (f
, " vaddr 0x");
571 fprintf_vma (f
, p
->p_vaddr
);
572 fprintf (f
, " paddr 0x");
573 fprintf_vma (f
, p
->p_paddr
);
574 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
575 fprintf (f
, " filesz 0x");
576 fprintf_vma (f
, p
->p_filesz
);
577 fprintf (f
, " memsz 0x");
578 fprintf_vma (f
, p
->p_memsz
);
579 fprintf (f
, " flags %c%c%c",
580 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
581 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
582 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
583 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
584 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
589 s
= bfd_get_section_by_name (abfd
, ".dynamic");
594 bfd_byte
*extdyn
, *extdynend
;
596 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
598 fprintf (f
, _("\nDynamic Section:\n"));
600 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
603 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
607 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
610 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
612 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
613 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
616 extdynend
= extdyn
+ s
->_raw_size
;
617 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
619 Elf_Internal_Dyn dyn
;
624 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
626 if (dyn
.d_tag
== DT_NULL
)
633 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
637 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
638 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
639 case DT_PLTGOT
: name
= "PLTGOT"; break;
640 case DT_HASH
: name
= "HASH"; break;
641 case DT_STRTAB
: name
= "STRTAB"; break;
642 case DT_SYMTAB
: name
= "SYMTAB"; break;
643 case DT_RELA
: name
= "RELA"; break;
644 case DT_RELASZ
: name
= "RELASZ"; break;
645 case DT_RELAENT
: name
= "RELAENT"; break;
646 case DT_STRSZ
: name
= "STRSZ"; break;
647 case DT_SYMENT
: name
= "SYMENT"; break;
648 case DT_INIT
: name
= "INIT"; break;
649 case DT_FINI
: name
= "FINI"; break;
650 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
651 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
652 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
653 case DT_REL
: name
= "REL"; break;
654 case DT_RELSZ
: name
= "RELSZ"; break;
655 case DT_RELENT
: name
= "RELENT"; break;
656 case DT_PLTREL
: name
= "PLTREL"; break;
657 case DT_DEBUG
: name
= "DEBUG"; break;
658 case DT_TEXTREL
: name
= "TEXTREL"; break;
659 case DT_JMPREL
: name
= "JMPREL"; break;
660 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
661 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
662 case DT_VERSYM
: name
= "VERSYM"; break;
663 case DT_VERDEF
: name
= "VERDEF"; break;
664 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
665 case DT_VERNEED
: name
= "VERNEED"; break;
666 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
669 fprintf (f
, " %-11s ", name
);
671 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
676 string
= bfd_elf_string_from_elf_section (abfd
, link
,
680 fprintf (f
, "%s", string
);
689 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
690 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
692 if (! _bfd_elf_slurp_version_tables (abfd
))
696 if (elf_dynverdef (abfd
) != 0)
698 Elf_Internal_Verdef
*t
;
700 fprintf (f
, _("\nVersion definitions:\n"));
701 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
703 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
704 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
705 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
707 Elf_Internal_Verdaux
*a
;
710 for (a
= t
->vd_auxptr
->vda_nextptr
;
713 fprintf (f
, "%s ", a
->vda_nodename
);
719 if (elf_dynverref (abfd
) != 0)
721 Elf_Internal_Verneed
*t
;
723 fprintf (f
, _("\nVersion References:\n"));
724 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
726 Elf_Internal_Vernaux
*a
;
728 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
729 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
730 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
731 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
743 /* Display ELF-specific fields of a symbol. */
746 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
750 bfd_print_symbol_type how
;
752 FILE *file
= (FILE *) filep
;
755 case bfd_print_symbol_name
:
756 fprintf (file
, "%s", symbol
->name
);
758 case bfd_print_symbol_more
:
759 fprintf (file
, "elf ");
760 fprintf_vma (file
, symbol
->value
);
761 fprintf (file
, " %lx", (long) symbol
->flags
);
763 case bfd_print_symbol_all
:
765 CONST
char *section_name
;
766 CONST
char *name
= NULL
;
767 struct elf_backend_data
*bed
;
768 unsigned char st_other
;
770 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
772 bed
= get_elf_backend_data (abfd
);
773 if (bed
->elf_backend_print_symbol_all
)
774 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
779 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
782 fprintf (file
, " %s\t", section_name
);
783 /* Print the "other" value for a symbol. For common symbols,
784 we've already printed the size; now print the alignment.
785 For other symbols, we have no specified alignment, and
786 we've printed the address; now print the size. */
788 (bfd_is_com_section (symbol
->section
)
789 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
790 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
792 /* If we have version information, print it. */
793 if (elf_tdata (abfd
)->dynversym_section
!= 0
794 && (elf_tdata (abfd
)->dynverdef_section
!= 0
795 || elf_tdata (abfd
)->dynverref_section
!= 0))
798 const char *version_string
;
800 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
804 else if (vernum
== 1)
805 version_string
= "Base";
806 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
808 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
811 Elf_Internal_Verneed
*t
;
814 for (t
= elf_tdata (abfd
)->verref
;
818 Elf_Internal_Vernaux
*a
;
820 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
822 if (a
->vna_other
== vernum
)
824 version_string
= a
->vna_nodename
;
831 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
832 fprintf (file
, " %-11s", version_string
);
837 fprintf (file
, " (%s)", version_string
);
838 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
843 /* If the st_other field is not zero, print it. */
844 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
849 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
850 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
851 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
853 /* Some other non-defined flags are also present, so print
855 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
858 fprintf (file
, " %s", name
);
864 /* Create an entry in an ELF linker hash table. */
866 struct bfd_hash_entry
*
867 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
868 struct bfd_hash_entry
*entry
;
869 struct bfd_hash_table
*table
;
872 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
874 /* Allocate the structure if it has not already been allocated by a
876 if (ret
== (struct elf_link_hash_entry
*) NULL
)
877 ret
= ((struct elf_link_hash_entry
*)
878 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
879 if (ret
== (struct elf_link_hash_entry
*) NULL
)
880 return (struct bfd_hash_entry
*) ret
;
882 /* Call the allocation method of the superclass. */
883 ret
= ((struct elf_link_hash_entry
*)
884 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
886 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
888 /* Set local fields. */
892 ret
->dynstr_index
= 0;
894 ret
->got
.offset
= (bfd_vma
) -1;
895 ret
->plt
.offset
= (bfd_vma
) -1;
896 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
897 ret
->verinfo
.verdef
= NULL
;
898 ret
->vtable_entries_used
= NULL
;
899 ret
->vtable_entries_size
= 0;
900 ret
->vtable_parent
= NULL
;
901 ret
->type
= STT_NOTYPE
;
903 /* Assume that we have been called by a non-ELF symbol reader.
904 This flag is then reset by the code which reads an ELF input
905 file. This ensures that a symbol created by a non-ELF symbol
906 reader will have the flag set correctly. */
907 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
910 return (struct bfd_hash_entry
*) ret
;
913 /* Copy data from an indirect symbol to its direct symbol, hiding the
914 old indirect symbol. */
917 _bfd_elf_link_hash_copy_indirect (dir
, ind
)
918 struct elf_link_hash_entry
*dir
, *ind
;
920 /* Copy down any references that we may have already seen to the
921 symbol which just became indirect. */
923 dir
->elf_link_hash_flags
|=
924 (ind
->elf_link_hash_flags
925 & (ELF_LINK_HASH_REF_DYNAMIC
926 | ELF_LINK_HASH_REF_REGULAR
927 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
928 | ELF_LINK_NON_GOT_REF
));
930 /* Copy over the global and procedure linkage table offset entries.
931 These may have been already set up by a check_relocs routine. */
932 if (dir
->got
.offset
== (bfd_vma
) -1)
934 dir
->got
.offset
= ind
->got
.offset
;
935 ind
->got
.offset
= (bfd_vma
) -1;
937 BFD_ASSERT (ind
->got
.offset
== (bfd_vma
) -1);
939 if (dir
->plt
.offset
== (bfd_vma
) -1)
941 dir
->plt
.offset
= ind
->plt
.offset
;
942 ind
->plt
.offset
= (bfd_vma
) -1;
944 BFD_ASSERT (ind
->plt
.offset
== (bfd_vma
) -1);
946 if (dir
->dynindx
== -1)
948 dir
->dynindx
= ind
->dynindx
;
949 dir
->dynstr_index
= ind
->dynstr_index
;
951 ind
->dynstr_index
= 0;
953 BFD_ASSERT (ind
->dynindx
== -1);
957 _bfd_elf_link_hash_hide_symbol(h
)
958 struct elf_link_hash_entry
*h
;
960 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
962 h
->plt
.offset
= (bfd_vma
) -1;
965 /* Initialize an ELF linker hash table. */
968 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
969 struct elf_link_hash_table
*table
;
971 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
972 struct bfd_hash_table
*,
975 table
->dynamic_sections_created
= false;
976 table
->dynobj
= NULL
;
977 /* The first dynamic symbol is a dummy. */
978 table
->dynsymcount
= 1;
979 table
->dynstr
= NULL
;
980 table
->bucketcount
= 0;
981 table
->needed
= NULL
;
983 table
->stab_info
= NULL
;
984 table
->dynlocal
= NULL
;
985 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
988 /* Create an ELF linker hash table. */
990 struct bfd_link_hash_table
*
991 _bfd_elf_link_hash_table_create (abfd
)
994 struct elf_link_hash_table
*ret
;
996 ret
= ((struct elf_link_hash_table
*)
997 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
998 if (ret
== (struct elf_link_hash_table
*) NULL
)
1001 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1003 bfd_release (abfd
, ret
);
1010 /* This is a hook for the ELF emulation code in the generic linker to
1011 tell the backend linker what file name to use for the DT_NEEDED
1012 entry for a dynamic object. The generic linker passes name as an
1013 empty string to indicate that no DT_NEEDED entry should be made. */
1016 bfd_elf_set_dt_needed_name (abfd
, name
)
1020 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1021 && bfd_get_format (abfd
) == bfd_object
)
1022 elf_dt_name (abfd
) = name
;
1025 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1026 the linker ELF emulation code. */
1028 struct bfd_link_needed_list
*
1029 bfd_elf_get_needed_list (abfd
, info
)
1030 bfd
*abfd ATTRIBUTE_UNUSED
;
1031 struct bfd_link_info
*info
;
1033 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1035 return elf_hash_table (info
)->needed
;
1038 /* Get the name actually used for a dynamic object for a link. This
1039 is the SONAME entry if there is one. Otherwise, it is the string
1040 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1043 bfd_elf_get_dt_soname (abfd
)
1046 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1047 && bfd_get_format (abfd
) == bfd_object
)
1048 return elf_dt_name (abfd
);
1052 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1053 the ELF linker emulation code. */
1056 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1058 struct bfd_link_needed_list
**pneeded
;
1061 bfd_byte
*dynbuf
= NULL
;
1064 bfd_byte
*extdyn
, *extdynend
;
1066 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1070 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1071 || bfd_get_format (abfd
) != bfd_object
)
1074 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1075 if (s
== NULL
|| s
->_raw_size
== 0)
1078 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1082 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1086 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1090 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1092 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1093 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1096 extdynend
= extdyn
+ s
->_raw_size
;
1097 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1099 Elf_Internal_Dyn dyn
;
1101 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1103 if (dyn
.d_tag
== DT_NULL
)
1106 if (dyn
.d_tag
== DT_NEEDED
)
1109 struct bfd_link_needed_list
*l
;
1111 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1116 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1137 /* Allocate an ELF string table--force the first byte to be zero. */
1139 struct bfd_strtab_hash
*
1140 _bfd_elf_stringtab_init ()
1142 struct bfd_strtab_hash
*ret
;
1144 ret
= _bfd_stringtab_init ();
1149 loc
= _bfd_stringtab_add (ret
, "", true, false);
1150 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1151 if (loc
== (bfd_size_type
) -1)
1153 _bfd_stringtab_free (ret
);
1160 /* ELF .o/exec file reading */
1162 /* Create a new bfd section from an ELF section header. */
1165 bfd_section_from_shdr (abfd
, shindex
)
1167 unsigned int shindex
;
1169 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1170 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1171 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1174 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1176 switch (hdr
->sh_type
)
1179 /* Inactive section. Throw it away. */
1182 case SHT_PROGBITS
: /* Normal section with contents. */
1183 case SHT_DYNAMIC
: /* Dynamic linking information. */
1184 case SHT_NOBITS
: /* .bss section. */
1185 case SHT_HASH
: /* .hash section. */
1186 case SHT_NOTE
: /* .note section. */
1187 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1189 case SHT_SYMTAB
: /* A symbol table */
1190 if (elf_onesymtab (abfd
) == shindex
)
1193 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1194 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1195 elf_onesymtab (abfd
) = shindex
;
1196 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1197 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1198 abfd
->flags
|= HAS_SYMS
;
1200 /* Sometimes a shared object will map in the symbol table. If
1201 SHF_ALLOC is set, and this is a shared object, then we also
1202 treat this section as a BFD section. We can not base the
1203 decision purely on SHF_ALLOC, because that flag is sometimes
1204 set in a relocateable object file, which would confuse the
1206 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1207 && (abfd
->flags
& DYNAMIC
) != 0
1208 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1213 case SHT_DYNSYM
: /* A dynamic symbol table */
1214 if (elf_dynsymtab (abfd
) == shindex
)
1217 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1218 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1219 elf_dynsymtab (abfd
) = shindex
;
1220 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1221 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1222 abfd
->flags
|= HAS_SYMS
;
1224 /* Besides being a symbol table, we also treat this as a regular
1225 section, so that objcopy can handle it. */
1226 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1228 case SHT_STRTAB
: /* A string table */
1229 if (hdr
->bfd_section
!= NULL
)
1231 if (ehdr
->e_shstrndx
== shindex
)
1233 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1234 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1240 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1242 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1243 if (hdr2
->sh_link
== shindex
)
1245 if (! bfd_section_from_shdr (abfd
, i
))
1247 if (elf_onesymtab (abfd
) == i
)
1249 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1250 elf_elfsections (abfd
)[shindex
] =
1251 &elf_tdata (abfd
)->strtab_hdr
;
1254 if (elf_dynsymtab (abfd
) == i
)
1256 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1257 elf_elfsections (abfd
)[shindex
] = hdr
=
1258 &elf_tdata (abfd
)->dynstrtab_hdr
;
1259 /* We also treat this as a regular section, so
1260 that objcopy can handle it. */
1263 #if 0 /* Not handling other string tables specially right now. */
1264 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1265 /* We have a strtab for some random other section. */
1266 newsect
= (asection
*) hdr2
->bfd_section
;
1269 hdr
->bfd_section
= newsect
;
1270 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1272 elf_elfsections (abfd
)[shindex
] = hdr2
;
1278 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1282 /* *These* do a lot of work -- but build no sections! */
1284 asection
*target_sect
;
1285 Elf_Internal_Shdr
*hdr2
;
1287 /* Check for a bogus link to avoid crashing. */
1288 if (hdr
->sh_link
>= ehdr
->e_shnum
)
1290 ((*_bfd_error_handler
)
1291 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1292 bfd_get_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1293 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1296 /* For some incomprehensible reason Oracle distributes
1297 libraries for Solaris in which some of the objects have
1298 bogus sh_link fields. It would be nice if we could just
1299 reject them, but, unfortunately, some people need to use
1300 them. We scan through the section headers; if we find only
1301 one suitable symbol table, we clobber the sh_link to point
1302 to it. I hope this doesn't break anything. */
1303 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1304 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1310 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1312 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1313 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1324 hdr
->sh_link
= found
;
1327 /* Get the symbol table. */
1328 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1329 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1332 /* If this reloc section does not use the main symbol table we
1333 don't treat it as a reloc section. BFD can't adequately
1334 represent such a section, so at least for now, we don't
1335 try. We just present it as a normal section. */
1336 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1337 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1339 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1341 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1342 if (target_sect
== NULL
)
1345 if ((target_sect
->flags
& SEC_RELOC
) == 0
1346 || target_sect
->reloc_count
== 0)
1347 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1350 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1351 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1352 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1355 elf_elfsections (abfd
)[shindex
] = hdr2
;
1356 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1357 target_sect
->flags
|= SEC_RELOC
;
1358 target_sect
->relocation
= NULL
;
1359 target_sect
->rel_filepos
= hdr
->sh_offset
;
1360 /* In the section to which the relocations apply, mark whether
1361 its relocations are of the REL or RELA variety. */
1362 if (hdr
->sh_size
!= 0)
1363 elf_section_data (target_sect
)->use_rela_p
1364 = (hdr
->sh_type
== SHT_RELA
);
1365 abfd
->flags
|= HAS_RELOC
;
1370 case SHT_GNU_verdef
:
1371 elf_dynverdef (abfd
) = shindex
;
1372 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1373 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1376 case SHT_GNU_versym
:
1377 elf_dynversym (abfd
) = shindex
;
1378 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1379 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1382 case SHT_GNU_verneed
:
1383 elf_dynverref (abfd
) = shindex
;
1384 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1385 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1392 /* Check for any processor-specific section types. */
1394 if (bed
->elf_backend_section_from_shdr
)
1395 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1403 /* Given an ELF section number, retrieve the corresponding BFD
1407 bfd_section_from_elf_index (abfd
, index
)
1411 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1412 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1414 return elf_elfsections (abfd
)[index
]->bfd_section
;
1418 _bfd_elf_new_section_hook (abfd
, sec
)
1422 struct bfd_elf_section_data
*sdata
;
1424 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, sizeof (*sdata
));
1427 sec
->used_by_bfd
= (PTR
) sdata
;
1429 /* Indicate whether or not this section should use RELA relocations. */
1431 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1436 /* Create a new bfd section from an ELF program header.
1438 Since program segments have no names, we generate a synthetic name
1439 of the form segment<NUM>, where NUM is generally the index in the
1440 program header table. For segments that are split (see below) we
1441 generate the names segment<NUM>a and segment<NUM>b.
1443 Note that some program segments may have a file size that is different than
1444 (less than) the memory size. All this means is that at execution the
1445 system must allocate the amount of memory specified by the memory size,
1446 but only initialize it with the first "file size" bytes read from the
1447 file. This would occur for example, with program segments consisting
1448 of combined data+bss.
1450 To handle the above situation, this routine generates TWO bfd sections
1451 for the single program segment. The first has the length specified by
1452 the file size of the segment, and the second has the length specified
1453 by the difference between the two sizes. In effect, the segment is split
1454 into it's initialized and uninitialized parts.
1459 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
1461 Elf_Internal_Phdr
*hdr
;
1463 const char *typename
;
1470 split
= ((hdr
->p_memsz
> 0)
1471 && (hdr
->p_filesz
> 0)
1472 && (hdr
->p_memsz
> hdr
->p_filesz
));
1473 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
1474 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1477 strcpy (name
, namebuf
);
1478 newsect
= bfd_make_section (abfd
, name
);
1479 if (newsect
== NULL
)
1481 newsect
->vma
= hdr
->p_vaddr
;
1482 newsect
->lma
= hdr
->p_paddr
;
1483 newsect
->_raw_size
= hdr
->p_filesz
;
1484 newsect
->filepos
= hdr
->p_offset
;
1485 newsect
->flags
|= SEC_HAS_CONTENTS
;
1486 if (hdr
->p_type
== PT_LOAD
)
1488 newsect
->flags
|= SEC_ALLOC
;
1489 newsect
->flags
|= SEC_LOAD
;
1490 if (hdr
->p_flags
& PF_X
)
1492 /* FIXME: all we known is that it has execute PERMISSION,
1494 newsect
->flags
|= SEC_CODE
;
1497 if (!(hdr
->p_flags
& PF_W
))
1499 newsect
->flags
|= SEC_READONLY
;
1504 sprintf (namebuf
, "%s%db", typename
, index
);
1505 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1508 strcpy (name
, namebuf
);
1509 newsect
= bfd_make_section (abfd
, name
);
1510 if (newsect
== NULL
)
1512 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1513 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1514 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1515 if (hdr
->p_type
== PT_LOAD
)
1517 newsect
->flags
|= SEC_ALLOC
;
1518 if (hdr
->p_flags
& PF_X
)
1519 newsect
->flags
|= SEC_CODE
;
1521 if (!(hdr
->p_flags
& PF_W
))
1522 newsect
->flags
|= SEC_READONLY
;
1529 bfd_section_from_phdr (abfd
, hdr
, index
)
1531 Elf_Internal_Phdr
*hdr
;
1534 struct elf_backend_data
*bed
;
1536 switch (hdr
->p_type
)
1539 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
1542 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
1545 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
1548 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
1551 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
1553 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
1558 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
1561 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
1564 /* Check for any processor-specific program segment types.
1565 If no handler for them, default to making "segment" sections. */
1566 bed
= get_elf_backend_data (abfd
);
1567 if (bed
->elf_backend_section_from_phdr
)
1568 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
1570 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
1574 /* Initialize REL_HDR, the section-header for new section, containing
1575 relocations against ASECT. If USE_RELA_P is true, we use RELA
1576 relocations; otherwise, we use REL relocations. */
1579 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
1581 Elf_Internal_Shdr
*rel_hdr
;
1586 struct elf_backend_data
*bed
;
1588 bed
= get_elf_backend_data (abfd
);
1589 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1592 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1594 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1596 if (rel_hdr
->sh_name
== (unsigned int) -1)
1598 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1599 rel_hdr
->sh_entsize
= (use_rela_p
1600 ? bed
->s
->sizeof_rela
1601 : bed
->s
->sizeof_rel
);
1602 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
1603 rel_hdr
->sh_flags
= 0;
1604 rel_hdr
->sh_addr
= 0;
1605 rel_hdr
->sh_size
= 0;
1606 rel_hdr
->sh_offset
= 0;
1611 /* Set up an ELF internal section header for a section. */
1615 elf_fake_sections (abfd
, asect
, failedptrarg
)
1620 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1621 boolean
*failedptr
= (boolean
*) failedptrarg
;
1622 Elf_Internal_Shdr
*this_hdr
;
1626 /* We already failed; just get out of the bfd_map_over_sections
1631 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1633 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1636 if (this_hdr
->sh_name
== (unsigned long) -1)
1642 this_hdr
->sh_flags
= 0;
1644 if ((asect
->flags
& SEC_ALLOC
) != 0
1645 || asect
->user_set_vma
)
1646 this_hdr
->sh_addr
= asect
->vma
;
1648 this_hdr
->sh_addr
= 0;
1650 this_hdr
->sh_offset
= 0;
1651 this_hdr
->sh_size
= asect
->_raw_size
;
1652 this_hdr
->sh_link
= 0;
1653 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1654 /* The sh_entsize and sh_info fields may have been set already by
1655 copy_private_section_data. */
1657 this_hdr
->bfd_section
= asect
;
1658 this_hdr
->contents
= NULL
;
1660 /* FIXME: This should not be based on section names. */
1661 if (strcmp (asect
->name
, ".dynstr") == 0)
1662 this_hdr
->sh_type
= SHT_STRTAB
;
1663 else if (strcmp (asect
->name
, ".hash") == 0)
1665 this_hdr
->sh_type
= SHT_HASH
;
1666 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
1668 else if (strcmp (asect
->name
, ".dynsym") == 0)
1670 this_hdr
->sh_type
= SHT_DYNSYM
;
1671 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1673 else if (strcmp (asect
->name
, ".dynamic") == 0)
1675 this_hdr
->sh_type
= SHT_DYNAMIC
;
1676 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1678 else if (strncmp (asect
->name
, ".rela", 5) == 0
1679 && get_elf_backend_data (abfd
)->may_use_rela_p
)
1681 this_hdr
->sh_type
= SHT_RELA
;
1682 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1684 else if (strncmp (asect
->name
, ".rel", 4) == 0
1685 && get_elf_backend_data (abfd
)->may_use_rel_p
)
1687 this_hdr
->sh_type
= SHT_REL
;
1688 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1690 else if (strncmp (asect
->name
, ".note", 5) == 0)
1691 this_hdr
->sh_type
= SHT_NOTE
;
1692 else if (strncmp (asect
->name
, ".stab", 5) == 0
1693 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1694 this_hdr
->sh_type
= SHT_STRTAB
;
1695 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1697 this_hdr
->sh_type
= SHT_GNU_versym
;
1698 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1700 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1702 this_hdr
->sh_type
= SHT_GNU_verdef
;
1703 this_hdr
->sh_entsize
= 0;
1704 /* objcopy or strip will copy over sh_info, but may not set
1705 cverdefs. The linker will set cverdefs, but sh_info will be
1707 if (this_hdr
->sh_info
== 0)
1708 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1710 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1711 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1713 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1715 this_hdr
->sh_type
= SHT_GNU_verneed
;
1716 this_hdr
->sh_entsize
= 0;
1717 /* objcopy or strip will copy over sh_info, but may not set
1718 cverrefs. The linker will set cverrefs, but sh_info will be
1720 if (this_hdr
->sh_info
== 0)
1721 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1723 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1724 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1726 else if ((asect
->flags
& SEC_ALLOC
) != 0
1727 && (asect
->flags
& SEC_LOAD
) != 0)
1728 this_hdr
->sh_type
= SHT_PROGBITS
;
1729 else if ((asect
->flags
& SEC_ALLOC
) != 0
1730 && ((asect
->flags
& SEC_LOAD
) == 0))
1731 this_hdr
->sh_type
= SHT_NOBITS
;
1735 this_hdr
->sh_type
= SHT_PROGBITS
;
1738 if ((asect
->flags
& SEC_ALLOC
) != 0)
1739 this_hdr
->sh_flags
|= SHF_ALLOC
;
1740 if ((asect
->flags
& SEC_READONLY
) == 0)
1741 this_hdr
->sh_flags
|= SHF_WRITE
;
1742 if ((asect
->flags
& SEC_CODE
) != 0)
1743 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1745 /* Check for processor-specific section types. */
1746 if (bed
->elf_backend_fake_sections
)
1747 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1749 /* If the section has relocs, set up a section header for the
1750 SHT_REL[A] section. If two relocation sections are required for
1751 this section, it is up to the processor-specific back-end to
1752 create the other. */
1753 if ((asect
->flags
& SEC_RELOC
) != 0
1754 && !_bfd_elf_init_reloc_shdr (abfd
,
1755 &elf_section_data (asect
)->rel_hdr
,
1757 elf_section_data (asect
)->use_rela_p
))
1761 /* Get elf arch size (32 / 64).
1762 Returns -1 if not elf. */
1765 bfd_elf_get_arch_size (abfd
)
1768 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1770 bfd_set_error (bfd_error_wrong_format
);
1774 return (get_elf_backend_data (abfd
))->s
->arch_size
;
1777 /* Assign all ELF section numbers. The dummy first section is handled here
1778 too. The link/info pointers for the standard section types are filled
1779 in here too, while we're at it. */
1782 assign_section_numbers (abfd
)
1785 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1787 unsigned int section_number
;
1788 Elf_Internal_Shdr
**i_shdrp
;
1792 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1794 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1796 d
->this_idx
= section_number
++;
1797 if ((sec
->flags
& SEC_RELOC
) == 0)
1800 d
->rel_idx
= section_number
++;
1803 d
->rel_idx2
= section_number
++;
1808 t
->shstrtab_section
= section_number
++;
1809 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1810 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1812 if (bfd_get_symcount (abfd
) > 0)
1814 t
->symtab_section
= section_number
++;
1815 t
->strtab_section
= section_number
++;
1818 elf_elfheader (abfd
)->e_shnum
= section_number
;
1820 /* Set up the list of section header pointers, in agreement with the
1822 i_shdrp
= ((Elf_Internal_Shdr
**)
1823 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1824 if (i_shdrp
== NULL
)
1827 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1828 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1829 if (i_shdrp
[0] == NULL
)
1831 bfd_release (abfd
, i_shdrp
);
1834 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1836 elf_elfsections (abfd
) = i_shdrp
;
1838 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1839 if (bfd_get_symcount (abfd
) > 0)
1841 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1842 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1843 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1845 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1847 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1851 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1852 if (d
->rel_idx
!= 0)
1853 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1854 if (d
->rel_idx2
!= 0)
1855 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
1857 /* Fill in the sh_link and sh_info fields while we're at it. */
1859 /* sh_link of a reloc section is the section index of the symbol
1860 table. sh_info is the section index of the section to which
1861 the relocation entries apply. */
1862 if (d
->rel_idx
!= 0)
1864 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1865 d
->rel_hdr
.sh_info
= d
->this_idx
;
1867 if (d
->rel_idx2
!= 0)
1869 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
1870 d
->rel_hdr2
->sh_info
= d
->this_idx
;
1873 switch (d
->this_hdr
.sh_type
)
1877 /* A reloc section which we are treating as a normal BFD
1878 section. sh_link is the section index of the symbol
1879 table. sh_info is the section index of the section to
1880 which the relocation entries apply. We assume that an
1881 allocated reloc section uses the dynamic symbol table.
1882 FIXME: How can we be sure? */
1883 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1885 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1887 /* We look up the section the relocs apply to by name. */
1889 if (d
->this_hdr
.sh_type
== SHT_REL
)
1893 s
= bfd_get_section_by_name (abfd
, name
);
1895 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1899 /* We assume that a section named .stab*str is a stabs
1900 string section. We look for a section with the same name
1901 but without the trailing ``str'', and set its sh_link
1902 field to point to this section. */
1903 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1904 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1909 len
= strlen (sec
->name
);
1910 alc
= (char *) bfd_malloc (len
- 2);
1913 strncpy (alc
, sec
->name
, len
- 3);
1914 alc
[len
- 3] = '\0';
1915 s
= bfd_get_section_by_name (abfd
, alc
);
1919 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1921 /* This is a .stab section. */
1922 elf_section_data (s
)->this_hdr
.sh_entsize
=
1923 4 + 2 * bfd_elf_get_arch_size (abfd
) / 8;
1930 case SHT_GNU_verneed
:
1931 case SHT_GNU_verdef
:
1932 /* sh_link is the section header index of the string table
1933 used for the dynamic entries, or the symbol table, or the
1935 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1937 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1941 case SHT_GNU_versym
:
1942 /* sh_link is the section header index of the symbol table
1943 this hash table or version table is for. */
1944 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1946 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1954 /* Map symbol from it's internal number to the external number, moving
1955 all local symbols to be at the head of the list. */
1958 sym_is_global (abfd
, sym
)
1962 /* If the backend has a special mapping, use it. */
1963 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1964 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1967 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1968 || bfd_is_und_section (bfd_get_section (sym
))
1969 || bfd_is_com_section (bfd_get_section (sym
)));
1973 elf_map_symbols (abfd
)
1976 int symcount
= bfd_get_symcount (abfd
);
1977 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1978 asymbol
**sect_syms
;
1980 int num_globals
= 0;
1981 int num_locals2
= 0;
1982 int num_globals2
= 0;
1984 int num_sections
= 0;
1991 fprintf (stderr
, "elf_map_symbols\n");
1995 /* Add a section symbol for each BFD section. FIXME: Is this really
1997 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1999 if (max_index
< asect
->index
)
2000 max_index
= asect
->index
;
2004 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
2005 if (sect_syms
== NULL
)
2007 elf_section_syms (abfd
) = sect_syms
;
2009 for (idx
= 0; idx
< symcount
; idx
++)
2013 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2020 if (sec
->owner
!= NULL
)
2022 if (sec
->owner
!= abfd
)
2024 if (sec
->output_offset
!= 0)
2027 sec
= sec
->output_section
;
2029 /* Empty sections in the input files may have had a section
2030 symbol created for them. (See the comment near the end of
2031 _bfd_generic_link_output_symbols in linker.c). If the linker
2032 script discards such sections then we will reach this point.
2033 Since we know that we cannot avoid this case, we detect it
2034 and skip the abort and the assignment to the sect_syms array.
2035 To reproduce this particular case try running the linker
2036 testsuite test ld-scripts/weak.exp for an ELF port that uses
2037 the generic linker. */
2038 if (sec
->owner
== NULL
)
2041 BFD_ASSERT (sec
->owner
== abfd
);
2043 sect_syms
[sec
->index
] = syms
[idx
];
2048 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2050 if (sect_syms
[asect
->index
] != NULL
)
2053 sym
= bfd_make_empty_symbol (abfd
);
2056 sym
->the_bfd
= abfd
;
2057 sym
->name
= asect
->name
;
2059 /* Set the flags to 0 to indicate that this one was newly added. */
2061 sym
->section
= asect
;
2062 sect_syms
[asect
->index
] = sym
;
2066 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
2067 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
2071 /* Classify all of the symbols. */
2072 for (idx
= 0; idx
< symcount
; idx
++)
2074 if (!sym_is_global (abfd
, syms
[idx
]))
2079 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2081 if (sect_syms
[asect
->index
] != NULL
2082 && sect_syms
[asect
->index
]->flags
== 0)
2084 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
2085 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
2089 sect_syms
[asect
->index
]->flags
= 0;
2093 /* Now sort the symbols so the local symbols are first. */
2094 new_syms
= ((asymbol
**)
2096 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
2097 if (new_syms
== NULL
)
2100 for (idx
= 0; idx
< symcount
; idx
++)
2102 asymbol
*sym
= syms
[idx
];
2105 if (!sym_is_global (abfd
, sym
))
2108 i
= num_locals
+ num_globals2
++;
2110 sym
->udata
.i
= i
+ 1;
2112 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2114 if (sect_syms
[asect
->index
] != NULL
2115 && sect_syms
[asect
->index
]->flags
== 0)
2117 asymbol
*sym
= sect_syms
[asect
->index
];
2120 sym
->flags
= BSF_SECTION_SYM
;
2121 if (!sym_is_global (abfd
, sym
))
2124 i
= num_locals
+ num_globals2
++;
2126 sym
->udata
.i
= i
+ 1;
2130 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2132 elf_num_locals (abfd
) = num_locals
;
2133 elf_num_globals (abfd
) = num_globals
;
2137 /* Align to the maximum file alignment that could be required for any
2138 ELF data structure. */
2140 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2141 static INLINE file_ptr
2142 align_file_position (off
, align
)
2146 return (off
+ align
- 1) & ~(align
- 1);
2149 /* Assign a file position to a section, optionally aligning to the
2150 required section alignment. */
2153 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2154 Elf_Internal_Shdr
*i_shdrp
;
2162 al
= i_shdrp
->sh_addralign
;
2164 offset
= BFD_ALIGN (offset
, al
);
2166 i_shdrp
->sh_offset
= offset
;
2167 if (i_shdrp
->bfd_section
!= NULL
)
2168 i_shdrp
->bfd_section
->filepos
= offset
;
2169 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2170 offset
+= i_shdrp
->sh_size
;
2174 /* Compute the file positions we are going to put the sections at, and
2175 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2176 is not NULL, this is being called by the ELF backend linker. */
2179 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2181 struct bfd_link_info
*link_info
;
2183 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2185 struct bfd_strtab_hash
*strtab
;
2186 Elf_Internal_Shdr
*shstrtab_hdr
;
2188 if (abfd
->output_has_begun
)
2191 /* Do any elf backend specific processing first. */
2192 if (bed
->elf_backend_begin_write_processing
)
2193 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2195 if (! prep_headers (abfd
))
2198 /* Post process the headers if necessary. */
2199 if (bed
->elf_backend_post_process_headers
)
2200 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2203 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2207 if (!assign_section_numbers (abfd
))
2210 /* The backend linker builds symbol table information itself. */
2211 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2213 /* Non-zero if doing a relocatable link. */
2214 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2216 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2220 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2221 /* sh_name was set in prep_headers. */
2222 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2223 shstrtab_hdr
->sh_flags
= 0;
2224 shstrtab_hdr
->sh_addr
= 0;
2225 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
2226 shstrtab_hdr
->sh_entsize
= 0;
2227 shstrtab_hdr
->sh_link
= 0;
2228 shstrtab_hdr
->sh_info
= 0;
2229 /* sh_offset is set in assign_file_positions_except_relocs. */
2230 shstrtab_hdr
->sh_addralign
= 1;
2232 if (!assign_file_positions_except_relocs (abfd
))
2235 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2238 Elf_Internal_Shdr
*hdr
;
2240 off
= elf_tdata (abfd
)->next_file_pos
;
2242 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2243 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2245 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2246 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2248 elf_tdata (abfd
)->next_file_pos
= off
;
2250 /* Now that we know where the .strtab section goes, write it
2252 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2253 || ! _bfd_stringtab_emit (abfd
, strtab
))
2255 _bfd_stringtab_free (strtab
);
2258 abfd
->output_has_begun
= true;
2263 /* Create a mapping from a set of sections to a program segment. */
2265 static INLINE
struct elf_segment_map
*
2266 make_mapping (abfd
, sections
, from
, to
, phdr
)
2268 asection
**sections
;
2273 struct elf_segment_map
*m
;
2277 m
= ((struct elf_segment_map
*)
2279 (sizeof (struct elf_segment_map
)
2280 + (to
- from
- 1) * sizeof (asection
*))));
2284 m
->p_type
= PT_LOAD
;
2285 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2286 m
->sections
[i
- from
] = *hdrpp
;
2287 m
->count
= to
- from
;
2289 if (from
== 0 && phdr
)
2291 /* Include the headers in the first PT_LOAD segment. */
2292 m
->includes_filehdr
= 1;
2293 m
->includes_phdrs
= 1;
2299 /* Set up a mapping from BFD sections to program segments. */
2302 map_sections_to_segments (abfd
)
2305 asection
**sections
= NULL
;
2309 struct elf_segment_map
*mfirst
;
2310 struct elf_segment_map
**pm
;
2311 struct elf_segment_map
*m
;
2313 unsigned int phdr_index
;
2314 bfd_vma maxpagesize
;
2316 boolean phdr_in_segment
= true;
2320 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2323 if (bfd_count_sections (abfd
) == 0)
2326 /* Select the allocated sections, and sort them. */
2328 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2329 * sizeof (asection
*));
2330 if (sections
== NULL
)
2334 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2336 if ((s
->flags
& SEC_ALLOC
) != 0)
2342 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2345 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2347 /* Build the mapping. */
2352 /* If we have a .interp section, then create a PT_PHDR segment for
2353 the program headers and a PT_INTERP segment for the .interp
2355 s
= bfd_get_section_by_name (abfd
, ".interp");
2356 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2358 m
= ((struct elf_segment_map
*)
2359 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2363 m
->p_type
= PT_PHDR
;
2364 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2365 m
->p_flags
= PF_R
| PF_X
;
2366 m
->p_flags_valid
= 1;
2367 m
->includes_phdrs
= 1;
2372 m
= ((struct elf_segment_map
*)
2373 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2377 m
->p_type
= PT_INTERP
;
2385 /* Look through the sections. We put sections in the same program
2386 segment when the start of the second section can be placed within
2387 a few bytes of the end of the first section. */
2390 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2392 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2394 && (dynsec
->flags
& SEC_LOAD
) == 0)
2397 /* Deal with -Ttext or something similar such that the first section
2398 is not adjacent to the program headers. This is an
2399 approximation, since at this point we don't know exactly how many
2400 program headers we will need. */
2403 bfd_size_type phdr_size
;
2405 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2407 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2408 if ((abfd
->flags
& D_PAGED
) == 0
2409 || sections
[0]->lma
< phdr_size
2410 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2411 phdr_in_segment
= false;
2414 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2417 boolean new_segment
;
2421 /* See if this section and the last one will fit in the same
2424 if (last_hdr
== NULL
)
2426 /* If we don't have a segment yet, then we don't need a new
2427 one (we build the last one after this loop). */
2428 new_segment
= false;
2430 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2432 /* If this section has a different relation between the
2433 virtual address and the load address, then we need a new
2437 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2438 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2440 /* If putting this section in this segment would force us to
2441 skip a page in the segment, then we need a new segment. */
2444 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2445 && (hdr
->flags
& SEC_LOAD
) != 0)
2447 /* We don't want to put a loadable section after a
2448 nonloadable section in the same segment. */
2451 else if ((abfd
->flags
& D_PAGED
) == 0)
2453 /* If the file is not demand paged, which means that we
2454 don't require the sections to be correctly aligned in the
2455 file, then there is no other reason for a new segment. */
2456 new_segment
= false;
2459 && (hdr
->flags
& SEC_READONLY
) == 0
2460 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2463 /* We don't want to put a writable section in a read only
2464 segment, unless they are on the same page in memory
2465 anyhow. We already know that the last section does not
2466 bring us past the current section on the page, so the
2467 only case in which the new section is not on the same
2468 page as the previous section is when the previous section
2469 ends precisely on a page boundary. */
2474 /* Otherwise, we can use the same segment. */
2475 new_segment
= false;
2480 if ((hdr
->flags
& SEC_READONLY
) == 0)
2486 /* We need a new program segment. We must create a new program
2487 header holding all the sections from phdr_index until hdr. */
2489 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2496 if ((hdr
->flags
& SEC_READONLY
) == 0)
2503 phdr_in_segment
= false;
2506 /* Create a final PT_LOAD program segment. */
2507 if (last_hdr
!= NULL
)
2509 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2517 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2520 m
= ((struct elf_segment_map
*)
2521 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2525 m
->p_type
= PT_DYNAMIC
;
2527 m
->sections
[0] = dynsec
;
2533 /* For each loadable .note section, add a PT_NOTE segment. We don't
2534 use bfd_get_section_by_name, because if we link together
2535 nonloadable .note sections and loadable .note sections, we will
2536 generate two .note sections in the output file. FIXME: Using
2537 names for section types is bogus anyhow. */
2538 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2540 if ((s
->flags
& SEC_LOAD
) != 0
2541 && strncmp (s
->name
, ".note", 5) == 0)
2543 m
= ((struct elf_segment_map
*)
2544 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2548 m
->p_type
= PT_NOTE
;
2560 elf_tdata (abfd
)->segment_map
= mfirst
;
2564 if (sections
!= NULL
)
2569 /* Sort sections by address. */
2572 elf_sort_sections (arg1
, arg2
)
2576 const asection
*sec1
= *(const asection
**) arg1
;
2577 const asection
*sec2
= *(const asection
**) arg2
;
2579 /* Sort by LMA first, since this is the address used to
2580 place the section into a segment. */
2581 if (sec1
->lma
< sec2
->lma
)
2583 else if (sec1
->lma
> sec2
->lma
)
2586 /* Then sort by VMA. Normally the LMA and the VMA will be
2587 the same, and this will do nothing. */
2588 if (sec1
->vma
< sec2
->vma
)
2590 else if (sec1
->vma
> sec2
->vma
)
2593 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2595 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2600 return sec1
->target_index
- sec2
->target_index
;
2610 /* Sort by size, to put zero sized sections before others at the
2613 if (sec1
->_raw_size
< sec2
->_raw_size
)
2615 if (sec1
->_raw_size
> sec2
->_raw_size
)
2618 return sec1
->target_index
- sec2
->target_index
;
2621 /* Assign file positions to the sections based on the mapping from
2622 sections to segments. This function also sets up some fields in
2623 the file header, and writes out the program headers. */
2626 assign_file_positions_for_segments (abfd
)
2629 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2631 struct elf_segment_map
*m
;
2633 Elf_Internal_Phdr
*phdrs
;
2635 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2636 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2637 Elf_Internal_Phdr
*p
;
2639 if (elf_tdata (abfd
)->segment_map
== NULL
)
2641 if (! map_sections_to_segments (abfd
))
2645 if (bed
->elf_backend_modify_segment_map
)
2647 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2652 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2655 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2656 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2657 elf_elfheader (abfd
)->e_phnum
= count
;
2662 /* If we already counted the number of program segments, make sure
2663 that we allocated enough space. This happens when SIZEOF_HEADERS
2664 is used in a linker script. */
2665 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2666 if (alloc
!= 0 && count
> alloc
)
2668 ((*_bfd_error_handler
)
2669 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2670 bfd_get_filename (abfd
), alloc
, count
));
2671 bfd_set_error (bfd_error_bad_value
);
2678 phdrs
= ((Elf_Internal_Phdr
*)
2679 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2683 off
= bed
->s
->sizeof_ehdr
;
2684 off
+= alloc
* bed
->s
->sizeof_phdr
;
2691 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2698 /* If elf_segment_map is not from map_sections_to_segments, the
2699 sections may not be correctly ordered. */
2701 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2704 p
->p_type
= m
->p_type
;
2705 p
->p_flags
= m
->p_flags
;
2707 if (p
->p_type
== PT_LOAD
2709 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2711 if ((abfd
->flags
& D_PAGED
) != 0)
2712 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2715 bfd_size_type align
;
2718 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2720 bfd_size_type secalign
;
2722 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
2723 if (secalign
> align
)
2727 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
2734 p
->p_vaddr
= m
->sections
[0]->vma
;
2736 if (m
->p_paddr_valid
)
2737 p
->p_paddr
= m
->p_paddr
;
2738 else if (m
->count
== 0)
2741 p
->p_paddr
= m
->sections
[0]->lma
;
2743 if (p
->p_type
== PT_LOAD
2744 && (abfd
->flags
& D_PAGED
) != 0)
2745 p
->p_align
= bed
->maxpagesize
;
2746 else if (m
->count
== 0)
2747 p
->p_align
= bed
->s
->file_align
;
2755 if (m
->includes_filehdr
)
2757 if (! m
->p_flags_valid
)
2760 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2761 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2764 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2766 if (p
->p_vaddr
< (bfd_vma
) off
)
2768 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2769 bfd_get_filename (abfd
));
2770 bfd_set_error (bfd_error_bad_value
);
2775 if (! m
->p_paddr_valid
)
2778 if (p
->p_type
== PT_LOAD
)
2780 filehdr_vaddr
= p
->p_vaddr
;
2781 filehdr_paddr
= p
->p_paddr
;
2785 if (m
->includes_phdrs
)
2787 if (! m
->p_flags_valid
)
2790 if (m
->includes_filehdr
)
2792 if (p
->p_type
== PT_LOAD
)
2794 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2795 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2800 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2804 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2805 p
->p_vaddr
-= off
- p
->p_offset
;
2806 if (! m
->p_paddr_valid
)
2807 p
->p_paddr
-= off
- p
->p_offset
;
2810 if (p
->p_type
== PT_LOAD
)
2812 phdrs_vaddr
= p
->p_vaddr
;
2813 phdrs_paddr
= p
->p_paddr
;
2816 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
2819 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2820 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2823 if (p
->p_type
== PT_LOAD
2824 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
2826 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2832 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2833 p
->p_filesz
+= adjust
;
2834 p
->p_memsz
+= adjust
;
2840 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2844 bfd_size_type align
;
2848 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2850 /* The section may have artificial alignment forced by a
2851 link script. Notice this case by the gap between the
2852 cumulative phdr vma and the section's vma. */
2853 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2855 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2857 p
->p_memsz
+= adjust
;
2860 if ((flags
& SEC_LOAD
) != 0)
2861 p
->p_filesz
+= adjust
;
2864 if (p
->p_type
== PT_LOAD
)
2866 bfd_signed_vma adjust
;
2868 if ((flags
& SEC_LOAD
) != 0)
2870 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2874 else if ((flags
& SEC_ALLOC
) != 0)
2876 /* The section VMA must equal the file position
2877 modulo the page size. FIXME: I'm not sure if
2878 this adjustment is really necessary. We used to
2879 not have the SEC_LOAD case just above, and then
2880 this was necessary, but now I'm not sure. */
2881 if ((abfd
->flags
& D_PAGED
) != 0)
2882 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2884 adjust
= (sec
->vma
- voff
) % align
;
2893 (* _bfd_error_handler
)
2894 (_("Error: First section in segment (%s) starts at 0x%x"),
2895 bfd_section_name (abfd
, sec
), sec
->lma
);
2896 (* _bfd_error_handler
)
2897 (_(" whereas segment starts at 0x%x"),
2902 p
->p_memsz
+= adjust
;
2905 if ((flags
& SEC_LOAD
) != 0)
2906 p
->p_filesz
+= adjust
;
2911 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2912 used in a linker script we may have a section with
2913 SEC_LOAD clear but which is supposed to have
2915 if ((flags
& SEC_LOAD
) != 0
2916 || (flags
& SEC_HAS_CONTENTS
) != 0)
2917 off
+= sec
->_raw_size
;
2919 if ((flags
& SEC_ALLOC
) != 0)
2920 voff
+= sec
->_raw_size
;
2923 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
2925 /* The actual "note" segment has i == 0.
2926 This is the one that actually contains everything. */
2930 p
->p_filesz
= sec
->_raw_size
;
2931 off
+= sec
->_raw_size
;
2936 /* Fake sections -- don't need to be written. */
2939 flags
= sec
->flags
= 0;
2946 p
->p_memsz
+= sec
->_raw_size
;
2948 if ((flags
& SEC_LOAD
) != 0)
2949 p
->p_filesz
+= sec
->_raw_size
;
2951 if (align
> p
->p_align
2952 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
2956 if (! m
->p_flags_valid
)
2959 if ((flags
& SEC_CODE
) != 0)
2961 if ((flags
& SEC_READONLY
) == 0)
2967 /* Now that we have set the section file positions, we can set up
2968 the file positions for the non PT_LOAD segments. */
2969 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2973 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2975 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2976 p
->p_offset
= m
->sections
[0]->filepos
;
2980 if (m
->includes_filehdr
)
2982 p
->p_vaddr
= filehdr_vaddr
;
2983 if (! m
->p_paddr_valid
)
2984 p
->p_paddr
= filehdr_paddr
;
2986 else if (m
->includes_phdrs
)
2988 p
->p_vaddr
= phdrs_vaddr
;
2989 if (! m
->p_paddr_valid
)
2990 p
->p_paddr
= phdrs_paddr
;
2995 /* Clear out any program headers we allocated but did not use. */
2996 for (; count
< alloc
; count
++, p
++)
2998 memset (p
, 0, sizeof *p
);
2999 p
->p_type
= PT_NULL
;
3002 elf_tdata (abfd
)->phdr
= phdrs
;
3004 elf_tdata (abfd
)->next_file_pos
= off
;
3006 /* Write out the program headers. */
3007 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
3008 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
3014 /* Get the size of the program header.
3016 If this is called by the linker before any of the section VMA's are set, it
3017 can't calculate the correct value for a strange memory layout. This only
3018 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3019 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3020 data segment (exclusive of .interp and .dynamic).
3022 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3023 will be two segments. */
3025 static bfd_size_type
3026 get_program_header_size (abfd
)
3031 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3033 /* We can't return a different result each time we're called. */
3034 if (elf_tdata (abfd
)->program_header_size
!= 0)
3035 return elf_tdata (abfd
)->program_header_size
;
3037 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3039 struct elf_segment_map
*m
;
3042 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3044 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3045 return elf_tdata (abfd
)->program_header_size
;
3048 /* Assume we will need exactly two PT_LOAD segments: one for text
3049 and one for data. */
3052 s
= bfd_get_section_by_name (abfd
, ".interp");
3053 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3055 /* If we have a loadable interpreter section, we need a
3056 PT_INTERP segment. In this case, assume we also need a
3057 PT_PHDR segment, although that may not be true for all
3062 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3064 /* We need a PT_DYNAMIC segment. */
3068 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3070 if ((s
->flags
& SEC_LOAD
) != 0
3071 && strncmp (s
->name
, ".note", 5) == 0)
3073 /* We need a PT_NOTE segment. */
3078 /* Let the backend count up any program headers it might need. */
3079 if (bed
->elf_backend_additional_program_headers
)
3083 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
3089 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3090 return elf_tdata (abfd
)->program_header_size
;
3093 /* Work out the file positions of all the sections. This is called by
3094 _bfd_elf_compute_section_file_positions. All the section sizes and
3095 VMAs must be known before this is called.
3097 We do not consider reloc sections at this point, unless they form
3098 part of the loadable image. Reloc sections are assigned file
3099 positions in assign_file_positions_for_relocs, which is called by
3100 write_object_contents and final_link.
3102 We also don't set the positions of the .symtab and .strtab here. */
3105 assign_file_positions_except_relocs (abfd
)
3108 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
3109 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
3110 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
3112 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3114 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3115 && bfd_get_format (abfd
) != bfd_core
)
3117 Elf_Internal_Shdr
**hdrpp
;
3120 /* Start after the ELF header. */
3121 off
= i_ehdrp
->e_ehsize
;
3123 /* We are not creating an executable, which means that we are
3124 not creating a program header, and that the actual order of
3125 the sections in the file is unimportant. */
3126 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
3128 Elf_Internal_Shdr
*hdr
;
3131 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
3133 hdr
->sh_offset
= -1;
3136 if (i
== tdata
->symtab_section
3137 || i
== tdata
->strtab_section
)
3139 hdr
->sh_offset
= -1;
3143 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3149 Elf_Internal_Shdr
**hdrpp
;
3151 /* Assign file positions for the loaded sections based on the
3152 assignment of sections to segments. */
3153 if (! assign_file_positions_for_segments (abfd
))
3156 /* Assign file positions for the other sections. */
3158 off
= elf_tdata (abfd
)->next_file_pos
;
3159 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
3161 Elf_Internal_Shdr
*hdr
;
3164 if (hdr
->bfd_section
!= NULL
3165 && hdr
->bfd_section
->filepos
!= 0)
3166 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3167 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3169 ((*_bfd_error_handler
)
3170 (_("%s: warning: allocated section `%s' not in segment"),
3171 bfd_get_filename (abfd
),
3172 (hdr
->bfd_section
== NULL
3174 : hdr
->bfd_section
->name
)));
3175 if ((abfd
->flags
& D_PAGED
) != 0)
3176 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3178 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3179 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3182 else if (hdr
->sh_type
== SHT_REL
3183 || hdr
->sh_type
== SHT_RELA
3184 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3185 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3186 hdr
->sh_offset
= -1;
3188 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3192 /* Place the section headers. */
3193 off
= align_file_position (off
, bed
->s
->file_align
);
3194 i_ehdrp
->e_shoff
= off
;
3195 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3197 elf_tdata (abfd
)->next_file_pos
= off
;
3206 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3207 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3208 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3210 struct bfd_strtab_hash
*shstrtab
;
3211 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3213 i_ehdrp
= elf_elfheader (abfd
);
3214 i_shdrp
= elf_elfsections (abfd
);
3216 shstrtab
= _bfd_elf_stringtab_init ();
3217 if (shstrtab
== NULL
)
3220 elf_shstrtab (abfd
) = shstrtab
;
3222 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3223 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3224 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3225 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3227 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3228 i_ehdrp
->e_ident
[EI_DATA
] =
3229 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3230 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3232 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_NONE
;
3233 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 0;
3235 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
3236 i_ehdrp
->e_ident
[count
] = 0;
3238 if ((abfd
->flags
& DYNAMIC
) != 0)
3239 i_ehdrp
->e_type
= ET_DYN
;
3240 else if ((abfd
->flags
& EXEC_P
) != 0)
3241 i_ehdrp
->e_type
= ET_EXEC
;
3242 else if (bfd_get_format (abfd
) == bfd_core
)
3243 i_ehdrp
->e_type
= ET_CORE
;
3245 i_ehdrp
->e_type
= ET_REL
;
3247 switch (bfd_get_arch (abfd
))
3249 case bfd_arch_unknown
:
3250 i_ehdrp
->e_machine
= EM_NONE
;
3252 case bfd_arch_sparc
:
3253 if (bfd_elf_get_arch_size (abfd
) == 64)
3254 i_ehdrp
->e_machine
= EM_SPARCV9
;
3256 i_ehdrp
->e_machine
= EM_SPARC
;
3259 i_ehdrp
->e_machine
= EM_S370
;
3262 i_ehdrp
->e_machine
= EM_386
;
3265 i_ehdrp
->e_machine
= EM_IA_64
;
3268 i_ehdrp
->e_machine
= EM_68K
;
3271 i_ehdrp
->e_machine
= EM_88K
;
3274 i_ehdrp
->e_machine
= EM_860
;
3277 i_ehdrp
->e_machine
= EM_960
;
3279 case bfd_arch_mips
: /* MIPS Rxxxx */
3280 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
3283 i_ehdrp
->e_machine
= EM_PARISC
;
3285 case bfd_arch_powerpc
:
3286 i_ehdrp
->e_machine
= EM_PPC
;
3288 case bfd_arch_alpha
:
3289 i_ehdrp
->e_machine
= EM_ALPHA
;
3292 i_ehdrp
->e_machine
= EM_SH
;
3295 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
3298 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3301 i_ehdrp
->e_machine
= EM_CYGNUS_FR30
;
3303 case bfd_arch_mcore
:
3304 i_ehdrp
->e_machine
= EM_MCORE
;
3307 i_ehdrp
->e_machine
= EM_AVR
;
3310 switch (bfd_get_mach (abfd
))
3313 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3317 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3320 i_ehdrp
->e_machine
= EM_ARM
;
3323 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3325 case bfd_arch_mn10200
:
3326 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3328 case bfd_arch_mn10300
:
3329 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3332 i_ehdrp
->e_machine
= EM_PJ
;
3334 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3336 i_ehdrp
->e_machine
= EM_NONE
;
3338 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3339 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3341 /* no program header, for now. */
3342 i_ehdrp
->e_phoff
= 0;
3343 i_ehdrp
->e_phentsize
= 0;
3344 i_ehdrp
->e_phnum
= 0;
3346 /* each bfd section is section header entry */
3347 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3348 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3350 /* if we're building an executable, we'll need a program header table */
3351 if (abfd
->flags
& EXEC_P
)
3353 /* it all happens later */
3355 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3357 /* elf_build_phdrs() returns a (NULL-terminated) array of
3358 Elf_Internal_Phdrs */
3359 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3360 i_ehdrp
->e_phoff
= outbase
;
3361 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3366 i_ehdrp
->e_phentsize
= 0;
3368 i_ehdrp
->e_phoff
= 0;
3371 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3372 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3373 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3374 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3375 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3376 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3377 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3378 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3379 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3385 /* Assign file positions for all the reloc sections which are not part
3386 of the loadable file image. */
3389 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3394 Elf_Internal_Shdr
**shdrpp
;
3396 off
= elf_tdata (abfd
)->next_file_pos
;
3398 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3399 i
< elf_elfheader (abfd
)->e_shnum
;
3402 Elf_Internal_Shdr
*shdrp
;
3405 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3406 && shdrp
->sh_offset
== -1)
3407 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3410 elf_tdata (abfd
)->next_file_pos
= off
;
3414 _bfd_elf_write_object_contents (abfd
)
3417 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3418 Elf_Internal_Ehdr
*i_ehdrp
;
3419 Elf_Internal_Shdr
**i_shdrp
;
3423 if (! abfd
->output_has_begun
3424 && ! _bfd_elf_compute_section_file_positions
3425 (abfd
, (struct bfd_link_info
*) NULL
))
3428 i_shdrp
= elf_elfsections (abfd
);
3429 i_ehdrp
= elf_elfheader (abfd
);
3432 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3436 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3438 /* After writing the headers, we need to write the sections too... */
3439 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3441 if (bed
->elf_backend_section_processing
)
3442 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3443 if (i_shdrp
[count
]->contents
)
3445 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3446 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3448 != i_shdrp
[count
]->sh_size
))
3453 /* Write out the section header names. */
3454 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3455 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3458 if (bed
->elf_backend_final_write_processing
)
3459 (*bed
->elf_backend_final_write_processing
) (abfd
,
3460 elf_tdata (abfd
)->linker
);
3462 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3466 _bfd_elf_write_corefile_contents (abfd
)
3469 /* Hopefully this can be done just like an object file. */
3470 return _bfd_elf_write_object_contents (abfd
);
3472 /* given a section, search the header to find them... */
3474 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3478 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3479 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3481 Elf_Internal_Shdr
*hdr
;
3482 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3484 for (index
= 0; index
< maxindex
; index
++)
3486 hdr
= i_shdrp
[index
];
3487 if (hdr
->bfd_section
== asect
)
3491 if (bed
->elf_backend_section_from_bfd_section
)
3493 for (index
= 0; index
< maxindex
; index
++)
3497 hdr
= i_shdrp
[index
];
3499 if ((*bed
->elf_backend_section_from_bfd_section
)
3500 (abfd
, hdr
, asect
, &retval
))
3505 if (bfd_is_abs_section (asect
))
3507 if (bfd_is_com_section (asect
))
3509 if (bfd_is_und_section (asect
))
3512 bfd_set_error (bfd_error_nonrepresentable_section
);
3517 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3521 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3523 asymbol
**asym_ptr_ptr
;
3525 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3527 flagword flags
= asym_ptr
->flags
;
3529 /* When gas creates relocations against local labels, it creates its
3530 own symbol for the section, but does put the symbol into the
3531 symbol chain, so udata is 0. When the linker is generating
3532 relocatable output, this section symbol may be for one of the
3533 input sections rather than the output section. */
3534 if (asym_ptr
->udata
.i
== 0
3535 && (flags
& BSF_SECTION_SYM
)
3536 && asym_ptr
->section
)
3540 if (asym_ptr
->section
->output_section
!= NULL
)
3541 indx
= asym_ptr
->section
->output_section
->index
;
3543 indx
= asym_ptr
->section
->index
;
3544 if (elf_section_syms (abfd
)[indx
])
3545 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3548 idx
= asym_ptr
->udata
.i
;
3552 /* This case can occur when using --strip-symbol on a symbol
3553 which is used in a relocation entry. */
3554 (*_bfd_error_handler
)
3555 (_("%s: symbol `%s' required but not present"),
3556 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3557 bfd_set_error (bfd_error_no_symbols
);
3564 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3565 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3566 elf_symbol_flags (flags
));
3574 /* Copy private BFD data. This copies any program header information. */
3577 copy_private_bfd_data (ibfd
, obfd
)
3581 Elf_Internal_Ehdr
*iehdr
;
3582 struct elf_segment_map
*mfirst
;
3583 struct elf_segment_map
**pm
;
3584 struct elf_segment_map
*m
;
3585 Elf_Internal_Phdr
*p
;
3587 unsigned int num_segments
;
3588 boolean phdr_included
= false;
3590 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3591 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3594 if (elf_tdata (ibfd
)->phdr
== NULL
)
3597 iehdr
= elf_elfheader (ibfd
);
3602 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
3604 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3605 ((addr) >= (bottom) \
3606 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3607 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3609 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3611 #define IS_COREFILE_NOTE(p, s) \
3612 (p->p_type == PT_NOTE \
3613 && bfd_get_format (ibfd) == bfd_core \
3614 && s->vma == 0 && s->lma == 0 \
3615 && (bfd_vma) s->filepos >= p->p_offset \
3616 && (bfd_vma) s->filepos + s->_raw_size \
3617 <= p->p_offset + p->p_filesz)
3619 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3620 linker, which generates a PT_INTERP section with p_vaddr and
3621 p_memsz set to 0. */
3623 #define IS_SOLARIS_PT_INTERP(p, s) \
3625 && p->p_filesz > 0 \
3626 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3627 && s->_raw_size > 0 \
3628 && (bfd_vma) s->filepos >= p->p_offset \
3629 && ((bfd_vma) s->filepos + s->_raw_size \
3630 <= p->p_offset + p->p_filesz))
3632 /* Scan through the segments specified in the program header
3633 of the input BFD. */
3634 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< num_segments
; i
++, p
++)
3638 asection
**sections
;
3641 bfd_vma matching_lma
;
3642 bfd_vma suggested_lma
;
3645 /* For each section in the input BFD, decide if it should be
3646 included in the current segment. A section will be included
3647 if it is within the address space of the segment, and it is
3648 an allocated segment, and there is an output section
3649 associated with it. */
3651 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3652 if (s
->output_section
!= NULL
)
3654 if ((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3655 || IS_SOLARIS_PT_INTERP (p
, s
))
3656 && (s
->flags
& SEC_ALLOC
) != 0)
3658 else if (IS_COREFILE_NOTE (p
, s
))
3662 /* Allocate a segment map big enough to contain all of the
3663 sections we have selected. */
3664 m
= ((struct elf_segment_map
*)
3666 (sizeof (struct elf_segment_map
)
3667 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3671 /* Initialise the fields of the segment map. Default to
3672 using the physical address of the segment in the input BFD. */
3674 m
->p_type
= p
->p_type
;
3675 m
->p_flags
= p
->p_flags
;
3676 m
->p_flags_valid
= 1;
3677 m
->p_paddr
= p
->p_paddr
;
3678 m
->p_paddr_valid
= 1;
3680 /* Determine if this segment contains the ELF file header
3681 and if it contains the program headers themselves. */
3682 m
->includes_filehdr
= (p
->p_offset
== 0
3683 && p
->p_filesz
>= iehdr
->e_ehsize
);
3685 m
->includes_phdrs
= 0;
3687 if (! phdr_included
|| p
->p_type
!= PT_LOAD
)
3690 (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3691 && (p
->p_offset
+ p
->p_filesz
3692 >= ((bfd_vma
) iehdr
->e_phoff
3693 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3694 if (p
->p_type
== PT_LOAD
&& m
->includes_phdrs
)
3695 phdr_included
= true;
3700 /* Special segments, such as the PT_PHDR segment, may contain
3701 no sections, but ordinary, loadable segments should contain
3704 if (p
->p_type
== PT_LOAD
)
3706 (_("%s: warning: Empty loadable segment detected\n"),
3707 bfd_get_filename (ibfd
));
3716 /* Now scan the sections in the input BFD again and attempt
3717 to add their corresponding output sections to the segment map.
3718 The problem here is how to handle an output section which has
3719 been moved (ie had its LMA changed). There are four possibilities:
3721 1. None of the sections have been moved.
3722 In this case we can continue to use the segment LMA from the
3725 2. All of the sections have been moved by the same amount.
3726 In this case we can change the segment's LMA to match the LMA
3727 of the first section.
3729 3. Some of the sections have been moved, others have not.
3730 In this case those sections which have not been moved can be
3731 placed in the current segment which will have to have its size,
3732 and possibly its LMA changed, and a new segment or segments will
3733 have to be created to contain the other sections.
3735 4. The sections have been moved, but not be the same amount.
3736 In this case we can change the segment's LMA to match the LMA
3737 of the first section and we will have to create a new segment
3738 or segments to contain the other sections.
3740 In order to save time, we allocate an array to hold the section
3741 pointers that we are interested in. As these sections get assigned
3742 to a segment, they are removed from this array. */
3744 sections
= (asection
**) bfd_malloc (sizeof (asection
*) * csecs
);
3745 if (sections
== NULL
)
3748 /* Step One: Scan for segment vs section LMA conflicts.
3749 Also add the sections to the section array allocated above.
3750 Also add the sections to the current segment. In the common
3751 case, where the sections have not been moved, this means that
3752 we have completely filled the segment, and there is nothing
3759 for (j
= 0, s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3761 os
= s
->output_section
;
3763 if ((((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3764 || IS_SOLARIS_PT_INTERP (p
, s
))
3765 && (s
->flags
& SEC_ALLOC
) != 0)
3766 || IS_COREFILE_NOTE (p
, s
))
3771 /* The Solaris native linker always sets p_paddr to 0.
3772 We try to catch that case here, and set it to the
3778 && (os
->vma
== (p
->p_vaddr
3779 + (m
->includes_filehdr
3782 + (m
->includes_phdrs
3783 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3785 m
->p_paddr
= p
->p_vaddr
;
3787 /* Match up the physical address of the segment with the
3788 LMA address of the output section. */
3789 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3790 || IS_COREFILE_NOTE (p
, s
))
3792 if (matching_lma
== 0)
3793 matching_lma
= os
->lma
;
3795 /* We assume that if the section fits within the segment
3796 that it does not overlap any other section within that
3798 m
->sections
[isec
++] = os
;
3800 else if (suggested_lma
== 0)
3801 suggested_lma
= os
->lma
;
3805 BFD_ASSERT (j
== csecs
);
3807 /* Step Two: Adjust the physical address of the current segment,
3811 /* All of the sections fitted within the segment as currently
3812 specified. This is the default case. Add the segment to
3813 the list of built segments and carry on to process the next
3814 program header in the input BFD. */
3824 if (matching_lma
!= 0)
3826 /* At least one section fits inside the current segment.
3827 Keep it, but modify its physical address to match the
3828 LMA of the first section that fitted. */
3830 m
->p_paddr
= matching_lma
;
3834 /* None of the sections fitted inside the current segment.
3835 Change the current segment's physical address to match
3836 the LMA of the first section. */
3838 m
->p_paddr
= suggested_lma
;
3841 /* Offset the segment physical address from the lma to allow
3842 for space taken up by elf headers. */
3843 if (m
->includes_filehdr
)
3844 m
->p_paddr
-= iehdr
->e_ehsize
;
3846 if (m
->includes_phdrs
)
3847 m
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
3850 /* Step Three: Loop over the sections again, this time assigning
3851 those that fit to the current segment and remvoing them from the
3852 sections array; but making sure not to leave large gaps. Once all
3853 possible sections have been assigned to the current segment it is
3854 added to the list of built segments and if sections still remain
3855 to be assigned, a new segment is constructed before repeating
3863 /* Fill the current segment with sections that fit. */
3864 for (j
= 0; j
< csecs
; j
++)
3871 os
= s
->output_section
;
3873 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3874 || IS_COREFILE_NOTE (p
, s
))
3878 /* If the first section in a segment does not start at
3879 the beginning of the segment, then something is wrong. */
3880 if (os
->lma
!= (m
->p_paddr
3881 + (m
->includes_filehdr
3882 ? iehdr
->e_ehsize
: 0)
3883 + (m
->includes_phdrs
3884 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3890 asection
* prev_sec
;
3891 bfd_vma maxpagesize
;
3893 prev_sec
= m
->sections
[m
->count
- 1];
3894 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
3896 /* If the gap between the end of the previous section
3897 and the start of this section is more than maxpagesize
3898 then we need to start a new segment. */
3899 if (BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
, maxpagesize
)
3900 < BFD_ALIGN (os
->lma
, maxpagesize
))
3902 if (suggested_lma
== 0)
3903 suggested_lma
= os
->lma
;
3909 m
->sections
[m
->count
++] = os
;
3913 else if (suggested_lma
== 0)
3914 suggested_lma
= os
->lma
;
3917 BFD_ASSERT (m
->count
> 0);
3919 /* Add the current segment to the list of built segments. */
3925 /* We still have not allocated all of the sections to
3926 segments. Create a new segment here, initialise it
3927 and carry on looping. */
3929 m
= ((struct elf_segment_map
*)
3931 (sizeof (struct elf_segment_map
)
3932 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3936 /* Initialise the fields of the segment map. Set the physical
3937 physical address to the LMA of the first section that has
3938 not yet been assigned. */
3941 m
->p_type
= p
->p_type
;
3942 m
->p_flags
= p
->p_flags
;
3943 m
->p_flags_valid
= 1;
3944 m
->p_paddr
= suggested_lma
;
3945 m
->p_paddr_valid
= 1;
3946 m
->includes_filehdr
= 0;
3947 m
->includes_phdrs
= 0;
3950 while (isec
< csecs
);
3955 /* The Solaris linker creates program headers in which all the
3956 p_paddr fields are zero. When we try to objcopy or strip such a
3957 file, we get confused. Check for this case, and if we find it
3958 reset the p_paddr_valid fields. */
3959 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3960 if (m
->p_paddr
!= 0)
3964 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3965 m
->p_paddr_valid
= 0;
3968 elf_tdata (obfd
)->segment_map
= mfirst
;
3971 /* Final Step: Sort the segments into ascending order of physical address. */
3974 struct elf_segment_map
* prev
;
3977 for (m
= mfirst
->next
; m
!= NULL
; prev
= m
, m
= m
->next
)
3979 /* Yes I know - its a bubble sort....*/
3980 if (m
->next
!= NULL
&& (m
->next
->p_paddr
< m
->p_paddr
))
3982 /* swap m and m->next */
3983 prev
->next
= m
->next
;
3984 m
->next
= m
->next
->next
;
3985 prev
->next
->next
= m
;
3994 #undef IS_CONTAINED_BY
3995 #undef IS_SOLARIS_PT_INTERP
3996 #undef IS_COREFILE_NOTE
4000 /* Copy private section information. This copies over the entsize
4001 field, and sometimes the info field. */
4004 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
4010 Elf_Internal_Shdr
*ihdr
, *ohdr
;
4012 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
4013 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
4016 /* Copy over private BFD data if it has not already been copied.
4017 This must be done here, rather than in the copy_private_bfd_data
4018 entry point, because the latter is called after the section
4019 contents have been set, which means that the program headers have
4020 already been worked out. */
4021 if (elf_tdata (obfd
)->segment_map
== NULL
4022 && elf_tdata (ibfd
)->phdr
!= NULL
)
4026 /* Only set up the segments if there are no more SEC_ALLOC
4027 sections. FIXME: This won't do the right thing if objcopy is
4028 used to remove the last SEC_ALLOC section, since objcopy
4029 won't call this routine in that case. */
4030 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
4031 if ((s
->flags
& SEC_ALLOC
) != 0)
4035 if (! copy_private_bfd_data (ibfd
, obfd
))
4040 ihdr
= &elf_section_data (isec
)->this_hdr
;
4041 ohdr
= &elf_section_data (osec
)->this_hdr
;
4043 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
4045 if (ihdr
->sh_type
== SHT_SYMTAB
4046 || ihdr
->sh_type
== SHT_DYNSYM
4047 || ihdr
->sh_type
== SHT_GNU_verneed
4048 || ihdr
->sh_type
== SHT_GNU_verdef
)
4049 ohdr
->sh_info
= ihdr
->sh_info
;
4051 elf_section_data (osec
)->use_rela_p
4052 = elf_section_data (isec
)->use_rela_p
;
4057 /* Copy private symbol information. If this symbol is in a section
4058 which we did not map into a BFD section, try to map the section
4059 index correctly. We use special macro definitions for the mapped
4060 section indices; these definitions are interpreted by the
4061 swap_out_syms function. */
4063 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4064 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4065 #define MAP_STRTAB (SHN_LORESERVE - 3)
4066 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4069 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
4075 elf_symbol_type
*isym
, *osym
;
4077 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4078 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4081 isym
= elf_symbol_from (ibfd
, isymarg
);
4082 osym
= elf_symbol_from (obfd
, osymarg
);
4086 && bfd_is_abs_section (isym
->symbol
.section
))
4090 shndx
= isym
->internal_elf_sym
.st_shndx
;
4091 if (shndx
== elf_onesymtab (ibfd
))
4092 shndx
= MAP_ONESYMTAB
;
4093 else if (shndx
== elf_dynsymtab (ibfd
))
4094 shndx
= MAP_DYNSYMTAB
;
4095 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
4097 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
4098 shndx
= MAP_SHSTRTAB
;
4099 osym
->internal_elf_sym
.st_shndx
= shndx
;
4105 /* Swap out the symbols. */
4108 swap_out_syms (abfd
, sttp
, relocatable_p
)
4110 struct bfd_strtab_hash
**sttp
;
4113 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4115 if (!elf_map_symbols (abfd
))
4118 /* Dump out the symtabs. */
4120 int symcount
= bfd_get_symcount (abfd
);
4121 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4122 struct bfd_strtab_hash
*stt
;
4123 Elf_Internal_Shdr
*symtab_hdr
;
4124 Elf_Internal_Shdr
*symstrtab_hdr
;
4125 char *outbound_syms
;
4128 stt
= _bfd_elf_stringtab_init ();
4132 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4133 symtab_hdr
->sh_type
= SHT_SYMTAB
;
4134 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
4135 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
4136 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
4137 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
4139 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4140 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4142 outbound_syms
= bfd_alloc (abfd
,
4143 (1 + symcount
) * bed
->s
->sizeof_sym
);
4144 if (outbound_syms
== NULL
)
4146 symtab_hdr
->contents
= (PTR
) outbound_syms
;
4148 /* now generate the data (for "contents") */
4150 /* Fill in zeroth symbol and swap it out. */
4151 Elf_Internal_Sym sym
;
4157 sym
.st_shndx
= SHN_UNDEF
;
4158 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4159 outbound_syms
+= bed
->s
->sizeof_sym
;
4161 for (idx
= 0; idx
< symcount
; idx
++)
4163 Elf_Internal_Sym sym
;
4164 bfd_vma value
= syms
[idx
]->value
;
4165 elf_symbol_type
*type_ptr
;
4166 flagword flags
= syms
[idx
]->flags
;
4169 if (flags
& BSF_SECTION_SYM
)
4170 /* Section symbols have no names. */
4174 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4177 if (sym
.st_name
== (unsigned long) -1)
4181 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4183 if ((flags
& BSF_SECTION_SYM
) == 0
4184 && bfd_is_com_section (syms
[idx
]->section
))
4186 /* ELF common symbols put the alignment into the `value' field,
4187 and the size into the `size' field. This is backwards from
4188 how BFD handles it, so reverse it here. */
4189 sym
.st_size
= value
;
4190 if (type_ptr
== NULL
4191 || type_ptr
->internal_elf_sym
.st_value
== 0)
4192 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4194 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4195 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4196 (abfd
, syms
[idx
]->section
);
4200 asection
*sec
= syms
[idx
]->section
;
4203 if (sec
->output_section
)
4205 value
+= sec
->output_offset
;
4206 sec
= sec
->output_section
;
4208 /* Don't add in the section vma for relocatable output. */
4209 if (! relocatable_p
)
4211 sym
.st_value
= value
;
4212 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4214 if (bfd_is_abs_section (sec
)
4216 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4218 /* This symbol is in a real ELF section which we did
4219 not create as a BFD section. Undo the mapping done
4220 by copy_private_symbol_data. */
4221 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4225 shndx
= elf_onesymtab (abfd
);
4228 shndx
= elf_dynsymtab (abfd
);
4231 shndx
= elf_tdata (abfd
)->strtab_section
;
4234 shndx
= elf_tdata (abfd
)->shstrtab_section
;
4242 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
4248 /* Writing this would be a hell of a lot easier if
4249 we had some decent documentation on bfd, and
4250 knew what to expect of the library, and what to
4251 demand of applications. For example, it
4252 appears that `objcopy' might not set the
4253 section of a symbol to be a section that is
4254 actually in the output file. */
4255 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
4256 BFD_ASSERT (sec2
!= 0);
4257 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
4258 BFD_ASSERT (shndx
!= -1);
4262 sym
.st_shndx
= shndx
;
4265 if ((flags
& BSF_FUNCTION
) != 0)
4267 else if ((flags
& BSF_OBJECT
) != 0)
4272 /* Processor-specific types */
4273 if (type_ptr
!= NULL
4274 && bed
->elf_backend_get_symbol_type
)
4275 type
= (*bed
->elf_backend_get_symbol_type
) (&type_ptr
->internal_elf_sym
, type
);
4277 if (flags
& BSF_SECTION_SYM
)
4278 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4279 else if (bfd_is_com_section (syms
[idx
]->section
))
4280 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
4281 else if (bfd_is_und_section (syms
[idx
]->section
))
4282 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
4286 else if (flags
& BSF_FILE
)
4287 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4290 int bind
= STB_LOCAL
;
4292 if (flags
& BSF_LOCAL
)
4294 else if (flags
& BSF_WEAK
)
4296 else if (flags
& BSF_GLOBAL
)
4299 sym
.st_info
= ELF_ST_INFO (bind
, type
);
4302 if (type_ptr
!= NULL
)
4303 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
4307 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4308 outbound_syms
+= bed
->s
->sizeof_sym
;
4312 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
4313 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4315 symstrtab_hdr
->sh_flags
= 0;
4316 symstrtab_hdr
->sh_addr
= 0;
4317 symstrtab_hdr
->sh_entsize
= 0;
4318 symstrtab_hdr
->sh_link
= 0;
4319 symstrtab_hdr
->sh_info
= 0;
4320 symstrtab_hdr
->sh_addralign
= 1;
4326 /* Return the number of bytes required to hold the symtab vector.
4328 Note that we base it on the count plus 1, since we will null terminate
4329 the vector allocated based on this size. However, the ELF symbol table
4330 always has a dummy entry as symbol #0, so it ends up even. */
4333 _bfd_elf_get_symtab_upper_bound (abfd
)
4338 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4340 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4341 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4347 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
4352 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4354 if (elf_dynsymtab (abfd
) == 0)
4356 bfd_set_error (bfd_error_invalid_operation
);
4360 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4361 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4367 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
4368 bfd
*abfd ATTRIBUTE_UNUSED
;
4371 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
4374 /* Canonicalize the relocs. */
4377 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4386 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
4392 tblptr
= section
->relocation
;
4393 for (i
= 0; i
< section
->reloc_count
; i
++)
4394 *relptr
++ = tblptr
++;
4398 return section
->reloc_count
;
4402 _bfd_elf_get_symtab (abfd
, alocation
)
4404 asymbol
**alocation
;
4406 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4407 (abfd
, alocation
, false);
4410 bfd_get_symcount (abfd
) = symcount
;
4415 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
4417 asymbol
**alocation
;
4419 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4420 (abfd
, alocation
, true);
4423 /* Return the size required for the dynamic reloc entries. Any
4424 section that was actually installed in the BFD, and has type
4425 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4426 considered to be a dynamic reloc section. */
4429 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
4435 if (elf_dynsymtab (abfd
) == 0)
4437 bfd_set_error (bfd_error_invalid_operation
);
4441 ret
= sizeof (arelent
*);
4442 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4443 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4444 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4445 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4446 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
4447 * sizeof (arelent
*));
4452 /* Canonicalize the dynamic relocation entries. Note that we return
4453 the dynamic relocations as a single block, although they are
4454 actually associated with particular sections; the interface, which
4455 was designed for SunOS style shared libraries, expects that there
4456 is only one set of dynamic relocs. Any section that was actually
4457 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4458 the dynamic symbol table, is considered to be a dynamic reloc
4462 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
4467 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
4471 if (elf_dynsymtab (abfd
) == 0)
4473 bfd_set_error (bfd_error_invalid_operation
);
4477 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
4479 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4481 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4482 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4483 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4488 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
4490 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
4492 for (i
= 0; i
< count
; i
++)
4503 /* Read in the version information. */
4506 _bfd_elf_slurp_version_tables (abfd
)
4509 bfd_byte
*contents
= NULL
;
4511 if (elf_dynverdef (abfd
) != 0)
4513 Elf_Internal_Shdr
*hdr
;
4514 Elf_External_Verdef
*everdef
;
4515 Elf_Internal_Verdef
*iverdef
;
4516 Elf_Internal_Verdef
*iverdefarr
;
4517 Elf_Internal_Verdef iverdefmem
;
4519 unsigned int maxidx
;
4521 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
4523 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4524 if (contents
== NULL
)
4526 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4527 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4530 /* We know the number of entries in the section but not the maximum
4531 index. Therefore we have to run through all entries and find
4533 everdef
= (Elf_External_Verdef
*) contents
;
4535 for (i
= 0; i
< hdr
->sh_info
; ++i
)
4537 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
4539 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) > maxidx
)
4540 maxidx
= iverdefmem
.vd_ndx
& VERSYM_VERSION
;
4542 everdef
= ((Elf_External_Verdef
*)
4543 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
4546 elf_tdata (abfd
)->verdef
=
4547 ((Elf_Internal_Verdef
*)
4548 bfd_zalloc (abfd
, maxidx
* sizeof (Elf_Internal_Verdef
)));
4549 if (elf_tdata (abfd
)->verdef
== NULL
)
4552 elf_tdata (abfd
)->cverdefs
= maxidx
;
4554 everdef
= (Elf_External_Verdef
*) contents
;
4555 iverdefarr
= elf_tdata (abfd
)->verdef
;
4556 for (i
= 0; i
< hdr
->sh_info
; i
++)
4558 Elf_External_Verdaux
*everdaux
;
4559 Elf_Internal_Verdaux
*iverdaux
;
4562 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
4564 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
4565 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
4567 iverdef
->vd_bfd
= abfd
;
4569 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
4572 * sizeof (Elf_Internal_Verdaux
))));
4573 if (iverdef
->vd_auxptr
== NULL
)
4576 everdaux
= ((Elf_External_Verdaux
*)
4577 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
4578 iverdaux
= iverdef
->vd_auxptr
;
4579 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
4581 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
4583 iverdaux
->vda_nodename
=
4584 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4585 iverdaux
->vda_name
);
4586 if (iverdaux
->vda_nodename
== NULL
)
4589 if (j
+ 1 < iverdef
->vd_cnt
)
4590 iverdaux
->vda_nextptr
= iverdaux
+ 1;
4592 iverdaux
->vda_nextptr
= NULL
;
4594 everdaux
= ((Elf_External_Verdaux
*)
4595 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
4598 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
4600 if (i
+ 1 < hdr
->sh_info
)
4601 iverdef
->vd_nextdef
= iverdef
+ 1;
4603 iverdef
->vd_nextdef
= NULL
;
4605 everdef
= ((Elf_External_Verdef
*)
4606 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4613 if (elf_dynverref (abfd
) != 0)
4615 Elf_Internal_Shdr
*hdr
;
4616 Elf_External_Verneed
*everneed
;
4617 Elf_Internal_Verneed
*iverneed
;
4620 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4622 elf_tdata (abfd
)->verref
=
4623 ((Elf_Internal_Verneed
*)
4624 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4625 if (elf_tdata (abfd
)->verref
== NULL
)
4628 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4630 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4631 if (contents
== NULL
)
4633 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4634 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4637 everneed
= (Elf_External_Verneed
*) contents
;
4638 iverneed
= elf_tdata (abfd
)->verref
;
4639 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4641 Elf_External_Vernaux
*evernaux
;
4642 Elf_Internal_Vernaux
*ivernaux
;
4645 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4647 iverneed
->vn_bfd
= abfd
;
4649 iverneed
->vn_filename
=
4650 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4652 if (iverneed
->vn_filename
== NULL
)
4655 iverneed
->vn_auxptr
=
4656 ((Elf_Internal_Vernaux
*)
4658 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4660 evernaux
= ((Elf_External_Vernaux
*)
4661 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4662 ivernaux
= iverneed
->vn_auxptr
;
4663 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4665 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4667 ivernaux
->vna_nodename
=
4668 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4669 ivernaux
->vna_name
);
4670 if (ivernaux
->vna_nodename
== NULL
)
4673 if (j
+ 1 < iverneed
->vn_cnt
)
4674 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4676 ivernaux
->vna_nextptr
= NULL
;
4678 evernaux
= ((Elf_External_Vernaux
*)
4679 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4682 if (i
+ 1 < hdr
->sh_info
)
4683 iverneed
->vn_nextref
= iverneed
+ 1;
4685 iverneed
->vn_nextref
= NULL
;
4687 everneed
= ((Elf_External_Verneed
*)
4688 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4698 if (contents
== NULL
)
4704 _bfd_elf_make_empty_symbol (abfd
)
4707 elf_symbol_type
*newsym
;
4709 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4714 newsym
->symbol
.the_bfd
= abfd
;
4715 return &newsym
->symbol
;
4720 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4721 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4725 bfd_symbol_info (symbol
, ret
);
4728 /* Return whether a symbol name implies a local symbol. Most targets
4729 use this function for the is_local_label_name entry point, but some
4733 _bfd_elf_is_local_label_name (abfd
, name
)
4734 bfd
*abfd ATTRIBUTE_UNUSED
;
4737 /* Normal local symbols start with ``.L''. */
4738 if (name
[0] == '.' && name
[1] == 'L')
4741 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4742 DWARF debugging symbols starting with ``..''. */
4743 if (name
[0] == '.' && name
[1] == '.')
4746 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4747 emitting DWARF debugging output. I suspect this is actually a
4748 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4749 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4750 underscore to be emitted on some ELF targets). For ease of use,
4751 we treat such symbols as local. */
4752 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4759 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4760 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4761 asymbol
*symbol ATTRIBUTE_UNUSED
;
4768 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4770 enum bfd_architecture arch
;
4771 unsigned long machine
;
4773 /* If this isn't the right architecture for this backend, and this
4774 isn't the generic backend, fail. */
4775 if (arch
!= get_elf_backend_data (abfd
)->arch
4776 && arch
!= bfd_arch_unknown
4777 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4780 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4783 /* Find the nearest line to a particular section and offset, for error
4787 _bfd_elf_find_nearest_line (abfd
,
4798 CONST
char **filename_ptr
;
4799 CONST
char **functionname_ptr
;
4800 unsigned int *line_ptr
;
4803 const char *filename
;
4808 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
4809 filename_ptr
, functionname_ptr
,
4813 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4814 filename_ptr
, functionname_ptr
,
4818 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4819 &found
, filename_ptr
,
4820 functionname_ptr
, line_ptr
,
4821 &elf_tdata (abfd
)->line_info
))
4826 if (symbols
== NULL
)
4833 for (p
= symbols
; *p
!= NULL
; p
++)
4837 q
= (elf_symbol_type
*) *p
;
4839 if (bfd_get_section (&q
->symbol
) != section
)
4842 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4847 filename
= bfd_asymbol_name (&q
->symbol
);
4851 if (q
->symbol
.section
== section
4852 && q
->symbol
.value
>= low_func
4853 && q
->symbol
.value
<= offset
)
4855 func
= (asymbol
*) q
;
4856 low_func
= q
->symbol
.value
;
4865 *filename_ptr
= filename
;
4866 *functionname_ptr
= bfd_asymbol_name (func
);
4872 _bfd_elf_sizeof_headers (abfd
, reloc
)
4878 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4880 ret
+= get_program_header_size (abfd
);
4885 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4890 bfd_size_type count
;
4892 Elf_Internal_Shdr
*hdr
;
4894 if (! abfd
->output_has_begun
4895 && ! _bfd_elf_compute_section_file_positions
4896 (abfd
, (struct bfd_link_info
*) NULL
))
4899 hdr
= &elf_section_data (section
)->this_hdr
;
4901 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4903 if (bfd_write (location
, 1, count
, abfd
) != count
)
4910 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4911 bfd
*abfd ATTRIBUTE_UNUSED
;
4912 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
4913 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
4920 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4923 Elf_Internal_Rel
*dst
;
4929 /* Try to convert a non-ELF reloc into an ELF one. */
4932 _bfd_elf_validate_reloc (abfd
, areloc
)
4936 /* Check whether we really have an ELF howto. */
4938 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4940 bfd_reloc_code_real_type code
;
4941 reloc_howto_type
*howto
;
4943 /* Alien reloc: Try to determine its type to replace it with an
4944 equivalent ELF reloc. */
4946 if (areloc
->howto
->pc_relative
)
4948 switch (areloc
->howto
->bitsize
)
4951 code
= BFD_RELOC_8_PCREL
;
4954 code
= BFD_RELOC_12_PCREL
;
4957 code
= BFD_RELOC_16_PCREL
;
4960 code
= BFD_RELOC_24_PCREL
;
4963 code
= BFD_RELOC_32_PCREL
;
4966 code
= BFD_RELOC_64_PCREL
;
4972 howto
= bfd_reloc_type_lookup (abfd
, code
);
4974 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4976 if (howto
->pcrel_offset
)
4977 areloc
->addend
+= areloc
->address
;
4979 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4984 switch (areloc
->howto
->bitsize
)
4990 code
= BFD_RELOC_14
;
4993 code
= BFD_RELOC_16
;
4996 code
= BFD_RELOC_26
;
4999 code
= BFD_RELOC_32
;
5002 code
= BFD_RELOC_64
;
5008 howto
= bfd_reloc_type_lookup (abfd
, code
);
5012 areloc
->howto
= howto
;
5020 (*_bfd_error_handler
)
5021 (_("%s: unsupported relocation type %s"),
5022 bfd_get_filename (abfd
), areloc
->howto
->name
);
5023 bfd_set_error (bfd_error_bad_value
);
5028 _bfd_elf_close_and_cleanup (abfd
)
5031 if (bfd_get_format (abfd
) == bfd_object
)
5033 if (elf_shstrtab (abfd
) != NULL
)
5034 _bfd_stringtab_free (elf_shstrtab (abfd
));
5037 return _bfd_generic_close_and_cleanup (abfd
);
5040 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5041 in the relocation's offset. Thus we cannot allow any sort of sanity
5042 range-checking to interfere. There is nothing else to do in processing
5045 bfd_reloc_status_type
5046 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
5047 bfd
*abfd ATTRIBUTE_UNUSED
;
5048 arelent
*re ATTRIBUTE_UNUSED
;
5049 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
5050 PTR data ATTRIBUTE_UNUSED
;
5051 asection
*is ATTRIBUTE_UNUSED
;
5052 bfd
*obfd ATTRIBUTE_UNUSED
;
5053 char **errmsg ATTRIBUTE_UNUSED
;
5055 return bfd_reloc_ok
;
5059 /* Elf core file support. Much of this only works on native
5060 toolchains, since we rely on knowing the
5061 machine-dependent procfs structure in order to pick
5062 out details about the corefile. */
5064 #ifdef HAVE_SYS_PROCFS_H
5065 # include <sys/procfs.h>
5069 /* Define offsetof for those systems which lack it. */
5072 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
5076 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5079 elfcore_make_pid (abfd
)
5082 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
5083 + (elf_tdata (abfd
)->core_pid
));
5087 /* If there isn't a section called NAME, make one, using
5088 data from SECT. Note, this function will generate a
5089 reference to NAME, so you shouldn't deallocate or
5093 elfcore_maybe_make_sect (abfd
, name
, sect
)
5100 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
5103 sect2
= bfd_make_section (abfd
, name
);
5107 sect2
->_raw_size
= sect
->_raw_size
;
5108 sect2
->filepos
= sect
->filepos
;
5109 sect2
->flags
= sect
->flags
;
5110 sect2
->alignment_power
= sect
->alignment_power
;
5115 /* prstatus_t exists on:
5117 linux 2.[01] + glibc
5121 #if defined (HAVE_PRSTATUS_T)
5123 elfcore_grok_prstatus (abfd
, note
)
5125 Elf_Internal_Note
* note
;
5132 if (note
->descsz
== sizeof (prstatus_t
))
5136 raw_size
= sizeof (prstat
.pr_reg
);
5137 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5139 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5140 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5142 /* pr_who exists on:
5145 pr_who doesn't exist on:
5148 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5149 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5152 #if defined (__sparcv9)
5153 else if (note
->descsz
== sizeof (prstatus32_t
))
5155 /* 64-bit host, 32-bit corefile */
5156 prstatus32_t prstat
;
5158 raw_size
= sizeof (prstat
.pr_reg
);
5159 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5161 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5162 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5164 /* pr_who exists on:
5167 pr_who doesn't exist on:
5170 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5171 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5174 #endif /* __sparcv9 */
5177 /* Fail - we don't know how to handle any other
5178 note size (ie. data object type). */
5182 /* Make a ".reg/999" section. */
5184 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5185 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5190 sect
= bfd_make_section (abfd
, name
);
5194 if (note
->descsz
== sizeof (prstatus_t
))
5196 sect
->_raw_size
= raw_size
;
5197 sect
->filepos
= note
->descpos
+ offsetof (prstatus_t
, pr_reg
);
5199 #if defined (__sparcv9)
5200 else if (note
->descsz
== sizeof (prstatus32_t
))
5202 sect
->_raw_size
= raw_size
;
5203 sect
->filepos
= note
->descpos
+ offsetof (prstatus32_t
, pr_reg
);
5207 sect
->flags
= SEC_HAS_CONTENTS
;
5208 sect
->alignment_power
= 2;
5210 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5215 #endif /* defined (HAVE_PRSTATUS_T) */
5218 /* Create a pseudosection containing the exact contents of NOTE. This
5219 actually creates up to two pseudosections:
5220 - For the single-threaded case, a section named NAME, unless
5221 such a section already exists.
5222 - For the multi-threaded case, a section named "NAME/PID", where
5223 PID is elfcore_make_pid (abfd).
5224 Both pseudosections have identical contents: the contents of NOTE. */
5227 elfcore_make_note_pseudosection (abfd
, name
, note
)
5230 Elf_Internal_Note
* note
;
5233 char *threaded_name
;
5236 /* Build the section name. */
5238 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
5239 threaded_name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5240 if (threaded_name
== NULL
)
5242 strcpy (threaded_name
, buf
);
5244 sect
= bfd_make_section (abfd
, threaded_name
);
5247 sect
->_raw_size
= note
->descsz
;
5248 sect
->filepos
= note
->descpos
;
5249 sect
->flags
= SEC_HAS_CONTENTS
;
5250 sect
->alignment_power
= 2;
5252 if (! elfcore_maybe_make_sect (abfd
, name
, sect
))
5259 /* There isn't a consistent prfpregset_t across platforms,
5260 but it doesn't matter, because we don't have to pick this
5261 data structure apart. */
5263 elfcore_grok_prfpreg (abfd
, note
)
5265 Elf_Internal_Note
* note
;
5267 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
5271 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5272 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5275 elfcore_grok_prxfpreg (abfd
, note
)
5277 Elf_Internal_Note
* note
;
5279 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
5283 #if defined (HAVE_PRPSINFO_T)
5284 typedef prpsinfo_t elfcore_psinfo_t
;
5285 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5286 typedef prpsinfo32_t elfcore_psinfo32_t
;
5290 #if defined (HAVE_PSINFO_T)
5291 typedef psinfo_t elfcore_psinfo_t
;
5292 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5293 typedef psinfo32_t elfcore_psinfo32_t
;
5298 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5300 /* return a malloc'ed copy of a string at START which is at
5301 most MAX bytes long, possibly without a terminating '\0'.
5302 the copy will always have a terminating '\0'. */
5305 elfcore_strndup (abfd
, start
, max
)
5311 char* end
= memchr (start
, '\0', max
);
5319 dup
= bfd_alloc (abfd
, len
+ 1);
5323 memcpy (dup
, start
, len
);
5330 elfcore_grok_psinfo (abfd
, note
)
5332 Elf_Internal_Note
* note
;
5334 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
5336 elfcore_psinfo_t psinfo
;
5338 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5340 elf_tdata (abfd
)->core_program
5341 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5343 elf_tdata (abfd
)->core_command
5344 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5346 #if defined (__sparcv9)
5347 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
5349 /* 64-bit host, 32-bit corefile */
5350 elfcore_psinfo32_t psinfo
;
5352 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5354 elf_tdata (abfd
)->core_program
5355 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5357 elf_tdata (abfd
)->core_command
5358 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5364 /* Fail - we don't know how to handle any other
5365 note size (ie. data object type). */
5369 /* Note that for some reason, a spurious space is tacked
5370 onto the end of the args in some (at least one anyway)
5371 implementations, so strip it off if it exists. */
5374 char* command
= elf_tdata (abfd
)->core_command
;
5375 int n
= strlen (command
);
5377 if (0 < n
&& command
[n
- 1] == ' ')
5378 command
[n
- 1] = '\0';
5383 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5386 #if defined (HAVE_PSTATUS_T)
5388 elfcore_grok_pstatus (abfd
, note
)
5390 Elf_Internal_Note
* note
;
5392 if (note
->descsz
== sizeof (pstatus_t
))
5396 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5398 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5400 #if defined (__sparcv9)
5401 else if (note
->descsz
== sizeof (pstatus32_t
))
5403 /* 64-bit host, 32-bit corefile */
5406 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5408 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5411 /* Could grab some more details from the "representative"
5412 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5413 NT_LWPSTATUS note, presumably. */
5417 #endif /* defined (HAVE_PSTATUS_T) */
5420 #if defined (HAVE_LWPSTATUS_T)
5422 elfcore_grok_lwpstatus (abfd
, note
)
5424 Elf_Internal_Note
* note
;
5426 lwpstatus_t lwpstat
;
5431 if (note
->descsz
!= sizeof (lwpstat
))
5434 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
5436 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
5437 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
5439 /* Make a ".reg/999" section. */
5441 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5442 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5447 sect
= bfd_make_section (abfd
, name
);
5451 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5452 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
5453 sect
->filepos
= note
->descpos
5454 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
5457 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5458 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
5459 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
5462 sect
->flags
= SEC_HAS_CONTENTS
;
5463 sect
->alignment_power
= 2;
5465 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5468 /* Make a ".reg2/999" section */
5470 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
5471 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5476 sect
= bfd_make_section (abfd
, name
);
5480 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5481 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
5482 sect
->filepos
= note
->descpos
5483 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
5486 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5487 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
5488 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
5491 sect
->flags
= SEC_HAS_CONTENTS
;
5492 sect
->alignment_power
= 2;
5494 if (!elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
5499 #endif /* defined (HAVE_LWPSTATUS_T) */
5501 #if defined (HAVE_WIN32_PSTATUS_T)
5503 elfcore_grok_win32pstatus (abfd
, note
)
5505 Elf_Internal_Note
* note
;
5510 win32_pstatus_t pstatus
;
5512 if (note
->descsz
< sizeof (pstatus
))
5515 memcpy (& pstatus
, note
->descdata
, note
->descsz
);
5517 switch (pstatus
.data_type
)
5519 case NOTE_INFO_PROCESS
:
5520 /* FIXME: need to add ->core_command. */
5521 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
5522 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
5525 case NOTE_INFO_THREAD
:
5526 /* Make a ".reg/999" section. */
5527 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
5529 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5535 sect
= bfd_make_section (abfd
, name
);
5539 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
5540 sect
->filepos
= note
->descpos
+ offsetof (struct win32_pstatus
,
5541 data
.thread_info
.thread_context
);
5542 sect
->flags
= SEC_HAS_CONTENTS
;
5543 sect
->alignment_power
= 2;
5545 if (pstatus
.data
.thread_info
.is_active_thread
)
5546 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5550 case NOTE_INFO_MODULE
:
5551 /* Make a ".module/xxxxxxxx" section. */
5552 sprintf (buf
, ".module/%08x" , pstatus
.data
.module_info
.base_address
);
5554 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5560 sect
= bfd_make_section (abfd
, name
);
5565 sect
->_raw_size
= note
->descsz
;
5566 sect
->filepos
= note
->descpos
;
5567 sect
->flags
= SEC_HAS_CONTENTS
;
5568 sect
->alignment_power
= 2;
5577 #endif /* HAVE_WIN32_PSTATUS_T */
5580 elfcore_grok_note (abfd
, note
)
5582 Elf_Internal_Note
* note
;
5589 #if defined (HAVE_PRSTATUS_T)
5591 return elfcore_grok_prstatus (abfd
, note
);
5594 #if defined (HAVE_PSTATUS_T)
5596 return elfcore_grok_pstatus (abfd
, note
);
5599 #if defined (HAVE_LWPSTATUS_T)
5601 return elfcore_grok_lwpstatus (abfd
, note
);
5604 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
5605 return elfcore_grok_prfpreg (abfd
, note
);
5607 #if defined (HAVE_WIN32_PSTATUS_T)
5608 case NT_WIN32PSTATUS
:
5609 return elfcore_grok_win32pstatus (abfd
, note
);
5612 case NT_PRXFPREG
: /* Linux SSE extension */
5613 if (note
->namesz
== 5
5614 && ! strcmp (note
->namedata
, "LINUX"))
5615 return elfcore_grok_prxfpreg (abfd
, note
);
5619 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5622 return elfcore_grok_psinfo (abfd
, note
);
5629 elfcore_read_notes (abfd
, offset
, size
)
5640 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
5643 buf
= bfd_malloc ((size_t) size
);
5647 if (bfd_read (buf
, size
, 1, abfd
) != size
)
5655 while (p
< buf
+ size
)
5657 /* FIXME: bad alignment assumption. */
5658 Elf_External_Note
* xnp
= (Elf_External_Note
*) p
;
5659 Elf_Internal_Note in
;
5661 in
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->type
);
5663 in
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->namesz
);
5664 in
.namedata
= xnp
->name
;
5666 in
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->descsz
);
5667 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
5668 in
.descpos
= offset
+ (in
.descdata
- buf
);
5670 if (! elfcore_grok_note (abfd
, &in
))
5673 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
5681 /* FIXME: This function is now unnecessary. Callers can just call
5682 bfd_section_from_phdr directly. */
5685 _bfd_elfcore_section_from_phdr (abfd
, phdr
, sec_num
)
5687 Elf_Internal_Phdr
* phdr
;
5690 if (! bfd_section_from_phdr (abfd
, phdr
, sec_num
))
5698 /* Providing external access to the ELF program header table. */
5700 /* Return an upper bound on the number of bytes required to store a
5701 copy of ABFD's program header table entries. Return -1 if an error
5702 occurs; bfd_get_error will return an appropriate code. */
5704 bfd_get_elf_phdr_upper_bound (abfd
)
5707 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5709 bfd_set_error (bfd_error_wrong_format
);
5713 return (elf_elfheader (abfd
)->e_phnum
5714 * sizeof (Elf_Internal_Phdr
));
5718 /* Copy ABFD's program header table entries to *PHDRS. The entries
5719 will be stored as an array of Elf_Internal_Phdr structures, as
5720 defined in include/elf/internal.h. To find out how large the
5721 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5723 Return the number of program header table entries read, or -1 if an
5724 error occurs; bfd_get_error will return an appropriate code. */
5726 bfd_get_elf_phdrs (abfd
, phdrs
)
5732 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5734 bfd_set_error (bfd_error_wrong_format
);
5738 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
5739 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
5740 num_phdrs
* sizeof (Elf_Internal_Phdr
));