1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2016 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
33 haven't bothered yet. */
35 /* For sparc64-cross-sparc32. */
43 #include "libiberty.h"
44 #include "safe-ctype.h"
45 #include "elf-linux-core.h"
51 static int elf_sort_sections (const void *, const void *);
52 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
53 static bfd_boolean
prep_headers (bfd
*);
54 static bfd_boolean
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int) ;
55 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
56 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
59 /* Swap version information in and out. The version information is
60 currently size independent. If that ever changes, this code will
61 need to move into elfcode.h. */
63 /* Swap in a Verdef structure. */
66 _bfd_elf_swap_verdef_in (bfd
*abfd
,
67 const Elf_External_Verdef
*src
,
68 Elf_Internal_Verdef
*dst
)
70 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
71 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
72 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
73 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
74 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
75 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
76 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
79 /* Swap out a Verdef structure. */
82 _bfd_elf_swap_verdef_out (bfd
*abfd
,
83 const Elf_Internal_Verdef
*src
,
84 Elf_External_Verdef
*dst
)
86 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
99 const Elf_External_Verdaux
*src
,
100 Elf_Internal_Verdaux
*dst
)
102 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
103 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
106 /* Swap out a Verdaux structure. */
109 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
110 const Elf_Internal_Verdaux
*src
,
111 Elf_External_Verdaux
*dst
)
113 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
114 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
117 /* Swap in a Verneed structure. */
120 _bfd_elf_swap_verneed_in (bfd
*abfd
,
121 const Elf_External_Verneed
*src
,
122 Elf_Internal_Verneed
*dst
)
124 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
125 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
126 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
127 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
128 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
131 /* Swap out a Verneed structure. */
134 _bfd_elf_swap_verneed_out (bfd
*abfd
,
135 const Elf_Internal_Verneed
*src
,
136 Elf_External_Verneed
*dst
)
138 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
139 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
140 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
141 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
142 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
145 /* Swap in a Vernaux structure. */
148 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
149 const Elf_External_Vernaux
*src
,
150 Elf_Internal_Vernaux
*dst
)
152 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
153 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
154 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
155 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
156 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
159 /* Swap out a Vernaux structure. */
162 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
163 const Elf_Internal_Vernaux
*src
,
164 Elf_External_Vernaux
*dst
)
166 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
167 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
168 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
169 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
170 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
173 /* Swap in a Versym structure. */
176 _bfd_elf_swap_versym_in (bfd
*abfd
,
177 const Elf_External_Versym
*src
,
178 Elf_Internal_Versym
*dst
)
180 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
183 /* Swap out a Versym structure. */
186 _bfd_elf_swap_versym_out (bfd
*abfd
,
187 const Elf_Internal_Versym
*src
,
188 Elf_External_Versym
*dst
)
190 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
193 /* Standard ELF hash function. Do not change this function; you will
194 cause invalid hash tables to be generated. */
197 bfd_elf_hash (const char *namearg
)
199 const unsigned char *name
= (const unsigned char *) namearg
;
204 while ((ch
= *name
++) != '\0')
207 if ((g
= (h
& 0xf0000000)) != 0)
210 /* The ELF ABI says `h &= ~g', but this is equivalent in
211 this case and on some machines one insn instead of two. */
215 return h
& 0xffffffff;
218 /* DT_GNU_HASH hash function. Do not change this function; you will
219 cause invalid hash tables to be generated. */
222 bfd_elf_gnu_hash (const char *namearg
)
224 const unsigned char *name
= (const unsigned char *) namearg
;
225 unsigned long h
= 5381;
228 while ((ch
= *name
++) != '\0')
229 h
= (h
<< 5) + h
+ ch
;
230 return h
& 0xffffffff;
233 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
234 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
236 bfd_elf_allocate_object (bfd
*abfd
,
238 enum elf_target_id object_id
)
240 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
241 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
242 if (abfd
->tdata
.any
== NULL
)
245 elf_object_id (abfd
) = object_id
;
246 if (abfd
->direction
!= read_direction
)
248 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
251 elf_tdata (abfd
)->o
= o
;
252 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
259 bfd_elf_make_object (bfd
*abfd
)
261 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
262 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
267 bfd_elf_mkcorefile (bfd
*abfd
)
269 /* I think this can be done just like an object file. */
270 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
272 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
273 return elf_tdata (abfd
)->core
!= NULL
;
277 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
279 Elf_Internal_Shdr
**i_shdrp
;
280 bfd_byte
*shstrtab
= NULL
;
282 bfd_size_type shstrtabsize
;
284 i_shdrp
= elf_elfsections (abfd
);
286 || shindex
>= elf_numsections (abfd
)
287 || i_shdrp
[shindex
] == 0)
290 shstrtab
= i_shdrp
[shindex
]->contents
;
291 if (shstrtab
== NULL
)
293 /* No cached one, attempt to read, and cache what we read. */
294 offset
= i_shdrp
[shindex
]->sh_offset
;
295 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
297 /* Allocate and clear an extra byte at the end, to prevent crashes
298 in case the string table is not terminated. */
299 if (shstrtabsize
+ 1 <= 1
300 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
301 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
303 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
305 if (bfd_get_error () != bfd_error_system_call
)
306 bfd_set_error (bfd_error_file_truncated
);
307 bfd_release (abfd
, shstrtab
);
309 /* Once we've failed to read it, make sure we don't keep
310 trying. Otherwise, we'll keep allocating space for
311 the string table over and over. */
312 i_shdrp
[shindex
]->sh_size
= 0;
315 shstrtab
[shstrtabsize
] = '\0';
316 i_shdrp
[shindex
]->contents
= shstrtab
;
318 return (char *) shstrtab
;
322 bfd_elf_string_from_elf_section (bfd
*abfd
,
323 unsigned int shindex
,
324 unsigned int strindex
)
326 Elf_Internal_Shdr
*hdr
;
331 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
334 hdr
= elf_elfsections (abfd
)[shindex
];
336 if (hdr
->contents
== NULL
)
338 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
340 /* PR 17512: file: f057ec89. */
341 /* xgettext:c-format */
342 _bfd_error_handler (_("%B: attempt to load strings from a non-string section (number %d)"),
347 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
351 if (strindex
>= hdr
->sh_size
)
353 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
355 /* xgettext:c-format */
356 (_("%B: invalid string offset %u >= %lu for section `%s'"),
357 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
358 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
360 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
364 return ((char *) hdr
->contents
) + strindex
;
367 /* Read and convert symbols to internal format.
368 SYMCOUNT specifies the number of symbols to read, starting from
369 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
370 are non-NULL, they are used to store the internal symbols, external
371 symbols, and symbol section index extensions, respectively.
372 Returns a pointer to the internal symbol buffer (malloced if necessary)
373 or NULL if there were no symbols or some kind of problem. */
376 bfd_elf_get_elf_syms (bfd
*ibfd
,
377 Elf_Internal_Shdr
*symtab_hdr
,
380 Elf_Internal_Sym
*intsym_buf
,
382 Elf_External_Sym_Shndx
*extshndx_buf
)
384 Elf_Internal_Shdr
*shndx_hdr
;
386 const bfd_byte
*esym
;
387 Elf_External_Sym_Shndx
*alloc_extshndx
;
388 Elf_External_Sym_Shndx
*shndx
;
389 Elf_Internal_Sym
*alloc_intsym
;
390 Elf_Internal_Sym
*isym
;
391 Elf_Internal_Sym
*isymend
;
392 const struct elf_backend_data
*bed
;
397 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
403 /* Normal syms might have section extension entries. */
405 if (elf_symtab_shndx_list (ibfd
) != NULL
)
407 elf_section_list
* entry
;
408 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
410 /* Find an index section that is linked to this symtab section. */
411 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
414 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
417 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
419 shndx_hdr
= & entry
->hdr
;
424 if (shndx_hdr
== NULL
)
426 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
427 /* Not really accurate, but this was how the old code used to work. */
428 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
429 /* Otherwise we do nothing. The assumption is that
430 the index table will not be needed. */
434 /* Read the symbols. */
436 alloc_extshndx
= NULL
;
438 bed
= get_elf_backend_data (ibfd
);
439 extsym_size
= bed
->s
->sizeof_sym
;
440 amt
= (bfd_size_type
) symcount
* extsym_size
;
441 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
442 if (extsym_buf
== NULL
)
444 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
445 extsym_buf
= alloc_ext
;
447 if (extsym_buf
== NULL
448 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
449 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
455 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
459 amt
= (bfd_size_type
) symcount
* sizeof (Elf_External_Sym_Shndx
);
460 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
461 if (extshndx_buf
== NULL
)
463 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
464 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
465 extshndx_buf
= alloc_extshndx
;
467 if (extshndx_buf
== NULL
468 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
469 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
476 if (intsym_buf
== NULL
)
478 alloc_intsym
= (Elf_Internal_Sym
*)
479 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
480 intsym_buf
= alloc_intsym
;
481 if (intsym_buf
== NULL
)
485 /* Convert the symbols to internal form. */
486 isymend
= intsym_buf
+ symcount
;
487 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
488 shndx
= extshndx_buf
;
490 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
491 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
493 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
494 /* xgettext:c-format */
495 _bfd_error_handler (_("%B symbol number %lu references "
496 "nonexistent SHT_SYMTAB_SHNDX section"),
497 ibfd
, (unsigned long) symoffset
);
498 if (alloc_intsym
!= NULL
)
505 if (alloc_ext
!= NULL
)
507 if (alloc_extshndx
!= NULL
)
508 free (alloc_extshndx
);
513 /* Look up a symbol name. */
515 bfd_elf_sym_name (bfd
*abfd
,
516 Elf_Internal_Shdr
*symtab_hdr
,
517 Elf_Internal_Sym
*isym
,
521 unsigned int iname
= isym
->st_name
;
522 unsigned int shindex
= symtab_hdr
->sh_link
;
524 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
525 /* Check for a bogus st_shndx to avoid crashing. */
526 && isym
->st_shndx
< elf_numsections (abfd
))
528 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
529 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
532 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
535 else if (sym_sec
&& *name
== '\0')
536 name
= bfd_section_name (abfd
, sym_sec
);
541 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
542 sections. The first element is the flags, the rest are section
545 typedef union elf_internal_group
{
546 Elf_Internal_Shdr
*shdr
;
548 } Elf_Internal_Group
;
550 /* Return the name of the group signature symbol. Why isn't the
551 signature just a string? */
554 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
556 Elf_Internal_Shdr
*hdr
;
557 unsigned char esym
[sizeof (Elf64_External_Sym
)];
558 Elf_External_Sym_Shndx eshndx
;
559 Elf_Internal_Sym isym
;
561 /* First we need to ensure the symbol table is available. Make sure
562 that it is a symbol table section. */
563 if (ghdr
->sh_link
>= elf_numsections (abfd
))
565 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
566 if (hdr
->sh_type
!= SHT_SYMTAB
567 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
570 /* Go read the symbol. */
571 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
572 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
573 &isym
, esym
, &eshndx
) == NULL
)
576 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
579 /* Set next_in_group list pointer, and group name for NEWSECT. */
582 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
584 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
586 /* If num_group is zero, read in all SHT_GROUP sections. The count
587 is set to -1 if there are no SHT_GROUP sections. */
590 unsigned int i
, shnum
;
592 /* First count the number of groups. If we have a SHT_GROUP
593 section with just a flag word (ie. sh_size is 4), ignore it. */
594 shnum
= elf_numsections (abfd
);
597 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
598 ( (shdr)->sh_type == SHT_GROUP \
599 && (shdr)->sh_size >= minsize \
600 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
601 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
603 for (i
= 0; i
< shnum
; i
++)
605 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
607 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
613 num_group
= (unsigned) -1;
614 elf_tdata (abfd
)->num_group
= num_group
;
618 /* We keep a list of elf section headers for group sections,
619 so we can find them quickly. */
622 elf_tdata (abfd
)->num_group
= num_group
;
623 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
624 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
625 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
629 for (i
= 0; i
< shnum
; i
++)
631 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
633 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
636 Elf_Internal_Group
*dest
;
638 /* Add to list of sections. */
639 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
642 /* Read the raw contents. */
643 BFD_ASSERT (sizeof (*dest
) >= 4);
644 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
645 shdr
->contents
= (unsigned char *)
646 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
647 /* PR binutils/4110: Handle corrupt group headers. */
648 if (shdr
->contents
== NULL
)
651 /* xgettext:c-format */
652 (_("%B: corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
653 bfd_set_error (bfd_error_bad_value
);
658 memset (shdr
->contents
, 0, amt
);
660 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
661 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
665 /* xgettext:c-format */
666 (_("%B: invalid size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
667 bfd_set_error (bfd_error_bad_value
);
669 /* PR 17510: If the group contents are even partially
670 corrupt, do not allow any of the contents to be used. */
671 memset (shdr
->contents
, 0, amt
);
675 /* Translate raw contents, a flag word followed by an
676 array of elf section indices all in target byte order,
677 to the flag word followed by an array of elf section
679 src
= shdr
->contents
+ shdr
->sh_size
;
680 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
688 idx
= H_GET_32 (abfd
, src
);
689 if (src
== shdr
->contents
)
692 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
693 shdr
->bfd_section
->flags
694 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
700 (_("%B: invalid SHT_GROUP entry"), abfd
);
703 dest
->shdr
= elf_elfsections (abfd
)[idx
];
708 /* PR 17510: Corrupt binaries might contain invalid groups. */
709 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
711 elf_tdata (abfd
)->num_group
= num_group
;
713 /* If all groups are invalid then fail. */
716 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
717 elf_tdata (abfd
)->num_group
= num_group
= -1;
719 (_("%B: no valid group sections found"), abfd
);
720 bfd_set_error (bfd_error_bad_value
);
726 if (num_group
!= (unsigned) -1)
730 for (i
= 0; i
< num_group
; i
++)
732 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
733 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
734 unsigned int n_elt
= shdr
->sh_size
/ 4;
736 /* Look through this group's sections to see if current
737 section is a member. */
739 if ((++idx
)->shdr
== hdr
)
743 /* We are a member of this group. Go looking through
744 other members to see if any others are linked via
746 idx
= (Elf_Internal_Group
*) shdr
->contents
;
747 n_elt
= shdr
->sh_size
/ 4;
749 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
750 && elf_next_in_group (s
) != NULL
)
754 /* Snarf the group name from other member, and
755 insert current section in circular list. */
756 elf_group_name (newsect
) = elf_group_name (s
);
757 elf_next_in_group (newsect
) = elf_next_in_group (s
);
758 elf_next_in_group (s
) = newsect
;
764 gname
= group_signature (abfd
, shdr
);
767 elf_group_name (newsect
) = gname
;
769 /* Start a circular list with one element. */
770 elf_next_in_group (newsect
) = newsect
;
773 /* If the group section has been created, point to the
775 if (shdr
->bfd_section
!= NULL
)
776 elf_next_in_group (shdr
->bfd_section
) = newsect
;
784 if (elf_group_name (newsect
) == NULL
)
786 /* xgettext:c-format */
787 _bfd_error_handler (_("%B: no group info for section %A"),
795 _bfd_elf_setup_sections (bfd
*abfd
)
798 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
799 bfd_boolean result
= TRUE
;
802 /* Process SHF_LINK_ORDER. */
803 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
805 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
806 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
808 unsigned int elfsec
= this_hdr
->sh_link
;
809 /* FIXME: The old Intel compiler and old strip/objcopy may
810 not set the sh_link or sh_info fields. Hence we could
811 get the situation where elfsec is 0. */
814 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
815 if (bed
->link_order_error_handler
)
816 bed
->link_order_error_handler
817 /* xgettext:c-format */
818 (_("%B: warning: sh_link not set for section `%A'"),
823 asection
*linksec
= NULL
;
825 if (elfsec
< elf_numsections (abfd
))
827 this_hdr
= elf_elfsections (abfd
)[elfsec
];
828 linksec
= this_hdr
->bfd_section
;
832 Some strip/objcopy may leave an incorrect value in
833 sh_link. We don't want to proceed. */
837 /* xgettext:c-format */
838 (_("%B: sh_link [%d] in section `%A' is incorrect"),
839 s
->owner
, s
, elfsec
);
843 elf_linked_to_section (s
) = linksec
;
846 else if (this_hdr
->sh_type
== SHT_GROUP
847 && elf_next_in_group (s
) == NULL
)
850 /* xgettext:c-format */
851 (_("%B: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
852 abfd
, elf_section_data (s
)->this_idx
);
857 /* Process section groups. */
858 if (num_group
== (unsigned) -1)
861 for (i
= 0; i
< num_group
; i
++)
863 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
864 Elf_Internal_Group
*idx
;
867 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
868 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
871 /* xgettext:c-format */
872 (_("%B: section group entry number %u is corrupt"),
878 idx
= (Elf_Internal_Group
*) shdr
->contents
;
879 n_elt
= shdr
->sh_size
/ 4;
882 if ((++idx
)->shdr
->bfd_section
)
883 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
884 else if (idx
->shdr
->sh_type
== SHT_RELA
885 || idx
->shdr
->sh_type
== SHT_REL
)
886 /* We won't include relocation sections in section groups in
887 output object files. We adjust the group section size here
888 so that relocatable link will work correctly when
889 relocation sections are in section group in input object
891 shdr
->bfd_section
->size
-= 4;
894 /* There are some unknown sections in the group. */
896 /* xgettext:c-format */
897 (_("%B: unknown [%d] section `%s' in group [%s]"),
899 (unsigned int) idx
->shdr
->sh_type
,
900 bfd_elf_string_from_elf_section (abfd
,
901 (elf_elfheader (abfd
)
904 shdr
->bfd_section
->name
);
912 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
914 return elf_next_in_group (sec
) != NULL
;
918 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
920 unsigned int len
= strlen (name
);
921 char *new_name
= bfd_alloc (abfd
, len
+ 2);
922 if (new_name
== NULL
)
926 memcpy (new_name
+ 2, name
+ 1, len
);
931 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
933 unsigned int len
= strlen (name
);
934 char *new_name
= bfd_alloc (abfd
, len
);
935 if (new_name
== NULL
)
938 memcpy (new_name
+ 1, name
+ 2, len
- 1);
942 /* Make a BFD section from an ELF section. We store a pointer to the
943 BFD section in the bfd_section field of the header. */
946 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
947 Elf_Internal_Shdr
*hdr
,
953 const struct elf_backend_data
*bed
;
955 if (hdr
->bfd_section
!= NULL
)
958 newsect
= bfd_make_section_anyway (abfd
, name
);
962 hdr
->bfd_section
= newsect
;
963 elf_section_data (newsect
)->this_hdr
= *hdr
;
964 elf_section_data (newsect
)->this_idx
= shindex
;
966 /* Always use the real type/flags. */
967 elf_section_type (newsect
) = hdr
->sh_type
;
968 elf_section_flags (newsect
) = hdr
->sh_flags
;
970 newsect
->filepos
= hdr
->sh_offset
;
972 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
973 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
974 || ! bfd_set_section_alignment (abfd
, newsect
,
975 bfd_log2 (hdr
->sh_addralign
)))
978 flags
= SEC_NO_FLAGS
;
979 if (hdr
->sh_type
!= SHT_NOBITS
)
980 flags
|= SEC_HAS_CONTENTS
;
981 if (hdr
->sh_type
== SHT_GROUP
)
982 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
983 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
986 if (hdr
->sh_type
!= SHT_NOBITS
)
989 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
990 flags
|= SEC_READONLY
;
991 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
993 else if ((flags
& SEC_LOAD
) != 0)
995 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
998 newsect
->entsize
= hdr
->sh_entsize
;
1000 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1001 flags
|= SEC_STRINGS
;
1002 if (hdr
->sh_flags
& SHF_GROUP
)
1003 if (!setup_group (abfd
, hdr
, newsect
))
1005 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1006 flags
|= SEC_THREAD_LOCAL
;
1007 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1008 flags
|= SEC_EXCLUDE
;
1010 if ((flags
& SEC_ALLOC
) == 0)
1012 /* The debugging sections appear to be recognized only by name,
1013 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1014 if (name
[0] == '.')
1019 p
= ".debug", n
= 6;
1020 else if (name
[1] == 'g' && name
[2] == 'n')
1021 p
= ".gnu.linkonce.wi.", n
= 17;
1022 else if (name
[1] == 'g' && name
[2] == 'd')
1023 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
1024 else if (name
[1] == 'l')
1026 else if (name
[1] == 's')
1028 else if (name
[1] == 'z')
1029 p
= ".zdebug", n
= 7;
1032 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
1033 flags
|= SEC_DEBUGGING
;
1037 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1038 only link a single copy of the section. This is used to support
1039 g++. g++ will emit each template expansion in its own section.
1040 The symbols will be defined as weak, so that multiple definitions
1041 are permitted. The GNU linker extension is to actually discard
1042 all but one of the sections. */
1043 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1044 && elf_next_in_group (newsect
) == NULL
)
1045 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1047 bed
= get_elf_backend_data (abfd
);
1048 if (bed
->elf_backend_section_flags
)
1049 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1052 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
1055 /* We do not parse the PT_NOTE segments as we are interested even in the
1056 separate debug info files which may have the segments offsets corrupted.
1057 PT_NOTEs from the core files are currently not parsed using BFD. */
1058 if (hdr
->sh_type
== SHT_NOTE
)
1062 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1065 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
, hdr
->sh_offset
);
1069 if ((flags
& SEC_ALLOC
) != 0)
1071 Elf_Internal_Phdr
*phdr
;
1072 unsigned int i
, nload
;
1074 /* Some ELF linkers produce binaries with all the program header
1075 p_paddr fields zero. If we have such a binary with more than
1076 one PT_LOAD header, then leave the section lma equal to vma
1077 so that we don't create sections with overlapping lma. */
1078 phdr
= elf_tdata (abfd
)->phdr
;
1079 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1080 if (phdr
->p_paddr
!= 0)
1082 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1084 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1087 phdr
= elf_tdata (abfd
)->phdr
;
1088 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1090 if (((phdr
->p_type
== PT_LOAD
1091 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1092 || phdr
->p_type
== PT_TLS
)
1093 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1095 if ((flags
& SEC_LOAD
) == 0)
1096 newsect
->lma
= (phdr
->p_paddr
1097 + hdr
->sh_addr
- phdr
->p_vaddr
);
1099 /* We used to use the same adjustment for SEC_LOAD
1100 sections, but that doesn't work if the segment
1101 is packed with code from multiple VMAs.
1102 Instead we calculate the section LMA based on
1103 the segment LMA. It is assumed that the
1104 segment will contain sections with contiguous
1105 LMAs, even if the VMAs are not. */
1106 newsect
->lma
= (phdr
->p_paddr
1107 + hdr
->sh_offset
- phdr
->p_offset
);
1109 /* With contiguous segments, we can't tell from file
1110 offsets whether a section with zero size should
1111 be placed at the end of one segment or the
1112 beginning of the next. Decide based on vaddr. */
1113 if (hdr
->sh_addr
>= phdr
->p_vaddr
1114 && (hdr
->sh_addr
+ hdr
->sh_size
1115 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1121 /* Compress/decompress DWARF debug sections with names: .debug_* and
1122 .zdebug_*, after the section flags is set. */
1123 if ((flags
& SEC_DEBUGGING
)
1124 && ((name
[1] == 'd' && name
[6] == '_')
1125 || (name
[1] == 'z' && name
[7] == '_')))
1127 enum { nothing
, compress
, decompress
} action
= nothing
;
1128 int compression_header_size
;
1129 bfd_size_type uncompressed_size
;
1130 bfd_boolean compressed
1131 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1132 &compression_header_size
,
1133 &uncompressed_size
);
1137 /* Compressed section. Check if we should decompress. */
1138 if ((abfd
->flags
& BFD_DECOMPRESS
))
1139 action
= decompress
;
1142 /* Compress the uncompressed section or convert from/to .zdebug*
1143 section. Check if we should compress. */
1144 if (action
== nothing
)
1146 if (newsect
->size
!= 0
1147 && (abfd
->flags
& BFD_COMPRESS
)
1148 && compression_header_size
>= 0
1149 && uncompressed_size
> 0
1151 || ((compression_header_size
> 0)
1152 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1158 if (action
== compress
)
1160 if (!bfd_init_section_compress_status (abfd
, newsect
))
1163 /* xgettext:c-format */
1164 (_("%B: unable to initialize compress status for section %s"),
1171 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1174 /* xgettext:c-format */
1175 (_("%B: unable to initialize decompress status for section %s"),
1181 if (abfd
->is_linker_input
)
1184 && (action
== decompress
1185 || (action
== compress
1186 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1188 /* Convert section name from .zdebug_* to .debug_* so
1189 that linker will consider this section as a debug
1191 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1192 if (new_name
== NULL
)
1194 bfd_rename_section (abfd
, newsect
, new_name
);
1198 /* For objdump, don't rename the section. For objcopy, delay
1199 section rename to elf_fake_sections. */
1200 newsect
->flags
|= SEC_ELF_RENAME
;
1206 const char *const bfd_elf_section_type_names
[] =
1208 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1209 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1210 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1213 /* ELF relocs are against symbols. If we are producing relocatable
1214 output, and the reloc is against an external symbol, and nothing
1215 has given us any additional addend, the resulting reloc will also
1216 be against the same symbol. In such a case, we don't want to
1217 change anything about the way the reloc is handled, since it will
1218 all be done at final link time. Rather than put special case code
1219 into bfd_perform_relocation, all the reloc types use this howto
1220 function. It just short circuits the reloc if producing
1221 relocatable output against an external symbol. */
1223 bfd_reloc_status_type
1224 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1225 arelent
*reloc_entry
,
1227 void *data ATTRIBUTE_UNUSED
,
1228 asection
*input_section
,
1230 char **error_message ATTRIBUTE_UNUSED
)
1232 if (output_bfd
!= NULL
1233 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1234 && (! reloc_entry
->howto
->partial_inplace
1235 || reloc_entry
->addend
== 0))
1237 reloc_entry
->address
+= input_section
->output_offset
;
1238 return bfd_reloc_ok
;
1241 return bfd_reloc_continue
;
1244 /* Returns TRUE if section A matches section B.
1245 Names, addresses and links may be different, but everything else
1246 should be the same. */
1249 section_match (const Elf_Internal_Shdr
* a
,
1250 const Elf_Internal_Shdr
* b
)
1253 a
->sh_type
== b
->sh_type
1254 && (a
->sh_flags
& ~ SHF_INFO_LINK
)
1255 == (b
->sh_flags
& ~ SHF_INFO_LINK
)
1256 && a
->sh_addralign
== b
->sh_addralign
1257 && a
->sh_size
== b
->sh_size
1258 && a
->sh_entsize
== b
->sh_entsize
1259 /* FIXME: Check sh_addr ? */
1263 /* Find a section in OBFD that has the same characteristics
1264 as IHEADER. Return the index of this section or SHN_UNDEF if
1265 none can be found. Check's section HINT first, as this is likely
1266 to be the correct section. */
1269 find_link (const bfd
* obfd
, const Elf_Internal_Shdr
* iheader
, const unsigned int hint
)
1271 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1274 BFD_ASSERT (iheader
!= NULL
);
1276 /* See PR 20922 for a reproducer of the NULL test. */
1277 if (oheaders
[hint
] != NULL
1278 && section_match (oheaders
[hint
], iheader
))
1281 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1283 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1285 if (oheader
== NULL
)
1287 if (section_match (oheader
, iheader
))
1288 /* FIXME: Do we care if there is a potential for
1289 multiple matches ? */
1296 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1297 Processor specific section, based upon a matching input section.
1298 Returns TRUE upon success, FALSE otherwise. */
1301 copy_special_section_fields (const bfd
*ibfd
,
1303 const Elf_Internal_Shdr
*iheader
,
1304 Elf_Internal_Shdr
*oheader
,
1305 const unsigned int secnum
)
1307 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1308 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1309 bfd_boolean changed
= FALSE
;
1310 unsigned int sh_link
;
1312 if (oheader
->sh_type
== SHT_NOBITS
)
1314 /* This is a feature for objcopy --only-keep-debug:
1315 When a section's type is changed to NOBITS, we preserve
1316 the sh_link and sh_info fields so that they can be
1317 matched up with the original.
1319 Note: Strictly speaking these assignments are wrong.
1320 The sh_link and sh_info fields should point to the
1321 relevent sections in the output BFD, which may not be in
1322 the same location as they were in the input BFD. But
1323 the whole point of this action is to preserve the
1324 original values of the sh_link and sh_info fields, so
1325 that they can be matched up with the section headers in
1326 the original file. So strictly speaking we may be
1327 creating an invalid ELF file, but it is only for a file
1328 that just contains debug info and only for sections
1329 without any contents. */
1330 if (oheader
->sh_link
== 0)
1331 oheader
->sh_link
= iheader
->sh_link
;
1332 if (oheader
->sh_info
== 0)
1333 oheader
->sh_info
= iheader
->sh_info
;
1337 /* Allow the target a chance to decide how these fields should be set. */
1338 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1339 && bed
->elf_backend_copy_special_section_fields
1340 (ibfd
, obfd
, iheader
, oheader
))
1343 /* We have an iheader which might match oheader, and which has non-zero
1344 sh_info and/or sh_link fields. Attempt to follow those links and find
1345 the section in the output bfd which corresponds to the linked section
1346 in the input bfd. */
1347 if (iheader
->sh_link
!= SHN_UNDEF
)
1349 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1350 if (sh_link
!= SHN_UNDEF
)
1352 oheader
->sh_link
= sh_link
;
1356 /* FIXME: Should we install iheader->sh_link
1357 if we could not find a match ? */
1358 (* _bfd_error_handler
)
1359 /* xgettext:c-format */
1360 (_("%B: Failed to find link section for section %d"), obfd
, secnum
);
1363 if (iheader
->sh_info
)
1365 /* The sh_info field can hold arbitrary information, but if the
1366 SHF_LINK_INFO flag is set then it should be interpreted as a
1368 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1370 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1372 if (sh_link
!= SHN_UNDEF
)
1373 oheader
->sh_flags
|= SHF_INFO_LINK
;
1376 /* No idea what it means - just copy it. */
1377 sh_link
= iheader
->sh_info
;
1379 if (sh_link
!= SHN_UNDEF
)
1381 oheader
->sh_info
= sh_link
;
1385 (* _bfd_error_handler
)
1386 /* xgettext:c-format */
1387 (_("%B: Failed to find info section for section %d"), obfd
, secnum
);
1393 /* Copy the program header and other data from one object module to
1397 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1399 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1400 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1401 const struct elf_backend_data
*bed
;
1404 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1405 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1408 if (!elf_flags_init (obfd
))
1410 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1411 elf_flags_init (obfd
) = TRUE
;
1414 elf_gp (obfd
) = elf_gp (ibfd
);
1416 /* Also copy the EI_OSABI field. */
1417 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1418 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1420 /* If set, copy the EI_ABIVERSION field. */
1421 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1422 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1423 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1425 /* Copy object attributes. */
1426 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1428 if (iheaders
== NULL
|| oheaders
== NULL
)
1431 bed
= get_elf_backend_data (obfd
);
1433 /* Possibly copy other fields in the section header. */
1434 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1437 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1439 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1440 because of a special case need for generating separate debug info
1441 files. See below for more details. */
1443 || (oheader
->sh_type
!= SHT_NOBITS
1444 && oheader
->sh_type
< SHT_LOOS
))
1447 /* Ignore empty sections, and sections whose
1448 fields have already been initialised. */
1449 if (oheader
->sh_size
== 0
1450 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1453 /* Scan for the matching section in the input bfd.
1454 First we try for a direct mapping between the input and output sections. */
1455 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1457 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1459 if (iheader
== NULL
)
1462 if (oheader
->bfd_section
!= NULL
1463 && iheader
->bfd_section
!= NULL
1464 && iheader
->bfd_section
->output_section
!= NULL
1465 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1467 /* We have found a connection from the input section to the
1468 output section. Attempt to copy the header fields. If
1469 this fails then do not try any further sections - there
1470 should only be a one-to-one mapping between input and output. */
1471 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1472 j
= elf_numsections (ibfd
);
1477 if (j
< elf_numsections (ibfd
))
1480 /* That failed. So try to deduce the corresponding input section.
1481 Unfortunately we cannot compare names as the output string table
1482 is empty, so instead we check size, address and type. */
1483 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1485 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1487 if (iheader
== NULL
)
1490 /* Try matching fields in the input section's header.
1491 Since --only-keep-debug turns all non-debug sections into
1492 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1494 if ((oheader
->sh_type
== SHT_NOBITS
1495 || iheader
->sh_type
== oheader
->sh_type
)
1496 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1497 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1498 && iheader
->sh_addralign
== oheader
->sh_addralign
1499 && iheader
->sh_entsize
== oheader
->sh_entsize
1500 && iheader
->sh_size
== oheader
->sh_size
1501 && iheader
->sh_addr
== oheader
->sh_addr
1502 && (iheader
->sh_info
!= oheader
->sh_info
1503 || iheader
->sh_link
!= oheader
->sh_link
))
1505 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1510 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1512 /* Final attempt. Call the backend copy function
1513 with a NULL input section. */
1514 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1515 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1523 get_segment_type (unsigned int p_type
)
1528 case PT_NULL
: pt
= "NULL"; break;
1529 case PT_LOAD
: pt
= "LOAD"; break;
1530 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1531 case PT_INTERP
: pt
= "INTERP"; break;
1532 case PT_NOTE
: pt
= "NOTE"; break;
1533 case PT_SHLIB
: pt
= "SHLIB"; break;
1534 case PT_PHDR
: pt
= "PHDR"; break;
1535 case PT_TLS
: pt
= "TLS"; break;
1536 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1537 case PT_GNU_STACK
: pt
= "STACK"; break;
1538 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1539 default: pt
= NULL
; break;
1544 /* Print out the program headers. */
1547 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1549 FILE *f
= (FILE *) farg
;
1550 Elf_Internal_Phdr
*p
;
1552 bfd_byte
*dynbuf
= NULL
;
1554 p
= elf_tdata (abfd
)->phdr
;
1559 fprintf (f
, _("\nProgram Header:\n"));
1560 c
= elf_elfheader (abfd
)->e_phnum
;
1561 for (i
= 0; i
< c
; i
++, p
++)
1563 const char *pt
= get_segment_type (p
->p_type
);
1568 sprintf (buf
, "0x%lx", p
->p_type
);
1571 fprintf (f
, "%8s off 0x", pt
);
1572 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1573 fprintf (f
, " vaddr 0x");
1574 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1575 fprintf (f
, " paddr 0x");
1576 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1577 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1578 fprintf (f
, " filesz 0x");
1579 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1580 fprintf (f
, " memsz 0x");
1581 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1582 fprintf (f
, " flags %c%c%c",
1583 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1584 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1585 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1586 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1587 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1592 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1595 unsigned int elfsec
;
1596 unsigned long shlink
;
1597 bfd_byte
*extdyn
, *extdynend
;
1599 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1601 fprintf (f
, _("\nDynamic Section:\n"));
1603 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1606 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1607 if (elfsec
== SHN_BAD
)
1609 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1611 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1612 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1615 /* PR 17512: file: 6f427532. */
1616 if (s
->size
< extdynsize
)
1618 extdynend
= extdyn
+ s
->size
;
1619 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1621 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1623 Elf_Internal_Dyn dyn
;
1624 const char *name
= "";
1626 bfd_boolean stringp
;
1627 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1629 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1631 if (dyn
.d_tag
== DT_NULL
)
1638 if (bed
->elf_backend_get_target_dtag
)
1639 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1641 if (!strcmp (name
, ""))
1643 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1648 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1649 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1650 case DT_PLTGOT
: name
= "PLTGOT"; break;
1651 case DT_HASH
: name
= "HASH"; break;
1652 case DT_STRTAB
: name
= "STRTAB"; break;
1653 case DT_SYMTAB
: name
= "SYMTAB"; break;
1654 case DT_RELA
: name
= "RELA"; break;
1655 case DT_RELASZ
: name
= "RELASZ"; break;
1656 case DT_RELAENT
: name
= "RELAENT"; break;
1657 case DT_STRSZ
: name
= "STRSZ"; break;
1658 case DT_SYMENT
: name
= "SYMENT"; break;
1659 case DT_INIT
: name
= "INIT"; break;
1660 case DT_FINI
: name
= "FINI"; break;
1661 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1662 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1663 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1664 case DT_REL
: name
= "REL"; break;
1665 case DT_RELSZ
: name
= "RELSZ"; break;
1666 case DT_RELENT
: name
= "RELENT"; break;
1667 case DT_PLTREL
: name
= "PLTREL"; break;
1668 case DT_DEBUG
: name
= "DEBUG"; break;
1669 case DT_TEXTREL
: name
= "TEXTREL"; break;
1670 case DT_JMPREL
: name
= "JMPREL"; break;
1671 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1672 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1673 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1674 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1675 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1676 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1677 case DT_FLAGS
: name
= "FLAGS"; break;
1678 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1679 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1680 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1681 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1682 case DT_MOVEENT
: name
= "MOVEENT"; break;
1683 case DT_MOVESZ
: name
= "MOVESZ"; break;
1684 case DT_FEATURE
: name
= "FEATURE"; break;
1685 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1686 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1687 case DT_SYMINENT
: name
= "SYMINENT"; break;
1688 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1689 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1690 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1691 case DT_PLTPAD
: name
= "PLTPAD"; break;
1692 case DT_MOVETAB
: name
= "MOVETAB"; break;
1693 case DT_SYMINFO
: name
= "SYMINFO"; break;
1694 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1695 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1696 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1697 case DT_VERSYM
: name
= "VERSYM"; break;
1698 case DT_VERDEF
: name
= "VERDEF"; break;
1699 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1700 case DT_VERNEED
: name
= "VERNEED"; break;
1701 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1702 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1703 case DT_USED
: name
= "USED"; break;
1704 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1705 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1708 fprintf (f
, " %-20s ", name
);
1712 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1717 unsigned int tagv
= dyn
.d_un
.d_val
;
1719 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1722 fprintf (f
, "%s", string
);
1731 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1732 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1734 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1738 if (elf_dynverdef (abfd
) != 0)
1740 Elf_Internal_Verdef
*t
;
1742 fprintf (f
, _("\nVersion definitions:\n"));
1743 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1745 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1746 t
->vd_flags
, t
->vd_hash
,
1747 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1748 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1750 Elf_Internal_Verdaux
*a
;
1753 for (a
= t
->vd_auxptr
->vda_nextptr
;
1757 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1763 if (elf_dynverref (abfd
) != 0)
1765 Elf_Internal_Verneed
*t
;
1767 fprintf (f
, _("\nVersion References:\n"));
1768 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1770 Elf_Internal_Vernaux
*a
;
1772 fprintf (f
, _(" required from %s:\n"),
1773 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1774 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1775 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1776 a
->vna_flags
, a
->vna_other
,
1777 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1789 /* Get version string. */
1792 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1793 bfd_boolean
*hidden
)
1795 const char *version_string
= NULL
;
1796 if (elf_dynversym (abfd
) != 0
1797 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1799 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1801 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1802 vernum
&= VERSYM_VERSION
;
1805 version_string
= "";
1806 else if (vernum
== 1)
1807 version_string
= "Base";
1808 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1810 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1813 Elf_Internal_Verneed
*t
;
1815 version_string
= "";
1816 for (t
= elf_tdata (abfd
)->verref
;
1820 Elf_Internal_Vernaux
*a
;
1822 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1824 if (a
->vna_other
== vernum
)
1826 version_string
= a
->vna_nodename
;
1833 return version_string
;
1836 /* Display ELF-specific fields of a symbol. */
1839 bfd_elf_print_symbol (bfd
*abfd
,
1842 bfd_print_symbol_type how
)
1844 FILE *file
= (FILE *) filep
;
1847 case bfd_print_symbol_name
:
1848 fprintf (file
, "%s", symbol
->name
);
1850 case bfd_print_symbol_more
:
1851 fprintf (file
, "elf ");
1852 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1853 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1855 case bfd_print_symbol_all
:
1857 const char *section_name
;
1858 const char *name
= NULL
;
1859 const struct elf_backend_data
*bed
;
1860 unsigned char st_other
;
1862 const char *version_string
;
1865 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1867 bed
= get_elf_backend_data (abfd
);
1868 if (bed
->elf_backend_print_symbol_all
)
1869 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1873 name
= symbol
->name
;
1874 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1877 fprintf (file
, " %s\t", section_name
);
1878 /* Print the "other" value for a symbol. For common symbols,
1879 we've already printed the size; now print the alignment.
1880 For other symbols, we have no specified alignment, and
1881 we've printed the address; now print the size. */
1882 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1883 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1885 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1886 bfd_fprintf_vma (abfd
, file
, val
);
1888 /* If we have version information, print it. */
1889 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1895 fprintf (file
, " %-11s", version_string
);
1900 fprintf (file
, " (%s)", version_string
);
1901 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1906 /* If the st_other field is not zero, print it. */
1907 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1912 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1913 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1914 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1916 /* Some other non-defined flags are also present, so print
1918 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1921 fprintf (file
, " %s", name
);
1927 /* ELF .o/exec file reading */
1929 /* Create a new bfd section from an ELF section header. */
1932 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1934 Elf_Internal_Shdr
*hdr
;
1935 Elf_Internal_Ehdr
*ehdr
;
1936 const struct elf_backend_data
*bed
;
1938 bfd_boolean ret
= TRUE
;
1939 static bfd_boolean
* sections_being_created
= NULL
;
1940 static bfd
* sections_being_created_abfd
= NULL
;
1941 static unsigned int nesting
= 0;
1943 if (shindex
>= elf_numsections (abfd
))
1948 /* PR17512: A corrupt ELF binary might contain a recursive group of
1949 sections, with each the string indicies pointing to the next in the
1950 loop. Detect this here, by refusing to load a section that we are
1951 already in the process of loading. We only trigger this test if
1952 we have nested at least three sections deep as normal ELF binaries
1953 can expect to recurse at least once.
1955 FIXME: It would be better if this array was attached to the bfd,
1956 rather than being held in a static pointer. */
1958 if (sections_being_created_abfd
!= abfd
)
1959 sections_being_created
= NULL
;
1960 if (sections_being_created
== NULL
)
1962 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
1963 sections_being_created
= (bfd_boolean
*)
1964 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
1965 sections_being_created_abfd
= abfd
;
1967 if (sections_being_created
[shindex
])
1970 (_("%B: warning: loop in section dependencies detected"), abfd
);
1973 sections_being_created
[shindex
] = TRUE
;
1976 hdr
= elf_elfsections (abfd
)[shindex
];
1977 ehdr
= elf_elfheader (abfd
);
1978 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1983 bed
= get_elf_backend_data (abfd
);
1984 switch (hdr
->sh_type
)
1987 /* Inactive section. Throw it away. */
1990 case SHT_PROGBITS
: /* Normal section with contents. */
1991 case SHT_NOBITS
: /* .bss section. */
1992 case SHT_HASH
: /* .hash section. */
1993 case SHT_NOTE
: /* .note section. */
1994 case SHT_INIT_ARRAY
: /* .init_array section. */
1995 case SHT_FINI_ARRAY
: /* .fini_array section. */
1996 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1997 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1998 case SHT_GNU_HASH
: /* .gnu.hash section. */
1999 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2002 case SHT_DYNAMIC
: /* Dynamic linking information. */
2003 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2006 if (hdr
->sh_link
> elf_numsections (abfd
))
2008 /* PR 10478: Accept Solaris binaries with a sh_link
2009 field set to SHN_BEFORE or SHN_AFTER. */
2010 switch (bfd_get_arch (abfd
))
2013 case bfd_arch_sparc
:
2014 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2015 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2017 /* Otherwise fall through. */
2022 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2024 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2026 Elf_Internal_Shdr
*dynsymhdr
;
2028 /* The shared libraries distributed with hpux11 have a bogus
2029 sh_link field for the ".dynamic" section. Find the
2030 string table for the ".dynsym" section instead. */
2031 if (elf_dynsymtab (abfd
) != 0)
2033 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2034 hdr
->sh_link
= dynsymhdr
->sh_link
;
2038 unsigned int i
, num_sec
;
2040 num_sec
= elf_numsections (abfd
);
2041 for (i
= 1; i
< num_sec
; i
++)
2043 dynsymhdr
= elf_elfsections (abfd
)[i
];
2044 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2046 hdr
->sh_link
= dynsymhdr
->sh_link
;
2054 case SHT_SYMTAB
: /* A symbol table. */
2055 if (elf_onesymtab (abfd
) == shindex
)
2058 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2061 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2063 if (hdr
->sh_size
!= 0)
2065 /* Some assemblers erroneously set sh_info to one with a
2066 zero sh_size. ld sees this as a global symbol count
2067 of (unsigned) -1. Fix it here. */
2072 /* PR 18854: A binary might contain more than one symbol table.
2073 Unusual, but possible. Warn, but continue. */
2074 if (elf_onesymtab (abfd
) != 0)
2077 /* xgettext:c-format */
2078 (_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"),
2082 elf_onesymtab (abfd
) = shindex
;
2083 elf_symtab_hdr (abfd
) = *hdr
;
2084 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2085 abfd
->flags
|= HAS_SYMS
;
2087 /* Sometimes a shared object will map in the symbol table. If
2088 SHF_ALLOC is set, and this is a shared object, then we also
2089 treat this section as a BFD section. We can not base the
2090 decision purely on SHF_ALLOC, because that flag is sometimes
2091 set in a relocatable object file, which would confuse the
2093 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2094 && (abfd
->flags
& DYNAMIC
) != 0
2095 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2099 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2100 can't read symbols without that section loaded as well. It
2101 is most likely specified by the next section header. */
2103 elf_section_list
* entry
;
2104 unsigned int i
, num_sec
;
2106 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2107 if (entry
->hdr
.sh_link
== shindex
)
2110 num_sec
= elf_numsections (abfd
);
2111 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2113 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2115 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2116 && hdr2
->sh_link
== shindex
)
2121 for (i
= 1; i
< shindex
; i
++)
2123 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2125 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2126 && hdr2
->sh_link
== shindex
)
2131 ret
= bfd_section_from_shdr (abfd
, i
);
2132 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2136 case SHT_DYNSYM
: /* A dynamic symbol table. */
2137 if (elf_dynsymtab (abfd
) == shindex
)
2140 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2143 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2145 if (hdr
->sh_size
!= 0)
2148 /* Some linkers erroneously set sh_info to one with a
2149 zero sh_size. ld sees this as a global symbol count
2150 of (unsigned) -1. Fix it here. */
2155 /* PR 18854: A binary might contain more than one dynamic symbol table.
2156 Unusual, but possible. Warn, but continue. */
2157 if (elf_dynsymtab (abfd
) != 0)
2160 /* xgettext:c-format */
2161 (_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"),
2165 elf_dynsymtab (abfd
) = shindex
;
2166 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2167 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2168 abfd
->flags
|= HAS_SYMS
;
2170 /* Besides being a symbol table, we also treat this as a regular
2171 section, so that objcopy can handle it. */
2172 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2175 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2177 elf_section_list
* entry
;
2179 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2180 if (entry
->ndx
== shindex
)
2183 entry
= bfd_alloc (abfd
, sizeof * entry
);
2186 entry
->ndx
= shindex
;
2188 entry
->next
= elf_symtab_shndx_list (abfd
);
2189 elf_symtab_shndx_list (abfd
) = entry
;
2190 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2194 case SHT_STRTAB
: /* A string table. */
2195 if (hdr
->bfd_section
!= NULL
)
2198 if (ehdr
->e_shstrndx
== shindex
)
2200 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2201 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2205 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2208 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2209 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2213 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2216 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2217 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2218 elf_elfsections (abfd
)[shindex
] = hdr
;
2219 /* We also treat this as a regular section, so that objcopy
2221 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2226 /* If the string table isn't one of the above, then treat it as a
2227 regular section. We need to scan all the headers to be sure,
2228 just in case this strtab section appeared before the above. */
2229 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2231 unsigned int i
, num_sec
;
2233 num_sec
= elf_numsections (abfd
);
2234 for (i
= 1; i
< num_sec
; i
++)
2236 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2237 if (hdr2
->sh_link
== shindex
)
2239 /* Prevent endless recursion on broken objects. */
2242 if (! bfd_section_from_shdr (abfd
, i
))
2244 if (elf_onesymtab (abfd
) == i
)
2246 if (elf_dynsymtab (abfd
) == i
)
2247 goto dynsymtab_strtab
;
2251 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2256 /* *These* do a lot of work -- but build no sections! */
2258 asection
*target_sect
;
2259 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2260 unsigned int num_sec
= elf_numsections (abfd
);
2261 struct bfd_elf_section_data
*esdt
;
2264 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2265 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2268 /* Check for a bogus link to avoid crashing. */
2269 if (hdr
->sh_link
>= num_sec
)
2272 /* xgettext:c-format */
2273 (_("%B: invalid link %lu for reloc section %s (index %u)"),
2274 abfd
, hdr
->sh_link
, name
, shindex
);
2275 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2280 /* For some incomprehensible reason Oracle distributes
2281 libraries for Solaris in which some of the objects have
2282 bogus sh_link fields. It would be nice if we could just
2283 reject them, but, unfortunately, some people need to use
2284 them. We scan through the section headers; if we find only
2285 one suitable symbol table, we clobber the sh_link to point
2286 to it. I hope this doesn't break anything.
2288 Don't do it on executable nor shared library. */
2289 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2290 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2291 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2297 for (scan
= 1; scan
< num_sec
; scan
++)
2299 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2300 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2311 hdr
->sh_link
= found
;
2314 /* Get the symbol table. */
2315 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2316 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2317 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2320 /* If this reloc section does not use the main symbol table we
2321 don't treat it as a reloc section. BFD can't adequately
2322 represent such a section, so at least for now, we don't
2323 try. We just present it as a normal section. We also
2324 can't use it as a reloc section if it points to the null
2325 section, an invalid section, another reloc section, or its
2326 sh_link points to the null section. */
2327 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2328 || hdr
->sh_link
== SHN_UNDEF
2329 || hdr
->sh_info
== SHN_UNDEF
2330 || hdr
->sh_info
>= num_sec
2331 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2332 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2334 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2339 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2342 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2343 if (target_sect
== NULL
)
2346 esdt
= elf_section_data (target_sect
);
2347 if (hdr
->sh_type
== SHT_RELA
)
2348 p_hdr
= &esdt
->rela
.hdr
;
2350 p_hdr
= &esdt
->rel
.hdr
;
2352 /* PR 17512: file: 0b4f81b7. */
2355 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2360 elf_elfsections (abfd
)[shindex
] = hdr2
;
2361 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2362 target_sect
->flags
|= SEC_RELOC
;
2363 target_sect
->relocation
= NULL
;
2364 target_sect
->rel_filepos
= hdr
->sh_offset
;
2365 /* In the section to which the relocations apply, mark whether
2366 its relocations are of the REL or RELA variety. */
2367 if (hdr
->sh_size
!= 0)
2369 if (hdr
->sh_type
== SHT_RELA
)
2370 target_sect
->use_rela_p
= 1;
2372 abfd
->flags
|= HAS_RELOC
;
2376 case SHT_GNU_verdef
:
2377 elf_dynverdef (abfd
) = shindex
;
2378 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2379 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2382 case SHT_GNU_versym
:
2383 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2386 elf_dynversym (abfd
) = shindex
;
2387 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2388 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2391 case SHT_GNU_verneed
:
2392 elf_dynverref (abfd
) = shindex
;
2393 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2394 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2401 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2404 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2407 if (hdr
->contents
!= NULL
)
2409 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2410 unsigned int n_elt
= hdr
->sh_size
/ sizeof (* idx
);
2415 if (idx
->flags
& GRP_COMDAT
)
2416 hdr
->bfd_section
->flags
2417 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2419 /* We try to keep the same section order as it comes in. */
2422 while (--n_elt
!= 0)
2426 if (idx
->shdr
!= NULL
2427 && (s
= idx
->shdr
->bfd_section
) != NULL
2428 && elf_next_in_group (s
) != NULL
)
2430 elf_next_in_group (hdr
->bfd_section
) = s
;
2438 /* Possibly an attributes section. */
2439 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2440 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2442 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2444 _bfd_elf_parse_attributes (abfd
, hdr
);
2448 /* Check for any processor-specific section types. */
2449 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2452 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2454 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2455 /* FIXME: How to properly handle allocated section reserved
2456 for applications? */
2458 /* xgettext:c-format */
2459 (_("%B: don't know how to handle allocated, application "
2460 "specific section `%s' [0x%8x]"),
2461 abfd
, name
, hdr
->sh_type
);
2464 /* Allow sections reserved for applications. */
2465 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2470 else if (hdr
->sh_type
>= SHT_LOPROC
2471 && hdr
->sh_type
<= SHT_HIPROC
)
2472 /* FIXME: We should handle this section. */
2474 /* xgettext:c-format */
2475 (_("%B: don't know how to handle processor specific section "
2477 abfd
, name
, hdr
->sh_type
);
2478 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2480 /* Unrecognised OS-specific sections. */
2481 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2482 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2483 required to correctly process the section and the file should
2484 be rejected with an error message. */
2486 /* xgettext:c-format */
2487 (_("%B: don't know how to handle OS specific section "
2489 abfd
, name
, hdr
->sh_type
);
2492 /* Otherwise it should be processed. */
2493 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2498 /* FIXME: We should handle this section. */
2500 /* xgettext:c-format */
2501 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2502 abfd
, name
, hdr
->sh_type
);
2510 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2511 sections_being_created
[shindex
] = FALSE
;
2512 if (-- nesting
== 0)
2514 sections_being_created
= NULL
;
2515 sections_being_created_abfd
= abfd
;
2520 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2523 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2525 unsigned long r_symndx
)
2527 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2529 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2531 Elf_Internal_Shdr
*symtab_hdr
;
2532 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2533 Elf_External_Sym_Shndx eshndx
;
2535 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2536 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2537 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2540 if (cache
->abfd
!= abfd
)
2542 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2545 cache
->indx
[ent
] = r_symndx
;
2548 return &cache
->sym
[ent
];
2551 /* Given an ELF section number, retrieve the corresponding BFD
2555 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2557 if (sec_index
>= elf_numsections (abfd
))
2559 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2562 static const struct bfd_elf_special_section special_sections_b
[] =
2564 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2565 { NULL
, 0, 0, 0, 0 }
2568 static const struct bfd_elf_special_section special_sections_c
[] =
2570 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2571 { NULL
, 0, 0, 0, 0 }
2574 static const struct bfd_elf_special_section special_sections_d
[] =
2576 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2577 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2578 /* There are more DWARF sections than these, but they needn't be added here
2579 unless you have to cope with broken compilers that don't emit section
2580 attributes or you want to help the user writing assembler. */
2581 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2582 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2583 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2584 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2585 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2586 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2587 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2588 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2589 { NULL
, 0, 0, 0, 0 }
2592 static const struct bfd_elf_special_section special_sections_f
[] =
2594 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2595 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2596 { NULL
, 0, 0, 0, 0 }
2599 static const struct bfd_elf_special_section special_sections_g
[] =
2601 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2602 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2603 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2604 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2605 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2606 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2607 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2608 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2609 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2610 { NULL
, 0, 0, 0, 0 }
2613 static const struct bfd_elf_special_section special_sections_h
[] =
2615 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2616 { NULL
, 0, 0, 0, 0 }
2619 static const struct bfd_elf_special_section special_sections_i
[] =
2621 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2622 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2623 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2624 { NULL
, 0, 0, 0, 0 }
2627 static const struct bfd_elf_special_section special_sections_l
[] =
2629 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2630 { NULL
, 0, 0, 0, 0 }
2633 static const struct bfd_elf_special_section special_sections_n
[] =
2635 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2636 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2637 { NULL
, 0, 0, 0, 0 }
2640 static const struct bfd_elf_special_section special_sections_p
[] =
2642 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2643 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2644 { NULL
, 0, 0, 0, 0 }
2647 static const struct bfd_elf_special_section special_sections_r
[] =
2649 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2650 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2651 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2652 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2653 { NULL
, 0, 0, 0, 0 }
2656 static const struct bfd_elf_special_section special_sections_s
[] =
2658 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2659 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2660 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2661 /* See struct bfd_elf_special_section declaration for the semantics of
2662 this special case where .prefix_length != strlen (.prefix). */
2663 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2664 { NULL
, 0, 0, 0, 0 }
2667 static const struct bfd_elf_special_section special_sections_t
[] =
2669 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2670 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2671 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2672 { NULL
, 0, 0, 0, 0 }
2675 static const struct bfd_elf_special_section special_sections_z
[] =
2677 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2678 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2679 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2680 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2681 { NULL
, 0, 0, 0, 0 }
2684 static const struct bfd_elf_special_section
* const special_sections
[] =
2686 special_sections_b
, /* 'b' */
2687 special_sections_c
, /* 'c' */
2688 special_sections_d
, /* 'd' */
2690 special_sections_f
, /* 'f' */
2691 special_sections_g
, /* 'g' */
2692 special_sections_h
, /* 'h' */
2693 special_sections_i
, /* 'i' */
2696 special_sections_l
, /* 'l' */
2698 special_sections_n
, /* 'n' */
2700 special_sections_p
, /* 'p' */
2702 special_sections_r
, /* 'r' */
2703 special_sections_s
, /* 's' */
2704 special_sections_t
, /* 't' */
2710 special_sections_z
/* 'z' */
2713 const struct bfd_elf_special_section
*
2714 _bfd_elf_get_special_section (const char *name
,
2715 const struct bfd_elf_special_section
*spec
,
2721 len
= strlen (name
);
2723 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2726 int prefix_len
= spec
[i
].prefix_length
;
2728 if (len
< prefix_len
)
2730 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2733 suffix_len
= spec
[i
].suffix_length
;
2734 if (suffix_len
<= 0)
2736 if (name
[prefix_len
] != 0)
2738 if (suffix_len
== 0)
2740 if (name
[prefix_len
] != '.'
2741 && (suffix_len
== -2
2742 || (rela
&& spec
[i
].type
== SHT_REL
)))
2748 if (len
< prefix_len
+ suffix_len
)
2750 if (memcmp (name
+ len
- suffix_len
,
2751 spec
[i
].prefix
+ prefix_len
,
2761 const struct bfd_elf_special_section
*
2762 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2765 const struct bfd_elf_special_section
*spec
;
2766 const struct elf_backend_data
*bed
;
2768 /* See if this is one of the special sections. */
2769 if (sec
->name
== NULL
)
2772 bed
= get_elf_backend_data (abfd
);
2773 spec
= bed
->special_sections
;
2776 spec
= _bfd_elf_get_special_section (sec
->name
,
2777 bed
->special_sections
,
2783 if (sec
->name
[0] != '.')
2786 i
= sec
->name
[1] - 'b';
2787 if (i
< 0 || i
> 'z' - 'b')
2790 spec
= special_sections
[i
];
2795 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2799 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2801 struct bfd_elf_section_data
*sdata
;
2802 const struct elf_backend_data
*bed
;
2803 const struct bfd_elf_special_section
*ssect
;
2805 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2808 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2812 sec
->used_by_bfd
= sdata
;
2815 /* Indicate whether or not this section should use RELA relocations. */
2816 bed
= get_elf_backend_data (abfd
);
2817 sec
->use_rela_p
= bed
->default_use_rela_p
;
2819 /* When we read a file, we don't need to set ELF section type and
2820 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2821 anyway. We will set ELF section type and flags for all linker
2822 created sections. If user specifies BFD section flags, we will
2823 set ELF section type and flags based on BFD section flags in
2824 elf_fake_sections. Special handling for .init_array/.fini_array
2825 output sections since they may contain .ctors/.dtors input
2826 sections. We don't want _bfd_elf_init_private_section_data to
2827 copy ELF section type from .ctors/.dtors input sections. */
2828 if (abfd
->direction
!= read_direction
2829 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2831 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2834 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2835 || ssect
->type
== SHT_INIT_ARRAY
2836 || ssect
->type
== SHT_FINI_ARRAY
))
2838 elf_section_type (sec
) = ssect
->type
;
2839 elf_section_flags (sec
) = ssect
->attr
;
2843 return _bfd_generic_new_section_hook (abfd
, sec
);
2846 /* Create a new bfd section from an ELF program header.
2848 Since program segments have no names, we generate a synthetic name
2849 of the form segment<NUM>, where NUM is generally the index in the
2850 program header table. For segments that are split (see below) we
2851 generate the names segment<NUM>a and segment<NUM>b.
2853 Note that some program segments may have a file size that is different than
2854 (less than) the memory size. All this means is that at execution the
2855 system must allocate the amount of memory specified by the memory size,
2856 but only initialize it with the first "file size" bytes read from the
2857 file. This would occur for example, with program segments consisting
2858 of combined data+bss.
2860 To handle the above situation, this routine generates TWO bfd sections
2861 for the single program segment. The first has the length specified by
2862 the file size of the segment, and the second has the length specified
2863 by the difference between the two sizes. In effect, the segment is split
2864 into its initialized and uninitialized parts.
2869 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2870 Elf_Internal_Phdr
*hdr
,
2872 const char *type_name
)
2880 split
= ((hdr
->p_memsz
> 0)
2881 && (hdr
->p_filesz
> 0)
2882 && (hdr
->p_memsz
> hdr
->p_filesz
));
2884 if (hdr
->p_filesz
> 0)
2886 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2887 len
= strlen (namebuf
) + 1;
2888 name
= (char *) bfd_alloc (abfd
, len
);
2891 memcpy (name
, namebuf
, len
);
2892 newsect
= bfd_make_section (abfd
, name
);
2893 if (newsect
== NULL
)
2895 newsect
->vma
= hdr
->p_vaddr
;
2896 newsect
->lma
= hdr
->p_paddr
;
2897 newsect
->size
= hdr
->p_filesz
;
2898 newsect
->filepos
= hdr
->p_offset
;
2899 newsect
->flags
|= SEC_HAS_CONTENTS
;
2900 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2901 if (hdr
->p_type
== PT_LOAD
)
2903 newsect
->flags
|= SEC_ALLOC
;
2904 newsect
->flags
|= SEC_LOAD
;
2905 if (hdr
->p_flags
& PF_X
)
2907 /* FIXME: all we known is that it has execute PERMISSION,
2909 newsect
->flags
|= SEC_CODE
;
2912 if (!(hdr
->p_flags
& PF_W
))
2914 newsect
->flags
|= SEC_READONLY
;
2918 if (hdr
->p_memsz
> hdr
->p_filesz
)
2922 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2923 len
= strlen (namebuf
) + 1;
2924 name
= (char *) bfd_alloc (abfd
, len
);
2927 memcpy (name
, namebuf
, len
);
2928 newsect
= bfd_make_section (abfd
, name
);
2929 if (newsect
== NULL
)
2931 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2932 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2933 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2934 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2935 align
= newsect
->vma
& -newsect
->vma
;
2936 if (align
== 0 || align
> hdr
->p_align
)
2937 align
= hdr
->p_align
;
2938 newsect
->alignment_power
= bfd_log2 (align
);
2939 if (hdr
->p_type
== PT_LOAD
)
2941 /* Hack for gdb. Segments that have not been modified do
2942 not have their contents written to a core file, on the
2943 assumption that a debugger can find the contents in the
2944 executable. We flag this case by setting the fake
2945 section size to zero. Note that "real" bss sections will
2946 always have their contents dumped to the core file. */
2947 if (bfd_get_format (abfd
) == bfd_core
)
2949 newsect
->flags
|= SEC_ALLOC
;
2950 if (hdr
->p_flags
& PF_X
)
2951 newsect
->flags
|= SEC_CODE
;
2953 if (!(hdr
->p_flags
& PF_W
))
2954 newsect
->flags
|= SEC_READONLY
;
2961 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2963 const struct elf_backend_data
*bed
;
2965 switch (hdr
->p_type
)
2968 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2971 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2974 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2977 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2980 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2982 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2987 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2990 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2992 case PT_GNU_EH_FRAME
:
2993 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2997 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3000 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3003 /* Check for any processor-specific program segment types. */
3004 bed
= get_elf_backend_data (abfd
);
3005 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3009 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3013 _bfd_elf_single_rel_hdr (asection
*sec
)
3015 if (elf_section_data (sec
)->rel
.hdr
)
3017 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3018 return elf_section_data (sec
)->rel
.hdr
;
3021 return elf_section_data (sec
)->rela
.hdr
;
3025 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3026 Elf_Internal_Shdr
*rel_hdr
,
3027 const char *sec_name
,
3028 bfd_boolean use_rela_p
)
3030 char *name
= (char *) bfd_alloc (abfd
,
3031 sizeof ".rela" + strlen (sec_name
));
3035 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3037 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3039 if (rel_hdr
->sh_name
== (unsigned int) -1)
3045 /* Allocate and initialize a section-header for a new reloc section,
3046 containing relocations against ASECT. It is stored in RELDATA. If
3047 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3051 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3052 struct bfd_elf_section_reloc_data
*reldata
,
3053 const char *sec_name
,
3054 bfd_boolean use_rela_p
,
3055 bfd_boolean delay_st_name_p
)
3057 Elf_Internal_Shdr
*rel_hdr
;
3058 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3060 BFD_ASSERT (reldata
->hdr
== NULL
);
3061 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3062 reldata
->hdr
= rel_hdr
;
3064 if (delay_st_name_p
)
3065 rel_hdr
->sh_name
= (unsigned int) -1;
3066 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3069 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3070 rel_hdr
->sh_entsize
= (use_rela_p
3071 ? bed
->s
->sizeof_rela
3072 : bed
->s
->sizeof_rel
);
3073 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3074 rel_hdr
->sh_flags
= 0;
3075 rel_hdr
->sh_addr
= 0;
3076 rel_hdr
->sh_size
= 0;
3077 rel_hdr
->sh_offset
= 0;
3082 /* Return the default section type based on the passed in section flags. */
3085 bfd_elf_get_default_section_type (flagword flags
)
3087 if ((flags
& SEC_ALLOC
) != 0
3088 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3090 return SHT_PROGBITS
;
3093 struct fake_section_arg
3095 struct bfd_link_info
*link_info
;
3099 /* Set up an ELF internal section header for a section. */
3102 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3104 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3105 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3106 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3107 Elf_Internal_Shdr
*this_hdr
;
3108 unsigned int sh_type
;
3109 const char *name
= asect
->name
;
3110 bfd_boolean delay_st_name_p
= FALSE
;
3114 /* We already failed; just get out of the bfd_map_over_sections
3119 this_hdr
= &esd
->this_hdr
;
3123 /* ld: compress DWARF debug sections with names: .debug_*. */
3124 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3125 && (asect
->flags
& SEC_DEBUGGING
)
3129 /* Set SEC_ELF_COMPRESS to indicate this section should be
3131 asect
->flags
|= SEC_ELF_COMPRESS
;
3133 /* If this section will be compressed, delay adding section
3134 name to section name section after it is compressed in
3135 _bfd_elf_assign_file_positions_for_non_load. */
3136 delay_st_name_p
= TRUE
;
3139 else if ((asect
->flags
& SEC_ELF_RENAME
))
3141 /* objcopy: rename output DWARF debug section. */
3142 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3144 /* When we decompress or compress with SHF_COMPRESSED,
3145 convert section name from .zdebug_* to .debug_* if
3149 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3150 if (new_name
== NULL
)
3158 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3160 /* PR binutils/18087: Compression does not always make a
3161 section smaller. So only rename the section when
3162 compression has actually taken place. If input section
3163 name is .zdebug_*, we should never compress it again. */
3164 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3165 if (new_name
== NULL
)
3170 BFD_ASSERT (name
[1] != 'z');
3175 if (delay_st_name_p
)
3176 this_hdr
->sh_name
= (unsigned int) -1;
3180 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3182 if (this_hdr
->sh_name
== (unsigned int) -1)
3189 /* Don't clear sh_flags. Assembler may set additional bits. */
3191 if ((asect
->flags
& SEC_ALLOC
) != 0
3192 || asect
->user_set_vma
)
3193 this_hdr
->sh_addr
= asect
->vma
;
3195 this_hdr
->sh_addr
= 0;
3197 this_hdr
->sh_offset
= 0;
3198 this_hdr
->sh_size
= asect
->size
;
3199 this_hdr
->sh_link
= 0;
3200 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3201 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3204 /* xgettext:c-format */
3205 (_("%B: error: Alignment power %d of section `%A' is too big"),
3206 abfd
, asect
, asect
->alignment_power
);
3210 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3211 /* The sh_entsize and sh_info fields may have been set already by
3212 copy_private_section_data. */
3214 this_hdr
->bfd_section
= asect
;
3215 this_hdr
->contents
= NULL
;
3217 /* If the section type is unspecified, we set it based on
3219 if ((asect
->flags
& SEC_GROUP
) != 0)
3220 sh_type
= SHT_GROUP
;
3222 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3224 if (this_hdr
->sh_type
== SHT_NULL
)
3225 this_hdr
->sh_type
= sh_type
;
3226 else if (this_hdr
->sh_type
== SHT_NOBITS
3227 && sh_type
== SHT_PROGBITS
3228 && (asect
->flags
& SEC_ALLOC
) != 0)
3230 /* Warn if we are changing a NOBITS section to PROGBITS, but
3231 allow the link to proceed. This can happen when users link
3232 non-bss input sections to bss output sections, or emit data
3233 to a bss output section via a linker script. */
3235 (_("warning: section `%A' type changed to PROGBITS"), asect
);
3236 this_hdr
->sh_type
= sh_type
;
3239 switch (this_hdr
->sh_type
)
3250 case SHT_INIT_ARRAY
:
3251 case SHT_FINI_ARRAY
:
3252 case SHT_PREINIT_ARRAY
:
3253 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3257 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3261 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3265 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3269 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3270 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3274 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3275 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3278 case SHT_GNU_versym
:
3279 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3282 case SHT_GNU_verdef
:
3283 this_hdr
->sh_entsize
= 0;
3284 /* objcopy or strip will copy over sh_info, but may not set
3285 cverdefs. The linker will set cverdefs, but sh_info will be
3287 if (this_hdr
->sh_info
== 0)
3288 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3290 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3291 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3294 case SHT_GNU_verneed
:
3295 this_hdr
->sh_entsize
= 0;
3296 /* objcopy or strip will copy over sh_info, but may not set
3297 cverrefs. The linker will set cverrefs, but sh_info will be
3299 if (this_hdr
->sh_info
== 0)
3300 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3302 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3303 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3307 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3311 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3315 if ((asect
->flags
& SEC_ALLOC
) != 0)
3316 this_hdr
->sh_flags
|= SHF_ALLOC
;
3317 if ((asect
->flags
& SEC_READONLY
) == 0)
3318 this_hdr
->sh_flags
|= SHF_WRITE
;
3319 if ((asect
->flags
& SEC_CODE
) != 0)
3320 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3321 if ((asect
->flags
& SEC_MERGE
) != 0)
3323 this_hdr
->sh_flags
|= SHF_MERGE
;
3324 this_hdr
->sh_entsize
= asect
->entsize
;
3326 if ((asect
->flags
& SEC_STRINGS
) != 0)
3327 this_hdr
->sh_flags
|= SHF_STRINGS
;
3328 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3329 this_hdr
->sh_flags
|= SHF_GROUP
;
3330 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3332 this_hdr
->sh_flags
|= SHF_TLS
;
3333 if (asect
->size
== 0
3334 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3336 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3338 this_hdr
->sh_size
= 0;
3341 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3342 if (this_hdr
->sh_size
!= 0)
3343 this_hdr
->sh_type
= SHT_NOBITS
;
3347 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3348 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3350 /* If the section has relocs, set up a section header for the
3351 SHT_REL[A] section. If two relocation sections are required for
3352 this section, it is up to the processor-specific back-end to
3353 create the other. */
3354 if ((asect
->flags
& SEC_RELOC
) != 0)
3356 /* When doing a relocatable link, create both REL and RELA sections if
3359 /* Do the normal setup if we wouldn't create any sections here. */
3360 && esd
->rel
.count
+ esd
->rela
.count
> 0
3361 && (bfd_link_relocatable (arg
->link_info
)
3362 || arg
->link_info
->emitrelocations
))
3364 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3365 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
, FALSE
,
3371 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3372 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
, TRUE
,
3379 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3381 ? &esd
->rela
: &esd
->rel
),
3388 /* Check for processor-specific section types. */
3389 sh_type
= this_hdr
->sh_type
;
3390 if (bed
->elf_backend_fake_sections
3391 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3394 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3396 /* Don't change the header type from NOBITS if we are being
3397 called for objcopy --only-keep-debug. */
3398 this_hdr
->sh_type
= sh_type
;
3402 /* Fill in the contents of a SHT_GROUP section. Called from
3403 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3404 when ELF targets use the generic linker, ld. Called for ld -r
3405 from bfd_elf_final_link. */
3408 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3410 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3411 asection
*elt
, *first
;
3415 /* Ignore linker created group section. See elfNN_ia64_object_p in
3417 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
3421 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3423 unsigned long symindx
= 0;
3425 /* elf_group_id will have been set up by objcopy and the
3427 if (elf_group_id (sec
) != NULL
)
3428 symindx
= elf_group_id (sec
)->udata
.i
;
3432 /* If called from the assembler, swap_out_syms will have set up
3433 elf_section_syms. */
3434 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3435 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3437 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3439 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3441 /* The ELF backend linker sets sh_info to -2 when the group
3442 signature symbol is global, and thus the index can't be
3443 set until all local symbols are output. */
3445 struct bfd_elf_section_data
*sec_data
;
3446 unsigned long symndx
;
3447 unsigned long extsymoff
;
3448 struct elf_link_hash_entry
*h
;
3450 /* The point of this little dance to the first SHF_GROUP section
3451 then back to the SHT_GROUP section is that this gets us to
3452 the SHT_GROUP in the input object. */
3453 igroup
= elf_sec_group (elf_next_in_group (sec
));
3454 sec_data
= elf_section_data (igroup
);
3455 symndx
= sec_data
->this_hdr
.sh_info
;
3457 if (!elf_bad_symtab (igroup
->owner
))
3459 Elf_Internal_Shdr
*symtab_hdr
;
3461 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3462 extsymoff
= symtab_hdr
->sh_info
;
3464 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3465 while (h
->root
.type
== bfd_link_hash_indirect
3466 || h
->root
.type
== bfd_link_hash_warning
)
3467 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3469 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3472 /* The contents won't be allocated for "ld -r" or objcopy. */
3474 if (sec
->contents
== NULL
)
3477 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3479 /* Arrange for the section to be written out. */
3480 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3481 if (sec
->contents
== NULL
)
3488 loc
= sec
->contents
+ sec
->size
;
3490 /* Get the pointer to the first section in the group that gas
3491 squirreled away here. objcopy arranges for this to be set to the
3492 start of the input section group. */
3493 first
= elt
= elf_next_in_group (sec
);
3495 /* First element is a flag word. Rest of section is elf section
3496 indices for all the sections of the group. Write them backwards
3497 just to keep the group in the same order as given in .section
3498 directives, not that it matters. */
3505 s
= s
->output_section
;
3507 && !bfd_is_abs_section (s
))
3509 unsigned int idx
= elf_section_data (s
)->this_idx
;
3512 H_PUT_32 (abfd
, idx
, loc
);
3514 elt
= elf_next_in_group (elt
);
3519 if ((loc
-= 4) != sec
->contents
)
3522 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3525 /* Return the section which RELOC_SEC applies to. */
3528 _bfd_elf_get_reloc_section (asection
*reloc_sec
)
3534 if (reloc_sec
== NULL
)
3537 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3538 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3541 /* We look up the section the relocs apply to by name. */
3542 name
= reloc_sec
->name
;
3543 if (type
== SHT_REL
)
3548 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3549 section apply to .got.plt section. */
3550 abfd
= reloc_sec
->owner
;
3551 if (get_elf_backend_data (abfd
)->want_got_plt
3552 && strcmp (name
, ".plt") == 0)
3554 /* .got.plt is a linker created input section. It may be mapped
3555 to some other output section. Try two likely sections. */
3557 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3558 if (reloc_sec
!= NULL
)
3563 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3567 /* Assign all ELF section numbers. The dummy first section is handled here
3568 too. The link/info pointers for the standard section types are filled
3569 in here too, while we're at it. */
3572 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3574 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3576 unsigned int section_number
;
3577 Elf_Internal_Shdr
**i_shdrp
;
3578 struct bfd_elf_section_data
*d
;
3579 bfd_boolean need_symtab
;
3583 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3585 /* SHT_GROUP sections are in relocatable files only. */
3586 if (link_info
== NULL
|| bfd_link_relocatable (link_info
))
3588 size_t reloc_count
= 0;
3590 /* Put SHT_GROUP sections first. */
3591 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3593 d
= elf_section_data (sec
);
3595 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3597 if (sec
->flags
& SEC_LINKER_CREATED
)
3599 /* Remove the linker created SHT_GROUP sections. */
3600 bfd_section_list_remove (abfd
, sec
);
3601 abfd
->section_count
--;
3604 d
->this_idx
= section_number
++;
3607 /* Count relocations. */
3608 reloc_count
+= sec
->reloc_count
;
3611 /* Clear HAS_RELOC if there are no relocations. */
3612 if (reloc_count
== 0)
3613 abfd
->flags
&= ~HAS_RELOC
;
3616 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3618 d
= elf_section_data (sec
);
3620 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3621 d
->this_idx
= section_number
++;
3622 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3623 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3626 d
->rel
.idx
= section_number
++;
3627 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3628 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3635 d
->rela
.idx
= section_number
++;
3636 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3637 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3643 need_symtab
= (bfd_get_symcount (abfd
) > 0
3644 || (link_info
== NULL
3645 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3649 elf_onesymtab (abfd
) = section_number
++;
3650 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3651 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3653 elf_section_list
* entry
;
3655 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3657 entry
= bfd_zalloc (abfd
, sizeof * entry
);
3658 entry
->ndx
= section_number
++;
3659 elf_symtab_shndx_list (abfd
) = entry
;
3661 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3662 ".symtab_shndx", FALSE
);
3663 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3666 elf_strtab_sec (abfd
) = section_number
++;
3667 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3670 elf_shstrtab_sec (abfd
) = section_number
++;
3671 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3672 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3674 if (section_number
>= SHN_LORESERVE
)
3676 /* xgettext:c-format */
3677 _bfd_error_handler (_("%B: too many sections: %u"),
3678 abfd
, section_number
);
3682 elf_numsections (abfd
) = section_number
;
3683 elf_elfheader (abfd
)->e_shnum
= section_number
;
3685 /* Set up the list of section header pointers, in agreement with the
3687 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3688 sizeof (Elf_Internal_Shdr
*));
3689 if (i_shdrp
== NULL
)
3692 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3693 sizeof (Elf_Internal_Shdr
));
3694 if (i_shdrp
[0] == NULL
)
3696 bfd_release (abfd
, i_shdrp
);
3700 elf_elfsections (abfd
) = i_shdrp
;
3702 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3705 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3706 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3708 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3709 BFD_ASSERT (entry
!= NULL
);
3710 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3711 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3713 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3714 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3717 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3721 d
= elf_section_data (sec
);
3723 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3724 if (d
->rel
.idx
!= 0)
3725 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3726 if (d
->rela
.idx
!= 0)
3727 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3729 /* Fill in the sh_link and sh_info fields while we're at it. */
3731 /* sh_link of a reloc section is the section index of the symbol
3732 table. sh_info is the section index of the section to which
3733 the relocation entries apply. */
3734 if (d
->rel
.idx
!= 0)
3736 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3737 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3738 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3740 if (d
->rela
.idx
!= 0)
3742 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3743 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3744 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3747 /* We need to set up sh_link for SHF_LINK_ORDER. */
3748 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3750 s
= elf_linked_to_section (sec
);
3753 /* elf_linked_to_section points to the input section. */
3754 if (link_info
!= NULL
)
3756 /* Check discarded linkonce section. */
3757 if (discarded_section (s
))
3761 /* xgettext:c-format */
3762 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3763 abfd
, d
->this_hdr
.bfd_section
,
3765 /* Point to the kept section if it has the same
3766 size as the discarded one. */
3767 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3770 bfd_set_error (bfd_error_bad_value
);
3776 s
= s
->output_section
;
3777 BFD_ASSERT (s
!= NULL
);
3781 /* Handle objcopy. */
3782 if (s
->output_section
== NULL
)
3785 /* xgettext:c-format */
3786 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3787 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3788 bfd_set_error (bfd_error_bad_value
);
3791 s
= s
->output_section
;
3793 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3798 The Intel C compiler generates SHT_IA_64_UNWIND with
3799 SHF_LINK_ORDER. But it doesn't set the sh_link or
3800 sh_info fields. Hence we could get the situation
3802 const struct elf_backend_data
*bed
3803 = get_elf_backend_data (abfd
);
3804 if (bed
->link_order_error_handler
)
3805 bed
->link_order_error_handler
3806 /* xgettext:c-format */
3807 (_("%B: warning: sh_link not set for section `%A'"),
3812 switch (d
->this_hdr
.sh_type
)
3816 /* A reloc section which we are treating as a normal BFD
3817 section. sh_link is the section index of the symbol
3818 table. sh_info is the section index of the section to
3819 which the relocation entries apply. We assume that an
3820 allocated reloc section uses the dynamic symbol table.
3821 FIXME: How can we be sure? */
3822 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3824 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3826 s
= get_elf_backend_data (abfd
)->get_reloc_section (sec
);
3829 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3830 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3835 /* We assume that a section named .stab*str is a stabs
3836 string section. We look for a section with the same name
3837 but without the trailing ``str'', and set its sh_link
3838 field to point to this section. */
3839 if (CONST_STRNEQ (sec
->name
, ".stab")
3840 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3845 len
= strlen (sec
->name
);
3846 alc
= (char *) bfd_malloc (len
- 2);
3849 memcpy (alc
, sec
->name
, len
- 3);
3850 alc
[len
- 3] = '\0';
3851 s
= bfd_get_section_by_name (abfd
, alc
);
3855 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3857 /* This is a .stab section. */
3858 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3859 elf_section_data (s
)->this_hdr
.sh_entsize
3860 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3867 case SHT_GNU_verneed
:
3868 case SHT_GNU_verdef
:
3869 /* sh_link is the section header index of the string table
3870 used for the dynamic entries, or the symbol table, or the
3872 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3874 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3877 case SHT_GNU_LIBLIST
:
3878 /* sh_link is the section header index of the prelink library
3879 list used for the dynamic entries, or the symbol table, or
3880 the version strings. */
3881 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3882 ? ".dynstr" : ".gnu.libstr");
3884 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3889 case SHT_GNU_versym
:
3890 /* sh_link is the section header index of the symbol table
3891 this hash table or version table is for. */
3892 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3894 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3898 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3902 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3903 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3904 debug section name from .debug_* to .zdebug_* if needed. */
3910 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3912 /* If the backend has a special mapping, use it. */
3913 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3914 if (bed
->elf_backend_sym_is_global
)
3915 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3917 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3918 || bfd_is_und_section (bfd_get_section (sym
))
3919 || bfd_is_com_section (bfd_get_section (sym
)));
3922 /* Filter global symbols of ABFD to include in the import library. All
3923 SYMCOUNT symbols of ABFD can be examined from their pointers in
3924 SYMS. Pointers of symbols to keep should be stored contiguously at
3925 the beginning of that array.
3927 Returns the number of symbols to keep. */
3930 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
3931 asymbol
**syms
, long symcount
)
3933 long src_count
, dst_count
= 0;
3935 for (src_count
= 0; src_count
< symcount
; src_count
++)
3937 asymbol
*sym
= syms
[src_count
];
3938 char *name
= (char *) bfd_asymbol_name (sym
);
3939 struct bfd_link_hash_entry
*h
;
3941 if (!sym_is_global (abfd
, sym
))
3944 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
3947 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
3949 if (h
->linker_def
|| h
->ldscript_def
)
3952 syms
[dst_count
++] = sym
;
3955 syms
[dst_count
] = NULL
;
3960 /* Don't output section symbols for sections that are not going to be
3961 output, that are duplicates or there is no BFD section. */
3964 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3966 elf_symbol_type
*type_ptr
;
3968 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3971 type_ptr
= elf_symbol_from (abfd
, sym
);
3972 return ((type_ptr
!= NULL
3973 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
3974 && bfd_is_abs_section (sym
->section
))
3975 || !(sym
->section
->owner
== abfd
3976 || (sym
->section
->output_section
->owner
== abfd
3977 && sym
->section
->output_offset
== 0)
3978 || bfd_is_abs_section (sym
->section
)));
3981 /* Map symbol from it's internal number to the external number, moving
3982 all local symbols to be at the head of the list. */
3985 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
3987 unsigned int symcount
= bfd_get_symcount (abfd
);
3988 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3989 asymbol
**sect_syms
;
3990 unsigned int num_locals
= 0;
3991 unsigned int num_globals
= 0;
3992 unsigned int num_locals2
= 0;
3993 unsigned int num_globals2
= 0;
3994 unsigned int max_index
= 0;
4000 fprintf (stderr
, "elf_map_symbols\n");
4004 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4006 if (max_index
< asect
->index
)
4007 max_index
= asect
->index
;
4011 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4012 if (sect_syms
== NULL
)
4014 elf_section_syms (abfd
) = sect_syms
;
4015 elf_num_section_syms (abfd
) = max_index
;
4017 /* Init sect_syms entries for any section symbols we have already
4018 decided to output. */
4019 for (idx
= 0; idx
< symcount
; idx
++)
4021 asymbol
*sym
= syms
[idx
];
4023 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4025 && !ignore_section_sym (abfd
, sym
)
4026 && !bfd_is_abs_section (sym
->section
))
4028 asection
*sec
= sym
->section
;
4030 if (sec
->owner
!= abfd
)
4031 sec
= sec
->output_section
;
4033 sect_syms
[sec
->index
] = syms
[idx
];
4037 /* Classify all of the symbols. */
4038 for (idx
= 0; idx
< symcount
; idx
++)
4040 if (sym_is_global (abfd
, syms
[idx
]))
4042 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4046 /* We will be adding a section symbol for each normal BFD section. Most
4047 sections will already have a section symbol in outsymbols, but
4048 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4049 at least in that case. */
4050 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4052 if (sect_syms
[asect
->index
] == NULL
)
4054 if (!sym_is_global (abfd
, asect
->symbol
))
4061 /* Now sort the symbols so the local symbols are first. */
4062 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4063 sizeof (asymbol
*));
4065 if (new_syms
== NULL
)
4068 for (idx
= 0; idx
< symcount
; idx
++)
4070 asymbol
*sym
= syms
[idx
];
4073 if (sym_is_global (abfd
, sym
))
4074 i
= num_locals
+ num_globals2
++;
4075 else if (!ignore_section_sym (abfd
, sym
))
4080 sym
->udata
.i
= i
+ 1;
4082 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4084 if (sect_syms
[asect
->index
] == NULL
)
4086 asymbol
*sym
= asect
->symbol
;
4089 sect_syms
[asect
->index
] = sym
;
4090 if (!sym_is_global (abfd
, sym
))
4093 i
= num_locals
+ num_globals2
++;
4095 sym
->udata
.i
= i
+ 1;
4099 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4101 *pnum_locals
= num_locals
;
4105 /* Align to the maximum file alignment that could be required for any
4106 ELF data structure. */
4108 static inline file_ptr
4109 align_file_position (file_ptr off
, int align
)
4111 return (off
+ align
- 1) & ~(align
- 1);
4114 /* Assign a file position to a section, optionally aligning to the
4115 required section alignment. */
4118 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4122 if (align
&& i_shdrp
->sh_addralign
> 1)
4123 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4124 i_shdrp
->sh_offset
= offset
;
4125 if (i_shdrp
->bfd_section
!= NULL
)
4126 i_shdrp
->bfd_section
->filepos
= offset
;
4127 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4128 offset
+= i_shdrp
->sh_size
;
4132 /* Compute the file positions we are going to put the sections at, and
4133 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4134 is not NULL, this is being called by the ELF backend linker. */
4137 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4138 struct bfd_link_info
*link_info
)
4140 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4141 struct fake_section_arg fsargs
;
4143 struct elf_strtab_hash
*strtab
= NULL
;
4144 Elf_Internal_Shdr
*shstrtab_hdr
;
4145 bfd_boolean need_symtab
;
4147 if (abfd
->output_has_begun
)
4150 /* Do any elf backend specific processing first. */
4151 if (bed
->elf_backend_begin_write_processing
)
4152 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4154 if (! prep_headers (abfd
))
4157 /* Post process the headers if necessary. */
4158 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
4160 fsargs
.failed
= FALSE
;
4161 fsargs
.link_info
= link_info
;
4162 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4166 if (!assign_section_numbers (abfd
, link_info
))
4169 /* The backend linker builds symbol table information itself. */
4170 need_symtab
= (link_info
== NULL
4171 && (bfd_get_symcount (abfd
) > 0
4172 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4176 /* Non-zero if doing a relocatable link. */
4177 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4179 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4184 if (link_info
== NULL
)
4186 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4191 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4192 /* sh_name was set in prep_headers. */
4193 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4194 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4195 shstrtab_hdr
->sh_addr
= 0;
4196 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4197 shstrtab_hdr
->sh_entsize
= 0;
4198 shstrtab_hdr
->sh_link
= 0;
4199 shstrtab_hdr
->sh_info
= 0;
4200 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4201 shstrtab_hdr
->sh_addralign
= 1;
4203 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4209 Elf_Internal_Shdr
*hdr
;
4211 off
= elf_next_file_pos (abfd
);
4213 hdr
= & elf_symtab_hdr (abfd
);
4214 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4216 if (elf_symtab_shndx_list (abfd
) != NULL
)
4218 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4219 if (hdr
->sh_size
!= 0)
4220 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4221 /* FIXME: What about other symtab_shndx sections in the list ? */
4224 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4225 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4227 elf_next_file_pos (abfd
) = off
;
4229 /* Now that we know where the .strtab section goes, write it
4231 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4232 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4234 _bfd_elf_strtab_free (strtab
);
4237 abfd
->output_has_begun
= TRUE
;
4242 /* Make an initial estimate of the size of the program header. If we
4243 get the number wrong here, we'll redo section placement. */
4245 static bfd_size_type
4246 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4250 const struct elf_backend_data
*bed
;
4252 /* Assume we will need exactly two PT_LOAD segments: one for text
4253 and one for data. */
4256 s
= bfd_get_section_by_name (abfd
, ".interp");
4257 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4259 /* If we have a loadable interpreter section, we need a
4260 PT_INTERP segment. In this case, assume we also need a
4261 PT_PHDR segment, although that may not be true for all
4266 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4268 /* We need a PT_DYNAMIC segment. */
4272 if (info
!= NULL
&& info
->relro
)
4274 /* We need a PT_GNU_RELRO segment. */
4278 if (elf_eh_frame_hdr (abfd
))
4280 /* We need a PT_GNU_EH_FRAME segment. */
4284 if (elf_stack_flags (abfd
))
4286 /* We need a PT_GNU_STACK segment. */
4290 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4292 if ((s
->flags
& SEC_LOAD
) != 0
4293 && CONST_STRNEQ (s
->name
, ".note"))
4295 /* We need a PT_NOTE segment. */
4297 /* Try to create just one PT_NOTE segment
4298 for all adjacent loadable .note* sections.
4299 gABI requires that within a PT_NOTE segment
4300 (and also inside of each SHT_NOTE section)
4301 each note is padded to a multiple of 4 size,
4302 so we check whether the sections are correctly
4304 if (s
->alignment_power
== 2)
4305 while (s
->next
!= NULL
4306 && s
->next
->alignment_power
== 2
4307 && (s
->next
->flags
& SEC_LOAD
) != 0
4308 && CONST_STRNEQ (s
->next
->name
, ".note"))
4313 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4315 if (s
->flags
& SEC_THREAD_LOCAL
)
4317 /* We need a PT_TLS segment. */
4323 /* Let the backend count up any program headers it might need. */
4324 bed
= get_elf_backend_data (abfd
);
4325 if (bed
->elf_backend_additional_program_headers
)
4329 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4335 return segs
* bed
->s
->sizeof_phdr
;
4338 /* Find the segment that contains the output_section of section. */
4341 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4343 struct elf_segment_map
*m
;
4344 Elf_Internal_Phdr
*p
;
4346 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4352 for (i
= m
->count
- 1; i
>= 0; i
--)
4353 if (m
->sections
[i
] == section
)
4360 /* Create a mapping from a set of sections to a program segment. */
4362 static struct elf_segment_map
*
4363 make_mapping (bfd
*abfd
,
4364 asection
**sections
,
4369 struct elf_segment_map
*m
;
4374 amt
= sizeof (struct elf_segment_map
);
4375 amt
+= (to
- from
- 1) * sizeof (asection
*);
4376 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4380 m
->p_type
= PT_LOAD
;
4381 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4382 m
->sections
[i
- from
] = *hdrpp
;
4383 m
->count
= to
- from
;
4385 if (from
== 0 && phdr
)
4387 /* Include the headers in the first PT_LOAD segment. */
4388 m
->includes_filehdr
= 1;
4389 m
->includes_phdrs
= 1;
4395 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4398 struct elf_segment_map
*
4399 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4401 struct elf_segment_map
*m
;
4403 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4404 sizeof (struct elf_segment_map
));
4408 m
->p_type
= PT_DYNAMIC
;
4410 m
->sections
[0] = dynsec
;
4415 /* Possibly add or remove segments from the segment map. */
4418 elf_modify_segment_map (bfd
*abfd
,
4419 struct bfd_link_info
*info
,
4420 bfd_boolean remove_empty_load
)
4422 struct elf_segment_map
**m
;
4423 const struct elf_backend_data
*bed
;
4425 /* The placement algorithm assumes that non allocated sections are
4426 not in PT_LOAD segments. We ensure this here by removing such
4427 sections from the segment map. We also remove excluded
4428 sections. Finally, any PT_LOAD segment without sections is
4430 m
= &elf_seg_map (abfd
);
4433 unsigned int i
, new_count
;
4435 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4437 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4438 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4439 || (*m
)->p_type
!= PT_LOAD
))
4441 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4445 (*m
)->count
= new_count
;
4447 if (remove_empty_load
4448 && (*m
)->p_type
== PT_LOAD
4450 && !(*m
)->includes_phdrs
)
4456 bed
= get_elf_backend_data (abfd
);
4457 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4459 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4466 /* Set up a mapping from BFD sections to program segments. */
4469 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4472 struct elf_segment_map
*m
;
4473 asection
**sections
= NULL
;
4474 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4475 bfd_boolean no_user_phdrs
;
4477 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4480 info
->user_phdrs
= !no_user_phdrs
;
4482 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4486 struct elf_segment_map
*mfirst
;
4487 struct elf_segment_map
**pm
;
4490 unsigned int phdr_index
;
4491 bfd_vma maxpagesize
;
4493 bfd_boolean phdr_in_segment
= TRUE
;
4494 bfd_boolean writable
;
4496 asection
*first_tls
= NULL
;
4497 asection
*dynsec
, *eh_frame_hdr
;
4499 bfd_vma addr_mask
, wrap_to
= 0;
4500 bfd_boolean linker_created_pt_phdr_segment
= FALSE
;
4502 /* Select the allocated sections, and sort them. */
4504 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4505 sizeof (asection
*));
4506 if (sections
== NULL
)
4509 /* Calculate top address, avoiding undefined behaviour of shift
4510 left operator when shift count is equal to size of type
4512 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4513 addr_mask
= (addr_mask
<< 1) + 1;
4516 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4518 if ((s
->flags
& SEC_ALLOC
) != 0)
4522 /* A wrapping section potentially clashes with header. */
4523 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4524 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4527 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4530 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4532 /* Build the mapping. */
4537 /* If we have a .interp section, then create a PT_PHDR segment for
4538 the program headers and a PT_INTERP segment for the .interp
4540 s
= bfd_get_section_by_name (abfd
, ".interp");
4541 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4543 amt
= sizeof (struct elf_segment_map
);
4544 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4548 m
->p_type
= PT_PHDR
;
4549 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
4550 m
->p_flags
= PF_R
| PF_X
;
4551 m
->p_flags_valid
= 1;
4552 m
->includes_phdrs
= 1;
4553 linker_created_pt_phdr_segment
= TRUE
;
4557 amt
= sizeof (struct elf_segment_map
);
4558 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4562 m
->p_type
= PT_INTERP
;
4570 /* Look through the sections. We put sections in the same program
4571 segment when the start of the second section can be placed within
4572 a few bytes of the end of the first section. */
4576 maxpagesize
= bed
->maxpagesize
;
4577 /* PR 17512: file: c8455299.
4578 Avoid divide-by-zero errors later on.
4579 FIXME: Should we abort if the maxpagesize is zero ? */
4580 if (maxpagesize
== 0)
4583 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4585 && (dynsec
->flags
& SEC_LOAD
) == 0)
4588 /* Deal with -Ttext or something similar such that the first section
4589 is not adjacent to the program headers. This is an
4590 approximation, since at this point we don't know exactly how many
4591 program headers we will need. */
4594 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
4596 if (phdr_size
== (bfd_size_type
) -1)
4597 phdr_size
= get_program_header_size (abfd
, info
);
4598 phdr_size
+= bed
->s
->sizeof_ehdr
;
4599 if ((abfd
->flags
& D_PAGED
) == 0
4600 || (sections
[0]->lma
& addr_mask
) < phdr_size
4601 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
4602 < phdr_size
% maxpagesize
)
4603 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
4605 /* PR 20815: The ELF standard says that a PT_PHDR segment, if
4606 present, must be included as part of the memory image of the
4607 program. Ie it must be part of a PT_LOAD segment as well.
4608 If we have had to create our own PT_PHDR segment, but it is
4609 not going to be covered by the first PT_LOAD segment, then
4610 force the inclusion if we can... */
4611 if ((abfd
->flags
& D_PAGED
) != 0
4612 && linker_created_pt_phdr_segment
)
4613 phdr_in_segment
= TRUE
;
4615 phdr_in_segment
= FALSE
;
4619 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4622 bfd_boolean new_segment
;
4626 /* See if this section and the last one will fit in the same
4629 if (last_hdr
== NULL
)
4631 /* If we don't have a segment yet, then we don't need a new
4632 one (we build the last one after this loop). */
4633 new_segment
= FALSE
;
4635 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4637 /* If this section has a different relation between the
4638 virtual address and the load address, then we need a new
4642 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4643 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4645 /* If this section has a load address that makes it overlap
4646 the previous section, then we need a new segment. */
4649 /* In the next test we have to be careful when last_hdr->lma is close
4650 to the end of the address space. If the aligned address wraps
4651 around to the start of the address space, then there are no more
4652 pages left in memory and it is OK to assume that the current
4653 section can be included in the current segment. */
4654 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4656 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4659 /* If putting this section in this segment would force us to
4660 skip a page in the segment, then we need a new segment. */
4663 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4664 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0
4665 && ((abfd
->flags
& D_PAGED
) == 0
4666 || (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4667 != (hdr
->lma
& -maxpagesize
))))
4669 /* We don't want to put a loaded section after a
4670 nonloaded (ie. bss style) section in the same segment
4671 as that will force the non-loaded section to be loaded.
4672 Consider .tbss sections as loaded for this purpose.
4673 However, like the writable/non-writable case below,
4674 if they are on the same page then they must be put
4675 in the same segment. */
4678 else if ((abfd
->flags
& D_PAGED
) == 0)
4680 /* If the file is not demand paged, which means that we
4681 don't require the sections to be correctly aligned in the
4682 file, then there is no other reason for a new segment. */
4683 new_segment
= FALSE
;
4686 && (hdr
->flags
& SEC_READONLY
) == 0
4687 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4688 != (hdr
->lma
& -maxpagesize
)))
4690 /* We don't want to put a writable section in a read only
4691 segment, unless they are on the same page in memory
4692 anyhow. We already know that the last section does not
4693 bring us past the current section on the page, so the
4694 only case in which the new section is not on the same
4695 page as the previous section is when the previous section
4696 ends precisely on a page boundary. */
4701 /* Otherwise, we can use the same segment. */
4702 new_segment
= FALSE
;
4705 /* Allow interested parties a chance to override our decision. */
4706 if (last_hdr
!= NULL
4708 && info
->callbacks
->override_segment_assignment
!= NULL
)
4710 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4716 if ((hdr
->flags
& SEC_READONLY
) == 0)
4719 /* .tbss sections effectively have zero size. */
4720 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4721 != SEC_THREAD_LOCAL
)
4722 last_size
= hdr
->size
;
4728 /* We need a new program segment. We must create a new program
4729 header holding all the sections from phdr_index until hdr. */
4731 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4738 if ((hdr
->flags
& SEC_READONLY
) == 0)
4744 /* .tbss sections effectively have zero size. */
4745 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4746 last_size
= hdr
->size
;
4750 phdr_in_segment
= FALSE
;
4753 /* Create a final PT_LOAD program segment, but not if it's just
4755 if (last_hdr
!= NULL
4756 && (i
- phdr_index
!= 1
4757 || ((last_hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4758 != SEC_THREAD_LOCAL
)))
4760 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4768 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4771 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4778 /* For each batch of consecutive loadable .note sections,
4779 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4780 because if we link together nonloadable .note sections and
4781 loadable .note sections, we will generate two .note sections
4782 in the output file. FIXME: Using names for section types is
4784 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4786 if ((s
->flags
& SEC_LOAD
) != 0
4787 && CONST_STRNEQ (s
->name
, ".note"))
4792 amt
= sizeof (struct elf_segment_map
);
4793 if (s
->alignment_power
== 2)
4794 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4796 if (s2
->next
->alignment_power
== 2
4797 && (s2
->next
->flags
& SEC_LOAD
) != 0
4798 && CONST_STRNEQ (s2
->next
->name
, ".note")
4799 && align_power (s2
->lma
+ s2
->size
, 2)
4805 amt
+= (count
- 1) * sizeof (asection
*);
4806 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4810 m
->p_type
= PT_NOTE
;
4814 m
->sections
[m
->count
- count
--] = s
;
4815 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4818 m
->sections
[m
->count
- 1] = s
;
4819 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4823 if (s
->flags
& SEC_THREAD_LOCAL
)
4831 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4834 amt
= sizeof (struct elf_segment_map
);
4835 amt
+= (tls_count
- 1) * sizeof (asection
*);
4836 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4841 m
->count
= tls_count
;
4842 /* Mandated PF_R. */
4844 m
->p_flags_valid
= 1;
4846 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4848 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
4851 (_("%B: TLS sections are not adjacent:"), abfd
);
4854 while (i
< (unsigned int) tls_count
)
4856 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
4858 _bfd_error_handler (_(" TLS: %A"), s
);
4862 _bfd_error_handler (_(" non-TLS: %A"), s
);
4865 bfd_set_error (bfd_error_bad_value
);
4876 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4878 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
4879 if (eh_frame_hdr
!= NULL
4880 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4882 amt
= sizeof (struct elf_segment_map
);
4883 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4887 m
->p_type
= PT_GNU_EH_FRAME
;
4889 m
->sections
[0] = eh_frame_hdr
->output_section
;
4895 if (elf_stack_flags (abfd
))
4897 amt
= sizeof (struct elf_segment_map
);
4898 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4902 m
->p_type
= PT_GNU_STACK
;
4903 m
->p_flags
= elf_stack_flags (abfd
);
4904 m
->p_align
= bed
->stack_align
;
4905 m
->p_flags_valid
= 1;
4906 m
->p_align_valid
= m
->p_align
!= 0;
4907 if (info
->stacksize
> 0)
4909 m
->p_size
= info
->stacksize
;
4910 m
->p_size_valid
= 1;
4917 if (info
!= NULL
&& info
->relro
)
4919 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
4921 if (m
->p_type
== PT_LOAD
4923 && m
->sections
[0]->vma
>= info
->relro_start
4924 && m
->sections
[0]->vma
< info
->relro_end
)
4927 while (--i
!= (unsigned) -1)
4928 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
4929 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
4932 if (i
!= (unsigned) -1)
4937 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4940 amt
= sizeof (struct elf_segment_map
);
4941 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4945 m
->p_type
= PT_GNU_RELRO
;
4952 elf_seg_map (abfd
) = mfirst
;
4955 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4958 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4960 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
4965 if (sections
!= NULL
)
4970 /* Sort sections by address. */
4973 elf_sort_sections (const void *arg1
, const void *arg2
)
4975 const asection
*sec1
= *(const asection
**) arg1
;
4976 const asection
*sec2
= *(const asection
**) arg2
;
4977 bfd_size_type size1
, size2
;
4979 /* Sort by LMA first, since this is the address used to
4980 place the section into a segment. */
4981 if (sec1
->lma
< sec2
->lma
)
4983 else if (sec1
->lma
> sec2
->lma
)
4986 /* Then sort by VMA. Normally the LMA and the VMA will be
4987 the same, and this will do nothing. */
4988 if (sec1
->vma
< sec2
->vma
)
4990 else if (sec1
->vma
> sec2
->vma
)
4993 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4995 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5001 /* If the indicies are the same, do not return 0
5002 here, but continue to try the next comparison. */
5003 if (sec1
->target_index
- sec2
->target_index
!= 0)
5004 return sec1
->target_index
- sec2
->target_index
;
5009 else if (TOEND (sec2
))
5014 /* Sort by size, to put zero sized sections
5015 before others at the same address. */
5017 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5018 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5025 return sec1
->target_index
- sec2
->target_index
;
5028 /* Ian Lance Taylor writes:
5030 We shouldn't be using % with a negative signed number. That's just
5031 not good. We have to make sure either that the number is not
5032 negative, or that the number has an unsigned type. When the types
5033 are all the same size they wind up as unsigned. When file_ptr is a
5034 larger signed type, the arithmetic winds up as signed long long,
5037 What we're trying to say here is something like ``increase OFF by
5038 the least amount that will cause it to be equal to the VMA modulo
5040 /* In other words, something like:
5042 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5043 off_offset = off % bed->maxpagesize;
5044 if (vma_offset < off_offset)
5045 adjustment = vma_offset + bed->maxpagesize - off_offset;
5047 adjustment = vma_offset - off_offset;
5049 which can can be collapsed into the expression below. */
5052 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5054 /* PR binutils/16199: Handle an alignment of zero. */
5055 if (maxpagesize
== 0)
5057 return ((vma
- off
) % maxpagesize
);
5061 print_segment_map (const struct elf_segment_map
*m
)
5064 const char *pt
= get_segment_type (m
->p_type
);
5069 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5070 sprintf (buf
, "LOPROC+%7.7x",
5071 (unsigned int) (m
->p_type
- PT_LOPROC
));
5072 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5073 sprintf (buf
, "LOOS+%7.7x",
5074 (unsigned int) (m
->p_type
- PT_LOOS
));
5076 snprintf (buf
, sizeof (buf
), "%8.8x",
5077 (unsigned int) m
->p_type
);
5081 fprintf (stderr
, "%s:", pt
);
5082 for (j
= 0; j
< m
->count
; j
++)
5083 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5089 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5094 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5096 buf
= bfd_zmalloc (len
);
5099 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5104 /* Assign file positions to the sections based on the mapping from
5105 sections to segments. This function also sets up some fields in
5109 assign_file_positions_for_load_sections (bfd
*abfd
,
5110 struct bfd_link_info
*link_info
)
5112 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5113 struct elf_segment_map
*m
;
5114 Elf_Internal_Phdr
*phdrs
;
5115 Elf_Internal_Phdr
*p
;
5117 bfd_size_type maxpagesize
;
5120 bfd_vma header_pad
= 0;
5122 if (link_info
== NULL
5123 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5127 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5131 header_pad
= m
->header_size
;
5136 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5137 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5141 /* PR binutils/12467. */
5142 elf_elfheader (abfd
)->e_phoff
= 0;
5143 elf_elfheader (abfd
)->e_phentsize
= 0;
5146 elf_elfheader (abfd
)->e_phnum
= alloc
;
5148 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5149 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5151 BFD_ASSERT (elf_program_header_size (abfd
)
5152 >= alloc
* bed
->s
->sizeof_phdr
);
5156 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5160 /* We're writing the size in elf_program_header_size (abfd),
5161 see assign_file_positions_except_relocs, so make sure we have
5162 that amount allocated, with trailing space cleared.
5163 The variable alloc contains the computed need, while
5164 elf_program_header_size (abfd) contains the size used for the
5166 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5167 where the layout is forced to according to a larger size in the
5168 last iterations for the testcase ld-elf/header. */
5169 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
5171 phdrs
= (Elf_Internal_Phdr
*)
5173 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
5174 sizeof (Elf_Internal_Phdr
));
5175 elf_tdata (abfd
)->phdr
= phdrs
;
5180 if ((abfd
->flags
& D_PAGED
) != 0)
5181 maxpagesize
= bed
->maxpagesize
;
5183 off
= bed
->s
->sizeof_ehdr
;
5184 off
+= alloc
* bed
->s
->sizeof_phdr
;
5185 if (header_pad
< (bfd_vma
) off
)
5191 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
5193 m
= m
->next
, p
++, j
++)
5197 bfd_boolean no_contents
;
5199 /* If elf_segment_map is not from map_sections_to_segments, the
5200 sections may not be correctly ordered. NOTE: sorting should
5201 not be done to the PT_NOTE section of a corefile, which may
5202 contain several pseudo-sections artificially created by bfd.
5203 Sorting these pseudo-sections breaks things badly. */
5205 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5206 && m
->p_type
== PT_NOTE
))
5207 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5210 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5211 number of sections with contents contributing to both p_filesz
5212 and p_memsz, followed by a number of sections with no contents
5213 that just contribute to p_memsz. In this loop, OFF tracks next
5214 available file offset for PT_LOAD and PT_NOTE segments. */
5215 p
->p_type
= m
->p_type
;
5216 p
->p_flags
= m
->p_flags
;
5221 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
5223 if (m
->p_paddr_valid
)
5224 p
->p_paddr
= m
->p_paddr
;
5225 else if (m
->count
== 0)
5228 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
5230 if (p
->p_type
== PT_LOAD
5231 && (abfd
->flags
& D_PAGED
) != 0)
5233 /* p_align in demand paged PT_LOAD segments effectively stores
5234 the maximum page size. When copying an executable with
5235 objcopy, we set m->p_align from the input file. Use this
5236 value for maxpagesize rather than bed->maxpagesize, which
5237 may be different. Note that we use maxpagesize for PT_TLS
5238 segment alignment later in this function, so we are relying
5239 on at least one PT_LOAD segment appearing before a PT_TLS
5241 if (m
->p_align_valid
)
5242 maxpagesize
= m
->p_align
;
5244 p
->p_align
= maxpagesize
;
5246 else if (m
->p_align_valid
)
5247 p
->p_align
= m
->p_align
;
5248 else if (m
->count
== 0)
5249 p
->p_align
= 1 << bed
->s
->log_file_align
;
5253 no_contents
= FALSE
;
5255 if (p
->p_type
== PT_LOAD
5258 bfd_size_type align
;
5259 unsigned int align_power
= 0;
5261 if (m
->p_align_valid
)
5265 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5267 unsigned int secalign
;
5269 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
5270 if (secalign
> align_power
)
5271 align_power
= secalign
;
5273 align
= (bfd_size_type
) 1 << align_power
;
5274 if (align
< maxpagesize
)
5275 align
= maxpagesize
;
5278 for (i
= 0; i
< m
->count
; i
++)
5279 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5280 /* If we aren't making room for this section, then
5281 it must be SHT_NOBITS regardless of what we've
5282 set via struct bfd_elf_special_section. */
5283 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5285 /* Find out whether this segment contains any loadable
5288 for (i
= 0; i
< m
->count
; i
++)
5289 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5291 no_contents
= FALSE
;
5295 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5299 /* We shouldn't need to align the segment on disk since
5300 the segment doesn't need file space, but the gABI
5301 arguably requires the alignment and glibc ld.so
5302 checks it. So to comply with the alignment
5303 requirement but not waste file space, we adjust
5304 p_offset for just this segment. (OFF_ADJUST is
5305 subtracted from OFF later.) This may put p_offset
5306 past the end of file, but that shouldn't matter. */
5311 /* Make sure the .dynamic section is the first section in the
5312 PT_DYNAMIC segment. */
5313 else if (p
->p_type
== PT_DYNAMIC
5315 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5318 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
5320 bfd_set_error (bfd_error_bad_value
);
5323 /* Set the note section type to SHT_NOTE. */
5324 else if (p
->p_type
== PT_NOTE
)
5325 for (i
= 0; i
< m
->count
; i
++)
5326 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5332 if (m
->includes_filehdr
)
5334 if (!m
->p_flags_valid
)
5336 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5337 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5340 if (p
->p_vaddr
< (bfd_vma
) off
5341 || (!m
->p_paddr_valid
5342 && p
->p_paddr
< (bfd_vma
) off
))
5345 (_("%B: Not enough room for program headers, try linking with -N"),
5347 bfd_set_error (bfd_error_bad_value
);
5352 if (!m
->p_paddr_valid
)
5357 if (m
->includes_phdrs
)
5359 if (!m
->p_flags_valid
)
5362 if (!m
->includes_filehdr
)
5364 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5368 p
->p_vaddr
-= off
- p
->p_offset
;
5369 if (!m
->p_paddr_valid
)
5370 p
->p_paddr
-= off
- p
->p_offset
;
5374 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
5375 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
5378 p
->p_filesz
+= header_pad
;
5379 p
->p_memsz
+= header_pad
;
5383 if (p
->p_type
== PT_LOAD
5384 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5386 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5392 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5394 p
->p_filesz
+= adjust
;
5395 p
->p_memsz
+= adjust
;
5399 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5400 maps. Set filepos for sections in PT_LOAD segments, and in
5401 core files, for sections in PT_NOTE segments.
5402 assign_file_positions_for_non_load_sections will set filepos
5403 for other sections and update p_filesz for other segments. */
5404 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5407 bfd_size_type align
;
5408 Elf_Internal_Shdr
*this_hdr
;
5411 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5412 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
5414 if ((p
->p_type
== PT_LOAD
5415 || p
->p_type
== PT_TLS
)
5416 && (this_hdr
->sh_type
!= SHT_NOBITS
5417 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5418 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5419 || p
->p_type
== PT_TLS
))))
5421 bfd_vma p_start
= p
->p_paddr
;
5422 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5423 bfd_vma s_start
= sec
->lma
;
5424 bfd_vma adjust
= s_start
- p_end
;
5428 || p_end
< p_start
))
5431 /* xgettext:c-format */
5432 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
5433 (unsigned long) s_start
, (unsigned long) p_end
);
5437 p
->p_memsz
+= adjust
;
5439 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5441 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5443 /* We have a PROGBITS section following NOBITS ones.
5444 Allocate file space for the NOBITS section(s) and
5446 adjust
= p
->p_memsz
- p
->p_filesz
;
5447 if (!write_zeros (abfd
, off
, adjust
))
5451 p
->p_filesz
+= adjust
;
5455 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5457 /* The section at i == 0 is the one that actually contains
5461 this_hdr
->sh_offset
= sec
->filepos
= off
;
5462 off
+= this_hdr
->sh_size
;
5463 p
->p_filesz
= this_hdr
->sh_size
;
5469 /* The rest are fake sections that shouldn't be written. */
5478 if (p
->p_type
== PT_LOAD
)
5480 this_hdr
->sh_offset
= sec
->filepos
= off
;
5481 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5482 off
+= this_hdr
->sh_size
;
5484 else if (this_hdr
->sh_type
== SHT_NOBITS
5485 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5486 && this_hdr
->sh_offset
== 0)
5488 /* This is a .tbss section that didn't get a PT_LOAD.
5489 (See _bfd_elf_map_sections_to_segments "Create a
5490 final PT_LOAD".) Set sh_offset to the value it
5491 would have if we had created a zero p_filesz and
5492 p_memsz PT_LOAD header for the section. This
5493 also makes the PT_TLS header have the same
5495 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5497 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5500 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5502 p
->p_filesz
+= this_hdr
->sh_size
;
5503 /* A load section without SHF_ALLOC is something like
5504 a note section in a PT_NOTE segment. These take
5505 file space but are not loaded into memory. */
5506 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5507 p
->p_memsz
+= this_hdr
->sh_size
;
5509 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5511 if (p
->p_type
== PT_TLS
)
5512 p
->p_memsz
+= this_hdr
->sh_size
;
5514 /* .tbss is special. It doesn't contribute to p_memsz of
5516 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5517 p
->p_memsz
+= this_hdr
->sh_size
;
5520 if (align
> p
->p_align
5521 && !m
->p_align_valid
5522 && (p
->p_type
!= PT_LOAD
5523 || (abfd
->flags
& D_PAGED
) == 0))
5527 if (!m
->p_flags_valid
)
5530 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5532 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5539 /* Check that all sections are in a PT_LOAD segment.
5540 Don't check funky gdb generated core files. */
5541 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5543 bfd_boolean check_vma
= TRUE
;
5545 for (i
= 1; i
< m
->count
; i
++)
5546 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5547 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5548 ->this_hdr
), p
) != 0
5549 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5550 ->this_hdr
), p
) != 0)
5552 /* Looks like we have overlays packed into the segment. */
5557 for (i
= 0; i
< m
->count
; i
++)
5559 Elf_Internal_Shdr
*this_hdr
;
5562 sec
= m
->sections
[i
];
5563 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5564 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5565 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5568 /* xgettext:c-format */
5569 (_("%B: section `%A' can't be allocated in segment %d"),
5571 print_segment_map (m
);
5577 elf_next_file_pos (abfd
) = off
;
5581 /* Assign file positions for the other sections. */
5584 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5585 struct bfd_link_info
*link_info
)
5587 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5588 Elf_Internal_Shdr
**i_shdrpp
;
5589 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
5590 Elf_Internal_Phdr
*phdrs
;
5591 Elf_Internal_Phdr
*p
;
5592 struct elf_segment_map
*m
;
5593 struct elf_segment_map
*hdrs_segment
;
5594 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5595 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5599 i_shdrpp
= elf_elfsections (abfd
);
5600 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
5601 off
= elf_next_file_pos (abfd
);
5602 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
5604 Elf_Internal_Shdr
*hdr
;
5607 if (hdr
->bfd_section
!= NULL
5608 && (hdr
->bfd_section
->filepos
!= 0
5609 || (hdr
->sh_type
== SHT_NOBITS
5610 && hdr
->contents
== NULL
)))
5611 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5612 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5614 if (hdr
->sh_size
!= 0)
5616 /* xgettext:c-format */
5617 (_("%B: warning: allocated section `%s' not in segment"),
5619 (hdr
->bfd_section
== NULL
5621 : hdr
->bfd_section
->name
));
5622 /* We don't need to page align empty sections. */
5623 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5624 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5627 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5629 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5632 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5633 && hdr
->bfd_section
== NULL
)
5634 || (hdr
->bfd_section
!= NULL
5635 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5636 /* Compress DWARF debug sections. */
5637 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5638 || (elf_symtab_shndx_list (abfd
) != NULL
5639 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5640 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
5641 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
5642 hdr
->sh_offset
= -1;
5644 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5647 /* Now that we have set the section file positions, we can set up
5648 the file positions for the non PT_LOAD segments. */
5652 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5654 hdrs_segment
= NULL
;
5655 phdrs
= elf_tdata (abfd
)->phdr
;
5656 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5659 if (p
->p_type
!= PT_LOAD
)
5662 if (m
->includes_filehdr
)
5664 filehdr_vaddr
= p
->p_vaddr
;
5665 filehdr_paddr
= p
->p_paddr
;
5667 if (m
->includes_phdrs
)
5669 phdrs_vaddr
= p
->p_vaddr
;
5670 phdrs_paddr
= p
->p_paddr
;
5671 if (m
->includes_filehdr
)
5674 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5675 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5680 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5682 /* There is a segment that contains both the file headers and the
5683 program headers, so provide a symbol __ehdr_start pointing there.
5684 A program can use this to examine itself robustly. */
5686 struct elf_link_hash_entry
*hash
5687 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5688 FALSE
, FALSE
, TRUE
);
5689 /* If the symbol was referenced and not defined, define it. */
5691 && (hash
->root
.type
== bfd_link_hash_new
5692 || hash
->root
.type
== bfd_link_hash_undefined
5693 || hash
->root
.type
== bfd_link_hash_undefweak
5694 || hash
->root
.type
== bfd_link_hash_common
))
5697 if (hdrs_segment
->count
!= 0)
5698 /* The segment contains sections, so use the first one. */
5699 s
= hdrs_segment
->sections
[0];
5701 /* Use the first (i.e. lowest-addressed) section in any segment. */
5702 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5711 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5712 hash
->root
.u
.def
.section
= s
;
5716 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5717 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5720 hash
->root
.type
= bfd_link_hash_defined
;
5721 hash
->def_regular
= 1;
5726 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5728 if (p
->p_type
== PT_GNU_RELRO
)
5730 const Elf_Internal_Phdr
*lp
;
5731 struct elf_segment_map
*lm
;
5733 if (link_info
!= NULL
)
5735 /* During linking the range of the RELRO segment is passed
5737 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5739 lm
= lm
->next
, lp
++)
5741 if (lp
->p_type
== PT_LOAD
5742 && lp
->p_vaddr
< link_info
->relro_end
5744 && lm
->sections
[0]->vma
>= link_info
->relro_start
)
5748 BFD_ASSERT (lm
!= NULL
);
5752 /* Otherwise we are copying an executable or shared
5753 library, but we need to use the same linker logic. */
5754 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
5756 if (lp
->p_type
== PT_LOAD
5757 && lp
->p_paddr
== p
->p_paddr
)
5762 if (lp
< phdrs
+ count
)
5764 p
->p_vaddr
= lp
->p_vaddr
;
5765 p
->p_paddr
= lp
->p_paddr
;
5766 p
->p_offset
= lp
->p_offset
;
5767 if (link_info
!= NULL
)
5768 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
5769 else if (m
->p_size_valid
)
5770 p
->p_filesz
= m
->p_size
;
5773 p
->p_memsz
= p
->p_filesz
;
5774 /* Preserve the alignment and flags if they are valid. The
5775 gold linker generates RW/4 for the PT_GNU_RELRO section.
5776 It is better for objcopy/strip to honor these attributes
5777 otherwise gdb will choke when using separate debug files.
5779 if (!m
->p_align_valid
)
5781 if (!m
->p_flags_valid
)
5786 memset (p
, 0, sizeof *p
);
5787 p
->p_type
= PT_NULL
;
5790 else if (p
->p_type
== PT_GNU_STACK
)
5792 if (m
->p_size_valid
)
5793 p
->p_memsz
= m
->p_size
;
5795 else if (m
->count
!= 0)
5799 if (p
->p_type
!= PT_LOAD
5800 && (p
->p_type
!= PT_NOTE
5801 || bfd_get_format (abfd
) != bfd_core
))
5803 /* A user specified segment layout may include a PHDR
5804 segment that overlaps with a LOAD segment... */
5805 if (p
->p_type
== PT_PHDR
)
5811 if (m
->includes_filehdr
|| m
->includes_phdrs
)
5813 /* PR 17512: file: 2195325e. */
5815 (_("%B: error: non-load segment %d includes file header and/or program header"),
5816 abfd
, (int)(p
- phdrs
));
5821 p
->p_offset
= m
->sections
[0]->filepos
;
5822 for (i
= m
->count
; i
-- != 0;)
5824 asection
*sect
= m
->sections
[i
];
5825 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
5826 if (hdr
->sh_type
!= SHT_NOBITS
)
5828 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
5835 else if (m
->includes_filehdr
)
5837 p
->p_vaddr
= filehdr_vaddr
;
5838 if (! m
->p_paddr_valid
)
5839 p
->p_paddr
= filehdr_paddr
;
5841 else if (m
->includes_phdrs
)
5843 p
->p_vaddr
= phdrs_vaddr
;
5844 if (! m
->p_paddr_valid
)
5845 p
->p_paddr
= phdrs_paddr
;
5849 elf_next_file_pos (abfd
) = off
;
5854 static elf_section_list
*
5855 find_section_in_list (unsigned int i
, elf_section_list
* list
)
5857 for (;list
!= NULL
; list
= list
->next
)
5863 /* Work out the file positions of all the sections. This is called by
5864 _bfd_elf_compute_section_file_positions. All the section sizes and
5865 VMAs must be known before this is called.
5867 Reloc sections come in two flavours: Those processed specially as
5868 "side-channel" data attached to a section to which they apply, and
5869 those that bfd doesn't process as relocations. The latter sort are
5870 stored in a normal bfd section by bfd_section_from_shdr. We don't
5871 consider the former sort here, unless they form part of the loadable
5872 image. Reloc sections not assigned here will be handled later by
5873 assign_file_positions_for_relocs.
5875 We also don't set the positions of the .symtab and .strtab here. */
5878 assign_file_positions_except_relocs (bfd
*abfd
,
5879 struct bfd_link_info
*link_info
)
5881 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
5882 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5883 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5885 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
5886 && bfd_get_format (abfd
) != bfd_core
)
5888 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
5889 unsigned int num_sec
= elf_numsections (abfd
);
5890 Elf_Internal_Shdr
**hdrpp
;
5894 /* Start after the ELF header. */
5895 off
= i_ehdrp
->e_ehsize
;
5897 /* We are not creating an executable, which means that we are
5898 not creating a program header, and that the actual order of
5899 the sections in the file is unimportant. */
5900 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5902 Elf_Internal_Shdr
*hdr
;
5905 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5906 && hdr
->bfd_section
== NULL
)
5907 || (hdr
->bfd_section
!= NULL
5908 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5909 /* Compress DWARF debug sections. */
5910 || i
== elf_onesymtab (abfd
)
5911 || (elf_symtab_shndx_list (abfd
) != NULL
5912 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5913 || i
== elf_strtab_sec (abfd
)
5914 || i
== elf_shstrtab_sec (abfd
))
5916 hdr
->sh_offset
= -1;
5919 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5922 elf_next_file_pos (abfd
) = off
;
5928 /* Assign file positions for the loaded sections based on the
5929 assignment of sections to segments. */
5930 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
5933 /* And for non-load sections. */
5934 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
5937 if (bed
->elf_backend_modify_program_headers
!= NULL
)
5939 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
5943 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
5944 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
5946 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
5947 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
5948 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
5950 /* Find the lowest p_vaddr in PT_LOAD segments. */
5951 bfd_vma p_vaddr
= (bfd_vma
) -1;
5952 for (; segment
< end_segment
; segment
++)
5953 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
5954 p_vaddr
= segment
->p_vaddr
;
5956 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5957 segments is non-zero. */
5959 i_ehdrp
->e_type
= ET_EXEC
;
5962 /* Write out the program headers. */
5963 alloc
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5965 /* Sort the program headers into the ordering required by the ELF standard. */
5969 /* PR ld/20815 - Check that the program header segment, if present, will
5970 be loaded into memory. FIXME: The check below is not sufficient as
5971 really all PT_LOAD segments should be checked before issuing an error
5972 message. Plus the PHDR segment does not have to be the first segment
5973 in the program header table. But this version of the check should
5974 catch all real world use cases.
5976 FIXME: We used to have code here to sort the PT_LOAD segments into
5977 ascending order, as per the ELF spec. But this breaks some programs,
5978 including the Linux kernel. But really either the spec should be
5979 changed or the programs updated. */
5981 && tdata
->phdr
[0].p_type
== PT_PHDR
5982 && ! bed
->elf_backend_allow_non_load_phdr (abfd
, tdata
->phdr
, alloc
)
5983 && tdata
->phdr
[1].p_type
== PT_LOAD
5984 && (tdata
->phdr
[1].p_vaddr
> tdata
->phdr
[0].p_vaddr
5985 || (tdata
->phdr
[1].p_vaddr
+ tdata
->phdr
[1].p_memsz
)
5986 < (tdata
->phdr
[0].p_vaddr
+ tdata
->phdr
[0].p_memsz
)))
5988 /* The fix for this error is usually to edit the linker script being
5989 used and set up the program headers manually. Either that or
5990 leave room for the headers at the start of the SECTIONS. */
5991 _bfd_error_handler (_("\
5992 %B: error: PHDR segment not covered by LOAD segment"),
5997 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
5998 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6006 prep_headers (bfd
*abfd
)
6008 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6009 struct elf_strtab_hash
*shstrtab
;
6010 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6012 i_ehdrp
= elf_elfheader (abfd
);
6014 shstrtab
= _bfd_elf_strtab_init ();
6015 if (shstrtab
== NULL
)
6018 elf_shstrtab (abfd
) = shstrtab
;
6020 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6021 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6022 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6023 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6025 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6026 i_ehdrp
->e_ident
[EI_DATA
] =
6027 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6028 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6030 if ((abfd
->flags
& DYNAMIC
) != 0)
6031 i_ehdrp
->e_type
= ET_DYN
;
6032 else if ((abfd
->flags
& EXEC_P
) != 0)
6033 i_ehdrp
->e_type
= ET_EXEC
;
6034 else if (bfd_get_format (abfd
) == bfd_core
)
6035 i_ehdrp
->e_type
= ET_CORE
;
6037 i_ehdrp
->e_type
= ET_REL
;
6039 switch (bfd_get_arch (abfd
))
6041 case bfd_arch_unknown
:
6042 i_ehdrp
->e_machine
= EM_NONE
;
6045 /* There used to be a long list of cases here, each one setting
6046 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6047 in the corresponding bfd definition. To avoid duplication,
6048 the switch was removed. Machines that need special handling
6049 can generally do it in elf_backend_final_write_processing(),
6050 unless they need the information earlier than the final write.
6051 Such need can generally be supplied by replacing the tests for
6052 e_machine with the conditions used to determine it. */
6054 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6057 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6058 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6060 /* No program header, for now. */
6061 i_ehdrp
->e_phoff
= 0;
6062 i_ehdrp
->e_phentsize
= 0;
6063 i_ehdrp
->e_phnum
= 0;
6065 /* Each bfd section is section header entry. */
6066 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6067 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6069 /* If we're building an executable, we'll need a program header table. */
6070 if (abfd
->flags
& EXEC_P
)
6071 /* It all happens later. */
6075 i_ehdrp
->e_phentsize
= 0;
6076 i_ehdrp
->e_phoff
= 0;
6079 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6080 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6081 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6082 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6083 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6084 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6085 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6086 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6087 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6093 /* Assign file positions for all the reloc sections which are not part
6094 of the loadable file image, and the file position of section headers. */
6097 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6100 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6101 Elf_Internal_Shdr
*shdrp
;
6102 Elf_Internal_Ehdr
*i_ehdrp
;
6103 const struct elf_backend_data
*bed
;
6105 off
= elf_next_file_pos (abfd
);
6107 shdrpp
= elf_elfsections (abfd
);
6108 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6109 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6112 if (shdrp
->sh_offset
== -1)
6114 asection
*sec
= shdrp
->bfd_section
;
6115 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6116 || shdrp
->sh_type
== SHT_RELA
);
6118 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6122 const char *name
= sec
->name
;
6123 struct bfd_elf_section_data
*d
;
6125 /* Compress DWARF debug sections. */
6126 if (!bfd_compress_section (abfd
, sec
,
6130 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6131 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6133 /* If section is compressed with zlib-gnu, convert
6134 section name from .debug_* to .zdebug_*. */
6136 = convert_debug_to_zdebug (abfd
, name
);
6137 if (new_name
== NULL
)
6141 /* Add section name to section name section. */
6142 if (shdrp
->sh_name
!= (unsigned int) -1)
6145 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6147 d
= elf_section_data (sec
);
6149 /* Add reloc section name to section name section. */
6151 && !_bfd_elf_set_reloc_sh_name (abfd
,
6156 && !_bfd_elf_set_reloc_sh_name (abfd
,
6161 /* Update section size and contents. */
6162 shdrp
->sh_size
= sec
->size
;
6163 shdrp
->contents
= sec
->contents
;
6164 shdrp
->bfd_section
->contents
= NULL
;
6166 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6173 /* Place section name section after DWARF debug sections have been
6175 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6176 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6177 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6178 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6180 /* Place the section headers. */
6181 i_ehdrp
= elf_elfheader (abfd
);
6182 bed
= get_elf_backend_data (abfd
);
6183 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6184 i_ehdrp
->e_shoff
= off
;
6185 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6186 elf_next_file_pos (abfd
) = off
;
6192 _bfd_elf_write_object_contents (bfd
*abfd
)
6194 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6195 Elf_Internal_Shdr
**i_shdrp
;
6197 unsigned int count
, num_sec
;
6198 struct elf_obj_tdata
*t
;
6200 if (! abfd
->output_has_begun
6201 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6204 i_shdrp
= elf_elfsections (abfd
);
6207 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6211 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6214 /* After writing the headers, we need to write the sections too... */
6215 num_sec
= elf_numsections (abfd
);
6216 for (count
= 1; count
< num_sec
; count
++)
6218 i_shdrp
[count
]->sh_name
6219 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6220 i_shdrp
[count
]->sh_name
);
6221 if (bed
->elf_backend_section_processing
)
6222 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
6223 if (i_shdrp
[count
]->contents
)
6225 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6227 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6228 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6233 /* Write out the section header names. */
6234 t
= elf_tdata (abfd
);
6235 if (elf_shstrtab (abfd
) != NULL
6236 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6237 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6240 if (bed
->elf_backend_final_write_processing
)
6241 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
6243 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6246 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6247 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6248 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6254 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6256 /* Hopefully this can be done just like an object file. */
6257 return _bfd_elf_write_object_contents (abfd
);
6260 /* Given a section, search the header to find them. */
6263 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6265 const struct elf_backend_data
*bed
;
6266 unsigned int sec_index
;
6268 if (elf_section_data (asect
) != NULL
6269 && elf_section_data (asect
)->this_idx
!= 0)
6270 return elf_section_data (asect
)->this_idx
;
6272 if (bfd_is_abs_section (asect
))
6273 sec_index
= SHN_ABS
;
6274 else if (bfd_is_com_section (asect
))
6275 sec_index
= SHN_COMMON
;
6276 else if (bfd_is_und_section (asect
))
6277 sec_index
= SHN_UNDEF
;
6279 sec_index
= SHN_BAD
;
6281 bed
= get_elf_backend_data (abfd
);
6282 if (bed
->elf_backend_section_from_bfd_section
)
6284 int retval
= sec_index
;
6286 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6290 if (sec_index
== SHN_BAD
)
6291 bfd_set_error (bfd_error_nonrepresentable_section
);
6296 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6300 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6302 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6304 flagword flags
= asym_ptr
->flags
;
6306 /* When gas creates relocations against local labels, it creates its
6307 own symbol for the section, but does put the symbol into the
6308 symbol chain, so udata is 0. When the linker is generating
6309 relocatable output, this section symbol may be for one of the
6310 input sections rather than the output section. */
6311 if (asym_ptr
->udata
.i
== 0
6312 && (flags
& BSF_SECTION_SYM
)
6313 && asym_ptr
->section
)
6318 sec
= asym_ptr
->section
;
6319 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6320 sec
= sec
->output_section
;
6321 if (sec
->owner
== abfd
6322 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6323 && elf_section_syms (abfd
)[indx
] != NULL
)
6324 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6327 idx
= asym_ptr
->udata
.i
;
6331 /* This case can occur when using --strip-symbol on a symbol
6332 which is used in a relocation entry. */
6334 /* xgettext:c-format */
6335 (_("%B: symbol `%s' required but not present"),
6336 abfd
, bfd_asymbol_name (asym_ptr
));
6337 bfd_set_error (bfd_error_no_symbols
);
6344 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
6345 (long) asym_ptr
, asym_ptr
->name
, idx
, (long) flags
);
6353 /* Rewrite program header information. */
6356 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6358 Elf_Internal_Ehdr
*iehdr
;
6359 struct elf_segment_map
*map
;
6360 struct elf_segment_map
*map_first
;
6361 struct elf_segment_map
**pointer_to_map
;
6362 Elf_Internal_Phdr
*segment
;
6365 unsigned int num_segments
;
6366 bfd_boolean phdr_included
= FALSE
;
6367 bfd_boolean p_paddr_valid
;
6368 bfd_vma maxpagesize
;
6369 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6370 unsigned int phdr_adjust_num
= 0;
6371 const struct elf_backend_data
*bed
;
6373 bed
= get_elf_backend_data (ibfd
);
6374 iehdr
= elf_elfheader (ibfd
);
6377 pointer_to_map
= &map_first
;
6379 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6380 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6382 /* Returns the end address of the segment + 1. */
6383 #define SEGMENT_END(segment, start) \
6384 (start + (segment->p_memsz > segment->p_filesz \
6385 ? segment->p_memsz : segment->p_filesz))
6387 #define SECTION_SIZE(section, segment) \
6388 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6389 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6390 ? section->size : 0)
6392 /* Returns TRUE if the given section is contained within
6393 the given segment. VMA addresses are compared. */
6394 #define IS_CONTAINED_BY_VMA(section, segment) \
6395 (section->vma >= segment->p_vaddr \
6396 && (section->vma + SECTION_SIZE (section, segment) \
6397 <= (SEGMENT_END (segment, segment->p_vaddr))))
6399 /* Returns TRUE if the given section is contained within
6400 the given segment. LMA addresses are compared. */
6401 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6402 (section->lma >= base \
6403 && (section->lma + SECTION_SIZE (section, segment) \
6404 <= SEGMENT_END (segment, base)))
6406 /* Handle PT_NOTE segment. */
6407 #define IS_NOTE(p, s) \
6408 (p->p_type == PT_NOTE \
6409 && elf_section_type (s) == SHT_NOTE \
6410 && (bfd_vma) s->filepos >= p->p_offset \
6411 && ((bfd_vma) s->filepos + s->size \
6412 <= p->p_offset + p->p_filesz))
6414 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6416 #define IS_COREFILE_NOTE(p, s) \
6418 && bfd_get_format (ibfd) == bfd_core \
6422 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6423 linker, which generates a PT_INTERP section with p_vaddr and
6424 p_memsz set to 0. */
6425 #define IS_SOLARIS_PT_INTERP(p, s) \
6427 && p->p_paddr == 0 \
6428 && p->p_memsz == 0 \
6429 && p->p_filesz > 0 \
6430 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6432 && (bfd_vma) s->filepos >= p->p_offset \
6433 && ((bfd_vma) s->filepos + s->size \
6434 <= p->p_offset + p->p_filesz))
6436 /* Decide if the given section should be included in the given segment.
6437 A section will be included if:
6438 1. It is within the address space of the segment -- we use the LMA
6439 if that is set for the segment and the VMA otherwise,
6440 2. It is an allocated section or a NOTE section in a PT_NOTE
6442 3. There is an output section associated with it,
6443 4. The section has not already been allocated to a previous segment.
6444 5. PT_GNU_STACK segments do not include any sections.
6445 6. PT_TLS segment includes only SHF_TLS sections.
6446 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6447 8. PT_DYNAMIC should not contain empty sections at the beginning
6448 (with the possible exception of .dynamic). */
6449 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6450 ((((segment->p_paddr \
6451 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6452 : IS_CONTAINED_BY_VMA (section, segment)) \
6453 && (section->flags & SEC_ALLOC) != 0) \
6454 || IS_NOTE (segment, section)) \
6455 && segment->p_type != PT_GNU_STACK \
6456 && (segment->p_type != PT_TLS \
6457 || (section->flags & SEC_THREAD_LOCAL)) \
6458 && (segment->p_type == PT_LOAD \
6459 || segment->p_type == PT_TLS \
6460 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6461 && (segment->p_type != PT_DYNAMIC \
6462 || SECTION_SIZE (section, segment) > 0 \
6463 || (segment->p_paddr \
6464 ? segment->p_paddr != section->lma \
6465 : segment->p_vaddr != section->vma) \
6466 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6468 && !section->segment_mark)
6470 /* If the output section of a section in the input segment is NULL,
6471 it is removed from the corresponding output segment. */
6472 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6473 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6474 && section->output_section != NULL)
6476 /* Returns TRUE iff seg1 starts after the end of seg2. */
6477 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6478 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6480 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6481 their VMA address ranges and their LMA address ranges overlap.
6482 It is possible to have overlapping VMA ranges without overlapping LMA
6483 ranges. RedBoot images for example can have both .data and .bss mapped
6484 to the same VMA range, but with the .data section mapped to a different
6486 #define SEGMENT_OVERLAPS(seg1, seg2) \
6487 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6488 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6489 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6490 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6492 /* Initialise the segment mark field. */
6493 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6494 section
->segment_mark
= FALSE
;
6496 /* The Solaris linker creates program headers in which all the
6497 p_paddr fields are zero. When we try to objcopy or strip such a
6498 file, we get confused. Check for this case, and if we find it
6499 don't set the p_paddr_valid fields. */
6500 p_paddr_valid
= FALSE
;
6501 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6504 if (segment
->p_paddr
!= 0)
6506 p_paddr_valid
= TRUE
;
6510 /* Scan through the segments specified in the program header
6511 of the input BFD. For this first scan we look for overlaps
6512 in the loadable segments. These can be created by weird
6513 parameters to objcopy. Also, fix some solaris weirdness. */
6514 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6519 Elf_Internal_Phdr
*segment2
;
6521 if (segment
->p_type
== PT_INTERP
)
6522 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6523 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6525 /* Mininal change so that the normal section to segment
6526 assignment code will work. */
6527 segment
->p_vaddr
= section
->vma
;
6531 if (segment
->p_type
!= PT_LOAD
)
6533 /* Remove PT_GNU_RELRO segment. */
6534 if (segment
->p_type
== PT_GNU_RELRO
)
6535 segment
->p_type
= PT_NULL
;
6539 /* Determine if this segment overlaps any previous segments. */
6540 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6542 bfd_signed_vma extra_length
;
6544 if (segment2
->p_type
!= PT_LOAD
6545 || !SEGMENT_OVERLAPS (segment
, segment2
))
6548 /* Merge the two segments together. */
6549 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6551 /* Extend SEGMENT2 to include SEGMENT and then delete
6553 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6554 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6556 if (extra_length
> 0)
6558 segment2
->p_memsz
+= extra_length
;
6559 segment2
->p_filesz
+= extra_length
;
6562 segment
->p_type
= PT_NULL
;
6564 /* Since we have deleted P we must restart the outer loop. */
6566 segment
= elf_tdata (ibfd
)->phdr
;
6571 /* Extend SEGMENT to include SEGMENT2 and then delete
6573 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
6574 - SEGMENT_END (segment
, segment
->p_vaddr
));
6576 if (extra_length
> 0)
6578 segment
->p_memsz
+= extra_length
;
6579 segment
->p_filesz
+= extra_length
;
6582 segment2
->p_type
= PT_NULL
;
6587 /* The second scan attempts to assign sections to segments. */
6588 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6592 unsigned int section_count
;
6593 asection
**sections
;
6594 asection
*output_section
;
6596 bfd_vma matching_lma
;
6597 bfd_vma suggested_lma
;
6600 asection
*first_section
;
6601 bfd_boolean first_matching_lma
;
6602 bfd_boolean first_suggested_lma
;
6604 if (segment
->p_type
== PT_NULL
)
6607 first_section
= NULL
;
6608 /* Compute how many sections might be placed into this segment. */
6609 for (section
= ibfd
->sections
, section_count
= 0;
6611 section
= section
->next
)
6613 /* Find the first section in the input segment, which may be
6614 removed from the corresponding output segment. */
6615 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
6617 if (first_section
== NULL
)
6618 first_section
= section
;
6619 if (section
->output_section
!= NULL
)
6624 /* Allocate a segment map big enough to contain
6625 all of the sections we have selected. */
6626 amt
= sizeof (struct elf_segment_map
);
6627 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6628 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6632 /* Initialise the fields of the segment map. Default to
6633 using the physical address of the segment in the input BFD. */
6635 map
->p_type
= segment
->p_type
;
6636 map
->p_flags
= segment
->p_flags
;
6637 map
->p_flags_valid
= 1;
6639 /* If the first section in the input segment is removed, there is
6640 no need to preserve segment physical address in the corresponding
6642 if (!first_section
|| first_section
->output_section
!= NULL
)
6644 map
->p_paddr
= segment
->p_paddr
;
6645 map
->p_paddr_valid
= p_paddr_valid
;
6648 /* Determine if this segment contains the ELF file header
6649 and if it contains the program headers themselves. */
6650 map
->includes_filehdr
= (segment
->p_offset
== 0
6651 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6652 map
->includes_phdrs
= 0;
6654 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
6656 map
->includes_phdrs
=
6657 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6658 && (segment
->p_offset
+ segment
->p_filesz
6659 >= ((bfd_vma
) iehdr
->e_phoff
6660 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6662 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6663 phdr_included
= TRUE
;
6666 if (section_count
== 0)
6668 /* Special segments, such as the PT_PHDR segment, may contain
6669 no sections, but ordinary, loadable segments should contain
6670 something. They are allowed by the ELF spec however, so only
6671 a warning is produced. */
6672 if (segment
->p_type
== PT_LOAD
)
6673 _bfd_error_handler (_("\
6674 %B: warning: Empty loadable segment detected, is this intentional ?"),
6678 *pointer_to_map
= map
;
6679 pointer_to_map
= &map
->next
;
6684 /* Now scan the sections in the input BFD again and attempt
6685 to add their corresponding output sections to the segment map.
6686 The problem here is how to handle an output section which has
6687 been moved (ie had its LMA changed). There are four possibilities:
6689 1. None of the sections have been moved.
6690 In this case we can continue to use the segment LMA from the
6693 2. All of the sections have been moved by the same amount.
6694 In this case we can change the segment's LMA to match the LMA
6695 of the first section.
6697 3. Some of the sections have been moved, others have not.
6698 In this case those sections which have not been moved can be
6699 placed in the current segment which will have to have its size,
6700 and possibly its LMA changed, and a new segment or segments will
6701 have to be created to contain the other sections.
6703 4. The sections have been moved, but not by the same amount.
6704 In this case we can change the segment's LMA to match the LMA
6705 of the first section and we will have to create a new segment
6706 or segments to contain the other sections.
6708 In order to save time, we allocate an array to hold the section
6709 pointers that we are interested in. As these sections get assigned
6710 to a segment, they are removed from this array. */
6712 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
6713 if (sections
== NULL
)
6716 /* Step One: Scan for segment vs section LMA conflicts.
6717 Also add the sections to the section array allocated above.
6718 Also add the sections to the current segment. In the common
6719 case, where the sections have not been moved, this means that
6720 we have completely filled the segment, and there is nothing
6725 first_matching_lma
= TRUE
;
6726 first_suggested_lma
= TRUE
;
6728 for (section
= first_section
, j
= 0;
6730 section
= section
->next
)
6732 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
6734 output_section
= section
->output_section
;
6736 sections
[j
++] = section
;
6738 /* The Solaris native linker always sets p_paddr to 0.
6739 We try to catch that case here, and set it to the
6740 correct value. Note - some backends require that
6741 p_paddr be left as zero. */
6743 && segment
->p_vaddr
!= 0
6744 && !bed
->want_p_paddr_set_to_zero
6746 && output_section
->lma
!= 0
6747 && output_section
->vma
== (segment
->p_vaddr
6748 + (map
->includes_filehdr
6751 + (map
->includes_phdrs
6753 * iehdr
->e_phentsize
)
6755 map
->p_paddr
= segment
->p_vaddr
;
6757 /* Match up the physical address of the segment with the
6758 LMA address of the output section. */
6759 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6760 || IS_COREFILE_NOTE (segment
, section
)
6761 || (bed
->want_p_paddr_set_to_zero
6762 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
6764 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
6766 matching_lma
= output_section
->lma
;
6767 first_matching_lma
= FALSE
;
6770 /* We assume that if the section fits within the segment
6771 then it does not overlap any other section within that
6773 map
->sections
[isec
++] = output_section
;
6775 else if (first_suggested_lma
)
6777 suggested_lma
= output_section
->lma
;
6778 first_suggested_lma
= FALSE
;
6781 if (j
== section_count
)
6786 BFD_ASSERT (j
== section_count
);
6788 /* Step Two: Adjust the physical address of the current segment,
6790 if (isec
== section_count
)
6792 /* All of the sections fitted within the segment as currently
6793 specified. This is the default case. Add the segment to
6794 the list of built segments and carry on to process the next
6795 program header in the input BFD. */
6796 map
->count
= section_count
;
6797 *pointer_to_map
= map
;
6798 pointer_to_map
= &map
->next
;
6801 && !bed
->want_p_paddr_set_to_zero
6802 && matching_lma
!= map
->p_paddr
6803 && !map
->includes_filehdr
6804 && !map
->includes_phdrs
)
6805 /* There is some padding before the first section in the
6806 segment. So, we must account for that in the output
6808 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
6815 if (!first_matching_lma
)
6817 /* At least one section fits inside the current segment.
6818 Keep it, but modify its physical address to match the
6819 LMA of the first section that fitted. */
6820 map
->p_paddr
= matching_lma
;
6824 /* None of the sections fitted inside the current segment.
6825 Change the current segment's physical address to match
6826 the LMA of the first section. */
6827 map
->p_paddr
= suggested_lma
;
6830 /* Offset the segment physical address from the lma
6831 to allow for space taken up by elf headers. */
6832 if (map
->includes_filehdr
)
6834 if (map
->p_paddr
>= iehdr
->e_ehsize
)
6835 map
->p_paddr
-= iehdr
->e_ehsize
;
6838 map
->includes_filehdr
= FALSE
;
6839 map
->includes_phdrs
= FALSE
;
6843 if (map
->includes_phdrs
)
6845 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
6847 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
6849 /* iehdr->e_phnum is just an estimate of the number
6850 of program headers that we will need. Make a note
6851 here of the number we used and the segment we chose
6852 to hold these headers, so that we can adjust the
6853 offset when we know the correct value. */
6854 phdr_adjust_num
= iehdr
->e_phnum
;
6855 phdr_adjust_seg
= map
;
6858 map
->includes_phdrs
= FALSE
;
6862 /* Step Three: Loop over the sections again, this time assigning
6863 those that fit to the current segment and removing them from the
6864 sections array; but making sure not to leave large gaps. Once all
6865 possible sections have been assigned to the current segment it is
6866 added to the list of built segments and if sections still remain
6867 to be assigned, a new segment is constructed before repeating
6874 first_suggested_lma
= TRUE
;
6876 /* Fill the current segment with sections that fit. */
6877 for (j
= 0; j
< section_count
; j
++)
6879 section
= sections
[j
];
6881 if (section
== NULL
)
6884 output_section
= section
->output_section
;
6886 BFD_ASSERT (output_section
!= NULL
);
6888 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6889 || IS_COREFILE_NOTE (segment
, section
))
6891 if (map
->count
== 0)
6893 /* If the first section in a segment does not start at
6894 the beginning of the segment, then something is
6896 if (output_section
->lma
6898 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
6899 + (map
->includes_phdrs
6900 ? iehdr
->e_phnum
* iehdr
->e_phentsize
6908 prev_sec
= map
->sections
[map
->count
- 1];
6910 /* If the gap between the end of the previous section
6911 and the start of this section is more than
6912 maxpagesize then we need to start a new segment. */
6913 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
6915 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
6916 || (prev_sec
->lma
+ prev_sec
->size
6917 > output_section
->lma
))
6919 if (first_suggested_lma
)
6921 suggested_lma
= output_section
->lma
;
6922 first_suggested_lma
= FALSE
;
6929 map
->sections
[map
->count
++] = output_section
;
6932 section
->segment_mark
= TRUE
;
6934 else if (first_suggested_lma
)
6936 suggested_lma
= output_section
->lma
;
6937 first_suggested_lma
= FALSE
;
6941 BFD_ASSERT (map
->count
> 0);
6943 /* Add the current segment to the list of built segments. */
6944 *pointer_to_map
= map
;
6945 pointer_to_map
= &map
->next
;
6947 if (isec
< section_count
)
6949 /* We still have not allocated all of the sections to
6950 segments. Create a new segment here, initialise it
6951 and carry on looping. */
6952 amt
= sizeof (struct elf_segment_map
);
6953 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6954 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6961 /* Initialise the fields of the segment map. Set the physical
6962 physical address to the LMA of the first section that has
6963 not yet been assigned. */
6965 map
->p_type
= segment
->p_type
;
6966 map
->p_flags
= segment
->p_flags
;
6967 map
->p_flags_valid
= 1;
6968 map
->p_paddr
= suggested_lma
;
6969 map
->p_paddr_valid
= p_paddr_valid
;
6970 map
->includes_filehdr
= 0;
6971 map
->includes_phdrs
= 0;
6974 while (isec
< section_count
);
6979 elf_seg_map (obfd
) = map_first
;
6981 /* If we had to estimate the number of program headers that were
6982 going to be needed, then check our estimate now and adjust
6983 the offset if necessary. */
6984 if (phdr_adjust_seg
!= NULL
)
6988 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
6991 if (count
> phdr_adjust_num
)
6992 phdr_adjust_seg
->p_paddr
6993 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
6998 #undef IS_CONTAINED_BY_VMA
6999 #undef IS_CONTAINED_BY_LMA
7001 #undef IS_COREFILE_NOTE
7002 #undef IS_SOLARIS_PT_INTERP
7003 #undef IS_SECTION_IN_INPUT_SEGMENT
7004 #undef INCLUDE_SECTION_IN_SEGMENT
7005 #undef SEGMENT_AFTER_SEGMENT
7006 #undef SEGMENT_OVERLAPS
7010 /* Copy ELF program header information. */
7013 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7015 Elf_Internal_Ehdr
*iehdr
;
7016 struct elf_segment_map
*map
;
7017 struct elf_segment_map
*map_first
;
7018 struct elf_segment_map
**pointer_to_map
;
7019 Elf_Internal_Phdr
*segment
;
7021 unsigned int num_segments
;
7022 bfd_boolean phdr_included
= FALSE
;
7023 bfd_boolean p_paddr_valid
;
7025 iehdr
= elf_elfheader (ibfd
);
7028 pointer_to_map
= &map_first
;
7030 /* If all the segment p_paddr fields are zero, don't set
7031 map->p_paddr_valid. */
7032 p_paddr_valid
= FALSE
;
7033 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7034 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7037 if (segment
->p_paddr
!= 0)
7039 p_paddr_valid
= TRUE
;
7043 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7048 unsigned int section_count
;
7050 Elf_Internal_Shdr
*this_hdr
;
7051 asection
*first_section
= NULL
;
7052 asection
*lowest_section
;
7054 /* Compute how many sections are in this segment. */
7055 for (section
= ibfd
->sections
, section_count
= 0;
7057 section
= section
->next
)
7059 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7060 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7062 if (first_section
== NULL
)
7063 first_section
= section
;
7068 /* Allocate a segment map big enough to contain
7069 all of the sections we have selected. */
7070 amt
= sizeof (struct elf_segment_map
);
7071 if (section_count
!= 0)
7072 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
7073 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7077 /* Initialize the fields of the output segment map with the
7080 map
->p_type
= segment
->p_type
;
7081 map
->p_flags
= segment
->p_flags
;
7082 map
->p_flags_valid
= 1;
7083 map
->p_paddr
= segment
->p_paddr
;
7084 map
->p_paddr_valid
= p_paddr_valid
;
7085 map
->p_align
= segment
->p_align
;
7086 map
->p_align_valid
= 1;
7087 map
->p_vaddr_offset
= 0;
7089 if (map
->p_type
== PT_GNU_RELRO
7090 || map
->p_type
== PT_GNU_STACK
)
7092 /* The PT_GNU_RELRO segment may contain the first a few
7093 bytes in the .got.plt section even if the whole .got.plt
7094 section isn't in the PT_GNU_RELRO segment. We won't
7095 change the size of the PT_GNU_RELRO segment.
7096 Similarly, PT_GNU_STACK size is significant on uclinux
7098 map
->p_size
= segment
->p_memsz
;
7099 map
->p_size_valid
= 1;
7102 /* Determine if this segment contains the ELF file header
7103 and if it contains the program headers themselves. */
7104 map
->includes_filehdr
= (segment
->p_offset
== 0
7105 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7107 map
->includes_phdrs
= 0;
7108 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7110 map
->includes_phdrs
=
7111 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7112 && (segment
->p_offset
+ segment
->p_filesz
7113 >= ((bfd_vma
) iehdr
->e_phoff
7114 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7116 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7117 phdr_included
= TRUE
;
7120 lowest_section
= NULL
;
7121 if (section_count
!= 0)
7123 unsigned int isec
= 0;
7125 for (section
= first_section
;
7127 section
= section
->next
)
7129 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7130 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7132 map
->sections
[isec
++] = section
->output_section
;
7133 if ((section
->flags
& SEC_ALLOC
) != 0)
7137 if (lowest_section
== NULL
7138 || section
->lma
< lowest_section
->lma
)
7139 lowest_section
= section
;
7141 /* Section lmas are set up from PT_LOAD header
7142 p_paddr in _bfd_elf_make_section_from_shdr.
7143 If this header has a p_paddr that disagrees
7144 with the section lma, flag the p_paddr as
7146 if ((section
->flags
& SEC_LOAD
) != 0)
7147 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7149 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7150 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7151 map
->p_paddr_valid
= FALSE
;
7153 if (isec
== section_count
)
7159 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
7160 /* We need to keep the space used by the headers fixed. */
7161 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
7163 if (!map
->includes_phdrs
7164 && !map
->includes_filehdr
7165 && map
->p_paddr_valid
)
7166 /* There is some other padding before the first section. */
7167 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
7168 - segment
->p_paddr
);
7170 map
->count
= section_count
;
7171 *pointer_to_map
= map
;
7172 pointer_to_map
= &map
->next
;
7175 elf_seg_map (obfd
) = map_first
;
7179 /* Copy private BFD data. This copies or rewrites ELF program header
7183 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7185 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7186 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7189 if (elf_tdata (ibfd
)->phdr
== NULL
)
7192 if (ibfd
->xvec
== obfd
->xvec
)
7194 /* Check to see if any sections in the input BFD
7195 covered by ELF program header have changed. */
7196 Elf_Internal_Phdr
*segment
;
7197 asection
*section
, *osec
;
7198 unsigned int i
, num_segments
;
7199 Elf_Internal_Shdr
*this_hdr
;
7200 const struct elf_backend_data
*bed
;
7202 bed
= get_elf_backend_data (ibfd
);
7204 /* Regenerate the segment map if p_paddr is set to 0. */
7205 if (bed
->want_p_paddr_set_to_zero
)
7208 /* Initialize the segment mark field. */
7209 for (section
= obfd
->sections
; section
!= NULL
;
7210 section
= section
->next
)
7211 section
->segment_mark
= FALSE
;
7213 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7214 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7218 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7219 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7220 which severly confuses things, so always regenerate the segment
7221 map in this case. */
7222 if (segment
->p_paddr
== 0
7223 && segment
->p_memsz
== 0
7224 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7227 for (section
= ibfd
->sections
;
7228 section
!= NULL
; section
= section
->next
)
7230 /* We mark the output section so that we know it comes
7231 from the input BFD. */
7232 osec
= section
->output_section
;
7234 osec
->segment_mark
= TRUE
;
7236 /* Check if this section is covered by the segment. */
7237 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7238 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7240 /* FIXME: Check if its output section is changed or
7241 removed. What else do we need to check? */
7243 || section
->flags
!= osec
->flags
7244 || section
->lma
!= osec
->lma
7245 || section
->vma
!= osec
->vma
7246 || section
->size
!= osec
->size
7247 || section
->rawsize
!= osec
->rawsize
7248 || section
->alignment_power
!= osec
->alignment_power
)
7254 /* Check to see if any output section do not come from the
7256 for (section
= obfd
->sections
; section
!= NULL
;
7257 section
= section
->next
)
7259 if (section
->segment_mark
== FALSE
)
7262 section
->segment_mark
= FALSE
;
7265 return copy_elf_program_header (ibfd
, obfd
);
7269 if (ibfd
->xvec
== obfd
->xvec
)
7271 /* When rewriting program header, set the output maxpagesize to
7272 the maximum alignment of input PT_LOAD segments. */
7273 Elf_Internal_Phdr
*segment
;
7275 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7276 bfd_vma maxpagesize
= 0;
7278 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7281 if (segment
->p_type
== PT_LOAD
7282 && maxpagesize
< segment
->p_align
)
7284 /* PR 17512: file: f17299af. */
7285 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7286 /* xgettext:c-format */
7287 _bfd_error_handler (_("\
7288 %B: warning: segment alignment of 0x%llx is too large"),
7289 ibfd
, (long long) segment
->p_align
);
7291 maxpagesize
= segment
->p_align
;
7294 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7295 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7298 return rewrite_elf_program_header (ibfd
, obfd
);
7301 /* Initialize private output section information from input section. */
7304 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7308 struct bfd_link_info
*link_info
)
7311 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7312 bfd_boolean final_link
= (link_info
!= NULL
7313 && !bfd_link_relocatable (link_info
));
7315 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7316 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7319 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7321 /* For objcopy and relocatable link, don't copy the output ELF
7322 section type from input if the output BFD section flags have been
7323 set to something different. For a final link allow some flags
7324 that the linker clears to differ. */
7325 if (elf_section_type (osec
) == SHT_NULL
7326 && (osec
->flags
== isec
->flags
7328 && ((osec
->flags
^ isec
->flags
)
7329 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7330 elf_section_type (osec
) = elf_section_type (isec
);
7332 /* FIXME: Is this correct for all OS/PROC specific flags? */
7333 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7334 & (SHF_MASKOS
| SHF_MASKPROC
));
7336 /* Set things up for objcopy and relocatable link. The output
7337 SHT_GROUP section will have its elf_next_in_group pointing back
7338 to the input group members. Ignore linker created group section.
7339 See elfNN_ia64_object_p in elfxx-ia64.c. */
7342 if (elf_sec_group (isec
) == NULL
7343 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
7345 if (elf_section_flags (isec
) & SHF_GROUP
)
7346 elf_section_flags (osec
) |= SHF_GROUP
;
7347 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7348 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7351 /* If not decompress, preserve SHF_COMPRESSED. */
7352 if ((ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7353 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7357 ihdr
= &elf_section_data (isec
)->this_hdr
;
7359 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7360 don't use the output section of the linked-to section since it
7361 may be NULL at this point. */
7362 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7364 ohdr
= &elf_section_data (osec
)->this_hdr
;
7365 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7366 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7369 osec
->use_rela_p
= isec
->use_rela_p
;
7374 /* Copy private section information. This copies over the entsize
7375 field, and sometimes the info field. */
7378 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7383 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7385 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7386 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7389 ihdr
= &elf_section_data (isec
)->this_hdr
;
7390 ohdr
= &elf_section_data (osec
)->this_hdr
;
7392 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7394 if (ihdr
->sh_type
== SHT_SYMTAB
7395 || ihdr
->sh_type
== SHT_DYNSYM
7396 || ihdr
->sh_type
== SHT_GNU_verneed
7397 || ihdr
->sh_type
== SHT_GNU_verdef
)
7398 ohdr
->sh_info
= ihdr
->sh_info
;
7400 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7404 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7405 necessary if we are removing either the SHT_GROUP section or any of
7406 the group member sections. DISCARDED is the value that a section's
7407 output_section has if the section will be discarded, NULL when this
7408 function is called from objcopy, bfd_abs_section_ptr when called
7412 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7416 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7417 if (elf_section_type (isec
) == SHT_GROUP
)
7419 asection
*first
= elf_next_in_group (isec
);
7420 asection
*s
= first
;
7421 bfd_size_type removed
= 0;
7425 /* If this member section is being output but the
7426 SHT_GROUP section is not, then clear the group info
7427 set up by _bfd_elf_copy_private_section_data. */
7428 if (s
->output_section
!= discarded
7429 && isec
->output_section
== discarded
)
7431 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7432 elf_group_name (s
->output_section
) = NULL
;
7434 /* Conversely, if the member section is not being output
7435 but the SHT_GROUP section is, then adjust its size. */
7436 else if (s
->output_section
== discarded
7437 && isec
->output_section
!= discarded
)
7439 s
= elf_next_in_group (s
);
7445 if (discarded
!= NULL
)
7447 /* If we've been called for ld -r, then we need to
7448 adjust the input section size. This function may
7449 be called multiple times, so save the original
7451 if (isec
->rawsize
== 0)
7452 isec
->rawsize
= isec
->size
;
7453 isec
->size
= isec
->rawsize
- removed
;
7457 /* Adjust the output section size when called from
7459 isec
->output_section
->size
-= removed
;
7467 /* Copy private header information. */
7470 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7472 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7473 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7476 /* Copy over private BFD data if it has not already been copied.
7477 This must be done here, rather than in the copy_private_bfd_data
7478 entry point, because the latter is called after the section
7479 contents have been set, which means that the program headers have
7480 already been worked out. */
7481 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7483 if (! copy_private_bfd_data (ibfd
, obfd
))
7487 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7490 /* Copy private symbol information. If this symbol is in a section
7491 which we did not map into a BFD section, try to map the section
7492 index correctly. We use special macro definitions for the mapped
7493 section indices; these definitions are interpreted by the
7494 swap_out_syms function. */
7496 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7497 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7498 #define MAP_STRTAB (SHN_HIOS + 3)
7499 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7500 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7503 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7508 elf_symbol_type
*isym
, *osym
;
7510 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7511 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7514 isym
= elf_symbol_from (ibfd
, isymarg
);
7515 osym
= elf_symbol_from (obfd
, osymarg
);
7518 && isym
->internal_elf_sym
.st_shndx
!= 0
7520 && bfd_is_abs_section (isym
->symbol
.section
))
7524 shndx
= isym
->internal_elf_sym
.st_shndx
;
7525 if (shndx
== elf_onesymtab (ibfd
))
7526 shndx
= MAP_ONESYMTAB
;
7527 else if (shndx
== elf_dynsymtab (ibfd
))
7528 shndx
= MAP_DYNSYMTAB
;
7529 else if (shndx
== elf_strtab_sec (ibfd
))
7531 else if (shndx
== elf_shstrtab_sec (ibfd
))
7532 shndx
= MAP_SHSTRTAB
;
7533 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7534 shndx
= MAP_SYM_SHNDX
;
7535 osym
->internal_elf_sym
.st_shndx
= shndx
;
7541 /* Swap out the symbols. */
7544 swap_out_syms (bfd
*abfd
,
7545 struct elf_strtab_hash
**sttp
,
7548 const struct elf_backend_data
*bed
;
7551 struct elf_strtab_hash
*stt
;
7552 Elf_Internal_Shdr
*symtab_hdr
;
7553 Elf_Internal_Shdr
*symtab_shndx_hdr
;
7554 Elf_Internal_Shdr
*symstrtab_hdr
;
7555 struct elf_sym_strtab
*symstrtab
;
7556 bfd_byte
*outbound_syms
;
7557 bfd_byte
*outbound_shndx
;
7558 unsigned long outbound_syms_index
;
7559 unsigned long outbound_shndx_index
;
7561 unsigned int num_locals
;
7563 bfd_boolean name_local_sections
;
7565 if (!elf_map_symbols (abfd
, &num_locals
))
7568 /* Dump out the symtabs. */
7569 stt
= _bfd_elf_strtab_init ();
7573 bed
= get_elf_backend_data (abfd
);
7574 symcount
= bfd_get_symcount (abfd
);
7575 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7576 symtab_hdr
->sh_type
= SHT_SYMTAB
;
7577 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
7578 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
7579 symtab_hdr
->sh_info
= num_locals
+ 1;
7580 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
7582 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
7583 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7585 /* Allocate buffer to swap out the .strtab section. */
7586 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc ((symcount
+ 1)
7587 * sizeof (*symstrtab
));
7588 if (symstrtab
== NULL
)
7590 _bfd_elf_strtab_free (stt
);
7594 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
7595 bed
->s
->sizeof_sym
);
7596 if (outbound_syms
== NULL
)
7599 _bfd_elf_strtab_free (stt
);
7603 symtab_hdr
->contents
= outbound_syms
;
7604 outbound_syms_index
= 0;
7606 outbound_shndx
= NULL
;
7607 outbound_shndx_index
= 0;
7609 if (elf_symtab_shndx_list (abfd
))
7611 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
7612 if (symtab_shndx_hdr
->sh_name
!= 0)
7614 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
7615 outbound_shndx
= (bfd_byte
*)
7616 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
7617 if (outbound_shndx
== NULL
)
7620 symtab_shndx_hdr
->contents
= outbound_shndx
;
7621 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
7622 symtab_shndx_hdr
->sh_size
= amt
;
7623 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
7624 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
7626 /* FIXME: What about any other headers in the list ? */
7629 /* Now generate the data (for "contents"). */
7631 /* Fill in zeroth symbol and swap it out. */
7632 Elf_Internal_Sym sym
;
7638 sym
.st_shndx
= SHN_UNDEF
;
7639 sym
.st_target_internal
= 0;
7640 symstrtab
[0].sym
= sym
;
7641 symstrtab
[0].dest_index
= outbound_syms_index
;
7642 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
7643 outbound_syms_index
++;
7644 if (outbound_shndx
!= NULL
)
7645 outbound_shndx_index
++;
7649 = (bed
->elf_backend_name_local_section_symbols
7650 && bed
->elf_backend_name_local_section_symbols (abfd
));
7652 syms
= bfd_get_outsymbols (abfd
);
7653 for (idx
= 0; idx
< symcount
;)
7655 Elf_Internal_Sym sym
;
7656 bfd_vma value
= syms
[idx
]->value
;
7657 elf_symbol_type
*type_ptr
;
7658 flagword flags
= syms
[idx
]->flags
;
7661 if (!name_local_sections
7662 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
7664 /* Local section symbols have no name. */
7665 sym
.st_name
= (unsigned long) -1;
7669 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7670 to get the final offset for st_name. */
7672 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
7674 if (sym
.st_name
== (unsigned long) -1)
7678 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
7680 if ((flags
& BSF_SECTION_SYM
) == 0
7681 && bfd_is_com_section (syms
[idx
]->section
))
7683 /* ELF common symbols put the alignment into the `value' field,
7684 and the size into the `size' field. This is backwards from
7685 how BFD handles it, so reverse it here. */
7686 sym
.st_size
= value
;
7687 if (type_ptr
== NULL
7688 || type_ptr
->internal_elf_sym
.st_value
== 0)
7689 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
7691 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
7692 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
7693 (abfd
, syms
[idx
]->section
);
7697 asection
*sec
= syms
[idx
]->section
;
7700 if (sec
->output_section
)
7702 value
+= sec
->output_offset
;
7703 sec
= sec
->output_section
;
7706 /* Don't add in the section vma for relocatable output. */
7707 if (! relocatable_p
)
7709 sym
.st_value
= value
;
7710 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
7712 if (bfd_is_abs_section (sec
)
7714 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
7716 /* This symbol is in a real ELF section which we did
7717 not create as a BFD section. Undo the mapping done
7718 by copy_private_symbol_data. */
7719 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
7723 shndx
= elf_onesymtab (abfd
);
7726 shndx
= elf_dynsymtab (abfd
);
7729 shndx
= elf_strtab_sec (abfd
);
7732 shndx
= elf_shstrtab_sec (abfd
);
7735 if (elf_symtab_shndx_list (abfd
))
7736 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
7745 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
7747 if (shndx
== SHN_BAD
)
7751 /* Writing this would be a hell of a lot easier if
7752 we had some decent documentation on bfd, and
7753 knew what to expect of the library, and what to
7754 demand of applications. For example, it
7755 appears that `objcopy' might not set the
7756 section of a symbol to be a section that is
7757 actually in the output file. */
7758 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
7760 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
7761 if (shndx
== SHN_BAD
)
7763 /* xgettext:c-format */
7764 _bfd_error_handler (_("\
7765 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7766 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
7768 bfd_set_error (bfd_error_invalid_operation
);
7774 sym
.st_shndx
= shndx
;
7777 if ((flags
& BSF_THREAD_LOCAL
) != 0)
7779 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
7780 type
= STT_GNU_IFUNC
;
7781 else if ((flags
& BSF_FUNCTION
) != 0)
7783 else if ((flags
& BSF_OBJECT
) != 0)
7785 else if ((flags
& BSF_RELC
) != 0)
7787 else if ((flags
& BSF_SRELC
) != 0)
7792 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
7795 /* Processor-specific types. */
7796 if (type_ptr
!= NULL
7797 && bed
->elf_backend_get_symbol_type
)
7798 type
= ((*bed
->elf_backend_get_symbol_type
)
7799 (&type_ptr
->internal_elf_sym
, type
));
7801 if (flags
& BSF_SECTION_SYM
)
7803 if (flags
& BSF_GLOBAL
)
7804 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7806 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
7808 else if (bfd_is_com_section (syms
[idx
]->section
))
7810 if (type
!= STT_TLS
)
7812 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
7813 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
7814 ? STT_COMMON
: STT_OBJECT
);
7816 type
= ((flags
& BSF_ELF_COMMON
) != 0
7817 ? STT_COMMON
: STT_OBJECT
);
7819 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
7821 else if (bfd_is_und_section (syms
[idx
]->section
))
7822 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
7826 else if (flags
& BSF_FILE
)
7827 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
7830 int bind
= STB_LOCAL
;
7832 if (flags
& BSF_LOCAL
)
7834 else if (flags
& BSF_GNU_UNIQUE
)
7835 bind
= STB_GNU_UNIQUE
;
7836 else if (flags
& BSF_WEAK
)
7838 else if (flags
& BSF_GLOBAL
)
7841 sym
.st_info
= ELF_ST_INFO (bind
, type
);
7844 if (type_ptr
!= NULL
)
7846 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
7847 sym
.st_target_internal
7848 = type_ptr
->internal_elf_sym
.st_target_internal
;
7853 sym
.st_target_internal
= 0;
7857 symstrtab
[idx
].sym
= sym
;
7858 symstrtab
[idx
].dest_index
= outbound_syms_index
;
7859 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
7861 outbound_syms_index
++;
7862 if (outbound_shndx
!= NULL
)
7863 outbound_shndx_index
++;
7866 /* Finalize the .strtab section. */
7867 _bfd_elf_strtab_finalize (stt
);
7869 /* Swap out the .strtab section. */
7870 for (idx
= 0; idx
<= symcount
; idx
++)
7872 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
7873 if (elfsym
->sym
.st_name
== (unsigned long) -1)
7874 elfsym
->sym
.st_name
= 0;
7876 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
7877 elfsym
->sym
.st_name
);
7878 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
7880 + (elfsym
->dest_index
7881 * bed
->s
->sizeof_sym
)),
7883 + (elfsym
->destshndx_index
7884 * sizeof (Elf_External_Sym_Shndx
))));
7889 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
7890 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7891 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
7892 symstrtab_hdr
->sh_addr
= 0;
7893 symstrtab_hdr
->sh_entsize
= 0;
7894 symstrtab_hdr
->sh_link
= 0;
7895 symstrtab_hdr
->sh_info
= 0;
7896 symstrtab_hdr
->sh_addralign
= 1;
7901 /* Return the number of bytes required to hold the symtab vector.
7903 Note that we base it on the count plus 1, since we will null terminate
7904 the vector allocated based on this size. However, the ELF symbol table
7905 always has a dummy entry as symbol #0, so it ends up even. */
7908 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
7912 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7914 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7915 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7917 symtab_size
-= sizeof (asymbol
*);
7923 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
7927 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
7929 if (elf_dynsymtab (abfd
) == 0)
7931 bfd_set_error (bfd_error_invalid_operation
);
7935 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7936 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7938 symtab_size
-= sizeof (asymbol
*);
7944 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
7947 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
7950 /* Canonicalize the relocs. */
7953 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
7960 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7962 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
7965 tblptr
= section
->relocation
;
7966 for (i
= 0; i
< section
->reloc_count
; i
++)
7967 *relptr
++ = tblptr
++;
7971 return section
->reloc_count
;
7975 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
7977 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7978 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
7981 bfd_get_symcount (abfd
) = symcount
;
7986 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
7987 asymbol
**allocation
)
7989 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7990 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
7993 bfd_get_dynamic_symcount (abfd
) = symcount
;
7997 /* Return the size required for the dynamic reloc entries. Any loadable
7998 section that was actually installed in the BFD, and has type SHT_REL
7999 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8000 dynamic reloc section. */
8003 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8008 if (elf_dynsymtab (abfd
) == 0)
8010 bfd_set_error (bfd_error_invalid_operation
);
8014 ret
= sizeof (arelent
*);
8015 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8016 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8017 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8018 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8019 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
8020 * sizeof (arelent
*));
8025 /* Canonicalize the dynamic relocation entries. Note that we return the
8026 dynamic relocations as a single block, although they are actually
8027 associated with particular sections; the interface, which was
8028 designed for SunOS style shared libraries, expects that there is only
8029 one set of dynamic relocs. Any loadable section that was actually
8030 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8031 dynamic symbol table, is considered to be a dynamic reloc section. */
8034 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8038 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8042 if (elf_dynsymtab (abfd
) == 0)
8044 bfd_set_error (bfd_error_invalid_operation
);
8048 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8050 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8052 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8053 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8054 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8059 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8061 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8063 for (i
= 0; i
< count
; i
++)
8074 /* Read in the version information. */
8077 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8079 bfd_byte
*contents
= NULL
;
8080 unsigned int freeidx
= 0;
8082 if (elf_dynverref (abfd
) != 0)
8084 Elf_Internal_Shdr
*hdr
;
8085 Elf_External_Verneed
*everneed
;
8086 Elf_Internal_Verneed
*iverneed
;
8088 bfd_byte
*contents_end
;
8090 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8092 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verneed
))
8094 error_return_bad_verref
:
8096 (_("%B: .gnu.version_r invalid entry"), abfd
);
8097 bfd_set_error (bfd_error_bad_value
);
8098 error_return_verref
:
8099 elf_tdata (abfd
)->verref
= NULL
;
8100 elf_tdata (abfd
)->cverrefs
= 0;
8104 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8105 if (contents
== NULL
)
8106 goto error_return_verref
;
8108 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8109 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8110 goto error_return_verref
;
8112 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8113 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8115 if (elf_tdata (abfd
)->verref
== NULL
)
8116 goto error_return_verref
;
8118 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8119 == sizeof (Elf_External_Vernaux
));
8120 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8121 everneed
= (Elf_External_Verneed
*) contents
;
8122 iverneed
= elf_tdata (abfd
)->verref
;
8123 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8125 Elf_External_Vernaux
*evernaux
;
8126 Elf_Internal_Vernaux
*ivernaux
;
8129 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8131 iverneed
->vn_bfd
= abfd
;
8133 iverneed
->vn_filename
=
8134 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8136 if (iverneed
->vn_filename
== NULL
)
8137 goto error_return_bad_verref
;
8139 if (iverneed
->vn_cnt
== 0)
8140 iverneed
->vn_auxptr
= NULL
;
8143 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8144 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8145 sizeof (Elf_Internal_Vernaux
));
8146 if (iverneed
->vn_auxptr
== NULL
)
8147 goto error_return_verref
;
8150 if (iverneed
->vn_aux
8151 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8152 goto error_return_bad_verref
;
8154 evernaux
= ((Elf_External_Vernaux
*)
8155 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8156 ivernaux
= iverneed
->vn_auxptr
;
8157 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8159 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8161 ivernaux
->vna_nodename
=
8162 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8163 ivernaux
->vna_name
);
8164 if (ivernaux
->vna_nodename
== NULL
)
8165 goto error_return_bad_verref
;
8167 if (ivernaux
->vna_other
> freeidx
)
8168 freeidx
= ivernaux
->vna_other
;
8170 ivernaux
->vna_nextptr
= NULL
;
8171 if (ivernaux
->vna_next
== 0)
8173 iverneed
->vn_cnt
= j
+ 1;
8176 if (j
+ 1 < iverneed
->vn_cnt
)
8177 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8179 if (ivernaux
->vna_next
8180 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8181 goto error_return_bad_verref
;
8183 evernaux
= ((Elf_External_Vernaux
*)
8184 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8187 iverneed
->vn_nextref
= NULL
;
8188 if (iverneed
->vn_next
== 0)
8190 if (i
+ 1 < hdr
->sh_info
)
8191 iverneed
->vn_nextref
= iverneed
+ 1;
8193 if (iverneed
->vn_next
8194 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8195 goto error_return_bad_verref
;
8197 everneed
= ((Elf_External_Verneed
*)
8198 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8200 elf_tdata (abfd
)->cverrefs
= i
;
8206 if (elf_dynverdef (abfd
) != 0)
8208 Elf_Internal_Shdr
*hdr
;
8209 Elf_External_Verdef
*everdef
;
8210 Elf_Internal_Verdef
*iverdef
;
8211 Elf_Internal_Verdef
*iverdefarr
;
8212 Elf_Internal_Verdef iverdefmem
;
8214 unsigned int maxidx
;
8215 bfd_byte
*contents_end_def
, *contents_end_aux
;
8217 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8219 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8221 error_return_bad_verdef
:
8223 (_("%B: .gnu.version_d invalid entry"), abfd
);
8224 bfd_set_error (bfd_error_bad_value
);
8225 error_return_verdef
:
8226 elf_tdata (abfd
)->verdef
= NULL
;
8227 elf_tdata (abfd
)->cverdefs
= 0;
8231 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8232 if (contents
== NULL
)
8233 goto error_return_verdef
;
8234 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8235 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8236 goto error_return_verdef
;
8238 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8239 >= sizeof (Elf_External_Verdaux
));
8240 contents_end_def
= contents
+ hdr
->sh_size
8241 - sizeof (Elf_External_Verdef
);
8242 contents_end_aux
= contents
+ hdr
->sh_size
8243 - sizeof (Elf_External_Verdaux
);
8245 /* We know the number of entries in the section but not the maximum
8246 index. Therefore we have to run through all entries and find
8248 everdef
= (Elf_External_Verdef
*) contents
;
8250 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8252 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8254 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8255 goto error_return_bad_verdef
;
8256 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8257 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8259 if (iverdefmem
.vd_next
== 0)
8262 if (iverdefmem
.vd_next
8263 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8264 goto error_return_bad_verdef
;
8266 everdef
= ((Elf_External_Verdef
*)
8267 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8270 if (default_imported_symver
)
8272 if (freeidx
> maxidx
)
8278 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8279 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8280 if (elf_tdata (abfd
)->verdef
== NULL
)
8281 goto error_return_verdef
;
8283 elf_tdata (abfd
)->cverdefs
= maxidx
;
8285 everdef
= (Elf_External_Verdef
*) contents
;
8286 iverdefarr
= elf_tdata (abfd
)->verdef
;
8287 for (i
= 0; i
< hdr
->sh_info
; i
++)
8289 Elf_External_Verdaux
*everdaux
;
8290 Elf_Internal_Verdaux
*iverdaux
;
8293 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8295 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8296 goto error_return_bad_verdef
;
8298 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8299 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8301 iverdef
->vd_bfd
= abfd
;
8303 if (iverdef
->vd_cnt
== 0)
8304 iverdef
->vd_auxptr
= NULL
;
8307 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8308 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8309 sizeof (Elf_Internal_Verdaux
));
8310 if (iverdef
->vd_auxptr
== NULL
)
8311 goto error_return_verdef
;
8315 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8316 goto error_return_bad_verdef
;
8318 everdaux
= ((Elf_External_Verdaux
*)
8319 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8320 iverdaux
= iverdef
->vd_auxptr
;
8321 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8323 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8325 iverdaux
->vda_nodename
=
8326 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8327 iverdaux
->vda_name
);
8328 if (iverdaux
->vda_nodename
== NULL
)
8329 goto error_return_bad_verdef
;
8331 iverdaux
->vda_nextptr
= NULL
;
8332 if (iverdaux
->vda_next
== 0)
8334 iverdef
->vd_cnt
= j
+ 1;
8337 if (j
+ 1 < iverdef
->vd_cnt
)
8338 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8340 if (iverdaux
->vda_next
8341 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8342 goto error_return_bad_verdef
;
8344 everdaux
= ((Elf_External_Verdaux
*)
8345 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8348 iverdef
->vd_nodename
= NULL
;
8349 if (iverdef
->vd_cnt
)
8350 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8352 iverdef
->vd_nextdef
= NULL
;
8353 if (iverdef
->vd_next
== 0)
8355 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8356 iverdef
->vd_nextdef
= iverdef
+ 1;
8358 everdef
= ((Elf_External_Verdef
*)
8359 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8365 else if (default_imported_symver
)
8372 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8373 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8374 if (elf_tdata (abfd
)->verdef
== NULL
)
8377 elf_tdata (abfd
)->cverdefs
= freeidx
;
8380 /* Create a default version based on the soname. */
8381 if (default_imported_symver
)
8383 Elf_Internal_Verdef
*iverdef
;
8384 Elf_Internal_Verdaux
*iverdaux
;
8386 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8388 iverdef
->vd_version
= VER_DEF_CURRENT
;
8389 iverdef
->vd_flags
= 0;
8390 iverdef
->vd_ndx
= freeidx
;
8391 iverdef
->vd_cnt
= 1;
8393 iverdef
->vd_bfd
= abfd
;
8395 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8396 if (iverdef
->vd_nodename
== NULL
)
8397 goto error_return_verdef
;
8398 iverdef
->vd_nextdef
= NULL
;
8399 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8400 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8401 if (iverdef
->vd_auxptr
== NULL
)
8402 goto error_return_verdef
;
8404 iverdaux
= iverdef
->vd_auxptr
;
8405 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8411 if (contents
!= NULL
)
8417 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8419 elf_symbol_type
*newsym
;
8421 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
8424 newsym
->symbol
.the_bfd
= abfd
;
8425 return &newsym
->symbol
;
8429 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8433 bfd_symbol_info (symbol
, ret
);
8436 /* Return whether a symbol name implies a local symbol. Most targets
8437 use this function for the is_local_label_name entry point, but some
8441 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8444 /* Normal local symbols start with ``.L''. */
8445 if (name
[0] == '.' && name
[1] == 'L')
8448 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8449 DWARF debugging symbols starting with ``..''. */
8450 if (name
[0] == '.' && name
[1] == '.')
8453 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8454 emitting DWARF debugging output. I suspect this is actually a
8455 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8456 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8457 underscore to be emitted on some ELF targets). For ease of use,
8458 we treat such symbols as local. */
8459 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8462 /* Treat assembler generated fake symbols, dollar local labels and
8463 forward-backward labels (aka local labels) as locals.
8464 These labels have the form:
8466 L0^A.* (fake symbols)
8468 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8470 Versions which start with .L will have already been matched above,
8471 so we only need to match the rest. */
8472 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8474 bfd_boolean ret
= FALSE
;
8478 for (p
= name
+ 2; (c
= *p
); p
++)
8480 if (c
== 1 || c
== 2)
8482 if (c
== 1 && p
== name
+ 2)
8483 /* A fake symbol. */
8486 /* FIXME: We are being paranoid here and treating symbols like
8487 L0^Bfoo as if there were non-local, on the grounds that the
8488 assembler will never generate them. But can any symbol
8489 containing an ASCII value in the range 1-31 ever be anything
8490 other than some kind of local ? */
8507 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
8508 asymbol
*symbol ATTRIBUTE_UNUSED
)
8515 _bfd_elf_set_arch_mach (bfd
*abfd
,
8516 enum bfd_architecture arch
,
8517 unsigned long machine
)
8519 /* If this isn't the right architecture for this backend, and this
8520 isn't the generic backend, fail. */
8521 if (arch
!= get_elf_backend_data (abfd
)->arch
8522 && arch
!= bfd_arch_unknown
8523 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
8526 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
8529 /* Find the nearest line to a particular section and offset,
8530 for error reporting. */
8533 _bfd_elf_find_nearest_line (bfd
*abfd
,
8537 const char **filename_ptr
,
8538 const char **functionname_ptr
,
8539 unsigned int *line_ptr
,
8540 unsigned int *discriminator_ptr
)
8544 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
8545 filename_ptr
, functionname_ptr
,
8546 line_ptr
, discriminator_ptr
,
8547 dwarf_debug_sections
, 0,
8548 &elf_tdata (abfd
)->dwarf2_find_line_info
)
8549 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
8550 filename_ptr
, functionname_ptr
,
8553 if (!*functionname_ptr
)
8554 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8555 *filename_ptr
? NULL
: filename_ptr
,
8560 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
8561 &found
, filename_ptr
,
8562 functionname_ptr
, line_ptr
,
8563 &elf_tdata (abfd
)->line_info
))
8565 if (found
&& (*functionname_ptr
|| *line_ptr
))
8568 if (symbols
== NULL
)
8571 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8572 filename_ptr
, functionname_ptr
))
8579 /* Find the line for a symbol. */
8582 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
8583 const char **filename_ptr
, unsigned int *line_ptr
)
8585 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
8586 filename_ptr
, NULL
, line_ptr
, NULL
,
8587 dwarf_debug_sections
, 0,
8588 &elf_tdata (abfd
)->dwarf2_find_line_info
);
8591 /* After a call to bfd_find_nearest_line, successive calls to
8592 bfd_find_inliner_info can be used to get source information about
8593 each level of function inlining that terminated at the address
8594 passed to bfd_find_nearest_line. Currently this is only supported
8595 for DWARF2 with appropriate DWARF3 extensions. */
8598 _bfd_elf_find_inliner_info (bfd
*abfd
,
8599 const char **filename_ptr
,
8600 const char **functionname_ptr
,
8601 unsigned int *line_ptr
)
8604 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
8605 functionname_ptr
, line_ptr
,
8606 & elf_tdata (abfd
)->dwarf2_find_line_info
);
8611 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
8613 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8614 int ret
= bed
->s
->sizeof_ehdr
;
8616 if (!bfd_link_relocatable (info
))
8618 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
8620 if (phdr_size
== (bfd_size_type
) -1)
8622 struct elf_segment_map
*m
;
8625 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
8626 phdr_size
+= bed
->s
->sizeof_phdr
;
8629 phdr_size
= get_program_header_size (abfd
, info
);
8632 elf_program_header_size (abfd
) = phdr_size
;
8640 _bfd_elf_set_section_contents (bfd
*abfd
,
8642 const void *location
,
8644 bfd_size_type count
)
8646 Elf_Internal_Shdr
*hdr
;
8649 if (! abfd
->output_has_begun
8650 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
8656 hdr
= &elf_section_data (section
)->this_hdr
;
8657 if (hdr
->sh_offset
== (file_ptr
) -1)
8659 /* We must compress this section. Write output to the buffer. */
8660 unsigned char *contents
= hdr
->contents
;
8661 if ((offset
+ count
) > hdr
->sh_size
8662 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
8663 || contents
== NULL
)
8665 memcpy (contents
+ offset
, location
, count
);
8668 pos
= hdr
->sh_offset
+ offset
;
8669 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
8670 || bfd_bwrite (location
, count
, abfd
) != count
)
8677 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
8678 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
8679 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
8684 /* Try to convert a non-ELF reloc into an ELF one. */
8687 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
8689 /* Check whether we really have an ELF howto. */
8691 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
8693 bfd_reloc_code_real_type code
;
8694 reloc_howto_type
*howto
;
8696 /* Alien reloc: Try to determine its type to replace it with an
8697 equivalent ELF reloc. */
8699 if (areloc
->howto
->pc_relative
)
8701 switch (areloc
->howto
->bitsize
)
8704 code
= BFD_RELOC_8_PCREL
;
8707 code
= BFD_RELOC_12_PCREL
;
8710 code
= BFD_RELOC_16_PCREL
;
8713 code
= BFD_RELOC_24_PCREL
;
8716 code
= BFD_RELOC_32_PCREL
;
8719 code
= BFD_RELOC_64_PCREL
;
8725 howto
= bfd_reloc_type_lookup (abfd
, code
);
8727 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
8729 if (howto
->pcrel_offset
)
8730 areloc
->addend
+= areloc
->address
;
8732 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
8737 switch (areloc
->howto
->bitsize
)
8743 code
= BFD_RELOC_14
;
8746 code
= BFD_RELOC_16
;
8749 code
= BFD_RELOC_26
;
8752 code
= BFD_RELOC_32
;
8755 code
= BFD_RELOC_64
;
8761 howto
= bfd_reloc_type_lookup (abfd
, code
);
8765 areloc
->howto
= howto
;
8774 /* xgettext:c-format */
8775 (_("%B: unsupported relocation type %s"),
8776 abfd
, areloc
->howto
->name
);
8777 bfd_set_error (bfd_error_bad_value
);
8782 _bfd_elf_close_and_cleanup (bfd
*abfd
)
8784 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
8785 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
8787 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
8788 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
8789 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
8792 return _bfd_generic_close_and_cleanup (abfd
);
8795 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8796 in the relocation's offset. Thus we cannot allow any sort of sanity
8797 range-checking to interfere. There is nothing else to do in processing
8800 bfd_reloc_status_type
8801 _bfd_elf_rel_vtable_reloc_fn
8802 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
8803 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
8804 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
8805 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
8807 return bfd_reloc_ok
;
8810 /* Elf core file support. Much of this only works on native
8811 toolchains, since we rely on knowing the
8812 machine-dependent procfs structure in order to pick
8813 out details about the corefile. */
8815 #ifdef HAVE_SYS_PROCFS_H
8816 /* Needed for new procfs interface on sparc-solaris. */
8817 # define _STRUCTURED_PROC 1
8818 # include <sys/procfs.h>
8821 /* Return a PID that identifies a "thread" for threaded cores, or the
8822 PID of the main process for non-threaded cores. */
8825 elfcore_make_pid (bfd
*abfd
)
8829 pid
= elf_tdata (abfd
)->core
->lwpid
;
8831 pid
= elf_tdata (abfd
)->core
->pid
;
8836 /* If there isn't a section called NAME, make one, using
8837 data from SECT. Note, this function will generate a
8838 reference to NAME, so you shouldn't deallocate or
8842 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
8846 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
8849 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
8853 sect2
->size
= sect
->size
;
8854 sect2
->filepos
= sect
->filepos
;
8855 sect2
->alignment_power
= sect
->alignment_power
;
8859 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
8860 actually creates up to two pseudosections:
8861 - For the single-threaded case, a section named NAME, unless
8862 such a section already exists.
8863 - For the multi-threaded case, a section named "NAME/PID", where
8864 PID is elfcore_make_pid (abfd).
8865 Both pseudosections have identical contents. */
8867 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
8873 char *threaded_name
;
8877 /* Build the section name. */
8879 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
8880 len
= strlen (buf
) + 1;
8881 threaded_name
= (char *) bfd_alloc (abfd
, len
);
8882 if (threaded_name
== NULL
)
8884 memcpy (threaded_name
, buf
, len
);
8886 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
8891 sect
->filepos
= filepos
;
8892 sect
->alignment_power
= 2;
8894 return elfcore_maybe_make_sect (abfd
, name
, sect
);
8897 /* prstatus_t exists on:
8899 linux 2.[01] + glibc
8903 #if defined (HAVE_PRSTATUS_T)
8906 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8911 if (note
->descsz
== sizeof (prstatus_t
))
8915 size
= sizeof (prstat
.pr_reg
);
8916 offset
= offsetof (prstatus_t
, pr_reg
);
8917 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8919 /* Do not overwrite the core signal if it
8920 has already been set by another thread. */
8921 if (elf_tdata (abfd
)->core
->signal
== 0)
8922 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8923 if (elf_tdata (abfd
)->core
->pid
== 0)
8924 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8926 /* pr_who exists on:
8929 pr_who doesn't exist on:
8932 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8933 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8935 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8938 #if defined (HAVE_PRSTATUS32_T)
8939 else if (note
->descsz
== sizeof (prstatus32_t
))
8941 /* 64-bit host, 32-bit corefile */
8942 prstatus32_t prstat
;
8944 size
= sizeof (prstat
.pr_reg
);
8945 offset
= offsetof (prstatus32_t
, pr_reg
);
8946 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8948 /* Do not overwrite the core signal if it
8949 has already been set by another thread. */
8950 if (elf_tdata (abfd
)->core
->signal
== 0)
8951 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8952 if (elf_tdata (abfd
)->core
->pid
== 0)
8953 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8955 /* pr_who exists on:
8958 pr_who doesn't exist on:
8961 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8962 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8964 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8967 #endif /* HAVE_PRSTATUS32_T */
8970 /* Fail - we don't know how to handle any other
8971 note size (ie. data object type). */
8975 /* Make a ".reg/999" section and a ".reg" section. */
8976 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
8977 size
, note
->descpos
+ offset
);
8979 #endif /* defined (HAVE_PRSTATUS_T) */
8981 /* Create a pseudosection containing the exact contents of NOTE. */
8983 elfcore_make_note_pseudosection (bfd
*abfd
,
8985 Elf_Internal_Note
*note
)
8987 return _bfd_elfcore_make_pseudosection (abfd
, name
,
8988 note
->descsz
, note
->descpos
);
8991 /* There isn't a consistent prfpregset_t across platforms,
8992 but it doesn't matter, because we don't have to pick this
8993 data structure apart. */
8996 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8998 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9001 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9002 type of NT_PRXFPREG. Just include the whole note's contents
9006 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9008 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9011 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9012 with a note type of NT_X86_XSTATE. Just include the whole note's
9013 contents literally. */
9016 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9018 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9022 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9024 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9028 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9030 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9034 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9036 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9040 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9042 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9046 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9048 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9052 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9054 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9058 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9060 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9064 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9066 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9070 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9072 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9076 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9078 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9082 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9084 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9088 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9090 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9094 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9096 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9100 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9102 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9106 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9108 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9112 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9114 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9118 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9120 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9123 #if defined (HAVE_PRPSINFO_T)
9124 typedef prpsinfo_t elfcore_psinfo_t
;
9125 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9126 typedef prpsinfo32_t elfcore_psinfo32_t
;
9130 #if defined (HAVE_PSINFO_T)
9131 typedef psinfo_t elfcore_psinfo_t
;
9132 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9133 typedef psinfo32_t elfcore_psinfo32_t
;
9137 /* return a malloc'ed copy of a string at START which is at
9138 most MAX bytes long, possibly without a terminating '\0'.
9139 the copy will always have a terminating '\0'. */
9142 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9145 char *end
= (char *) memchr (start
, '\0', max
);
9153 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9157 memcpy (dups
, start
, len
);
9163 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9165 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9167 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9169 elfcore_psinfo_t psinfo
;
9171 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9173 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9174 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9176 elf_tdata (abfd
)->core
->program
9177 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9178 sizeof (psinfo
.pr_fname
));
9180 elf_tdata (abfd
)->core
->command
9181 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9182 sizeof (psinfo
.pr_psargs
));
9184 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9185 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9187 /* 64-bit host, 32-bit corefile */
9188 elfcore_psinfo32_t psinfo
;
9190 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9192 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9193 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9195 elf_tdata (abfd
)->core
->program
9196 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9197 sizeof (psinfo
.pr_fname
));
9199 elf_tdata (abfd
)->core
->command
9200 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9201 sizeof (psinfo
.pr_psargs
));
9207 /* Fail - we don't know how to handle any other
9208 note size (ie. data object type). */
9212 /* Note that for some reason, a spurious space is tacked
9213 onto the end of the args in some (at least one anyway)
9214 implementations, so strip it off if it exists. */
9217 char *command
= elf_tdata (abfd
)->core
->command
;
9218 int n
= strlen (command
);
9220 if (0 < n
&& command
[n
- 1] == ' ')
9221 command
[n
- 1] = '\0';
9226 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9228 #if defined (HAVE_PSTATUS_T)
9230 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9232 if (note
->descsz
== sizeof (pstatus_t
)
9233 #if defined (HAVE_PXSTATUS_T)
9234 || note
->descsz
== sizeof (pxstatus_t
)
9240 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9242 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9244 #if defined (HAVE_PSTATUS32_T)
9245 else if (note
->descsz
== sizeof (pstatus32_t
))
9247 /* 64-bit host, 32-bit corefile */
9250 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9252 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9255 /* Could grab some more details from the "representative"
9256 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9257 NT_LWPSTATUS note, presumably. */
9261 #endif /* defined (HAVE_PSTATUS_T) */
9263 #if defined (HAVE_LWPSTATUS_T)
9265 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9267 lwpstatus_t lwpstat
;
9273 if (note
->descsz
!= sizeof (lwpstat
)
9274 #if defined (HAVE_LWPXSTATUS_T)
9275 && note
->descsz
!= sizeof (lwpxstatus_t
)
9280 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9282 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9283 /* Do not overwrite the core signal if it has already been set by
9285 if (elf_tdata (abfd
)->core
->signal
== 0)
9286 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9288 /* Make a ".reg/999" section. */
9290 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9291 len
= strlen (buf
) + 1;
9292 name
= bfd_alloc (abfd
, len
);
9295 memcpy (name
, buf
, len
);
9297 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9301 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9302 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9303 sect
->filepos
= note
->descpos
9304 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9307 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9308 sect
->size
= sizeof (lwpstat
.pr_reg
);
9309 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9312 sect
->alignment_power
= 2;
9314 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9317 /* Make a ".reg2/999" section */
9319 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9320 len
= strlen (buf
) + 1;
9321 name
= bfd_alloc (abfd
, len
);
9324 memcpy (name
, buf
, len
);
9326 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9330 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9331 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9332 sect
->filepos
= note
->descpos
9333 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9336 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9337 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9338 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9341 sect
->alignment_power
= 2;
9343 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9345 #endif /* defined (HAVE_LWPSTATUS_T) */
9348 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9355 int is_active_thread
;
9358 if (note
->descsz
< 728)
9361 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9364 type
= bfd_get_32 (abfd
, note
->descdata
);
9368 case 1 /* NOTE_INFO_PROCESS */:
9369 /* FIXME: need to add ->core->command. */
9370 /* process_info.pid */
9371 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9372 /* process_info.signal */
9373 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
9376 case 2 /* NOTE_INFO_THREAD */:
9377 /* Make a ".reg/999" section. */
9378 /* thread_info.tid */
9379 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
9381 len
= strlen (buf
) + 1;
9382 name
= (char *) bfd_alloc (abfd
, len
);
9386 memcpy (name
, buf
, len
);
9388 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9392 /* sizeof (thread_info.thread_context) */
9394 /* offsetof (thread_info.thread_context) */
9395 sect
->filepos
= note
->descpos
+ 12;
9396 sect
->alignment_power
= 2;
9398 /* thread_info.is_active_thread */
9399 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9401 if (is_active_thread
)
9402 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9406 case 3 /* NOTE_INFO_MODULE */:
9407 /* Make a ".module/xxxxxxxx" section. */
9408 /* module_info.base_address */
9409 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
9410 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
9412 len
= strlen (buf
) + 1;
9413 name
= (char *) bfd_alloc (abfd
, len
);
9417 memcpy (name
, buf
, len
);
9419 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9424 sect
->size
= note
->descsz
;
9425 sect
->filepos
= note
->descpos
;
9426 sect
->alignment_power
= 2;
9437 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9439 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9447 if (bed
->elf_backend_grok_prstatus
)
9448 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
9450 #if defined (HAVE_PRSTATUS_T)
9451 return elfcore_grok_prstatus (abfd
, note
);
9456 #if defined (HAVE_PSTATUS_T)
9458 return elfcore_grok_pstatus (abfd
, note
);
9461 #if defined (HAVE_LWPSTATUS_T)
9463 return elfcore_grok_lwpstatus (abfd
, note
);
9466 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
9467 return elfcore_grok_prfpreg (abfd
, note
);
9469 case NT_WIN32PSTATUS
:
9470 return elfcore_grok_win32pstatus (abfd
, note
);
9472 case NT_PRXFPREG
: /* Linux SSE extension */
9473 if (note
->namesz
== 6
9474 && strcmp (note
->namedata
, "LINUX") == 0)
9475 return elfcore_grok_prxfpreg (abfd
, note
);
9479 case NT_X86_XSTATE
: /* Linux XSAVE extension */
9480 if (note
->namesz
== 6
9481 && strcmp (note
->namedata
, "LINUX") == 0)
9482 return elfcore_grok_xstatereg (abfd
, note
);
9487 if (note
->namesz
== 6
9488 && strcmp (note
->namedata
, "LINUX") == 0)
9489 return elfcore_grok_ppc_vmx (abfd
, note
);
9494 if (note
->namesz
== 6
9495 && strcmp (note
->namedata
, "LINUX") == 0)
9496 return elfcore_grok_ppc_vsx (abfd
, note
);
9500 case NT_S390_HIGH_GPRS
:
9501 if (note
->namesz
== 6
9502 && strcmp (note
->namedata
, "LINUX") == 0)
9503 return elfcore_grok_s390_high_gprs (abfd
, note
);
9508 if (note
->namesz
== 6
9509 && strcmp (note
->namedata
, "LINUX") == 0)
9510 return elfcore_grok_s390_timer (abfd
, note
);
9514 case NT_S390_TODCMP
:
9515 if (note
->namesz
== 6
9516 && strcmp (note
->namedata
, "LINUX") == 0)
9517 return elfcore_grok_s390_todcmp (abfd
, note
);
9521 case NT_S390_TODPREG
:
9522 if (note
->namesz
== 6
9523 && strcmp (note
->namedata
, "LINUX") == 0)
9524 return elfcore_grok_s390_todpreg (abfd
, note
);
9529 if (note
->namesz
== 6
9530 && strcmp (note
->namedata
, "LINUX") == 0)
9531 return elfcore_grok_s390_ctrs (abfd
, note
);
9535 case NT_S390_PREFIX
:
9536 if (note
->namesz
== 6
9537 && strcmp (note
->namedata
, "LINUX") == 0)
9538 return elfcore_grok_s390_prefix (abfd
, note
);
9542 case NT_S390_LAST_BREAK
:
9543 if (note
->namesz
== 6
9544 && strcmp (note
->namedata
, "LINUX") == 0)
9545 return elfcore_grok_s390_last_break (abfd
, note
);
9549 case NT_S390_SYSTEM_CALL
:
9550 if (note
->namesz
== 6
9551 && strcmp (note
->namedata
, "LINUX") == 0)
9552 return elfcore_grok_s390_system_call (abfd
, note
);
9557 if (note
->namesz
== 6
9558 && strcmp (note
->namedata
, "LINUX") == 0)
9559 return elfcore_grok_s390_tdb (abfd
, note
);
9563 case NT_S390_VXRS_LOW
:
9564 if (note
->namesz
== 6
9565 && strcmp (note
->namedata
, "LINUX") == 0)
9566 return elfcore_grok_s390_vxrs_low (abfd
, note
);
9570 case NT_S390_VXRS_HIGH
:
9571 if (note
->namesz
== 6
9572 && strcmp (note
->namedata
, "LINUX") == 0)
9573 return elfcore_grok_s390_vxrs_high (abfd
, note
);
9578 if (note
->namesz
== 6
9579 && strcmp (note
->namedata
, "LINUX") == 0)
9580 return elfcore_grok_arm_vfp (abfd
, note
);
9585 if (note
->namesz
== 6
9586 && strcmp (note
->namedata
, "LINUX") == 0)
9587 return elfcore_grok_aarch_tls (abfd
, note
);
9591 case NT_ARM_HW_BREAK
:
9592 if (note
->namesz
== 6
9593 && strcmp (note
->namedata
, "LINUX") == 0)
9594 return elfcore_grok_aarch_hw_break (abfd
, note
);
9598 case NT_ARM_HW_WATCH
:
9599 if (note
->namesz
== 6
9600 && strcmp (note
->namedata
, "LINUX") == 0)
9601 return elfcore_grok_aarch_hw_watch (abfd
, note
);
9607 if (bed
->elf_backend_grok_psinfo
)
9608 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
9610 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9611 return elfcore_grok_psinfo (abfd
, note
);
9618 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9623 sect
->size
= note
->descsz
;
9624 sect
->filepos
= note
->descpos
;
9625 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9631 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
9635 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
9642 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
9644 struct bfd_build_id
* build_id
;
9646 if (note
->descsz
== 0)
9649 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
9650 if (build_id
== NULL
)
9653 build_id
->size
= note
->descsz
;
9654 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
9655 abfd
->build_id
= build_id
;
9661 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9668 case NT_GNU_BUILD_ID
:
9669 return elfobj_grok_gnu_build_id (abfd
, note
);
9674 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
9676 struct sdt_note
*cur
=
9677 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
9680 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
9681 cur
->size
= (bfd_size_type
) note
->descsz
;
9682 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
9684 elf_tdata (abfd
)->sdt_note_head
= cur
;
9690 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9695 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
9703 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9707 switch (abfd
->arch_info
->bits_per_word
)
9710 if (note
->descsz
< 108)
9715 if (note
->descsz
< 120)
9723 /* Check for version 1 in pr_version. */
9724 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
9728 /* Skip over pr_psinfosz. */
9729 if (abfd
->arch_info
->bits_per_word
== 32)
9733 offset
+= 4; /* Padding before pr_psinfosz. */
9737 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
9738 elf_tdata (abfd
)->core
->program
9739 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
9742 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
9743 elf_tdata (abfd
)->core
->command
9744 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
9747 /* Padding before pr_pid. */
9750 /* The pr_pid field was added in version "1a". */
9751 if (note
->descsz
< offset
+ 4)
9754 elf_tdata (abfd
)->core
->pid
9755 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9761 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9766 /* Check for version 1 in pr_version. */
9767 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
9771 /* Skip over pr_statussz. */
9772 switch (abfd
->arch_info
->bits_per_word
)
9779 offset
+= 4; /* Padding before pr_statussz. */
9787 /* Extract size of pr_reg from pr_gregsetsz. */
9788 if (abfd
->arch_info
->bits_per_word
== 32)
9789 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9791 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9793 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
9794 offset
+= (abfd
->arch_info
->bits_per_word
/ 8) * 2;
9796 /* Skip over pr_osreldate. */
9799 /* Read signal from pr_cursig. */
9800 if (elf_tdata (abfd
)->core
->signal
== 0)
9801 elf_tdata (abfd
)->core
->signal
9802 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9805 /* Read TID from pr_pid. */
9806 elf_tdata (abfd
)->core
->lwpid
9807 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9810 /* Padding before pr_reg. */
9811 if (abfd
->arch_info
->bits_per_word
== 64)
9814 /* Make a ".reg/999" section and a ".reg" section. */
9815 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9816 size
, note
->descpos
+ offset
);
9820 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9825 return elfcore_grok_freebsd_prstatus (abfd
, note
);
9828 return elfcore_grok_prfpreg (abfd
, note
);
9831 return elfcore_grok_freebsd_psinfo (abfd
, note
);
9833 case NT_FREEBSD_THRMISC
:
9834 if (note
->namesz
== 8)
9835 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
9839 case NT_FREEBSD_PROCSTAT_AUXV
:
9841 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9846 sect
->size
= note
->descsz
- 4;
9847 sect
->filepos
= note
->descpos
+ 4;
9848 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9854 if (note
->namesz
== 8)
9855 return elfcore_grok_xstatereg (abfd
, note
);
9865 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
9869 cp
= strchr (note
->namedata
, '@');
9872 *lwpidp
= atoi(cp
+ 1);
9879 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9881 /* Signal number at offset 0x08. */
9882 elf_tdata (abfd
)->core
->signal
9883 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
9885 /* Process ID at offset 0x50. */
9886 elf_tdata (abfd
)->core
->pid
9887 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
9889 /* Command name at 0x7c (max 32 bytes, including nul). */
9890 elf_tdata (abfd
)->core
->command
9891 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
9893 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
9898 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9902 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
9903 elf_tdata (abfd
)->core
->lwpid
= lwp
;
9905 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
9907 /* NetBSD-specific core "procinfo". Note that we expect to
9908 find this note before any of the others, which is fine,
9909 since the kernel writes this note out first when it
9910 creates a core file. */
9912 return elfcore_grok_netbsd_procinfo (abfd
, note
);
9915 /* As of Jan 2002 there are no other machine-independent notes
9916 defined for NetBSD core files. If the note type is less
9917 than the start of the machine-dependent note types, we don't
9920 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
9924 switch (bfd_get_arch (abfd
))
9926 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
9927 PT_GETFPREGS == mach+2. */
9929 case bfd_arch_alpha
:
9930 case bfd_arch_sparc
:
9933 case NT_NETBSDCORE_FIRSTMACH
+0:
9934 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9936 case NT_NETBSDCORE_FIRSTMACH
+2:
9937 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9943 /* On all other arch's, PT_GETREGS == mach+1 and
9944 PT_GETFPREGS == mach+3. */
9949 case NT_NETBSDCORE_FIRSTMACH
+1:
9950 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9952 case NT_NETBSDCORE_FIRSTMACH
+3:
9953 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9963 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9965 /* Signal number at offset 0x08. */
9966 elf_tdata (abfd
)->core
->signal
9967 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
9969 /* Process ID at offset 0x20. */
9970 elf_tdata (abfd
)->core
->pid
9971 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
9973 /* Command name at 0x48 (max 32 bytes, including nul). */
9974 elf_tdata (abfd
)->core
->command
9975 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
9981 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9983 if (note
->type
== NT_OPENBSD_PROCINFO
)
9984 return elfcore_grok_openbsd_procinfo (abfd
, note
);
9986 if (note
->type
== NT_OPENBSD_REGS
)
9987 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9989 if (note
->type
== NT_OPENBSD_FPREGS
)
9990 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9992 if (note
->type
== NT_OPENBSD_XFPREGS
)
9993 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9995 if (note
->type
== NT_OPENBSD_AUXV
)
9997 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10002 sect
->size
= note
->descsz
;
10003 sect
->filepos
= note
->descpos
;
10004 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10009 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10011 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10016 sect
->size
= note
->descsz
;
10017 sect
->filepos
= note
->descpos
;
10018 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10027 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10029 void *ddata
= note
->descdata
;
10036 /* nto_procfs_status 'pid' field is at offset 0. */
10037 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10039 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10040 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10042 /* nto_procfs_status 'flags' field is at offset 8. */
10043 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10045 /* nto_procfs_status 'what' field is at offset 14. */
10046 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10048 elf_tdata (abfd
)->core
->signal
= sig
;
10049 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10052 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10053 do not come from signals so we make sure we set the current
10054 thread just in case. */
10055 if (flags
& 0x00000080)
10056 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10058 /* Make a ".qnx_core_status/%d" section. */
10059 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10061 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10064 strcpy (name
, buf
);
10066 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10070 sect
->size
= note
->descsz
;
10071 sect
->filepos
= note
->descpos
;
10072 sect
->alignment_power
= 2;
10074 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10078 elfcore_grok_nto_regs (bfd
*abfd
,
10079 Elf_Internal_Note
*note
,
10087 /* Make a "(base)/%d" section. */
10088 sprintf (buf
, "%s/%ld", base
, tid
);
10090 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10093 strcpy (name
, buf
);
10095 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10099 sect
->size
= note
->descsz
;
10100 sect
->filepos
= note
->descpos
;
10101 sect
->alignment_power
= 2;
10103 /* This is the current thread. */
10104 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10105 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10110 #define BFD_QNT_CORE_INFO 7
10111 #define BFD_QNT_CORE_STATUS 8
10112 #define BFD_QNT_CORE_GREG 9
10113 #define BFD_QNT_CORE_FPREG 10
10116 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10118 /* Every GREG section has a STATUS section before it. Store the
10119 tid from the previous call to pass down to the next gregs
10121 static long tid
= 1;
10123 switch (note
->type
)
10125 case BFD_QNT_CORE_INFO
:
10126 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10127 case BFD_QNT_CORE_STATUS
:
10128 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10129 case BFD_QNT_CORE_GREG
:
10130 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10131 case BFD_QNT_CORE_FPREG
:
10132 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10139 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10145 /* Use note name as section name. */
10146 len
= note
->namesz
;
10147 name
= (char *) bfd_alloc (abfd
, len
);
10150 memcpy (name
, note
->namedata
, len
);
10151 name
[len
- 1] = '\0';
10153 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10157 sect
->size
= note
->descsz
;
10158 sect
->filepos
= note
->descpos
;
10159 sect
->alignment_power
= 1;
10164 /* Function: elfcore_write_note
10167 buffer to hold note, and current size of buffer
10171 size of data for note
10173 Writes note to end of buffer. ELF64 notes are written exactly as
10174 for ELF32, despite the current (as of 2006) ELF gabi specifying
10175 that they ought to have 8-byte namesz and descsz field, and have
10176 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10179 Pointer to realloc'd buffer, *BUFSIZ updated. */
10182 elfcore_write_note (bfd
*abfd
,
10190 Elf_External_Note
*xnp
;
10197 namesz
= strlen (name
) + 1;
10199 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10201 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10204 dest
= buf
+ *bufsiz
;
10205 *bufsiz
+= newspace
;
10206 xnp
= (Elf_External_Note
*) dest
;
10207 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10208 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10209 H_PUT_32 (abfd
, type
, xnp
->type
);
10213 memcpy (dest
, name
, namesz
);
10221 memcpy (dest
, input
, size
);
10232 elfcore_write_prpsinfo (bfd
*abfd
,
10236 const char *psargs
)
10238 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10240 if (bed
->elf_backend_write_core_note
!= NULL
)
10243 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10244 NT_PRPSINFO
, fname
, psargs
);
10249 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10250 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10251 if (bed
->s
->elfclass
== ELFCLASS32
)
10253 #if defined (HAVE_PSINFO32_T)
10255 int note_type
= NT_PSINFO
;
10258 int note_type
= NT_PRPSINFO
;
10261 memset (&data
, 0, sizeof (data
));
10262 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10263 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10264 return elfcore_write_note (abfd
, buf
, bufsiz
,
10265 "CORE", note_type
, &data
, sizeof (data
));
10270 #if defined (HAVE_PSINFO_T)
10272 int note_type
= NT_PSINFO
;
10275 int note_type
= NT_PRPSINFO
;
10278 memset (&data
, 0, sizeof (data
));
10279 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10280 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10281 return elfcore_write_note (abfd
, buf
, bufsiz
,
10282 "CORE", note_type
, &data
, sizeof (data
));
10284 #endif /* PSINFO_T or PRPSINFO_T */
10291 elfcore_write_linux_prpsinfo32
10292 (bfd
*abfd
, char *buf
, int *bufsiz
,
10293 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10295 struct elf_external_linux_prpsinfo32 data
;
10297 swap_linux_prpsinfo32_out (abfd
, prpsinfo
, &data
);
10298 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
10299 &data
, sizeof (data
));
10303 elfcore_write_linux_prpsinfo64
10304 (bfd
*abfd
, char *buf
, int *bufsiz
,
10305 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10307 struct elf_external_linux_prpsinfo64 data
;
10309 swap_linux_prpsinfo64_out (abfd
, prpsinfo
, &data
);
10310 return elfcore_write_note (abfd
, buf
, bufsiz
,
10311 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
10315 elfcore_write_prstatus (bfd
*abfd
,
10322 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10324 if (bed
->elf_backend_write_core_note
!= NULL
)
10327 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10329 pid
, cursig
, gregs
);
10334 #if defined (HAVE_PRSTATUS_T)
10335 #if defined (HAVE_PRSTATUS32_T)
10336 if (bed
->s
->elfclass
== ELFCLASS32
)
10338 prstatus32_t prstat
;
10340 memset (&prstat
, 0, sizeof (prstat
));
10341 prstat
.pr_pid
= pid
;
10342 prstat
.pr_cursig
= cursig
;
10343 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
10344 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
10345 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
10352 memset (&prstat
, 0, sizeof (prstat
));
10353 prstat
.pr_pid
= pid
;
10354 prstat
.pr_cursig
= cursig
;
10355 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
10356 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
10357 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
10359 #endif /* HAVE_PRSTATUS_T */
10365 #if defined (HAVE_LWPSTATUS_T)
10367 elfcore_write_lwpstatus (bfd
*abfd
,
10374 lwpstatus_t lwpstat
;
10375 const char *note_name
= "CORE";
10377 memset (&lwpstat
, 0, sizeof (lwpstat
));
10378 lwpstat
.pr_lwpid
= pid
>> 16;
10379 lwpstat
.pr_cursig
= cursig
;
10380 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10381 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
10382 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10383 #if !defined(gregs)
10384 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
10385 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
10387 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
10388 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
10391 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10392 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
10394 #endif /* HAVE_LWPSTATUS_T */
10396 #if defined (HAVE_PSTATUS_T)
10398 elfcore_write_pstatus (bfd
*abfd
,
10402 int cursig ATTRIBUTE_UNUSED
,
10403 const void *gregs ATTRIBUTE_UNUSED
)
10405 const char *note_name
= "CORE";
10406 #if defined (HAVE_PSTATUS32_T)
10407 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10409 if (bed
->s
->elfclass
== ELFCLASS32
)
10413 memset (&pstat
, 0, sizeof (pstat
));
10414 pstat
.pr_pid
= pid
& 0xffff;
10415 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10416 NT_PSTATUS
, &pstat
, sizeof (pstat
));
10424 memset (&pstat
, 0, sizeof (pstat
));
10425 pstat
.pr_pid
= pid
& 0xffff;
10426 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10427 NT_PSTATUS
, &pstat
, sizeof (pstat
));
10431 #endif /* HAVE_PSTATUS_T */
10434 elfcore_write_prfpreg (bfd
*abfd
,
10437 const void *fpregs
,
10440 const char *note_name
= "CORE";
10441 return elfcore_write_note (abfd
, buf
, bufsiz
,
10442 note_name
, NT_FPREGSET
, fpregs
, size
);
10446 elfcore_write_prxfpreg (bfd
*abfd
,
10449 const void *xfpregs
,
10452 char *note_name
= "LINUX";
10453 return elfcore_write_note (abfd
, buf
, bufsiz
,
10454 note_name
, NT_PRXFPREG
, xfpregs
, size
);
10458 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
10459 const void *xfpregs
, int size
)
10462 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
10463 note_name
= "FreeBSD";
10465 note_name
= "LINUX";
10466 return elfcore_write_note (abfd
, buf
, bufsiz
,
10467 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
10471 elfcore_write_ppc_vmx (bfd
*abfd
,
10474 const void *ppc_vmx
,
10477 char *note_name
= "LINUX";
10478 return elfcore_write_note (abfd
, buf
, bufsiz
,
10479 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
10483 elfcore_write_ppc_vsx (bfd
*abfd
,
10486 const void *ppc_vsx
,
10489 char *note_name
= "LINUX";
10490 return elfcore_write_note (abfd
, buf
, bufsiz
,
10491 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
10495 elfcore_write_s390_high_gprs (bfd
*abfd
,
10498 const void *s390_high_gprs
,
10501 char *note_name
= "LINUX";
10502 return elfcore_write_note (abfd
, buf
, bufsiz
,
10503 note_name
, NT_S390_HIGH_GPRS
,
10504 s390_high_gprs
, size
);
10508 elfcore_write_s390_timer (bfd
*abfd
,
10511 const void *s390_timer
,
10514 char *note_name
= "LINUX";
10515 return elfcore_write_note (abfd
, buf
, bufsiz
,
10516 note_name
, NT_S390_TIMER
, s390_timer
, size
);
10520 elfcore_write_s390_todcmp (bfd
*abfd
,
10523 const void *s390_todcmp
,
10526 char *note_name
= "LINUX";
10527 return elfcore_write_note (abfd
, buf
, bufsiz
,
10528 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
10532 elfcore_write_s390_todpreg (bfd
*abfd
,
10535 const void *s390_todpreg
,
10538 char *note_name
= "LINUX";
10539 return elfcore_write_note (abfd
, buf
, bufsiz
,
10540 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
10544 elfcore_write_s390_ctrs (bfd
*abfd
,
10547 const void *s390_ctrs
,
10550 char *note_name
= "LINUX";
10551 return elfcore_write_note (abfd
, buf
, bufsiz
,
10552 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
10556 elfcore_write_s390_prefix (bfd
*abfd
,
10559 const void *s390_prefix
,
10562 char *note_name
= "LINUX";
10563 return elfcore_write_note (abfd
, buf
, bufsiz
,
10564 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
10568 elfcore_write_s390_last_break (bfd
*abfd
,
10571 const void *s390_last_break
,
10574 char *note_name
= "LINUX";
10575 return elfcore_write_note (abfd
, buf
, bufsiz
,
10576 note_name
, NT_S390_LAST_BREAK
,
10577 s390_last_break
, size
);
10581 elfcore_write_s390_system_call (bfd
*abfd
,
10584 const void *s390_system_call
,
10587 char *note_name
= "LINUX";
10588 return elfcore_write_note (abfd
, buf
, bufsiz
,
10589 note_name
, NT_S390_SYSTEM_CALL
,
10590 s390_system_call
, size
);
10594 elfcore_write_s390_tdb (bfd
*abfd
,
10597 const void *s390_tdb
,
10600 char *note_name
= "LINUX";
10601 return elfcore_write_note (abfd
, buf
, bufsiz
,
10602 note_name
, NT_S390_TDB
, s390_tdb
, size
);
10606 elfcore_write_s390_vxrs_low (bfd
*abfd
,
10609 const void *s390_vxrs_low
,
10612 char *note_name
= "LINUX";
10613 return elfcore_write_note (abfd
, buf
, bufsiz
,
10614 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
10618 elfcore_write_s390_vxrs_high (bfd
*abfd
,
10621 const void *s390_vxrs_high
,
10624 char *note_name
= "LINUX";
10625 return elfcore_write_note (abfd
, buf
, bufsiz
,
10626 note_name
, NT_S390_VXRS_HIGH
,
10627 s390_vxrs_high
, size
);
10631 elfcore_write_arm_vfp (bfd
*abfd
,
10634 const void *arm_vfp
,
10637 char *note_name
= "LINUX";
10638 return elfcore_write_note (abfd
, buf
, bufsiz
,
10639 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
10643 elfcore_write_aarch_tls (bfd
*abfd
,
10646 const void *aarch_tls
,
10649 char *note_name
= "LINUX";
10650 return elfcore_write_note (abfd
, buf
, bufsiz
,
10651 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
10655 elfcore_write_aarch_hw_break (bfd
*abfd
,
10658 const void *aarch_hw_break
,
10661 char *note_name
= "LINUX";
10662 return elfcore_write_note (abfd
, buf
, bufsiz
,
10663 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
10667 elfcore_write_aarch_hw_watch (bfd
*abfd
,
10670 const void *aarch_hw_watch
,
10673 char *note_name
= "LINUX";
10674 return elfcore_write_note (abfd
, buf
, bufsiz
,
10675 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
10679 elfcore_write_register_note (bfd
*abfd
,
10682 const char *section
,
10686 if (strcmp (section
, ".reg2") == 0)
10687 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
10688 if (strcmp (section
, ".reg-xfp") == 0)
10689 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
10690 if (strcmp (section
, ".reg-xstate") == 0)
10691 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
10692 if (strcmp (section
, ".reg-ppc-vmx") == 0)
10693 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
10694 if (strcmp (section
, ".reg-ppc-vsx") == 0)
10695 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
10696 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
10697 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
10698 if (strcmp (section
, ".reg-s390-timer") == 0)
10699 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
10700 if (strcmp (section
, ".reg-s390-todcmp") == 0)
10701 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
10702 if (strcmp (section
, ".reg-s390-todpreg") == 0)
10703 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
10704 if (strcmp (section
, ".reg-s390-ctrs") == 0)
10705 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
10706 if (strcmp (section
, ".reg-s390-prefix") == 0)
10707 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
10708 if (strcmp (section
, ".reg-s390-last-break") == 0)
10709 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
10710 if (strcmp (section
, ".reg-s390-system-call") == 0)
10711 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
10712 if (strcmp (section
, ".reg-s390-tdb") == 0)
10713 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
10714 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
10715 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
10716 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
10717 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
10718 if (strcmp (section
, ".reg-arm-vfp") == 0)
10719 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
10720 if (strcmp (section
, ".reg-aarch-tls") == 0)
10721 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
10722 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
10723 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
10724 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
10725 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
10730 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
10735 while (p
< buf
+ size
)
10737 /* FIXME: bad alignment assumption. */
10738 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
10739 Elf_Internal_Note in
;
10741 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
10744 in
.type
= H_GET_32 (abfd
, xnp
->type
);
10746 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
10747 in
.namedata
= xnp
->name
;
10748 if (in
.namesz
> buf
- in
.namedata
+ size
)
10751 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
10752 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
10753 in
.descpos
= offset
+ (in
.descdata
- buf
);
10755 && (in
.descdata
>= buf
+ size
10756 || in
.descsz
> buf
- in
.descdata
+ size
))
10759 switch (bfd_get_format (abfd
))
10766 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
10769 const char * string
;
10771 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
10775 GROKER_ELEMENT ("", elfcore_grok_note
),
10776 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
10777 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
10778 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
10779 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
10780 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
10782 #undef GROKER_ELEMENT
10785 for (i
= ARRAY_SIZE (grokers
); i
--;)
10787 if (in
.namesz
>= grokers
[i
].len
10788 && strncmp (in
.namedata
, grokers
[i
].string
,
10789 grokers
[i
].len
) == 0)
10791 if (! grokers
[i
].func (abfd
, & in
))
10800 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
10802 if (! elfobj_grok_gnu_note (abfd
, &in
))
10805 else if (in
.namesz
== sizeof "stapsdt"
10806 && strcmp (in
.namedata
, "stapsdt") == 0)
10808 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
10814 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
10821 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
10828 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
10831 buf
= (char *) bfd_malloc (size
+ 1);
10835 /* PR 17512: file: ec08f814
10836 0-termintate the buffer so that string searches will not overflow. */
10839 if (bfd_bread (buf
, size
, abfd
) != size
10840 || !elf_parse_notes (abfd
, buf
, size
, offset
))
10850 /* Providing external access to the ELF program header table. */
10852 /* Return an upper bound on the number of bytes required to store a
10853 copy of ABFD's program header table entries. Return -1 if an error
10854 occurs; bfd_get_error will return an appropriate code. */
10857 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
10859 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
10861 bfd_set_error (bfd_error_wrong_format
);
10865 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
10868 /* Copy ABFD's program header table entries to *PHDRS. The entries
10869 will be stored as an array of Elf_Internal_Phdr structures, as
10870 defined in include/elf/internal.h. To find out how large the
10871 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
10873 Return the number of program header table entries read, or -1 if an
10874 error occurs; bfd_get_error will return an appropriate code. */
10877 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
10881 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
10883 bfd_set_error (bfd_error_wrong_format
);
10887 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
10888 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
10889 num_phdrs
* sizeof (Elf_Internal_Phdr
));
10894 enum elf_reloc_type_class
10895 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
10896 const asection
*rel_sec ATTRIBUTE_UNUSED
,
10897 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
10899 return reloc_class_normal
;
10902 /* For RELA architectures, return the relocation value for a
10903 relocation against a local symbol. */
10906 _bfd_elf_rela_local_sym (bfd
*abfd
,
10907 Elf_Internal_Sym
*sym
,
10909 Elf_Internal_Rela
*rel
)
10911 asection
*sec
= *psec
;
10912 bfd_vma relocation
;
10914 relocation
= (sec
->output_section
->vma
10915 + sec
->output_offset
10917 if ((sec
->flags
& SEC_MERGE
)
10918 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
10919 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
10922 _bfd_merged_section_offset (abfd
, psec
,
10923 elf_section_data (sec
)->sec_info
,
10924 sym
->st_value
+ rel
->r_addend
);
10927 /* If we have changed the section, and our original section is
10928 marked with SEC_EXCLUDE, it means that the original
10929 SEC_MERGE section has been completely subsumed in some
10930 other SEC_MERGE section. In this case, we need to leave
10931 some info around for --emit-relocs. */
10932 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
10933 sec
->kept_section
= *psec
;
10936 rel
->r_addend
-= relocation
;
10937 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
10943 _bfd_elf_rel_local_sym (bfd
*abfd
,
10944 Elf_Internal_Sym
*sym
,
10948 asection
*sec
= *psec
;
10950 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
10951 return sym
->st_value
+ addend
;
10953 return _bfd_merged_section_offset (abfd
, psec
,
10954 elf_section_data (sec
)->sec_info
,
10955 sym
->st_value
+ addend
);
10958 /* Adjust an address within a section. Given OFFSET within SEC, return
10959 the new offset within the section, based upon changes made to the
10960 section. Returns -1 if the offset is now invalid.
10961 The offset (in abnd out) is in target sized bytes, however big a
10965 _bfd_elf_section_offset (bfd
*abfd
,
10966 struct bfd_link_info
*info
,
10970 switch (sec
->sec_info_type
)
10972 case SEC_INFO_TYPE_STABS
:
10973 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
10975 case SEC_INFO_TYPE_EH_FRAME
:
10976 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
10979 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
10981 /* Reverse the offset. */
10982 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10983 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
10985 /* address_size and sec->size are in octets. Convert
10986 to bytes before subtracting the original offset. */
10987 offset
= (sec
->size
- address_size
) / bfd_octets_per_byte (abfd
) - offset
;
10993 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
10994 reconstruct an ELF file by reading the segments out of remote memory
10995 based on the ELF file header at EHDR_VMA and the ELF program headers it
10996 points to. If not null, *LOADBASEP is filled in with the difference
10997 between the VMAs from which the segments were read, and the VMAs the
10998 file headers (and hence BFD's idea of each section's VMA) put them at.
11000 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11001 remote memory at target address VMA into the local buffer at MYADDR; it
11002 should return zero on success or an `errno' code on failure. TEMPL must
11003 be a BFD for an ELF target with the word size and byte order found in
11004 the remote memory. */
11007 bfd_elf_bfd_from_remote_memory
11010 bfd_size_type size
,
11011 bfd_vma
*loadbasep
,
11012 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
11014 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
11015 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
11019 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
11020 long symcount ATTRIBUTE_UNUSED
,
11021 asymbol
**syms ATTRIBUTE_UNUSED
,
11026 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11029 const char *relplt_name
;
11030 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
11034 Elf_Internal_Shdr
*hdr
;
11040 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
11043 if (dynsymcount
<= 0)
11046 if (!bed
->plt_sym_val
)
11049 relplt_name
= bed
->relplt_name
;
11050 if (relplt_name
== NULL
)
11051 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
11052 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
11053 if (relplt
== NULL
)
11056 hdr
= &elf_section_data (relplt
)->this_hdr
;
11057 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
11058 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
11061 plt
= bfd_get_section_by_name (abfd
, ".plt");
11065 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
11066 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
11069 count
= relplt
->size
/ hdr
->sh_entsize
;
11070 size
= count
* sizeof (asymbol
);
11071 p
= relplt
->relocation
;
11072 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11074 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
11075 if (p
->addend
!= 0)
11078 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
11080 size
+= sizeof ("+0x") - 1 + 8;
11085 s
= *ret
= (asymbol
*) bfd_malloc (size
);
11089 names
= (char *) (s
+ count
);
11090 p
= relplt
->relocation
;
11092 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11097 addr
= bed
->plt_sym_val (i
, plt
, p
);
11098 if (addr
== (bfd_vma
) -1)
11101 *s
= **p
->sym_ptr_ptr
;
11102 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
11103 we are defining a symbol, ensure one of them is set. */
11104 if ((s
->flags
& BSF_LOCAL
) == 0)
11105 s
->flags
|= BSF_GLOBAL
;
11106 s
->flags
|= BSF_SYNTHETIC
;
11108 s
->value
= addr
- plt
->vma
;
11111 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
11112 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
11114 if (p
->addend
!= 0)
11118 memcpy (names
, "+0x", sizeof ("+0x") - 1);
11119 names
+= sizeof ("+0x") - 1;
11120 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
11121 for (a
= buf
; *a
== '0'; ++a
)
11124 memcpy (names
, a
, len
);
11127 memcpy (names
, "@plt", sizeof ("@plt"));
11128 names
+= sizeof ("@plt");
11135 /* It is only used by x86-64 so far.
11136 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
11137 but current usage would allow all of _bfd_std_section to be zero. t*/
11138 asection _bfd_elf_large_com_section
11139 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, NULL
,
11140 "LARGE_COMMON", 0, SEC_IS_COMMON
);
11143 _bfd_elf_post_process_headers (bfd
* abfd
,
11144 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
11146 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
11148 i_ehdrp
= elf_elfheader (abfd
);
11150 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
11152 /* To make things simpler for the loader on Linux systems we set the
11153 osabi field to ELFOSABI_GNU if the binary contains symbols of
11154 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
11155 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
11156 && elf_tdata (abfd
)->has_gnu_symbols
)
11157 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
11161 /* Return TRUE for ELF symbol types that represent functions.
11162 This is the default version of this function, which is sufficient for
11163 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
11166 _bfd_elf_is_function_type (unsigned int type
)
11168 return (type
== STT_FUNC
11169 || type
== STT_GNU_IFUNC
);
11172 /* If the ELF symbol SYM might be a function in SEC, return the
11173 function size and set *CODE_OFF to the function's entry point,
11174 otherwise return zero. */
11177 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
11180 bfd_size_type size
;
11182 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
11183 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
11184 || sym
->section
!= sec
)
11187 *code_off
= sym
->value
;
11189 if (!(sym
->flags
& BSF_SYNTHETIC
))
11190 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;