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(info
, h
)
958 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
959 struct elf_link_hash_entry
*h
;
961 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
963 h
->plt
.offset
= (bfd_vma
) -1;
966 /* Initialize an ELF linker hash table. */
969 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
970 struct elf_link_hash_table
*table
;
972 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
973 struct bfd_hash_table
*,
976 table
->dynamic_sections_created
= false;
977 table
->dynobj
= NULL
;
978 /* The first dynamic symbol is a dummy. */
979 table
->dynsymcount
= 1;
980 table
->dynstr
= NULL
;
981 table
->bucketcount
= 0;
982 table
->needed
= NULL
;
984 table
->stab_info
= NULL
;
985 table
->dynlocal
= NULL
;
986 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
989 /* Create an ELF linker hash table. */
991 struct bfd_link_hash_table
*
992 _bfd_elf_link_hash_table_create (abfd
)
995 struct elf_link_hash_table
*ret
;
997 ret
= ((struct elf_link_hash_table
*)
998 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
999 if (ret
== (struct elf_link_hash_table
*) NULL
)
1002 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1004 bfd_release (abfd
, ret
);
1011 /* This is a hook for the ELF emulation code in the generic linker to
1012 tell the backend linker what file name to use for the DT_NEEDED
1013 entry for a dynamic object. The generic linker passes name as an
1014 empty string to indicate that no DT_NEEDED entry should be made. */
1017 bfd_elf_set_dt_needed_name (abfd
, name
)
1021 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1022 && bfd_get_format (abfd
) == bfd_object
)
1023 elf_dt_name (abfd
) = name
;
1026 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1027 the linker ELF emulation code. */
1029 struct bfd_link_needed_list
*
1030 bfd_elf_get_needed_list (abfd
, info
)
1031 bfd
*abfd ATTRIBUTE_UNUSED
;
1032 struct bfd_link_info
*info
;
1034 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1036 return elf_hash_table (info
)->needed
;
1039 /* Get the name actually used for a dynamic object for a link. This
1040 is the SONAME entry if there is one. Otherwise, it is the string
1041 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1044 bfd_elf_get_dt_soname (abfd
)
1047 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1048 && bfd_get_format (abfd
) == bfd_object
)
1049 return elf_dt_name (abfd
);
1053 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1054 the ELF linker emulation code. */
1057 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1059 struct bfd_link_needed_list
**pneeded
;
1062 bfd_byte
*dynbuf
= NULL
;
1065 bfd_byte
*extdyn
, *extdynend
;
1067 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1071 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1072 || bfd_get_format (abfd
) != bfd_object
)
1075 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1076 if (s
== NULL
|| s
->_raw_size
== 0)
1079 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1083 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1087 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1091 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1093 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1094 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1097 extdynend
= extdyn
+ s
->_raw_size
;
1098 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1100 Elf_Internal_Dyn dyn
;
1102 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1104 if (dyn
.d_tag
== DT_NULL
)
1107 if (dyn
.d_tag
== DT_NEEDED
)
1110 struct bfd_link_needed_list
*l
;
1112 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1117 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1138 /* Allocate an ELF string table--force the first byte to be zero. */
1140 struct bfd_strtab_hash
*
1141 _bfd_elf_stringtab_init ()
1143 struct bfd_strtab_hash
*ret
;
1145 ret
= _bfd_stringtab_init ();
1150 loc
= _bfd_stringtab_add (ret
, "", true, false);
1151 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1152 if (loc
== (bfd_size_type
) -1)
1154 _bfd_stringtab_free (ret
);
1161 /* ELF .o/exec file reading */
1163 /* Create a new bfd section from an ELF section header. */
1166 bfd_section_from_shdr (abfd
, shindex
)
1168 unsigned int shindex
;
1170 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1171 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1172 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1175 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1177 switch (hdr
->sh_type
)
1180 /* Inactive section. Throw it away. */
1183 case SHT_PROGBITS
: /* Normal section with contents. */
1184 case SHT_DYNAMIC
: /* Dynamic linking information. */
1185 case SHT_NOBITS
: /* .bss section. */
1186 case SHT_HASH
: /* .hash section. */
1187 case SHT_NOTE
: /* .note section. */
1188 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1190 case SHT_SYMTAB
: /* A symbol table */
1191 if (elf_onesymtab (abfd
) == shindex
)
1194 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1195 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1196 elf_onesymtab (abfd
) = shindex
;
1197 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1198 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1199 abfd
->flags
|= HAS_SYMS
;
1201 /* Sometimes a shared object will map in the symbol table. If
1202 SHF_ALLOC is set, and this is a shared object, then we also
1203 treat this section as a BFD section. We can not base the
1204 decision purely on SHF_ALLOC, because that flag is sometimes
1205 set in a relocateable object file, which would confuse the
1207 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1208 && (abfd
->flags
& DYNAMIC
) != 0
1209 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1214 case SHT_DYNSYM
: /* A dynamic symbol table */
1215 if (elf_dynsymtab (abfd
) == shindex
)
1218 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1219 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1220 elf_dynsymtab (abfd
) = shindex
;
1221 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1222 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1223 abfd
->flags
|= HAS_SYMS
;
1225 /* Besides being a symbol table, we also treat this as a regular
1226 section, so that objcopy can handle it. */
1227 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1229 case SHT_STRTAB
: /* A string table */
1230 if (hdr
->bfd_section
!= NULL
)
1232 if (ehdr
->e_shstrndx
== shindex
)
1234 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1235 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1241 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1243 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1244 if (hdr2
->sh_link
== shindex
)
1246 if (! bfd_section_from_shdr (abfd
, i
))
1248 if (elf_onesymtab (abfd
) == i
)
1250 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1251 elf_elfsections (abfd
)[shindex
] =
1252 &elf_tdata (abfd
)->strtab_hdr
;
1255 if (elf_dynsymtab (abfd
) == i
)
1257 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1258 elf_elfsections (abfd
)[shindex
] = hdr
=
1259 &elf_tdata (abfd
)->dynstrtab_hdr
;
1260 /* We also treat this as a regular section, so
1261 that objcopy can handle it. */
1264 #if 0 /* Not handling other string tables specially right now. */
1265 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1266 /* We have a strtab for some random other section. */
1267 newsect
= (asection
*) hdr2
->bfd_section
;
1270 hdr
->bfd_section
= newsect
;
1271 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1273 elf_elfsections (abfd
)[shindex
] = hdr2
;
1279 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1283 /* *These* do a lot of work -- but build no sections! */
1285 asection
*target_sect
;
1286 Elf_Internal_Shdr
*hdr2
;
1288 /* Check for a bogus link to avoid crashing. */
1289 if (hdr
->sh_link
>= ehdr
->e_shnum
)
1291 ((*_bfd_error_handler
)
1292 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1293 bfd_get_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1294 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1297 /* For some incomprehensible reason Oracle distributes
1298 libraries for Solaris in which some of the objects have
1299 bogus sh_link fields. It would be nice if we could just
1300 reject them, but, unfortunately, some people need to use
1301 them. We scan through the section headers; if we find only
1302 one suitable symbol table, we clobber the sh_link to point
1303 to it. I hope this doesn't break anything. */
1304 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1305 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1311 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1313 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1314 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1325 hdr
->sh_link
= found
;
1328 /* Get the symbol table. */
1329 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1330 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1333 /* If this reloc section does not use the main symbol table we
1334 don't treat it as a reloc section. BFD can't adequately
1335 represent such a section, so at least for now, we don't
1336 try. We just present it as a normal section. We also
1337 can't use it as a reloc section if it points to the null
1339 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1340 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1342 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1344 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1345 if (target_sect
== NULL
)
1348 if ((target_sect
->flags
& SEC_RELOC
) == 0
1349 || target_sect
->reloc_count
== 0)
1350 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1353 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1354 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1355 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1358 elf_elfsections (abfd
)[shindex
] = hdr2
;
1359 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1360 target_sect
->flags
|= SEC_RELOC
;
1361 target_sect
->relocation
= NULL
;
1362 target_sect
->rel_filepos
= hdr
->sh_offset
;
1363 /* In the section to which the relocations apply, mark whether
1364 its relocations are of the REL or RELA variety. */
1365 if (hdr
->sh_size
!= 0)
1366 elf_section_data (target_sect
)->use_rela_p
1367 = (hdr
->sh_type
== SHT_RELA
);
1368 abfd
->flags
|= HAS_RELOC
;
1373 case SHT_GNU_verdef
:
1374 elf_dynverdef (abfd
) = shindex
;
1375 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1376 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1379 case SHT_GNU_versym
:
1380 elf_dynversym (abfd
) = shindex
;
1381 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1382 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1385 case SHT_GNU_verneed
:
1386 elf_dynverref (abfd
) = shindex
;
1387 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1388 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1395 /* Check for any processor-specific section types. */
1397 if (bed
->elf_backend_section_from_shdr
)
1398 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1406 /* Given an ELF section number, retrieve the corresponding BFD
1410 bfd_section_from_elf_index (abfd
, index
)
1414 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1415 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1417 return elf_elfsections (abfd
)[index
]->bfd_section
;
1421 _bfd_elf_new_section_hook (abfd
, sec
)
1425 struct bfd_elf_section_data
*sdata
;
1427 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, sizeof (*sdata
));
1430 sec
->used_by_bfd
= (PTR
) sdata
;
1432 /* Indicate whether or not this section should use RELA relocations. */
1434 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1439 /* Create a new bfd section from an ELF program header.
1441 Since program segments have no names, we generate a synthetic name
1442 of the form segment<NUM>, where NUM is generally the index in the
1443 program header table. For segments that are split (see below) we
1444 generate the names segment<NUM>a and segment<NUM>b.
1446 Note that some program segments may have a file size that is different than
1447 (less than) the memory size. All this means is that at execution the
1448 system must allocate the amount of memory specified by the memory size,
1449 but only initialize it with the first "file size" bytes read from the
1450 file. This would occur for example, with program segments consisting
1451 of combined data+bss.
1453 To handle the above situation, this routine generates TWO bfd sections
1454 for the single program segment. The first has the length specified by
1455 the file size of the segment, and the second has the length specified
1456 by the difference between the two sizes. In effect, the segment is split
1457 into it's initialized and uninitialized parts.
1462 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
1464 Elf_Internal_Phdr
*hdr
;
1466 const char *typename
;
1473 split
= ((hdr
->p_memsz
> 0)
1474 && (hdr
->p_filesz
> 0)
1475 && (hdr
->p_memsz
> hdr
->p_filesz
));
1476 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
1477 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1480 strcpy (name
, namebuf
);
1481 newsect
= bfd_make_section (abfd
, name
);
1482 if (newsect
== NULL
)
1484 newsect
->vma
= hdr
->p_vaddr
;
1485 newsect
->lma
= hdr
->p_paddr
;
1486 newsect
->_raw_size
= hdr
->p_filesz
;
1487 newsect
->filepos
= hdr
->p_offset
;
1488 newsect
->flags
|= SEC_HAS_CONTENTS
;
1489 if (hdr
->p_type
== PT_LOAD
)
1491 newsect
->flags
|= SEC_ALLOC
;
1492 newsect
->flags
|= SEC_LOAD
;
1493 if (hdr
->p_flags
& PF_X
)
1495 /* FIXME: all we known is that it has execute PERMISSION,
1497 newsect
->flags
|= SEC_CODE
;
1500 if (!(hdr
->p_flags
& PF_W
))
1502 newsect
->flags
|= SEC_READONLY
;
1507 sprintf (namebuf
, "%s%db", typename
, index
);
1508 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1511 strcpy (name
, namebuf
);
1512 newsect
= bfd_make_section (abfd
, name
);
1513 if (newsect
== NULL
)
1515 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1516 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1517 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1518 if (hdr
->p_type
== PT_LOAD
)
1520 newsect
->flags
|= SEC_ALLOC
;
1521 if (hdr
->p_flags
& PF_X
)
1522 newsect
->flags
|= SEC_CODE
;
1524 if (!(hdr
->p_flags
& PF_W
))
1525 newsect
->flags
|= SEC_READONLY
;
1532 bfd_section_from_phdr (abfd
, hdr
, index
)
1534 Elf_Internal_Phdr
*hdr
;
1537 struct elf_backend_data
*bed
;
1539 switch (hdr
->p_type
)
1542 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
1545 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
1548 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
1551 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
1554 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
1556 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
1561 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
1564 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
1567 /* Check for any processor-specific program segment types.
1568 If no handler for them, default to making "segment" sections. */
1569 bed
= get_elf_backend_data (abfd
);
1570 if (bed
->elf_backend_section_from_phdr
)
1571 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
1573 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
1577 /* Initialize REL_HDR, the section-header for new section, containing
1578 relocations against ASECT. If USE_RELA_P is true, we use RELA
1579 relocations; otherwise, we use REL relocations. */
1582 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
1584 Elf_Internal_Shdr
*rel_hdr
;
1589 struct elf_backend_data
*bed
;
1591 bed
= get_elf_backend_data (abfd
);
1592 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1595 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1597 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1599 if (rel_hdr
->sh_name
== (unsigned int) -1)
1601 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1602 rel_hdr
->sh_entsize
= (use_rela_p
1603 ? bed
->s
->sizeof_rela
1604 : bed
->s
->sizeof_rel
);
1605 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
1606 rel_hdr
->sh_flags
= 0;
1607 rel_hdr
->sh_addr
= 0;
1608 rel_hdr
->sh_size
= 0;
1609 rel_hdr
->sh_offset
= 0;
1614 /* Set up an ELF internal section header for a section. */
1618 elf_fake_sections (abfd
, asect
, failedptrarg
)
1623 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1624 boolean
*failedptr
= (boolean
*) failedptrarg
;
1625 Elf_Internal_Shdr
*this_hdr
;
1629 /* We already failed; just get out of the bfd_map_over_sections
1634 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1636 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1639 if (this_hdr
->sh_name
== (unsigned long) -1)
1645 this_hdr
->sh_flags
= 0;
1647 if ((asect
->flags
& SEC_ALLOC
) != 0
1648 || asect
->user_set_vma
)
1649 this_hdr
->sh_addr
= asect
->vma
;
1651 this_hdr
->sh_addr
= 0;
1653 this_hdr
->sh_offset
= 0;
1654 this_hdr
->sh_size
= asect
->_raw_size
;
1655 this_hdr
->sh_link
= 0;
1656 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1657 /* The sh_entsize and sh_info fields may have been set already by
1658 copy_private_section_data. */
1660 this_hdr
->bfd_section
= asect
;
1661 this_hdr
->contents
= NULL
;
1663 /* FIXME: This should not be based on section names. */
1664 if (strcmp (asect
->name
, ".dynstr") == 0)
1665 this_hdr
->sh_type
= SHT_STRTAB
;
1666 else if (strcmp (asect
->name
, ".hash") == 0)
1668 this_hdr
->sh_type
= SHT_HASH
;
1669 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
1671 else if (strcmp (asect
->name
, ".dynsym") == 0)
1673 this_hdr
->sh_type
= SHT_DYNSYM
;
1674 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1676 else if (strcmp (asect
->name
, ".dynamic") == 0)
1678 this_hdr
->sh_type
= SHT_DYNAMIC
;
1679 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1681 else if (strncmp (asect
->name
, ".rela", 5) == 0
1682 && get_elf_backend_data (abfd
)->may_use_rela_p
)
1684 this_hdr
->sh_type
= SHT_RELA
;
1685 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1687 else if (strncmp (asect
->name
, ".rel", 4) == 0
1688 && get_elf_backend_data (abfd
)->may_use_rel_p
)
1690 this_hdr
->sh_type
= SHT_REL
;
1691 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1693 else if (strncmp (asect
->name
, ".note", 5) == 0)
1694 this_hdr
->sh_type
= SHT_NOTE
;
1695 else if (strncmp (asect
->name
, ".stab", 5) == 0
1696 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1697 this_hdr
->sh_type
= SHT_STRTAB
;
1698 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1700 this_hdr
->sh_type
= SHT_GNU_versym
;
1701 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1703 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1705 this_hdr
->sh_type
= SHT_GNU_verdef
;
1706 this_hdr
->sh_entsize
= 0;
1707 /* objcopy or strip will copy over sh_info, but may not set
1708 cverdefs. The linker will set cverdefs, but sh_info will be
1710 if (this_hdr
->sh_info
== 0)
1711 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1713 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1714 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1716 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1718 this_hdr
->sh_type
= SHT_GNU_verneed
;
1719 this_hdr
->sh_entsize
= 0;
1720 /* objcopy or strip will copy over sh_info, but may not set
1721 cverrefs. The linker will set cverrefs, but sh_info will be
1723 if (this_hdr
->sh_info
== 0)
1724 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1726 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1727 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1729 else if ((asect
->flags
& SEC_ALLOC
) != 0
1730 && (asect
->flags
& SEC_LOAD
) != 0)
1731 this_hdr
->sh_type
= SHT_PROGBITS
;
1732 else if ((asect
->flags
& SEC_ALLOC
) != 0
1733 && ((asect
->flags
& SEC_LOAD
) == 0))
1734 this_hdr
->sh_type
= SHT_NOBITS
;
1738 this_hdr
->sh_type
= SHT_PROGBITS
;
1741 if ((asect
->flags
& SEC_ALLOC
) != 0)
1742 this_hdr
->sh_flags
|= SHF_ALLOC
;
1743 if ((asect
->flags
& SEC_READONLY
) == 0)
1744 this_hdr
->sh_flags
|= SHF_WRITE
;
1745 if ((asect
->flags
& SEC_CODE
) != 0)
1746 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1748 /* Check for processor-specific section types. */
1749 if (bed
->elf_backend_fake_sections
)
1750 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1752 /* If the section has relocs, set up a section header for the
1753 SHT_REL[A] section. If two relocation sections are required for
1754 this section, it is up to the processor-specific back-end to
1755 create the other. */
1756 if ((asect
->flags
& SEC_RELOC
) != 0
1757 && !_bfd_elf_init_reloc_shdr (abfd
,
1758 &elf_section_data (asect
)->rel_hdr
,
1760 elf_section_data (asect
)->use_rela_p
))
1764 /* Assign all ELF section numbers. The dummy first section is handled here
1765 too. The link/info pointers for the standard section types are filled
1766 in here too, while we're at it. */
1769 assign_section_numbers (abfd
)
1772 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1774 unsigned int section_number
;
1775 Elf_Internal_Shdr
**i_shdrp
;
1779 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1781 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1783 d
->this_idx
= section_number
++;
1784 if ((sec
->flags
& SEC_RELOC
) == 0)
1787 d
->rel_idx
= section_number
++;
1790 d
->rel_idx2
= section_number
++;
1795 t
->shstrtab_section
= section_number
++;
1796 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1797 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1799 if (bfd_get_symcount (abfd
) > 0)
1801 t
->symtab_section
= section_number
++;
1802 t
->strtab_section
= section_number
++;
1805 elf_elfheader (abfd
)->e_shnum
= section_number
;
1807 /* Set up the list of section header pointers, in agreement with the
1809 i_shdrp
= ((Elf_Internal_Shdr
**)
1810 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1811 if (i_shdrp
== NULL
)
1814 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1815 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1816 if (i_shdrp
[0] == NULL
)
1818 bfd_release (abfd
, i_shdrp
);
1821 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1823 elf_elfsections (abfd
) = i_shdrp
;
1825 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1826 if (bfd_get_symcount (abfd
) > 0)
1828 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1829 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1830 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1832 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1834 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1838 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1839 if (d
->rel_idx
!= 0)
1840 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1841 if (d
->rel_idx2
!= 0)
1842 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
1844 /* Fill in the sh_link and sh_info fields while we're at it. */
1846 /* sh_link of a reloc section is the section index of the symbol
1847 table. sh_info is the section index of the section to which
1848 the relocation entries apply. */
1849 if (d
->rel_idx
!= 0)
1851 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1852 d
->rel_hdr
.sh_info
= d
->this_idx
;
1854 if (d
->rel_idx2
!= 0)
1856 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
1857 d
->rel_hdr2
->sh_info
= d
->this_idx
;
1860 switch (d
->this_hdr
.sh_type
)
1864 /* A reloc section which we are treating as a normal BFD
1865 section. sh_link is the section index of the symbol
1866 table. sh_info is the section index of the section to
1867 which the relocation entries apply. We assume that an
1868 allocated reloc section uses the dynamic symbol table.
1869 FIXME: How can we be sure? */
1870 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1872 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1874 /* We look up the section the relocs apply to by name. */
1876 if (d
->this_hdr
.sh_type
== SHT_REL
)
1880 s
= bfd_get_section_by_name (abfd
, name
);
1882 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1886 /* We assume that a section named .stab*str is a stabs
1887 string section. We look for a section with the same name
1888 but without the trailing ``str'', and set its sh_link
1889 field to point to this section. */
1890 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1891 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1896 len
= strlen (sec
->name
);
1897 alc
= (char *) bfd_malloc (len
- 2);
1900 strncpy (alc
, sec
->name
, len
- 3);
1901 alc
[len
- 3] = '\0';
1902 s
= bfd_get_section_by_name (abfd
, alc
);
1906 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1908 /* This is a .stab section. */
1909 elf_section_data (s
)->this_hdr
.sh_entsize
=
1910 4 + 2 * bfd_get_arch_size (abfd
) / 8;
1917 case SHT_GNU_verneed
:
1918 case SHT_GNU_verdef
:
1919 /* sh_link is the section header index of the string table
1920 used for the dynamic entries, or the symbol table, or the
1922 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1924 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1928 case SHT_GNU_versym
:
1929 /* sh_link is the section header index of the symbol table
1930 this hash table or version table is for. */
1931 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1933 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1941 /* Map symbol from it's internal number to the external number, moving
1942 all local symbols to be at the head of the list. */
1945 sym_is_global (abfd
, sym
)
1949 /* If the backend has a special mapping, use it. */
1950 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1951 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1954 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1955 || bfd_is_und_section (bfd_get_section (sym
))
1956 || bfd_is_com_section (bfd_get_section (sym
)));
1960 elf_map_symbols (abfd
)
1963 int symcount
= bfd_get_symcount (abfd
);
1964 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1965 asymbol
**sect_syms
;
1967 int num_globals
= 0;
1968 int num_locals2
= 0;
1969 int num_globals2
= 0;
1971 int num_sections
= 0;
1978 fprintf (stderr
, "elf_map_symbols\n");
1982 /* Add a section symbol for each BFD section. FIXME: Is this really
1984 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1986 if (max_index
< asect
->index
)
1987 max_index
= asect
->index
;
1991 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1992 if (sect_syms
== NULL
)
1994 elf_section_syms (abfd
) = sect_syms
;
1996 for (idx
= 0; idx
< symcount
; idx
++)
2000 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2007 if (sec
->owner
!= NULL
)
2009 if (sec
->owner
!= abfd
)
2011 if (sec
->output_offset
!= 0)
2014 sec
= sec
->output_section
;
2016 /* Empty sections in the input files may have had a section
2017 symbol created for them. (See the comment near the end of
2018 _bfd_generic_link_output_symbols in linker.c). If the linker
2019 script discards such sections then we will reach this point.
2020 Since we know that we cannot avoid this case, we detect it
2021 and skip the abort and the assignment to the sect_syms array.
2022 To reproduce this particular case try running the linker
2023 testsuite test ld-scripts/weak.exp for an ELF port that uses
2024 the generic linker. */
2025 if (sec
->owner
== NULL
)
2028 BFD_ASSERT (sec
->owner
== abfd
);
2030 sect_syms
[sec
->index
] = syms
[idx
];
2035 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2037 if (sect_syms
[asect
->index
] != NULL
)
2040 sym
= bfd_make_empty_symbol (abfd
);
2043 sym
->the_bfd
= abfd
;
2044 sym
->name
= asect
->name
;
2046 /* Set the flags to 0 to indicate that this one was newly added. */
2048 sym
->section
= asect
;
2049 sect_syms
[asect
->index
] = sym
;
2053 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
2054 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
2058 /* Classify all of the symbols. */
2059 for (idx
= 0; idx
< symcount
; idx
++)
2061 if (!sym_is_global (abfd
, syms
[idx
]))
2066 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2068 if (sect_syms
[asect
->index
] != NULL
2069 && sect_syms
[asect
->index
]->flags
== 0)
2071 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
2072 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
2076 sect_syms
[asect
->index
]->flags
= 0;
2080 /* Now sort the symbols so the local symbols are first. */
2081 new_syms
= ((asymbol
**)
2083 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
2084 if (new_syms
== NULL
)
2087 for (idx
= 0; idx
< symcount
; idx
++)
2089 asymbol
*sym
= syms
[idx
];
2092 if (!sym_is_global (abfd
, sym
))
2095 i
= num_locals
+ num_globals2
++;
2097 sym
->udata
.i
= i
+ 1;
2099 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2101 if (sect_syms
[asect
->index
] != NULL
2102 && sect_syms
[asect
->index
]->flags
== 0)
2104 asymbol
*sym
= sect_syms
[asect
->index
];
2107 sym
->flags
= BSF_SECTION_SYM
;
2108 if (!sym_is_global (abfd
, sym
))
2111 i
= num_locals
+ num_globals2
++;
2113 sym
->udata
.i
= i
+ 1;
2117 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2119 elf_num_locals (abfd
) = num_locals
;
2120 elf_num_globals (abfd
) = num_globals
;
2124 /* Align to the maximum file alignment that could be required for any
2125 ELF data structure. */
2127 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2128 static INLINE file_ptr
2129 align_file_position (off
, align
)
2133 return (off
+ align
- 1) & ~(align
- 1);
2136 /* Assign a file position to a section, optionally aligning to the
2137 required section alignment. */
2140 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2141 Elf_Internal_Shdr
*i_shdrp
;
2149 al
= i_shdrp
->sh_addralign
;
2151 offset
= BFD_ALIGN (offset
, al
);
2153 i_shdrp
->sh_offset
= offset
;
2154 if (i_shdrp
->bfd_section
!= NULL
)
2155 i_shdrp
->bfd_section
->filepos
= offset
;
2156 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2157 offset
+= i_shdrp
->sh_size
;
2161 /* Compute the file positions we are going to put the sections at, and
2162 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2163 is not NULL, this is being called by the ELF backend linker. */
2166 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2168 struct bfd_link_info
*link_info
;
2170 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2172 struct bfd_strtab_hash
*strtab
;
2173 Elf_Internal_Shdr
*shstrtab_hdr
;
2175 if (abfd
->output_has_begun
)
2178 /* Do any elf backend specific processing first. */
2179 if (bed
->elf_backend_begin_write_processing
)
2180 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2182 if (! prep_headers (abfd
))
2185 /* Post process the headers if necessary. */
2186 if (bed
->elf_backend_post_process_headers
)
2187 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2190 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2194 if (!assign_section_numbers (abfd
))
2197 /* The backend linker builds symbol table information itself. */
2198 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2200 /* Non-zero if doing a relocatable link. */
2201 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2203 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2207 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2208 /* sh_name was set in prep_headers. */
2209 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2210 shstrtab_hdr
->sh_flags
= 0;
2211 shstrtab_hdr
->sh_addr
= 0;
2212 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
2213 shstrtab_hdr
->sh_entsize
= 0;
2214 shstrtab_hdr
->sh_link
= 0;
2215 shstrtab_hdr
->sh_info
= 0;
2216 /* sh_offset is set in assign_file_positions_except_relocs. */
2217 shstrtab_hdr
->sh_addralign
= 1;
2219 if (!assign_file_positions_except_relocs (abfd
))
2222 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2225 Elf_Internal_Shdr
*hdr
;
2227 off
= elf_tdata (abfd
)->next_file_pos
;
2229 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2230 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2232 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2233 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2235 elf_tdata (abfd
)->next_file_pos
= off
;
2237 /* Now that we know where the .strtab section goes, write it
2239 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2240 || ! _bfd_stringtab_emit (abfd
, strtab
))
2242 _bfd_stringtab_free (strtab
);
2245 abfd
->output_has_begun
= true;
2250 /* Create a mapping from a set of sections to a program segment. */
2252 static INLINE
struct elf_segment_map
*
2253 make_mapping (abfd
, sections
, from
, to
, phdr
)
2255 asection
**sections
;
2260 struct elf_segment_map
*m
;
2264 m
= ((struct elf_segment_map
*)
2266 (sizeof (struct elf_segment_map
)
2267 + (to
- from
- 1) * sizeof (asection
*))));
2271 m
->p_type
= PT_LOAD
;
2272 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2273 m
->sections
[i
- from
] = *hdrpp
;
2274 m
->count
= to
- from
;
2276 if (from
== 0 && phdr
)
2278 /* Include the headers in the first PT_LOAD segment. */
2279 m
->includes_filehdr
= 1;
2280 m
->includes_phdrs
= 1;
2286 /* Set up a mapping from BFD sections to program segments. */
2289 map_sections_to_segments (abfd
)
2292 asection
**sections
= NULL
;
2296 struct elf_segment_map
*mfirst
;
2297 struct elf_segment_map
**pm
;
2298 struct elf_segment_map
*m
;
2300 unsigned int phdr_index
;
2301 bfd_vma maxpagesize
;
2303 boolean phdr_in_segment
= true;
2307 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2310 if (bfd_count_sections (abfd
) == 0)
2313 /* Select the allocated sections, and sort them. */
2315 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2316 * sizeof (asection
*));
2317 if (sections
== NULL
)
2321 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2323 if ((s
->flags
& SEC_ALLOC
) != 0)
2329 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2332 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2334 /* Build the mapping. */
2339 /* If we have a .interp section, then create a PT_PHDR segment for
2340 the program headers and a PT_INTERP segment for the .interp
2342 s
= bfd_get_section_by_name (abfd
, ".interp");
2343 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2345 m
= ((struct elf_segment_map
*)
2346 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2350 m
->p_type
= PT_PHDR
;
2351 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2352 m
->p_flags
= PF_R
| PF_X
;
2353 m
->p_flags_valid
= 1;
2354 m
->includes_phdrs
= 1;
2359 m
= ((struct elf_segment_map
*)
2360 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2364 m
->p_type
= PT_INTERP
;
2372 /* Look through the sections. We put sections in the same program
2373 segment when the start of the second section can be placed within
2374 a few bytes of the end of the first section. */
2377 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2379 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2381 && (dynsec
->flags
& SEC_LOAD
) == 0)
2384 /* Deal with -Ttext or something similar such that the first section
2385 is not adjacent to the program headers. This is an
2386 approximation, since at this point we don't know exactly how many
2387 program headers we will need. */
2390 bfd_size_type phdr_size
;
2392 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2394 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2395 if ((abfd
->flags
& D_PAGED
) == 0
2396 || sections
[0]->lma
< phdr_size
2397 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2398 phdr_in_segment
= false;
2401 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2404 boolean new_segment
;
2408 /* See if this section and the last one will fit in the same
2411 if (last_hdr
== NULL
)
2413 /* If we don't have a segment yet, then we don't need a new
2414 one (we build the last one after this loop). */
2415 new_segment
= false;
2417 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2419 /* If this section has a different relation between the
2420 virtual address and the load address, then we need a new
2424 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2425 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2427 /* If putting this section in this segment would force us to
2428 skip a page in the segment, then we need a new segment. */
2431 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2432 && (hdr
->flags
& SEC_LOAD
) != 0)
2434 /* We don't want to put a loadable section after a
2435 nonloadable section in the same segment. */
2438 else if ((abfd
->flags
& D_PAGED
) == 0)
2440 /* If the file is not demand paged, which means that we
2441 don't require the sections to be correctly aligned in the
2442 file, then there is no other reason for a new segment. */
2443 new_segment
= false;
2446 && (hdr
->flags
& SEC_READONLY
) == 0
2447 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2450 /* We don't want to put a writable section in a read only
2451 segment, unless they are on the same page in memory
2452 anyhow. We already know that the last section does not
2453 bring us past the current section on the page, so the
2454 only case in which the new section is not on the same
2455 page as the previous section is when the previous section
2456 ends precisely on a page boundary. */
2461 /* Otherwise, we can use the same segment. */
2462 new_segment
= false;
2467 if ((hdr
->flags
& SEC_READONLY
) == 0)
2473 /* We need a new program segment. We must create a new program
2474 header holding all the sections from phdr_index until hdr. */
2476 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2483 if ((hdr
->flags
& SEC_READONLY
) == 0)
2490 phdr_in_segment
= false;
2493 /* Create a final PT_LOAD program segment. */
2494 if (last_hdr
!= NULL
)
2496 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2504 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2507 m
= ((struct elf_segment_map
*)
2508 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2512 m
->p_type
= PT_DYNAMIC
;
2514 m
->sections
[0] = dynsec
;
2520 /* For each loadable .note section, add a PT_NOTE segment. We don't
2521 use bfd_get_section_by_name, because if we link together
2522 nonloadable .note sections and loadable .note sections, we will
2523 generate two .note sections in the output file. FIXME: Using
2524 names for section types is bogus anyhow. */
2525 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2527 if ((s
->flags
& SEC_LOAD
) != 0
2528 && strncmp (s
->name
, ".note", 5) == 0)
2530 m
= ((struct elf_segment_map
*)
2531 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2535 m
->p_type
= PT_NOTE
;
2547 elf_tdata (abfd
)->segment_map
= mfirst
;
2551 if (sections
!= NULL
)
2556 /* Sort sections by address. */
2559 elf_sort_sections (arg1
, arg2
)
2563 const asection
*sec1
= *(const asection
**) arg1
;
2564 const asection
*sec2
= *(const asection
**) arg2
;
2566 /* Sort by LMA first, since this is the address used to
2567 place the section into a segment. */
2568 if (sec1
->lma
< sec2
->lma
)
2570 else if (sec1
->lma
> sec2
->lma
)
2573 /* Then sort by VMA. Normally the LMA and the VMA will be
2574 the same, and this will do nothing. */
2575 if (sec1
->vma
< sec2
->vma
)
2577 else if (sec1
->vma
> sec2
->vma
)
2580 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2582 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2587 return sec1
->target_index
- sec2
->target_index
;
2597 /* Sort by size, to put zero sized sections before others at the
2600 if (sec1
->_raw_size
< sec2
->_raw_size
)
2602 if (sec1
->_raw_size
> sec2
->_raw_size
)
2605 return sec1
->target_index
- sec2
->target_index
;
2608 /* Assign file positions to the sections based on the mapping from
2609 sections to segments. This function also sets up some fields in
2610 the file header, and writes out the program headers. */
2613 assign_file_positions_for_segments (abfd
)
2616 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2618 struct elf_segment_map
*m
;
2620 Elf_Internal_Phdr
*phdrs
;
2622 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2623 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2624 Elf_Internal_Phdr
*p
;
2626 if (elf_tdata (abfd
)->segment_map
== NULL
)
2628 if (! map_sections_to_segments (abfd
))
2632 if (bed
->elf_backend_modify_segment_map
)
2634 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2639 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2642 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2643 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2644 elf_elfheader (abfd
)->e_phnum
= count
;
2649 /* If we already counted the number of program segments, make sure
2650 that we allocated enough space. This happens when SIZEOF_HEADERS
2651 is used in a linker script. */
2652 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2653 if (alloc
!= 0 && count
> alloc
)
2655 ((*_bfd_error_handler
)
2656 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2657 bfd_get_filename (abfd
), alloc
, count
));
2658 bfd_set_error (bfd_error_bad_value
);
2665 phdrs
= ((Elf_Internal_Phdr
*)
2666 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2670 off
= bed
->s
->sizeof_ehdr
;
2671 off
+= alloc
* bed
->s
->sizeof_phdr
;
2678 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2685 /* If elf_segment_map is not from map_sections_to_segments, the
2686 sections may not be correctly ordered. */
2688 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2691 p
->p_type
= m
->p_type
;
2692 p
->p_flags
= m
->p_flags
;
2694 if (p
->p_type
== PT_LOAD
2696 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2698 if ((abfd
->flags
& D_PAGED
) != 0)
2699 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2702 bfd_size_type align
;
2705 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2707 bfd_size_type secalign
;
2709 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
2710 if (secalign
> align
)
2714 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
2721 p
->p_vaddr
= m
->sections
[0]->vma
;
2723 if (m
->p_paddr_valid
)
2724 p
->p_paddr
= m
->p_paddr
;
2725 else if (m
->count
== 0)
2728 p
->p_paddr
= m
->sections
[0]->lma
;
2730 if (p
->p_type
== PT_LOAD
2731 && (abfd
->flags
& D_PAGED
) != 0)
2732 p
->p_align
= bed
->maxpagesize
;
2733 else if (m
->count
== 0)
2734 p
->p_align
= bed
->s
->file_align
;
2742 if (m
->includes_filehdr
)
2744 if (! m
->p_flags_valid
)
2747 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2748 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2751 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2753 if (p
->p_vaddr
< (bfd_vma
) off
)
2755 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2756 bfd_get_filename (abfd
));
2757 bfd_set_error (bfd_error_bad_value
);
2762 if (! m
->p_paddr_valid
)
2765 if (p
->p_type
== PT_LOAD
)
2767 filehdr_vaddr
= p
->p_vaddr
;
2768 filehdr_paddr
= p
->p_paddr
;
2772 if (m
->includes_phdrs
)
2774 if (! m
->p_flags_valid
)
2777 if (m
->includes_filehdr
)
2779 if (p
->p_type
== PT_LOAD
)
2781 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2782 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2787 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2791 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2792 p
->p_vaddr
-= off
- p
->p_offset
;
2793 if (! m
->p_paddr_valid
)
2794 p
->p_paddr
-= off
- p
->p_offset
;
2797 if (p
->p_type
== PT_LOAD
)
2799 phdrs_vaddr
= p
->p_vaddr
;
2800 phdrs_paddr
= p
->p_paddr
;
2803 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
2806 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2807 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2810 if (p
->p_type
== PT_LOAD
2811 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
2813 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2819 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2820 p
->p_filesz
+= adjust
;
2821 p
->p_memsz
+= adjust
;
2827 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2831 bfd_size_type align
;
2835 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2837 /* The section may have artificial alignment forced by a
2838 link script. Notice this case by the gap between the
2839 cumulative phdr vma and the section's vma. */
2840 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2842 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2844 p
->p_memsz
+= adjust
;
2847 if ((flags
& SEC_LOAD
) != 0)
2848 p
->p_filesz
+= adjust
;
2851 if (p
->p_type
== PT_LOAD
)
2853 bfd_signed_vma adjust
;
2855 if ((flags
& SEC_LOAD
) != 0)
2857 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2861 else if ((flags
& SEC_ALLOC
) != 0)
2863 /* The section VMA must equal the file position
2864 modulo the page size. FIXME: I'm not sure if
2865 this adjustment is really necessary. We used to
2866 not have the SEC_LOAD case just above, and then
2867 this was necessary, but now I'm not sure. */
2868 if ((abfd
->flags
& D_PAGED
) != 0)
2869 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2871 adjust
= (sec
->vma
- voff
) % align
;
2880 (* _bfd_error_handler
)
2881 (_("Error: First section in segment (%s) starts at 0x%x"),
2882 bfd_section_name (abfd
, sec
), sec
->lma
);
2883 (* _bfd_error_handler
)
2884 (_(" whereas segment starts at 0x%x"),
2889 p
->p_memsz
+= adjust
;
2892 if ((flags
& SEC_LOAD
) != 0)
2893 p
->p_filesz
+= adjust
;
2898 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2899 used in a linker script we may have a section with
2900 SEC_LOAD clear but which is supposed to have
2902 if ((flags
& SEC_LOAD
) != 0
2903 || (flags
& SEC_HAS_CONTENTS
) != 0)
2904 off
+= sec
->_raw_size
;
2906 if ((flags
& SEC_ALLOC
) != 0)
2907 voff
+= sec
->_raw_size
;
2910 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
2912 /* The actual "note" segment has i == 0.
2913 This is the one that actually contains everything. */
2917 p
->p_filesz
= sec
->_raw_size
;
2918 off
+= sec
->_raw_size
;
2923 /* Fake sections -- don't need to be written. */
2926 flags
= sec
->flags
= 0;
2933 p
->p_memsz
+= sec
->_raw_size
;
2935 if ((flags
& SEC_LOAD
) != 0)
2936 p
->p_filesz
+= sec
->_raw_size
;
2938 if (align
> p
->p_align
2939 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
2943 if (! m
->p_flags_valid
)
2946 if ((flags
& SEC_CODE
) != 0)
2948 if ((flags
& SEC_READONLY
) == 0)
2954 /* Now that we have set the section file positions, we can set up
2955 the file positions for the non PT_LOAD segments. */
2956 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2960 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2962 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2963 p
->p_offset
= m
->sections
[0]->filepos
;
2967 if (m
->includes_filehdr
)
2969 p
->p_vaddr
= filehdr_vaddr
;
2970 if (! m
->p_paddr_valid
)
2971 p
->p_paddr
= filehdr_paddr
;
2973 else if (m
->includes_phdrs
)
2975 p
->p_vaddr
= phdrs_vaddr
;
2976 if (! m
->p_paddr_valid
)
2977 p
->p_paddr
= phdrs_paddr
;
2982 /* Clear out any program headers we allocated but did not use. */
2983 for (; count
< alloc
; count
++, p
++)
2985 memset (p
, 0, sizeof *p
);
2986 p
->p_type
= PT_NULL
;
2989 elf_tdata (abfd
)->phdr
= phdrs
;
2991 elf_tdata (abfd
)->next_file_pos
= off
;
2993 /* Write out the program headers. */
2994 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2995 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
3001 /* Get the size of the program header.
3003 If this is called by the linker before any of the section VMA's are set, it
3004 can't calculate the correct value for a strange memory layout. This only
3005 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3006 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3007 data segment (exclusive of .interp and .dynamic).
3009 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3010 will be two segments. */
3012 static bfd_size_type
3013 get_program_header_size (abfd
)
3018 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3020 /* We can't return a different result each time we're called. */
3021 if (elf_tdata (abfd
)->program_header_size
!= 0)
3022 return elf_tdata (abfd
)->program_header_size
;
3024 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3026 struct elf_segment_map
*m
;
3029 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3031 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3032 return elf_tdata (abfd
)->program_header_size
;
3035 /* Assume we will need exactly two PT_LOAD segments: one for text
3036 and one for data. */
3039 s
= bfd_get_section_by_name (abfd
, ".interp");
3040 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3042 /* If we have a loadable interpreter section, we need a
3043 PT_INTERP segment. In this case, assume we also need a
3044 PT_PHDR segment, although that may not be true for all
3049 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3051 /* We need a PT_DYNAMIC segment. */
3055 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3057 if ((s
->flags
& SEC_LOAD
) != 0
3058 && strncmp (s
->name
, ".note", 5) == 0)
3060 /* We need a PT_NOTE segment. */
3065 /* Let the backend count up any program headers it might need. */
3066 if (bed
->elf_backend_additional_program_headers
)
3070 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
3076 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3077 return elf_tdata (abfd
)->program_header_size
;
3080 /* Work out the file positions of all the sections. This is called by
3081 _bfd_elf_compute_section_file_positions. All the section sizes and
3082 VMAs must be known before this is called.
3084 We do not consider reloc sections at this point, unless they form
3085 part of the loadable image. Reloc sections are assigned file
3086 positions in assign_file_positions_for_relocs, which is called by
3087 write_object_contents and final_link.
3089 We also don't set the positions of the .symtab and .strtab here. */
3092 assign_file_positions_except_relocs (abfd
)
3095 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
3096 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
3097 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
3099 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3101 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3102 && bfd_get_format (abfd
) != bfd_core
)
3104 Elf_Internal_Shdr
**hdrpp
;
3107 /* Start after the ELF header. */
3108 off
= i_ehdrp
->e_ehsize
;
3110 /* We are not creating an executable, which means that we are
3111 not creating a program header, and that the actual order of
3112 the sections in the file is unimportant. */
3113 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
3115 Elf_Internal_Shdr
*hdr
;
3118 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
3120 hdr
->sh_offset
= -1;
3123 if (i
== tdata
->symtab_section
3124 || i
== tdata
->strtab_section
)
3126 hdr
->sh_offset
= -1;
3130 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3136 Elf_Internal_Shdr
**hdrpp
;
3138 /* Assign file positions for the loaded sections based on the
3139 assignment of sections to segments. */
3140 if (! assign_file_positions_for_segments (abfd
))
3143 /* Assign file positions for the other sections. */
3145 off
= elf_tdata (abfd
)->next_file_pos
;
3146 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
3148 Elf_Internal_Shdr
*hdr
;
3151 if (hdr
->bfd_section
!= NULL
3152 && hdr
->bfd_section
->filepos
!= 0)
3153 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3154 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3156 ((*_bfd_error_handler
)
3157 (_("%s: warning: allocated section `%s' not in segment"),
3158 bfd_get_filename (abfd
),
3159 (hdr
->bfd_section
== NULL
3161 : hdr
->bfd_section
->name
)));
3162 if ((abfd
->flags
& D_PAGED
) != 0)
3163 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3165 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3166 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3169 else if (hdr
->sh_type
== SHT_REL
3170 || hdr
->sh_type
== SHT_RELA
3171 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3172 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3173 hdr
->sh_offset
= -1;
3175 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3179 /* Place the section headers. */
3180 off
= align_file_position (off
, bed
->s
->file_align
);
3181 i_ehdrp
->e_shoff
= off
;
3182 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3184 elf_tdata (abfd
)->next_file_pos
= off
;
3193 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3194 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3195 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3197 struct bfd_strtab_hash
*shstrtab
;
3198 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3200 i_ehdrp
= elf_elfheader (abfd
);
3201 i_shdrp
= elf_elfsections (abfd
);
3203 shstrtab
= _bfd_elf_stringtab_init ();
3204 if (shstrtab
== NULL
)
3207 elf_shstrtab (abfd
) = shstrtab
;
3209 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3210 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3211 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3212 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3214 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3215 i_ehdrp
->e_ident
[EI_DATA
] =
3216 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3217 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3219 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_NONE
;
3220 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 0;
3222 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
3223 i_ehdrp
->e_ident
[count
] = 0;
3225 if ((abfd
->flags
& DYNAMIC
) != 0)
3226 i_ehdrp
->e_type
= ET_DYN
;
3227 else if ((abfd
->flags
& EXEC_P
) != 0)
3228 i_ehdrp
->e_type
= ET_EXEC
;
3229 else if (bfd_get_format (abfd
) == bfd_core
)
3230 i_ehdrp
->e_type
= ET_CORE
;
3232 i_ehdrp
->e_type
= ET_REL
;
3234 switch (bfd_get_arch (abfd
))
3236 case bfd_arch_unknown
:
3237 i_ehdrp
->e_machine
= EM_NONE
;
3239 case bfd_arch_sparc
:
3240 if (bfd_get_arch_size (abfd
) == 64)
3241 i_ehdrp
->e_machine
= EM_SPARCV9
;
3243 i_ehdrp
->e_machine
= EM_SPARC
;
3246 i_ehdrp
->e_machine
= EM_S370
;
3249 i_ehdrp
->e_machine
= EM_386
;
3252 i_ehdrp
->e_machine
= EM_IA_64
;
3254 case bfd_arch_m68hc11
:
3255 i_ehdrp
->e_machine
= EM_68HC11
;
3257 case bfd_arch_m68hc12
:
3258 i_ehdrp
->e_machine
= EM_68HC12
;
3261 i_ehdrp
->e_machine
= EM_68K
;
3264 i_ehdrp
->e_machine
= EM_88K
;
3267 i_ehdrp
->e_machine
= EM_860
;
3270 i_ehdrp
->e_machine
= EM_960
;
3272 case bfd_arch_mips
: /* MIPS Rxxxx */
3273 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
3276 i_ehdrp
->e_machine
= EM_PARISC
;
3278 case bfd_arch_powerpc
:
3279 i_ehdrp
->e_machine
= EM_PPC
;
3281 case bfd_arch_alpha
:
3282 i_ehdrp
->e_machine
= EM_ALPHA
;
3285 i_ehdrp
->e_machine
= EM_SH
;
3288 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
3291 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3294 i_ehdrp
->e_machine
= EM_CYGNUS_FR30
;
3296 case bfd_arch_mcore
:
3297 i_ehdrp
->e_machine
= EM_MCORE
;
3300 i_ehdrp
->e_machine
= EM_AVR
;
3303 switch (bfd_get_mach (abfd
))
3306 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3310 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3313 i_ehdrp
->e_machine
= EM_ARM
;
3316 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3318 case bfd_arch_mn10200
:
3319 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3321 case bfd_arch_mn10300
:
3322 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3325 i_ehdrp
->e_machine
= EM_PJ
;
3327 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3329 i_ehdrp
->e_machine
= EM_NONE
;
3331 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3332 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3334 /* no program header, for now. */
3335 i_ehdrp
->e_phoff
= 0;
3336 i_ehdrp
->e_phentsize
= 0;
3337 i_ehdrp
->e_phnum
= 0;
3339 /* each bfd section is section header entry */
3340 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3341 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3343 /* if we're building an executable, we'll need a program header table */
3344 if (abfd
->flags
& EXEC_P
)
3346 /* it all happens later */
3348 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3350 /* elf_build_phdrs() returns a (NULL-terminated) array of
3351 Elf_Internal_Phdrs */
3352 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3353 i_ehdrp
->e_phoff
= outbase
;
3354 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3359 i_ehdrp
->e_phentsize
= 0;
3361 i_ehdrp
->e_phoff
= 0;
3364 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3365 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3366 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3367 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3368 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3369 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3370 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3371 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3372 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3378 /* Assign file positions for all the reloc sections which are not part
3379 of the loadable file image. */
3382 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3387 Elf_Internal_Shdr
**shdrpp
;
3389 off
= elf_tdata (abfd
)->next_file_pos
;
3391 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3392 i
< elf_elfheader (abfd
)->e_shnum
;
3395 Elf_Internal_Shdr
*shdrp
;
3398 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3399 && shdrp
->sh_offset
== -1)
3400 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3403 elf_tdata (abfd
)->next_file_pos
= off
;
3407 _bfd_elf_write_object_contents (abfd
)
3410 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3411 Elf_Internal_Ehdr
*i_ehdrp
;
3412 Elf_Internal_Shdr
**i_shdrp
;
3416 if (! abfd
->output_has_begun
3417 && ! _bfd_elf_compute_section_file_positions
3418 (abfd
, (struct bfd_link_info
*) NULL
))
3421 i_shdrp
= elf_elfsections (abfd
);
3422 i_ehdrp
= elf_elfheader (abfd
);
3425 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3429 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3431 /* After writing the headers, we need to write the sections too... */
3432 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3434 if (bed
->elf_backend_section_processing
)
3435 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3436 if (i_shdrp
[count
]->contents
)
3438 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3439 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3441 != i_shdrp
[count
]->sh_size
))
3446 /* Write out the section header names. */
3447 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3448 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3451 if (bed
->elf_backend_final_write_processing
)
3452 (*bed
->elf_backend_final_write_processing
) (abfd
,
3453 elf_tdata (abfd
)->linker
);
3455 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3459 _bfd_elf_write_corefile_contents (abfd
)
3462 /* Hopefully this can be done just like an object file. */
3463 return _bfd_elf_write_object_contents (abfd
);
3465 /* given a section, search the header to find them... */
3467 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3471 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3472 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3474 Elf_Internal_Shdr
*hdr
;
3475 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3477 for (index
= 0; index
< maxindex
; index
++)
3479 hdr
= i_shdrp
[index
];
3480 if (hdr
->bfd_section
== asect
)
3484 if (bed
->elf_backend_section_from_bfd_section
)
3486 for (index
= 0; index
< maxindex
; index
++)
3490 hdr
= i_shdrp
[index
];
3492 if ((*bed
->elf_backend_section_from_bfd_section
)
3493 (abfd
, hdr
, asect
, &retval
))
3498 if (bfd_is_abs_section (asect
))
3500 if (bfd_is_com_section (asect
))
3502 if (bfd_is_und_section (asect
))
3505 bfd_set_error (bfd_error_nonrepresentable_section
);
3510 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3514 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3516 asymbol
**asym_ptr_ptr
;
3518 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3520 flagword flags
= asym_ptr
->flags
;
3522 /* When gas creates relocations against local labels, it creates its
3523 own symbol for the section, but does put the symbol into the
3524 symbol chain, so udata is 0. When the linker is generating
3525 relocatable output, this section symbol may be for one of the
3526 input sections rather than the output section. */
3527 if (asym_ptr
->udata
.i
== 0
3528 && (flags
& BSF_SECTION_SYM
)
3529 && asym_ptr
->section
)
3533 if (asym_ptr
->section
->output_section
!= NULL
)
3534 indx
= asym_ptr
->section
->output_section
->index
;
3536 indx
= asym_ptr
->section
->index
;
3537 if (elf_section_syms (abfd
)[indx
])
3538 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3541 idx
= asym_ptr
->udata
.i
;
3545 /* This case can occur when using --strip-symbol on a symbol
3546 which is used in a relocation entry. */
3547 (*_bfd_error_handler
)
3548 (_("%s: symbol `%s' required but not present"),
3549 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3550 bfd_set_error (bfd_error_no_symbols
);
3557 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3558 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3559 elf_symbol_flags (flags
));
3567 /* Copy private BFD data. This copies any program header information. */
3570 copy_private_bfd_data (ibfd
, obfd
)
3574 Elf_Internal_Ehdr
*iehdr
;
3575 struct elf_segment_map
*mfirst
;
3576 struct elf_segment_map
**pm
;
3577 struct elf_segment_map
*m
;
3578 Elf_Internal_Phdr
*p
;
3580 unsigned int num_segments
;
3581 boolean phdr_included
= false;
3583 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3584 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3587 if (elf_tdata (ibfd
)->phdr
== NULL
)
3590 iehdr
= elf_elfheader (ibfd
);
3595 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
3597 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3598 ((addr) >= (bottom) \
3599 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3600 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3602 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3604 #define IS_COREFILE_NOTE(p, s) \
3605 (p->p_type == PT_NOTE \
3606 && bfd_get_format (ibfd) == bfd_core \
3607 && s->vma == 0 && s->lma == 0 \
3608 && (bfd_vma) s->filepos >= p->p_offset \
3609 && (bfd_vma) s->filepos + s->_raw_size \
3610 <= p->p_offset + p->p_filesz)
3612 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3613 linker, which generates a PT_INTERP section with p_vaddr and
3614 p_memsz set to 0. */
3616 #define IS_SOLARIS_PT_INTERP(p, s) \
3618 && p->p_filesz > 0 \
3619 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3620 && s->_raw_size > 0 \
3621 && (bfd_vma) s->filepos >= p->p_offset \
3622 && ((bfd_vma) s->filepos + s->_raw_size \
3623 <= p->p_offset + p->p_filesz))
3625 /* Scan through the segments specified in the program header
3626 of the input BFD. */
3627 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< num_segments
; i
++, p
++)
3631 asection
**sections
;
3634 bfd_vma matching_lma
;
3635 bfd_vma suggested_lma
;
3638 /* For each section in the input BFD, decide if it should be
3639 included in the current segment. A section will be included
3640 if it is within the address space of the segment, and it is
3641 an allocated segment, and there is an output section
3642 associated with it. */
3644 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3645 if (s
->output_section
!= NULL
)
3647 if ((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3648 || IS_SOLARIS_PT_INTERP (p
, s
))
3649 && (s
->flags
& SEC_ALLOC
) != 0)
3651 else if (IS_COREFILE_NOTE (p
, s
))
3655 /* Allocate a segment map big enough to contain all of the
3656 sections we have selected. */
3657 m
= ((struct elf_segment_map
*)
3659 (sizeof (struct elf_segment_map
)
3660 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3664 /* Initialise the fields of the segment map. Default to
3665 using the physical address of the segment in the input BFD. */
3667 m
->p_type
= p
->p_type
;
3668 m
->p_flags
= p
->p_flags
;
3669 m
->p_flags_valid
= 1;
3670 m
->p_paddr
= p
->p_paddr
;
3671 m
->p_paddr_valid
= 1;
3673 /* Determine if this segment contains the ELF file header
3674 and if it contains the program headers themselves. */
3675 m
->includes_filehdr
= (p
->p_offset
== 0
3676 && p
->p_filesz
>= iehdr
->e_ehsize
);
3678 m
->includes_phdrs
= 0;
3680 if (! phdr_included
|| p
->p_type
!= PT_LOAD
)
3683 (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3684 && (p
->p_offset
+ p
->p_filesz
3685 >= ((bfd_vma
) iehdr
->e_phoff
3686 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3687 if (p
->p_type
== PT_LOAD
&& m
->includes_phdrs
)
3688 phdr_included
= true;
3693 /* Special segments, such as the PT_PHDR segment, may contain
3694 no sections, but ordinary, loadable segments should contain
3697 if (p
->p_type
== PT_LOAD
)
3699 (_("%s: warning: Empty loadable segment detected\n"),
3700 bfd_get_filename (ibfd
));
3709 /* Now scan the sections in the input BFD again and attempt
3710 to add their corresponding output sections to the segment map.
3711 The problem here is how to handle an output section which has
3712 been moved (ie had its LMA changed). There are four possibilities:
3714 1. None of the sections have been moved.
3715 In this case we can continue to use the segment LMA from the
3718 2. All of the sections have been moved by the same amount.
3719 In this case we can change the segment's LMA to match the LMA
3720 of the first section.
3722 3. Some of the sections have been moved, others have not.
3723 In this case those sections which have not been moved can be
3724 placed in the current segment which will have to have its size,
3725 and possibly its LMA changed, and a new segment or segments will
3726 have to be created to contain the other sections.
3728 4. The sections have been moved, but not be the same amount.
3729 In this case we can change the segment's LMA to match the LMA
3730 of the first section and we will have to create a new segment
3731 or segments to contain the other sections.
3733 In order to save time, we allocate an array to hold the section
3734 pointers that we are interested in. As these sections get assigned
3735 to a segment, they are removed from this array. */
3737 sections
= (asection
**) bfd_malloc (sizeof (asection
*) * csecs
);
3738 if (sections
== NULL
)
3741 /* Step One: Scan for segment vs section LMA conflicts.
3742 Also add the sections to the section array allocated above.
3743 Also add the sections to the current segment. In the common
3744 case, where the sections have not been moved, this means that
3745 we have completely filled the segment, and there is nothing
3752 for (j
= 0, s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3754 os
= s
->output_section
;
3756 if ((((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3757 || IS_SOLARIS_PT_INTERP (p
, s
))
3758 && (s
->flags
& SEC_ALLOC
) != 0)
3759 || IS_COREFILE_NOTE (p
, s
))
3764 /* The Solaris native linker always sets p_paddr to 0.
3765 We try to catch that case here, and set it to the
3771 && (os
->vma
== (p
->p_vaddr
3772 + (m
->includes_filehdr
3775 + (m
->includes_phdrs
3776 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3778 m
->p_paddr
= p
->p_vaddr
;
3780 /* Match up the physical address of the segment with the
3781 LMA address of the output section. */
3782 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3783 || IS_COREFILE_NOTE (p
, s
))
3785 if (matching_lma
== 0)
3786 matching_lma
= os
->lma
;
3788 /* We assume that if the section fits within the segment
3789 that it does not overlap any other section within that
3791 m
->sections
[isec
++] = os
;
3793 else if (suggested_lma
== 0)
3794 suggested_lma
= os
->lma
;
3798 BFD_ASSERT (j
== csecs
);
3800 /* Step Two: Adjust the physical address of the current segment,
3804 /* All of the sections fitted within the segment as currently
3805 specified. This is the default case. Add the segment to
3806 the list of built segments and carry on to process the next
3807 program header in the input BFD. */
3817 if (matching_lma
!= 0)
3819 /* At least one section fits inside the current segment.
3820 Keep it, but modify its physical address to match the
3821 LMA of the first section that fitted. */
3823 m
->p_paddr
= matching_lma
;
3827 /* None of the sections fitted inside the current segment.
3828 Change the current segment's physical address to match
3829 the LMA of the first section. */
3831 m
->p_paddr
= suggested_lma
;
3834 /* Offset the segment physical address from the lma to allow
3835 for space taken up by elf headers. */
3836 if (m
->includes_filehdr
)
3837 m
->p_paddr
-= iehdr
->e_ehsize
;
3839 if (m
->includes_phdrs
)
3840 m
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
3843 /* Step Three: Loop over the sections again, this time assigning
3844 those that fit to the current segment and remvoing them from the
3845 sections array; but making sure not to leave large gaps. Once all
3846 possible sections have been assigned to the current segment it is
3847 added to the list of built segments and if sections still remain
3848 to be assigned, a new segment is constructed before repeating
3856 /* Fill the current segment with sections that fit. */
3857 for (j
= 0; j
< csecs
; j
++)
3864 os
= s
->output_section
;
3866 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3867 || IS_COREFILE_NOTE (p
, s
))
3871 /* If the first section in a segment does not start at
3872 the beginning of the segment, then something is wrong. */
3873 if (os
->lma
!= (m
->p_paddr
3874 + (m
->includes_filehdr
3875 ? iehdr
->e_ehsize
: 0)
3876 + (m
->includes_phdrs
3877 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3883 asection
* prev_sec
;
3884 bfd_vma maxpagesize
;
3886 prev_sec
= m
->sections
[m
->count
- 1];
3887 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
3889 /* If the gap between the end of the previous section
3890 and the start of this section is more than maxpagesize
3891 then we need to start a new segment. */
3892 if (BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
, maxpagesize
)
3893 < BFD_ALIGN (os
->lma
, maxpagesize
))
3895 if (suggested_lma
== 0)
3896 suggested_lma
= os
->lma
;
3902 m
->sections
[m
->count
++] = os
;
3906 else if (suggested_lma
== 0)
3907 suggested_lma
= os
->lma
;
3910 BFD_ASSERT (m
->count
> 0);
3912 /* Add the current segment to the list of built segments. */
3918 /* We still have not allocated all of the sections to
3919 segments. Create a new segment here, initialise it
3920 and carry on looping. */
3922 m
= ((struct elf_segment_map
*)
3924 (sizeof (struct elf_segment_map
)
3925 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3929 /* Initialise the fields of the segment map. Set the physical
3930 physical address to the LMA of the first section that has
3931 not yet been assigned. */
3934 m
->p_type
= p
->p_type
;
3935 m
->p_flags
= p
->p_flags
;
3936 m
->p_flags_valid
= 1;
3937 m
->p_paddr
= suggested_lma
;
3938 m
->p_paddr_valid
= 1;
3939 m
->includes_filehdr
= 0;
3940 m
->includes_phdrs
= 0;
3943 while (isec
< csecs
);
3948 /* The Solaris linker creates program headers in which all the
3949 p_paddr fields are zero. When we try to objcopy or strip such a
3950 file, we get confused. Check for this case, and if we find it
3951 reset the p_paddr_valid fields. */
3952 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3953 if (m
->p_paddr
!= 0)
3957 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3958 m
->p_paddr_valid
= 0;
3961 elf_tdata (obfd
)->segment_map
= mfirst
;
3964 /* Final Step: Sort the segments into ascending order of physical address. */
3967 struct elf_segment_map
* prev
;
3970 for (m
= mfirst
->next
; m
!= NULL
; prev
= m
, m
= m
->next
)
3972 /* Yes I know - its a bubble sort....*/
3973 if (m
->next
!= NULL
&& (m
->next
->p_paddr
< m
->p_paddr
))
3975 /* swap m and m->next */
3976 prev
->next
= m
->next
;
3977 m
->next
= m
->next
->next
;
3978 prev
->next
->next
= m
;
3987 #undef IS_CONTAINED_BY
3988 #undef IS_SOLARIS_PT_INTERP
3989 #undef IS_COREFILE_NOTE
3993 /* Copy private section information. This copies over the entsize
3994 field, and sometimes the info field. */
3997 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
4003 Elf_Internal_Shdr
*ihdr
, *ohdr
;
4005 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
4006 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
4009 /* Copy over private BFD data if it has not already been copied.
4010 This must be done here, rather than in the copy_private_bfd_data
4011 entry point, because the latter is called after the section
4012 contents have been set, which means that the program headers have
4013 already been worked out. */
4014 if (elf_tdata (obfd
)->segment_map
== NULL
4015 && elf_tdata (ibfd
)->phdr
!= NULL
)
4019 /* Only set up the segments if there are no more SEC_ALLOC
4020 sections. FIXME: This won't do the right thing if objcopy is
4021 used to remove the last SEC_ALLOC section, since objcopy
4022 won't call this routine in that case. */
4023 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
4024 if ((s
->flags
& SEC_ALLOC
) != 0)
4028 if (! copy_private_bfd_data (ibfd
, obfd
))
4033 ihdr
= &elf_section_data (isec
)->this_hdr
;
4034 ohdr
= &elf_section_data (osec
)->this_hdr
;
4036 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
4038 if (ihdr
->sh_type
== SHT_SYMTAB
4039 || ihdr
->sh_type
== SHT_DYNSYM
4040 || ihdr
->sh_type
== SHT_GNU_verneed
4041 || ihdr
->sh_type
== SHT_GNU_verdef
)
4042 ohdr
->sh_info
= ihdr
->sh_info
;
4044 elf_section_data (osec
)->use_rela_p
4045 = elf_section_data (isec
)->use_rela_p
;
4050 /* Copy private symbol information. If this symbol is in a section
4051 which we did not map into a BFD section, try to map the section
4052 index correctly. We use special macro definitions for the mapped
4053 section indices; these definitions are interpreted by the
4054 swap_out_syms function. */
4056 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4057 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4058 #define MAP_STRTAB (SHN_LORESERVE - 3)
4059 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4062 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
4068 elf_symbol_type
*isym
, *osym
;
4070 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4071 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4074 isym
= elf_symbol_from (ibfd
, isymarg
);
4075 osym
= elf_symbol_from (obfd
, osymarg
);
4079 && bfd_is_abs_section (isym
->symbol
.section
))
4083 shndx
= isym
->internal_elf_sym
.st_shndx
;
4084 if (shndx
== elf_onesymtab (ibfd
))
4085 shndx
= MAP_ONESYMTAB
;
4086 else if (shndx
== elf_dynsymtab (ibfd
))
4087 shndx
= MAP_DYNSYMTAB
;
4088 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
4090 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
4091 shndx
= MAP_SHSTRTAB
;
4092 osym
->internal_elf_sym
.st_shndx
= shndx
;
4098 /* Swap out the symbols. */
4101 swap_out_syms (abfd
, sttp
, relocatable_p
)
4103 struct bfd_strtab_hash
**sttp
;
4106 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4108 if (!elf_map_symbols (abfd
))
4111 /* Dump out the symtabs. */
4113 int symcount
= bfd_get_symcount (abfd
);
4114 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4115 struct bfd_strtab_hash
*stt
;
4116 Elf_Internal_Shdr
*symtab_hdr
;
4117 Elf_Internal_Shdr
*symstrtab_hdr
;
4118 char *outbound_syms
;
4121 stt
= _bfd_elf_stringtab_init ();
4125 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4126 symtab_hdr
->sh_type
= SHT_SYMTAB
;
4127 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
4128 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
4129 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
4130 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
4132 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4133 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4135 outbound_syms
= bfd_alloc (abfd
,
4136 (1 + symcount
) * bed
->s
->sizeof_sym
);
4137 if (outbound_syms
== NULL
)
4139 symtab_hdr
->contents
= (PTR
) outbound_syms
;
4141 /* now generate the data (for "contents") */
4143 /* Fill in zeroth symbol and swap it out. */
4144 Elf_Internal_Sym sym
;
4150 sym
.st_shndx
= SHN_UNDEF
;
4151 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4152 outbound_syms
+= bed
->s
->sizeof_sym
;
4154 for (idx
= 0; idx
< symcount
; idx
++)
4156 Elf_Internal_Sym sym
;
4157 bfd_vma value
= syms
[idx
]->value
;
4158 elf_symbol_type
*type_ptr
;
4159 flagword flags
= syms
[idx
]->flags
;
4162 if (flags
& BSF_SECTION_SYM
)
4163 /* Section symbols have no names. */
4167 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4170 if (sym
.st_name
== (unsigned long) -1)
4174 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4176 if ((flags
& BSF_SECTION_SYM
) == 0
4177 && bfd_is_com_section (syms
[idx
]->section
))
4179 /* ELF common symbols put the alignment into the `value' field,
4180 and the size into the `size' field. This is backwards from
4181 how BFD handles it, so reverse it here. */
4182 sym
.st_size
= value
;
4183 if (type_ptr
== NULL
4184 || type_ptr
->internal_elf_sym
.st_value
== 0)
4185 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4187 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4188 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4189 (abfd
, syms
[idx
]->section
);
4193 asection
*sec
= syms
[idx
]->section
;
4196 if (sec
->output_section
)
4198 value
+= sec
->output_offset
;
4199 sec
= sec
->output_section
;
4201 /* Don't add in the section vma for relocatable output. */
4202 if (! relocatable_p
)
4204 sym
.st_value
= value
;
4205 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4207 if (bfd_is_abs_section (sec
)
4209 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4211 /* This symbol is in a real ELF section which we did
4212 not create as a BFD section. Undo the mapping done
4213 by copy_private_symbol_data. */
4214 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4218 shndx
= elf_onesymtab (abfd
);
4221 shndx
= elf_dynsymtab (abfd
);
4224 shndx
= elf_tdata (abfd
)->strtab_section
;
4227 shndx
= elf_tdata (abfd
)->shstrtab_section
;
4235 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
4241 /* Writing this would be a hell of a lot easier if
4242 we had some decent documentation on bfd, and
4243 knew what to expect of the library, and what to
4244 demand of applications. For example, it
4245 appears that `objcopy' might not set the
4246 section of a symbol to be a section that is
4247 actually in the output file. */
4248 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
4249 BFD_ASSERT (sec2
!= 0);
4250 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
4251 BFD_ASSERT (shndx
!= -1);
4255 sym
.st_shndx
= shndx
;
4258 if ((flags
& BSF_FUNCTION
) != 0)
4260 else if ((flags
& BSF_OBJECT
) != 0)
4265 /* Processor-specific types */
4266 if (type_ptr
!= NULL
4267 && bed
->elf_backend_get_symbol_type
)
4268 type
= (*bed
->elf_backend_get_symbol_type
) (&type_ptr
->internal_elf_sym
, type
);
4270 if (flags
& BSF_SECTION_SYM
)
4271 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4272 else if (bfd_is_com_section (syms
[idx
]->section
))
4273 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
4274 else if (bfd_is_und_section (syms
[idx
]->section
))
4275 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
4279 else if (flags
& BSF_FILE
)
4280 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4283 int bind
= STB_LOCAL
;
4285 if (flags
& BSF_LOCAL
)
4287 else if (flags
& BSF_WEAK
)
4289 else if (flags
& BSF_GLOBAL
)
4292 sym
.st_info
= ELF_ST_INFO (bind
, type
);
4295 if (type_ptr
!= NULL
)
4296 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
4300 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4301 outbound_syms
+= bed
->s
->sizeof_sym
;
4305 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
4306 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4308 symstrtab_hdr
->sh_flags
= 0;
4309 symstrtab_hdr
->sh_addr
= 0;
4310 symstrtab_hdr
->sh_entsize
= 0;
4311 symstrtab_hdr
->sh_link
= 0;
4312 symstrtab_hdr
->sh_info
= 0;
4313 symstrtab_hdr
->sh_addralign
= 1;
4319 /* Return the number of bytes required to hold the symtab vector.
4321 Note that we base it on the count plus 1, since we will null terminate
4322 the vector allocated based on this size. However, the ELF symbol table
4323 always has a dummy entry as symbol #0, so it ends up even. */
4326 _bfd_elf_get_symtab_upper_bound (abfd
)
4331 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4333 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4334 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4340 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
4345 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4347 if (elf_dynsymtab (abfd
) == 0)
4349 bfd_set_error (bfd_error_invalid_operation
);
4353 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4354 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4360 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
4361 bfd
*abfd ATTRIBUTE_UNUSED
;
4364 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
4367 /* Canonicalize the relocs. */
4370 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4379 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
4385 tblptr
= section
->relocation
;
4386 for (i
= 0; i
< section
->reloc_count
; i
++)
4387 *relptr
++ = tblptr
++;
4391 return section
->reloc_count
;
4395 _bfd_elf_get_symtab (abfd
, alocation
)
4397 asymbol
**alocation
;
4399 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4400 (abfd
, alocation
, false);
4403 bfd_get_symcount (abfd
) = symcount
;
4408 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
4410 asymbol
**alocation
;
4412 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4413 (abfd
, alocation
, true);
4416 /* Return the size required for the dynamic reloc entries. Any
4417 section that was actually installed in the BFD, and has type
4418 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4419 considered to be a dynamic reloc section. */
4422 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
4428 if (elf_dynsymtab (abfd
) == 0)
4430 bfd_set_error (bfd_error_invalid_operation
);
4434 ret
= sizeof (arelent
*);
4435 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4436 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4437 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4438 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4439 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
4440 * sizeof (arelent
*));
4445 /* Canonicalize the dynamic relocation entries. Note that we return
4446 the dynamic relocations as a single block, although they are
4447 actually associated with particular sections; the interface, which
4448 was designed for SunOS style shared libraries, expects that there
4449 is only one set of dynamic relocs. Any section that was actually
4450 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4451 the dynamic symbol table, is considered to be a dynamic reloc
4455 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
4460 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
4464 if (elf_dynsymtab (abfd
) == 0)
4466 bfd_set_error (bfd_error_invalid_operation
);
4470 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
4472 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4474 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4475 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4476 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4481 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
4483 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
4485 for (i
= 0; i
< count
; i
++)
4496 /* Read in the version information. */
4499 _bfd_elf_slurp_version_tables (abfd
)
4502 bfd_byte
*contents
= NULL
;
4504 if (elf_dynverdef (abfd
) != 0)
4506 Elf_Internal_Shdr
*hdr
;
4507 Elf_External_Verdef
*everdef
;
4508 Elf_Internal_Verdef
*iverdef
;
4509 Elf_Internal_Verdef
*iverdefarr
;
4510 Elf_Internal_Verdef iverdefmem
;
4512 unsigned int maxidx
;
4514 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
4516 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4517 if (contents
== NULL
)
4519 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4520 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4523 /* We know the number of entries in the section but not the maximum
4524 index. Therefore we have to run through all entries and find
4526 everdef
= (Elf_External_Verdef
*) contents
;
4528 for (i
= 0; i
< hdr
->sh_info
; ++i
)
4530 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
4532 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) > maxidx
)
4533 maxidx
= iverdefmem
.vd_ndx
& VERSYM_VERSION
;
4535 everdef
= ((Elf_External_Verdef
*)
4536 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
4539 elf_tdata (abfd
)->verdef
=
4540 ((Elf_Internal_Verdef
*)
4541 bfd_zalloc (abfd
, maxidx
* sizeof (Elf_Internal_Verdef
)));
4542 if (elf_tdata (abfd
)->verdef
== NULL
)
4545 elf_tdata (abfd
)->cverdefs
= maxidx
;
4547 everdef
= (Elf_External_Verdef
*) contents
;
4548 iverdefarr
= elf_tdata (abfd
)->verdef
;
4549 for (i
= 0; i
< hdr
->sh_info
; i
++)
4551 Elf_External_Verdaux
*everdaux
;
4552 Elf_Internal_Verdaux
*iverdaux
;
4555 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
4557 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
4558 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
4560 iverdef
->vd_bfd
= abfd
;
4562 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
4565 * sizeof (Elf_Internal_Verdaux
))));
4566 if (iverdef
->vd_auxptr
== NULL
)
4569 everdaux
= ((Elf_External_Verdaux
*)
4570 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
4571 iverdaux
= iverdef
->vd_auxptr
;
4572 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
4574 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
4576 iverdaux
->vda_nodename
=
4577 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4578 iverdaux
->vda_name
);
4579 if (iverdaux
->vda_nodename
== NULL
)
4582 if (j
+ 1 < iverdef
->vd_cnt
)
4583 iverdaux
->vda_nextptr
= iverdaux
+ 1;
4585 iverdaux
->vda_nextptr
= NULL
;
4587 everdaux
= ((Elf_External_Verdaux
*)
4588 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
4591 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
4593 if (i
+ 1 < hdr
->sh_info
)
4594 iverdef
->vd_nextdef
= iverdef
+ 1;
4596 iverdef
->vd_nextdef
= NULL
;
4598 everdef
= ((Elf_External_Verdef
*)
4599 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4606 if (elf_dynverref (abfd
) != 0)
4608 Elf_Internal_Shdr
*hdr
;
4609 Elf_External_Verneed
*everneed
;
4610 Elf_Internal_Verneed
*iverneed
;
4613 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4615 elf_tdata (abfd
)->verref
=
4616 ((Elf_Internal_Verneed
*)
4617 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4618 if (elf_tdata (abfd
)->verref
== NULL
)
4621 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4623 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4624 if (contents
== NULL
)
4626 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4627 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4630 everneed
= (Elf_External_Verneed
*) contents
;
4631 iverneed
= elf_tdata (abfd
)->verref
;
4632 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4634 Elf_External_Vernaux
*evernaux
;
4635 Elf_Internal_Vernaux
*ivernaux
;
4638 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4640 iverneed
->vn_bfd
= abfd
;
4642 iverneed
->vn_filename
=
4643 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4645 if (iverneed
->vn_filename
== NULL
)
4648 iverneed
->vn_auxptr
=
4649 ((Elf_Internal_Vernaux
*)
4651 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4653 evernaux
= ((Elf_External_Vernaux
*)
4654 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4655 ivernaux
= iverneed
->vn_auxptr
;
4656 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4658 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4660 ivernaux
->vna_nodename
=
4661 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4662 ivernaux
->vna_name
);
4663 if (ivernaux
->vna_nodename
== NULL
)
4666 if (j
+ 1 < iverneed
->vn_cnt
)
4667 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4669 ivernaux
->vna_nextptr
= NULL
;
4671 evernaux
= ((Elf_External_Vernaux
*)
4672 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4675 if (i
+ 1 < hdr
->sh_info
)
4676 iverneed
->vn_nextref
= iverneed
+ 1;
4678 iverneed
->vn_nextref
= NULL
;
4680 everneed
= ((Elf_External_Verneed
*)
4681 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4691 if (contents
== NULL
)
4697 _bfd_elf_make_empty_symbol (abfd
)
4700 elf_symbol_type
*newsym
;
4702 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4707 newsym
->symbol
.the_bfd
= abfd
;
4708 return &newsym
->symbol
;
4713 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4714 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4718 bfd_symbol_info (symbol
, ret
);
4721 /* Return whether a symbol name implies a local symbol. Most targets
4722 use this function for the is_local_label_name entry point, but some
4726 _bfd_elf_is_local_label_name (abfd
, name
)
4727 bfd
*abfd ATTRIBUTE_UNUSED
;
4730 /* Normal local symbols start with ``.L''. */
4731 if (name
[0] == '.' && name
[1] == 'L')
4734 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4735 DWARF debugging symbols starting with ``..''. */
4736 if (name
[0] == '.' && name
[1] == '.')
4739 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4740 emitting DWARF debugging output. I suspect this is actually a
4741 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4742 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4743 underscore to be emitted on some ELF targets). For ease of use,
4744 we treat such symbols as local. */
4745 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4752 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4753 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4754 asymbol
*symbol ATTRIBUTE_UNUSED
;
4761 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4763 enum bfd_architecture arch
;
4764 unsigned long machine
;
4766 /* If this isn't the right architecture for this backend, and this
4767 isn't the generic backend, fail. */
4768 if (arch
!= get_elf_backend_data (abfd
)->arch
4769 && arch
!= bfd_arch_unknown
4770 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4773 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4776 /* Find the nearest line to a particular section and offset, for error
4780 _bfd_elf_find_nearest_line (abfd
,
4791 CONST
char **filename_ptr
;
4792 CONST
char **functionname_ptr
;
4793 unsigned int *line_ptr
;
4796 const char *filename
;
4801 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
4802 filename_ptr
, functionname_ptr
,
4806 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4807 filename_ptr
, functionname_ptr
,
4811 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4812 &found
, filename_ptr
,
4813 functionname_ptr
, line_ptr
,
4814 &elf_tdata (abfd
)->line_info
))
4819 if (symbols
== NULL
)
4826 for (p
= symbols
; *p
!= NULL
; p
++)
4830 q
= (elf_symbol_type
*) *p
;
4832 if (bfd_get_section (&q
->symbol
) != section
)
4835 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4840 filename
= bfd_asymbol_name (&q
->symbol
);
4844 if (q
->symbol
.section
== section
4845 && q
->symbol
.value
>= low_func
4846 && q
->symbol
.value
<= offset
)
4848 func
= (asymbol
*) q
;
4849 low_func
= q
->symbol
.value
;
4858 *filename_ptr
= filename
;
4859 *functionname_ptr
= bfd_asymbol_name (func
);
4865 _bfd_elf_sizeof_headers (abfd
, reloc
)
4871 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4873 ret
+= get_program_header_size (abfd
);
4878 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4883 bfd_size_type count
;
4885 Elf_Internal_Shdr
*hdr
;
4887 if (! abfd
->output_has_begun
4888 && ! _bfd_elf_compute_section_file_positions
4889 (abfd
, (struct bfd_link_info
*) NULL
))
4892 hdr
= &elf_section_data (section
)->this_hdr
;
4894 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4896 if (bfd_write (location
, 1, count
, abfd
) != count
)
4903 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4904 bfd
*abfd ATTRIBUTE_UNUSED
;
4905 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
4906 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
4913 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4916 Elf_Internal_Rel
*dst
;
4922 /* Try to convert a non-ELF reloc into an ELF one. */
4925 _bfd_elf_validate_reloc (abfd
, areloc
)
4929 /* Check whether we really have an ELF howto. */
4931 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4933 bfd_reloc_code_real_type code
;
4934 reloc_howto_type
*howto
;
4936 /* Alien reloc: Try to determine its type to replace it with an
4937 equivalent ELF reloc. */
4939 if (areloc
->howto
->pc_relative
)
4941 switch (areloc
->howto
->bitsize
)
4944 code
= BFD_RELOC_8_PCREL
;
4947 code
= BFD_RELOC_12_PCREL
;
4950 code
= BFD_RELOC_16_PCREL
;
4953 code
= BFD_RELOC_24_PCREL
;
4956 code
= BFD_RELOC_32_PCREL
;
4959 code
= BFD_RELOC_64_PCREL
;
4965 howto
= bfd_reloc_type_lookup (abfd
, code
);
4967 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4969 if (howto
->pcrel_offset
)
4970 areloc
->addend
+= areloc
->address
;
4972 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4977 switch (areloc
->howto
->bitsize
)
4983 code
= BFD_RELOC_14
;
4986 code
= BFD_RELOC_16
;
4989 code
= BFD_RELOC_26
;
4992 code
= BFD_RELOC_32
;
4995 code
= BFD_RELOC_64
;
5001 howto
= bfd_reloc_type_lookup (abfd
, code
);
5005 areloc
->howto
= howto
;
5013 (*_bfd_error_handler
)
5014 (_("%s: unsupported relocation type %s"),
5015 bfd_get_filename (abfd
), areloc
->howto
->name
);
5016 bfd_set_error (bfd_error_bad_value
);
5021 _bfd_elf_close_and_cleanup (abfd
)
5024 if (bfd_get_format (abfd
) == bfd_object
)
5026 if (elf_shstrtab (abfd
) != NULL
)
5027 _bfd_stringtab_free (elf_shstrtab (abfd
));
5030 return _bfd_generic_close_and_cleanup (abfd
);
5033 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5034 in the relocation's offset. Thus we cannot allow any sort of sanity
5035 range-checking to interfere. There is nothing else to do in processing
5038 bfd_reloc_status_type
5039 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
5040 bfd
*abfd ATTRIBUTE_UNUSED
;
5041 arelent
*re ATTRIBUTE_UNUSED
;
5042 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
5043 PTR data ATTRIBUTE_UNUSED
;
5044 asection
*is ATTRIBUTE_UNUSED
;
5045 bfd
*obfd ATTRIBUTE_UNUSED
;
5046 char **errmsg ATTRIBUTE_UNUSED
;
5048 return bfd_reloc_ok
;
5052 /* Elf core file support. Much of this only works on native
5053 toolchains, since we rely on knowing the
5054 machine-dependent procfs structure in order to pick
5055 out details about the corefile. */
5057 #ifdef HAVE_SYS_PROCFS_H
5058 # include <sys/procfs.h>
5062 /* Define offsetof for those systems which lack it. */
5065 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
5069 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5072 elfcore_make_pid (abfd
)
5075 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
5076 + (elf_tdata (abfd
)->core_pid
));
5080 /* If there isn't a section called NAME, make one, using
5081 data from SECT. Note, this function will generate a
5082 reference to NAME, so you shouldn't deallocate or
5086 elfcore_maybe_make_sect (abfd
, name
, sect
)
5093 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
5096 sect2
= bfd_make_section (abfd
, name
);
5100 sect2
->_raw_size
= sect
->_raw_size
;
5101 sect2
->filepos
= sect
->filepos
;
5102 sect2
->flags
= sect
->flags
;
5103 sect2
->alignment_power
= sect
->alignment_power
;
5108 /* prstatus_t exists on:
5110 linux 2.[01] + glibc
5114 #if defined (HAVE_PRSTATUS_T)
5116 elfcore_grok_prstatus (abfd
, note
)
5118 Elf_Internal_Note
* note
;
5125 if (note
->descsz
== sizeof (prstatus_t
))
5129 raw_size
= sizeof (prstat
.pr_reg
);
5130 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5132 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5133 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5135 /* pr_who exists on:
5138 pr_who doesn't exist on:
5141 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5142 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5145 #if defined (__sparcv9)
5146 else if (note
->descsz
== sizeof (prstatus32_t
))
5148 /* 64-bit host, 32-bit corefile */
5149 prstatus32_t prstat
;
5151 raw_size
= sizeof (prstat
.pr_reg
);
5152 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5154 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5155 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5157 /* pr_who exists on:
5160 pr_who doesn't exist on:
5163 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5164 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5167 #endif /* __sparcv9 */
5170 /* Fail - we don't know how to handle any other
5171 note size (ie. data object type). */
5175 /* Make a ".reg/999" section. */
5177 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5178 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5183 sect
= bfd_make_section (abfd
, name
);
5187 if (note
->descsz
== sizeof (prstatus_t
))
5189 sect
->_raw_size
= raw_size
;
5190 sect
->filepos
= note
->descpos
+ offsetof (prstatus_t
, pr_reg
);
5192 #if defined (__sparcv9)
5193 else if (note
->descsz
== sizeof (prstatus32_t
))
5195 sect
->_raw_size
= raw_size
;
5196 sect
->filepos
= note
->descpos
+ offsetof (prstatus32_t
, pr_reg
);
5200 sect
->flags
= SEC_HAS_CONTENTS
;
5201 sect
->alignment_power
= 2;
5203 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5208 #endif /* defined (HAVE_PRSTATUS_T) */
5211 /* Create a pseudosection containing the exact contents of NOTE. This
5212 actually creates up to two pseudosections:
5213 - For the single-threaded case, a section named NAME, unless
5214 such a section already exists.
5215 - For the multi-threaded case, a section named "NAME/PID", where
5216 PID is elfcore_make_pid (abfd).
5217 Both pseudosections have identical contents: the contents of NOTE. */
5220 elfcore_make_note_pseudosection (abfd
, name
, note
)
5223 Elf_Internal_Note
* note
;
5226 char *threaded_name
;
5229 /* Build the section name. */
5231 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
5232 threaded_name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5233 if (threaded_name
== NULL
)
5235 strcpy (threaded_name
, buf
);
5237 sect
= bfd_make_section (abfd
, threaded_name
);
5240 sect
->_raw_size
= note
->descsz
;
5241 sect
->filepos
= note
->descpos
;
5242 sect
->flags
= SEC_HAS_CONTENTS
;
5243 sect
->alignment_power
= 2;
5245 if (! elfcore_maybe_make_sect (abfd
, name
, sect
))
5252 /* There isn't a consistent prfpregset_t across platforms,
5253 but it doesn't matter, because we don't have to pick this
5254 data structure apart. */
5256 elfcore_grok_prfpreg (abfd
, note
)
5258 Elf_Internal_Note
* note
;
5260 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
5264 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5265 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5268 elfcore_grok_prxfpreg (abfd
, note
)
5270 Elf_Internal_Note
* note
;
5272 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
5276 #if defined (HAVE_PRPSINFO_T)
5277 typedef prpsinfo_t elfcore_psinfo_t
;
5278 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5279 typedef prpsinfo32_t elfcore_psinfo32_t
;
5283 #if defined (HAVE_PSINFO_T)
5284 typedef psinfo_t elfcore_psinfo_t
;
5285 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5286 typedef psinfo32_t elfcore_psinfo32_t
;
5291 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5293 /* return a malloc'ed copy of a string at START which is at
5294 most MAX bytes long, possibly without a terminating '\0'.
5295 the copy will always have a terminating '\0'. */
5298 elfcore_strndup (abfd
, start
, max
)
5304 char* end
= memchr (start
, '\0', max
);
5312 dup
= bfd_alloc (abfd
, len
+ 1);
5316 memcpy (dup
, start
, len
);
5323 elfcore_grok_psinfo (abfd
, note
)
5325 Elf_Internal_Note
* note
;
5327 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
5329 elfcore_psinfo_t psinfo
;
5331 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5333 elf_tdata (abfd
)->core_program
5334 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5336 elf_tdata (abfd
)->core_command
5337 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5339 #if defined (__sparcv9)
5340 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
5342 /* 64-bit host, 32-bit corefile */
5343 elfcore_psinfo32_t psinfo
;
5345 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5347 elf_tdata (abfd
)->core_program
5348 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5350 elf_tdata (abfd
)->core_command
5351 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5357 /* Fail - we don't know how to handle any other
5358 note size (ie. data object type). */
5362 /* Note that for some reason, a spurious space is tacked
5363 onto the end of the args in some (at least one anyway)
5364 implementations, so strip it off if it exists. */
5367 char* command
= elf_tdata (abfd
)->core_command
;
5368 int n
= strlen (command
);
5370 if (0 < n
&& command
[n
- 1] == ' ')
5371 command
[n
- 1] = '\0';
5376 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5379 #if defined (HAVE_PSTATUS_T)
5381 elfcore_grok_pstatus (abfd
, note
)
5383 Elf_Internal_Note
* note
;
5385 if (note
->descsz
== sizeof (pstatus_t
))
5389 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5391 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5393 #if defined (__sparcv9)
5394 else if (note
->descsz
== sizeof (pstatus32_t
))
5396 /* 64-bit host, 32-bit corefile */
5399 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5401 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5404 /* Could grab some more details from the "representative"
5405 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5406 NT_LWPSTATUS note, presumably. */
5410 #endif /* defined (HAVE_PSTATUS_T) */
5413 #if defined (HAVE_LWPSTATUS_T)
5415 elfcore_grok_lwpstatus (abfd
, note
)
5417 Elf_Internal_Note
* note
;
5419 lwpstatus_t lwpstat
;
5424 if (note
->descsz
!= sizeof (lwpstat
))
5427 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
5429 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
5430 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
5432 /* Make a ".reg/999" section. */
5434 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5435 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5440 sect
= bfd_make_section (abfd
, name
);
5444 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5445 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
5446 sect
->filepos
= note
->descpos
5447 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
5450 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5451 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
5452 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
5455 sect
->flags
= SEC_HAS_CONTENTS
;
5456 sect
->alignment_power
= 2;
5458 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5461 /* Make a ".reg2/999" section */
5463 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
5464 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5469 sect
= bfd_make_section (abfd
, name
);
5473 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5474 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
5475 sect
->filepos
= note
->descpos
5476 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
5479 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5480 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
5481 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
5484 sect
->flags
= SEC_HAS_CONTENTS
;
5485 sect
->alignment_power
= 2;
5487 if (!elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
5492 #endif /* defined (HAVE_LWPSTATUS_T) */
5494 #if defined (HAVE_WIN32_PSTATUS_T)
5496 elfcore_grok_win32pstatus (abfd
, note
)
5498 Elf_Internal_Note
* note
;
5503 win32_pstatus_t pstatus
;
5505 if (note
->descsz
< sizeof (pstatus
))
5508 memcpy (& pstatus
, note
->descdata
, note
->descsz
);
5510 switch (pstatus
.data_type
)
5512 case NOTE_INFO_PROCESS
:
5513 /* FIXME: need to add ->core_command. */
5514 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
5515 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
5518 case NOTE_INFO_THREAD
:
5519 /* Make a ".reg/999" section. */
5520 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
5522 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5528 sect
= bfd_make_section (abfd
, name
);
5532 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
5533 sect
->filepos
= note
->descpos
+ offsetof (struct win32_pstatus
,
5534 data
.thread_info
.thread_context
);
5535 sect
->flags
= SEC_HAS_CONTENTS
;
5536 sect
->alignment_power
= 2;
5538 if (pstatus
.data
.thread_info
.is_active_thread
)
5539 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5543 case NOTE_INFO_MODULE
:
5544 /* Make a ".module/xxxxxxxx" section. */
5545 sprintf (buf
, ".module/%08x" , pstatus
.data
.module_info
.base_address
);
5547 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5553 sect
= bfd_make_section (abfd
, name
);
5558 sect
->_raw_size
= note
->descsz
;
5559 sect
->filepos
= note
->descpos
;
5560 sect
->flags
= SEC_HAS_CONTENTS
;
5561 sect
->alignment_power
= 2;
5570 #endif /* HAVE_WIN32_PSTATUS_T */
5573 elfcore_grok_note (abfd
, note
)
5575 Elf_Internal_Note
* note
;
5582 #if defined (HAVE_PRSTATUS_T)
5584 return elfcore_grok_prstatus (abfd
, note
);
5587 #if defined (HAVE_PSTATUS_T)
5589 return elfcore_grok_pstatus (abfd
, note
);
5592 #if defined (HAVE_LWPSTATUS_T)
5594 return elfcore_grok_lwpstatus (abfd
, note
);
5597 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
5598 return elfcore_grok_prfpreg (abfd
, note
);
5600 #if defined (HAVE_WIN32_PSTATUS_T)
5601 case NT_WIN32PSTATUS
:
5602 return elfcore_grok_win32pstatus (abfd
, note
);
5605 case NT_PRXFPREG
: /* Linux SSE extension */
5606 if (note
->namesz
== 5
5607 && ! strcmp (note
->namedata
, "LINUX"))
5608 return elfcore_grok_prxfpreg (abfd
, note
);
5612 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5615 return elfcore_grok_psinfo (abfd
, note
);
5622 elfcore_read_notes (abfd
, offset
, size
)
5633 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
5636 buf
= bfd_malloc ((size_t) size
);
5640 if (bfd_read (buf
, size
, 1, abfd
) != size
)
5648 while (p
< buf
+ size
)
5650 /* FIXME: bad alignment assumption. */
5651 Elf_External_Note
* xnp
= (Elf_External_Note
*) p
;
5652 Elf_Internal_Note in
;
5654 in
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->type
);
5656 in
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->namesz
);
5657 in
.namedata
= xnp
->name
;
5659 in
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->descsz
);
5660 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
5661 in
.descpos
= offset
+ (in
.descdata
- buf
);
5663 if (! elfcore_grok_note (abfd
, &in
))
5666 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
5674 /* FIXME: This function is now unnecessary. Callers can just call
5675 bfd_section_from_phdr directly. */
5678 _bfd_elfcore_section_from_phdr (abfd
, phdr
, sec_num
)
5680 Elf_Internal_Phdr
* phdr
;
5683 if (! bfd_section_from_phdr (abfd
, phdr
, sec_num
))
5691 /* Providing external access to the ELF program header table. */
5693 /* Return an upper bound on the number of bytes required to store a
5694 copy of ABFD's program header table entries. Return -1 if an error
5695 occurs; bfd_get_error will return an appropriate code. */
5697 bfd_get_elf_phdr_upper_bound (abfd
)
5700 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5702 bfd_set_error (bfd_error_wrong_format
);
5706 return (elf_elfheader (abfd
)->e_phnum
5707 * sizeof (Elf_Internal_Phdr
));
5711 /* Copy ABFD's program header table entries to *PHDRS. The entries
5712 will be stored as an array of Elf_Internal_Phdr structures, as
5713 defined in include/elf/internal.h. To find out how large the
5714 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5716 Return the number of program header table entries read, or -1 if an
5717 error occurs; bfd_get_error will return an appropriate code. */
5719 bfd_get_elf_phdrs (abfd
, phdrs
)
5725 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5727 bfd_set_error (bfd_error_wrong_format
);
5731 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
5732 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
5733 num_phdrs
* sizeof (Elf_Internal_Phdr
));