1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2015 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-psinfo.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 bfd_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 _bfd_error_handler (_("%B: attempt to load strings from a non-string section (number %d)"),
346 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
350 if (strindex
>= hdr
->sh_size
)
352 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
353 (*_bfd_error_handler
)
354 (_("%B: invalid string offset %u >= %lu for section `%s'"),
355 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
356 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
358 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
362 return ((char *) hdr
->contents
) + strindex
;
365 /* Read and convert symbols to internal format.
366 SYMCOUNT specifies the number of symbols to read, starting from
367 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
368 are non-NULL, they are used to store the internal symbols, external
369 symbols, and symbol section index extensions, respectively.
370 Returns a pointer to the internal symbol buffer (malloced if necessary)
371 or NULL if there were no symbols or some kind of problem. */
374 bfd_elf_get_elf_syms (bfd
*ibfd
,
375 Elf_Internal_Shdr
*symtab_hdr
,
378 Elf_Internal_Sym
*intsym_buf
,
380 Elf_External_Sym_Shndx
*extshndx_buf
)
382 Elf_Internal_Shdr
*shndx_hdr
;
384 const bfd_byte
*esym
;
385 Elf_External_Sym_Shndx
*alloc_extshndx
;
386 Elf_External_Sym_Shndx
*shndx
;
387 Elf_Internal_Sym
*alloc_intsym
;
388 Elf_Internal_Sym
*isym
;
389 Elf_Internal_Sym
*isymend
;
390 const struct elf_backend_data
*bed
;
395 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
401 /* Normal syms might have section extension entries. */
403 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
404 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
406 /* Read the symbols. */
408 alloc_extshndx
= NULL
;
410 bed
= get_elf_backend_data (ibfd
);
411 extsym_size
= bed
->s
->sizeof_sym
;
412 amt
= symcount
* extsym_size
;
413 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
414 if (extsym_buf
== NULL
)
416 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
417 extsym_buf
= alloc_ext
;
419 if (extsym_buf
== NULL
420 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
421 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
427 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
431 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
432 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
433 if (extshndx_buf
== NULL
)
435 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
436 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
437 extshndx_buf
= alloc_extshndx
;
439 if (extshndx_buf
== NULL
440 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
441 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
448 if (intsym_buf
== NULL
)
450 alloc_intsym
= (Elf_Internal_Sym
*)
451 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
452 intsym_buf
= alloc_intsym
;
453 if (intsym_buf
== NULL
)
457 /* Convert the symbols to internal form. */
458 isymend
= intsym_buf
+ symcount
;
459 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
460 shndx
= extshndx_buf
;
462 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
463 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
465 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
466 (*_bfd_error_handler
) (_("%B symbol number %lu references "
467 "nonexistent SHT_SYMTAB_SHNDX section"),
468 ibfd
, (unsigned long) symoffset
);
469 if (alloc_intsym
!= NULL
)
476 if (alloc_ext
!= NULL
)
478 if (alloc_extshndx
!= NULL
)
479 free (alloc_extshndx
);
484 /* Look up a symbol name. */
486 bfd_elf_sym_name (bfd
*abfd
,
487 Elf_Internal_Shdr
*symtab_hdr
,
488 Elf_Internal_Sym
*isym
,
492 unsigned int iname
= isym
->st_name
;
493 unsigned int shindex
= symtab_hdr
->sh_link
;
495 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
496 /* Check for a bogus st_shndx to avoid crashing. */
497 && isym
->st_shndx
< elf_numsections (abfd
))
499 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
500 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
503 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
506 else if (sym_sec
&& *name
== '\0')
507 name
= bfd_section_name (abfd
, sym_sec
);
512 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
513 sections. The first element is the flags, the rest are section
516 typedef union elf_internal_group
{
517 Elf_Internal_Shdr
*shdr
;
519 } Elf_Internal_Group
;
521 /* Return the name of the group signature symbol. Why isn't the
522 signature just a string? */
525 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
527 Elf_Internal_Shdr
*hdr
;
528 unsigned char esym
[sizeof (Elf64_External_Sym
)];
529 Elf_External_Sym_Shndx eshndx
;
530 Elf_Internal_Sym isym
;
532 /* First we need to ensure the symbol table is available. Make sure
533 that it is a symbol table section. */
534 if (ghdr
->sh_link
>= elf_numsections (abfd
))
536 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
537 if (hdr
->sh_type
!= SHT_SYMTAB
538 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
541 /* Go read the symbol. */
542 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
543 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
544 &isym
, esym
, &eshndx
) == NULL
)
547 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
550 /* Set next_in_group list pointer, and group name for NEWSECT. */
553 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
555 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
557 /* If num_group is zero, read in all SHT_GROUP sections. The count
558 is set to -1 if there are no SHT_GROUP sections. */
561 unsigned int i
, shnum
;
563 /* First count the number of groups. If we have a SHT_GROUP
564 section with just a flag word (ie. sh_size is 4), ignore it. */
565 shnum
= elf_numsections (abfd
);
568 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
569 ( (shdr)->sh_type == SHT_GROUP \
570 && (shdr)->sh_size >= minsize \
571 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
572 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
574 for (i
= 0; i
< shnum
; i
++)
576 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
578 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
584 num_group
= (unsigned) -1;
585 elf_tdata (abfd
)->num_group
= num_group
;
589 /* We keep a list of elf section headers for group sections,
590 so we can find them quickly. */
593 elf_tdata (abfd
)->num_group
= num_group
;
594 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
595 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
596 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
600 for (i
= 0; i
< shnum
; i
++)
602 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
604 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
607 Elf_Internal_Group
*dest
;
609 /* Add to list of sections. */
610 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
613 /* Read the raw contents. */
614 BFD_ASSERT (sizeof (*dest
) >= 4);
615 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
616 shdr
->contents
= (unsigned char *)
617 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
618 /* PR binutils/4110: Handle corrupt group headers. */
619 if (shdr
->contents
== NULL
)
622 (_("%B: corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
623 bfd_set_error (bfd_error_bad_value
);
628 memset (shdr
->contents
, 0, amt
);
630 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
631 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
635 (_("%B: invalid size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
636 bfd_set_error (bfd_error_bad_value
);
638 /* PR 17510: If the group contents are even partially
639 corrupt, do not allow any of the contents to be used. */
640 memset (shdr
->contents
, 0, amt
);
644 /* Translate raw contents, a flag word followed by an
645 array of elf section indices all in target byte order,
646 to the flag word followed by an array of elf section
648 src
= shdr
->contents
+ shdr
->sh_size
;
649 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
657 idx
= H_GET_32 (abfd
, src
);
658 if (src
== shdr
->contents
)
661 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
662 shdr
->bfd_section
->flags
663 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
668 ((*_bfd_error_handler
)
669 (_("%B: invalid SHT_GROUP entry"), abfd
));
672 dest
->shdr
= elf_elfsections (abfd
)[idx
];
677 /* PR 17510: Corrupt binaries might contain invalid groups. */
678 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
680 elf_tdata (abfd
)->num_group
= num_group
;
682 /* If all groups are invalid then fail. */
685 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
686 elf_tdata (abfd
)->num_group
= num_group
= -1;
687 (*_bfd_error_handler
) (_("%B: no valid group sections found"), abfd
);
688 bfd_set_error (bfd_error_bad_value
);
694 if (num_group
!= (unsigned) -1)
698 for (i
= 0; i
< num_group
; i
++)
700 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
701 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
702 unsigned int n_elt
= shdr
->sh_size
/ 4;
704 /* Look through this group's sections to see if current
705 section is a member. */
707 if ((++idx
)->shdr
== hdr
)
711 /* We are a member of this group. Go looking through
712 other members to see if any others are linked via
714 idx
= (Elf_Internal_Group
*) shdr
->contents
;
715 n_elt
= shdr
->sh_size
/ 4;
717 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
718 && elf_next_in_group (s
) != NULL
)
722 /* Snarf the group name from other member, and
723 insert current section in circular list. */
724 elf_group_name (newsect
) = elf_group_name (s
);
725 elf_next_in_group (newsect
) = elf_next_in_group (s
);
726 elf_next_in_group (s
) = newsect
;
732 gname
= group_signature (abfd
, shdr
);
735 elf_group_name (newsect
) = gname
;
737 /* Start a circular list with one element. */
738 elf_next_in_group (newsect
) = newsect
;
741 /* If the group section has been created, point to the
743 if (shdr
->bfd_section
!= NULL
)
744 elf_next_in_group (shdr
->bfd_section
) = newsect
;
752 if (elf_group_name (newsect
) == NULL
)
754 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
762 _bfd_elf_setup_sections (bfd
*abfd
)
765 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
766 bfd_boolean result
= TRUE
;
769 /* Process SHF_LINK_ORDER. */
770 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
772 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
773 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
775 unsigned int elfsec
= this_hdr
->sh_link
;
776 /* FIXME: The old Intel compiler and old strip/objcopy may
777 not set the sh_link or sh_info fields. Hence we could
778 get the situation where elfsec is 0. */
781 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
782 if (bed
->link_order_error_handler
)
783 bed
->link_order_error_handler
784 (_("%B: warning: sh_link not set for section `%A'"),
789 asection
*linksec
= NULL
;
791 if (elfsec
< elf_numsections (abfd
))
793 this_hdr
= elf_elfsections (abfd
)[elfsec
];
794 linksec
= this_hdr
->bfd_section
;
798 Some strip/objcopy may leave an incorrect value in
799 sh_link. We don't want to proceed. */
802 (*_bfd_error_handler
)
803 (_("%B: sh_link [%d] in section `%A' is incorrect"),
804 s
->owner
, s
, elfsec
);
808 elf_linked_to_section (s
) = linksec
;
813 /* Process section groups. */
814 if (num_group
== (unsigned) -1)
817 for (i
= 0; i
< num_group
; i
++)
819 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
820 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
821 unsigned int n_elt
= shdr
->sh_size
/ 4;
824 if ((++idx
)->shdr
->bfd_section
)
825 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
826 else if (idx
->shdr
->sh_type
== SHT_RELA
827 || idx
->shdr
->sh_type
== SHT_REL
)
828 /* We won't include relocation sections in section groups in
829 output object files. We adjust the group section size here
830 so that relocatable link will work correctly when
831 relocation sections are in section group in input object
833 shdr
->bfd_section
->size
-= 4;
836 /* There are some unknown sections in the group. */
837 (*_bfd_error_handler
)
838 (_("%B: unknown [%d] section `%s' in group [%s]"),
840 (unsigned int) idx
->shdr
->sh_type
,
841 bfd_elf_string_from_elf_section (abfd
,
842 (elf_elfheader (abfd
)
845 shdr
->bfd_section
->name
);
853 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
855 return elf_next_in_group (sec
) != NULL
;
858 /* Make a BFD section from an ELF section. We store a pointer to the
859 BFD section in the bfd_section field of the header. */
862 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
863 Elf_Internal_Shdr
*hdr
,
869 const struct elf_backend_data
*bed
;
871 if (hdr
->bfd_section
!= NULL
)
874 newsect
= bfd_make_section_anyway (abfd
, name
);
878 hdr
->bfd_section
= newsect
;
879 elf_section_data (newsect
)->this_hdr
= *hdr
;
880 elf_section_data (newsect
)->this_idx
= shindex
;
882 /* Always use the real type/flags. */
883 elf_section_type (newsect
) = hdr
->sh_type
;
884 elf_section_flags (newsect
) = hdr
->sh_flags
;
886 newsect
->filepos
= hdr
->sh_offset
;
888 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
889 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
890 || ! bfd_set_section_alignment (abfd
, newsect
,
891 bfd_log2 (hdr
->sh_addralign
)))
894 flags
= SEC_NO_FLAGS
;
895 if (hdr
->sh_type
!= SHT_NOBITS
)
896 flags
|= SEC_HAS_CONTENTS
;
897 if (hdr
->sh_type
== SHT_GROUP
)
898 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
899 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
902 if (hdr
->sh_type
!= SHT_NOBITS
)
905 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
906 flags
|= SEC_READONLY
;
907 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
909 else if ((flags
& SEC_LOAD
) != 0)
911 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
914 newsect
->entsize
= hdr
->sh_entsize
;
915 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
916 flags
|= SEC_STRINGS
;
918 if (hdr
->sh_flags
& SHF_GROUP
)
919 if (!setup_group (abfd
, hdr
, newsect
))
921 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
922 flags
|= SEC_THREAD_LOCAL
;
923 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
924 flags
|= SEC_EXCLUDE
;
926 if ((flags
& SEC_ALLOC
) == 0)
928 /* The debugging sections appear to be recognized only by name,
929 not any sort of flag. Their SEC_ALLOC bits are cleared. */
936 else if (name
[1] == 'g' && name
[2] == 'n')
937 p
= ".gnu.linkonce.wi.", n
= 17;
938 else if (name
[1] == 'g' && name
[2] == 'd')
939 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
940 else if (name
[1] == 'l')
942 else if (name
[1] == 's')
944 else if (name
[1] == 'z')
945 p
= ".zdebug", n
= 7;
948 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
949 flags
|= SEC_DEBUGGING
;
953 /* As a GNU extension, if the name begins with .gnu.linkonce, we
954 only link a single copy of the section. This is used to support
955 g++. g++ will emit each template expansion in its own section.
956 The symbols will be defined as weak, so that multiple definitions
957 are permitted. The GNU linker extension is to actually discard
958 all but one of the sections. */
959 if (CONST_STRNEQ (name
, ".gnu.linkonce")
960 && elf_next_in_group (newsect
) == NULL
)
961 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
963 bed
= get_elf_backend_data (abfd
);
964 if (bed
->elf_backend_section_flags
)
965 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
968 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
971 /* We do not parse the PT_NOTE segments as we are interested even in the
972 separate debug info files which may have the segments offsets corrupted.
973 PT_NOTEs from the core files are currently not parsed using BFD. */
974 if (hdr
->sh_type
== SHT_NOTE
)
978 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
981 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
, -1);
985 if ((flags
& SEC_ALLOC
) != 0)
987 Elf_Internal_Phdr
*phdr
;
988 unsigned int i
, nload
;
990 /* Some ELF linkers produce binaries with all the program header
991 p_paddr fields zero. If we have such a binary with more than
992 one PT_LOAD header, then leave the section lma equal to vma
993 so that we don't create sections with overlapping lma. */
994 phdr
= elf_tdata (abfd
)->phdr
;
995 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
996 if (phdr
->p_paddr
!= 0)
998 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1000 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1003 phdr
= elf_tdata (abfd
)->phdr
;
1004 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1006 if (((phdr
->p_type
== PT_LOAD
1007 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1008 || phdr
->p_type
== PT_TLS
)
1009 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1011 if ((flags
& SEC_LOAD
) == 0)
1012 newsect
->lma
= (phdr
->p_paddr
1013 + hdr
->sh_addr
- phdr
->p_vaddr
);
1015 /* We used to use the same adjustment for SEC_LOAD
1016 sections, but that doesn't work if the segment
1017 is packed with code from multiple VMAs.
1018 Instead we calculate the section LMA based on
1019 the segment LMA. It is assumed that the
1020 segment will contain sections with contiguous
1021 LMAs, even if the VMAs are not. */
1022 newsect
->lma
= (phdr
->p_paddr
1023 + hdr
->sh_offset
- phdr
->p_offset
);
1025 /* With contiguous segments, we can't tell from file
1026 offsets whether a section with zero size should
1027 be placed at the end of one segment or the
1028 beginning of the next. Decide based on vaddr. */
1029 if (hdr
->sh_addr
>= phdr
->p_vaddr
1030 && (hdr
->sh_addr
+ hdr
->sh_size
1031 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1037 /* Compress/decompress DWARF debug sections with names: .debug_* and
1038 .zdebug_*, after the section flags is set. */
1039 if ((flags
& SEC_DEBUGGING
)
1040 && ((name
[1] == 'd' && name
[6] == '_')
1041 || (name
[1] == 'z' && name
[7] == '_')))
1043 enum { nothing
, compress
, decompress
} action
= nothing
;
1046 if (bfd_is_section_compressed (abfd
, newsect
))
1048 /* Compressed section. Check if we should decompress. */
1049 if ((abfd
->flags
& BFD_DECOMPRESS
))
1050 action
= decompress
;
1054 /* Normal section. Check if we should compress. */
1055 if ((abfd
->flags
& BFD_COMPRESS
) && newsect
->size
!= 0)
1065 if (!bfd_init_section_compress_status (abfd
, newsect
))
1067 (*_bfd_error_handler
)
1068 (_("%B: unable to initialize compress status for section %s"),
1074 unsigned int len
= strlen (name
);
1076 new_name
= bfd_alloc (abfd
, len
+ 2);
1077 if (new_name
== NULL
)
1081 memcpy (new_name
+ 2, name
+ 1, len
);
1085 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1087 (*_bfd_error_handler
)
1088 (_("%B: unable to initialize decompress status for section %s"),
1094 unsigned int len
= strlen (name
);
1096 new_name
= bfd_alloc (abfd
, len
);
1097 if (new_name
== NULL
)
1100 memcpy (new_name
+ 1, name
+ 2, len
- 1);
1104 if (new_name
!= NULL
)
1105 bfd_rename_section (abfd
, newsect
, new_name
);
1111 const char *const bfd_elf_section_type_names
[] = {
1112 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1113 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1114 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1117 /* ELF relocs are against symbols. If we are producing relocatable
1118 output, and the reloc is against an external symbol, and nothing
1119 has given us any additional addend, the resulting reloc will also
1120 be against the same symbol. In such a case, we don't want to
1121 change anything about the way the reloc is handled, since it will
1122 all be done at final link time. Rather than put special case code
1123 into bfd_perform_relocation, all the reloc types use this howto
1124 function. It just short circuits the reloc if producing
1125 relocatable output against an external symbol. */
1127 bfd_reloc_status_type
1128 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1129 arelent
*reloc_entry
,
1131 void *data ATTRIBUTE_UNUSED
,
1132 asection
*input_section
,
1134 char **error_message ATTRIBUTE_UNUSED
)
1136 if (output_bfd
!= NULL
1137 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1138 && (! reloc_entry
->howto
->partial_inplace
1139 || reloc_entry
->addend
== 0))
1141 reloc_entry
->address
+= input_section
->output_offset
;
1142 return bfd_reloc_ok
;
1145 return bfd_reloc_continue
;
1148 /* Copy the program header and other data from one object module to
1152 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1154 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1155 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1158 if (!elf_flags_init (obfd
))
1160 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1161 elf_flags_init (obfd
) = TRUE
;
1164 elf_gp (obfd
) = elf_gp (ibfd
);
1166 /* Also copy the EI_OSABI field. */
1167 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1168 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1170 /* Copy object attributes. */
1171 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1176 get_segment_type (unsigned int p_type
)
1181 case PT_NULL
: pt
= "NULL"; break;
1182 case PT_LOAD
: pt
= "LOAD"; break;
1183 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1184 case PT_INTERP
: pt
= "INTERP"; break;
1185 case PT_NOTE
: pt
= "NOTE"; break;
1186 case PT_SHLIB
: pt
= "SHLIB"; break;
1187 case PT_PHDR
: pt
= "PHDR"; break;
1188 case PT_TLS
: pt
= "TLS"; break;
1189 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1190 case PT_GNU_STACK
: pt
= "STACK"; break;
1191 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1192 default: pt
= NULL
; break;
1197 /* Print out the program headers. */
1200 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1202 FILE *f
= (FILE *) farg
;
1203 Elf_Internal_Phdr
*p
;
1205 bfd_byte
*dynbuf
= NULL
;
1207 p
= elf_tdata (abfd
)->phdr
;
1212 fprintf (f
, _("\nProgram Header:\n"));
1213 c
= elf_elfheader (abfd
)->e_phnum
;
1214 for (i
= 0; i
< c
; i
++, p
++)
1216 const char *pt
= get_segment_type (p
->p_type
);
1221 sprintf (buf
, "0x%lx", p
->p_type
);
1224 fprintf (f
, "%8s off 0x", pt
);
1225 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1226 fprintf (f
, " vaddr 0x");
1227 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1228 fprintf (f
, " paddr 0x");
1229 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1230 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1231 fprintf (f
, " filesz 0x");
1232 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1233 fprintf (f
, " memsz 0x");
1234 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1235 fprintf (f
, " flags %c%c%c",
1236 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1237 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1238 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1239 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1240 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1245 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1248 unsigned int elfsec
;
1249 unsigned long shlink
;
1250 bfd_byte
*extdyn
, *extdynend
;
1252 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1254 fprintf (f
, _("\nDynamic Section:\n"));
1256 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1259 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1260 if (elfsec
== SHN_BAD
)
1262 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1264 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1265 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1268 /* PR 17512: file: 6f427532. */
1269 if (s
->size
< extdynsize
)
1271 extdynend
= extdyn
+ s
->size
;
1272 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1274 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1276 Elf_Internal_Dyn dyn
;
1277 const char *name
= "";
1279 bfd_boolean stringp
;
1280 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1282 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1284 if (dyn
.d_tag
== DT_NULL
)
1291 if (bed
->elf_backend_get_target_dtag
)
1292 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1294 if (!strcmp (name
, ""))
1296 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1301 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1302 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1303 case DT_PLTGOT
: name
= "PLTGOT"; break;
1304 case DT_HASH
: name
= "HASH"; break;
1305 case DT_STRTAB
: name
= "STRTAB"; break;
1306 case DT_SYMTAB
: name
= "SYMTAB"; break;
1307 case DT_RELA
: name
= "RELA"; break;
1308 case DT_RELASZ
: name
= "RELASZ"; break;
1309 case DT_RELAENT
: name
= "RELAENT"; break;
1310 case DT_STRSZ
: name
= "STRSZ"; break;
1311 case DT_SYMENT
: name
= "SYMENT"; break;
1312 case DT_INIT
: name
= "INIT"; break;
1313 case DT_FINI
: name
= "FINI"; break;
1314 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1315 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1316 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1317 case DT_REL
: name
= "REL"; break;
1318 case DT_RELSZ
: name
= "RELSZ"; break;
1319 case DT_RELENT
: name
= "RELENT"; break;
1320 case DT_PLTREL
: name
= "PLTREL"; break;
1321 case DT_DEBUG
: name
= "DEBUG"; break;
1322 case DT_TEXTREL
: name
= "TEXTREL"; break;
1323 case DT_JMPREL
: name
= "JMPREL"; break;
1324 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1325 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1326 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1327 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1328 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1329 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1330 case DT_FLAGS
: name
= "FLAGS"; break;
1331 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1332 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1333 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1334 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1335 case DT_MOVEENT
: name
= "MOVEENT"; break;
1336 case DT_MOVESZ
: name
= "MOVESZ"; break;
1337 case DT_FEATURE
: name
= "FEATURE"; break;
1338 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1339 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1340 case DT_SYMINENT
: name
= "SYMINENT"; break;
1341 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1342 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1343 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1344 case DT_PLTPAD
: name
= "PLTPAD"; break;
1345 case DT_MOVETAB
: name
= "MOVETAB"; break;
1346 case DT_SYMINFO
: name
= "SYMINFO"; break;
1347 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1348 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1349 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1350 case DT_VERSYM
: name
= "VERSYM"; break;
1351 case DT_VERDEF
: name
= "VERDEF"; break;
1352 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1353 case DT_VERNEED
: name
= "VERNEED"; break;
1354 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1355 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1356 case DT_USED
: name
= "USED"; break;
1357 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1358 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1361 fprintf (f
, " %-20s ", name
);
1365 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1370 unsigned int tagv
= dyn
.d_un
.d_val
;
1372 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1375 fprintf (f
, "%s", string
);
1384 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1385 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1387 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1391 if (elf_dynverdef (abfd
) != 0)
1393 Elf_Internal_Verdef
*t
;
1395 fprintf (f
, _("\nVersion definitions:\n"));
1396 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1398 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1399 t
->vd_flags
, t
->vd_hash
,
1400 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1401 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1403 Elf_Internal_Verdaux
*a
;
1406 for (a
= t
->vd_auxptr
->vda_nextptr
;
1410 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1416 if (elf_dynverref (abfd
) != 0)
1418 Elf_Internal_Verneed
*t
;
1420 fprintf (f
, _("\nVersion References:\n"));
1421 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1423 Elf_Internal_Vernaux
*a
;
1425 fprintf (f
, _(" required from %s:\n"),
1426 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1427 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1428 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1429 a
->vna_flags
, a
->vna_other
,
1430 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1442 /* Get version string. */
1445 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1446 bfd_boolean
*hidden
)
1448 const char *version_string
= NULL
;
1449 if (elf_dynversym (abfd
) != 0
1450 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1452 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1454 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1455 vernum
&= VERSYM_VERSION
;
1458 version_string
= "";
1459 else if (vernum
== 1)
1460 version_string
= "Base";
1461 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1463 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1466 Elf_Internal_Verneed
*t
;
1468 version_string
= "";
1469 for (t
= elf_tdata (abfd
)->verref
;
1473 Elf_Internal_Vernaux
*a
;
1475 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1477 if (a
->vna_other
== vernum
)
1479 version_string
= a
->vna_nodename
;
1486 return version_string
;
1489 /* Display ELF-specific fields of a symbol. */
1492 bfd_elf_print_symbol (bfd
*abfd
,
1495 bfd_print_symbol_type how
)
1497 FILE *file
= (FILE *) filep
;
1500 case bfd_print_symbol_name
:
1501 fprintf (file
, "%s", symbol
->name
);
1503 case bfd_print_symbol_more
:
1504 fprintf (file
, "elf ");
1505 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1506 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1508 case bfd_print_symbol_all
:
1510 const char *section_name
;
1511 const char *name
= NULL
;
1512 const struct elf_backend_data
*bed
;
1513 unsigned char st_other
;
1515 const char *version_string
;
1518 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1520 bed
= get_elf_backend_data (abfd
);
1521 if (bed
->elf_backend_print_symbol_all
)
1522 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1526 name
= symbol
->name
;
1527 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1530 fprintf (file
, " %s\t", section_name
);
1531 /* Print the "other" value for a symbol. For common symbols,
1532 we've already printed the size; now print the alignment.
1533 For other symbols, we have no specified alignment, and
1534 we've printed the address; now print the size. */
1535 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1536 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1538 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1539 bfd_fprintf_vma (abfd
, file
, val
);
1541 /* If we have version information, print it. */
1542 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1548 fprintf (file
, " %-11s", version_string
);
1553 fprintf (file
, " (%s)", version_string
);
1554 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1559 /* If the st_other field is not zero, print it. */
1560 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1565 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1566 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1567 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1569 /* Some other non-defined flags are also present, so print
1571 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1574 fprintf (file
, " %s", name
);
1580 /* Allocate an ELF string table--force the first byte to be zero. */
1582 struct bfd_strtab_hash
*
1583 _bfd_elf_stringtab_init (void)
1585 struct bfd_strtab_hash
*ret
;
1587 ret
= _bfd_stringtab_init ();
1592 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1593 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1594 if (loc
== (bfd_size_type
) -1)
1596 _bfd_stringtab_free (ret
);
1603 /* ELF .o/exec file reading */
1605 /* Create a new bfd section from an ELF section header. */
1608 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1610 Elf_Internal_Shdr
*hdr
;
1611 Elf_Internal_Ehdr
*ehdr
;
1612 const struct elf_backend_data
*bed
;
1614 bfd_boolean ret
= TRUE
;
1615 static bfd_boolean
* sections_being_created
= NULL
;
1616 static bfd
* sections_being_created_abfd
= NULL
;
1617 static unsigned int nesting
= 0;
1619 if (shindex
>= elf_numsections (abfd
))
1624 /* PR17512: A corrupt ELF binary might contain a recursive group of
1625 sections, with each the string indicies pointing to the next in the
1626 loop. Detect this here, by refusing to load a section that we are
1627 already in the process of loading. We only trigger this test if
1628 we have nested at least three sections deep as normal ELF binaries
1629 can expect to recurse at least once.
1631 FIXME: It would be better if this array was attached to the bfd,
1632 rather than being held in a static pointer. */
1634 if (sections_being_created_abfd
!= abfd
)
1635 sections_being_created
= NULL
;
1636 if (sections_being_created
== NULL
)
1638 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
1639 sections_being_created
= (bfd_boolean
*)
1640 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
1641 sections_being_created_abfd
= abfd
;
1643 if (sections_being_created
[shindex
])
1645 (*_bfd_error_handler
)
1646 (_("%B: warning: loop in section dependencies detected"), abfd
);
1649 sections_being_created
[shindex
] = TRUE
;
1652 hdr
= elf_elfsections (abfd
)[shindex
];
1653 ehdr
= elf_elfheader (abfd
);
1654 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1659 bed
= get_elf_backend_data (abfd
);
1660 switch (hdr
->sh_type
)
1663 /* Inactive section. Throw it away. */
1666 case SHT_PROGBITS
: /* Normal section with contents. */
1667 case SHT_NOBITS
: /* .bss section. */
1668 case SHT_HASH
: /* .hash section. */
1669 case SHT_NOTE
: /* .note section. */
1670 case SHT_INIT_ARRAY
: /* .init_array section. */
1671 case SHT_FINI_ARRAY
: /* .fini_array section. */
1672 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1673 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1674 case SHT_GNU_HASH
: /* .gnu.hash section. */
1675 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1678 case SHT_DYNAMIC
: /* Dynamic linking information. */
1679 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1682 if (hdr
->sh_link
> elf_numsections (abfd
))
1684 /* PR 10478: Accept Solaris binaries with a sh_link
1685 field set to SHN_BEFORE or SHN_AFTER. */
1686 switch (bfd_get_arch (abfd
))
1689 case bfd_arch_sparc
:
1690 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
1691 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
1693 /* Otherwise fall through. */
1698 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1700 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1702 Elf_Internal_Shdr
*dynsymhdr
;
1704 /* The shared libraries distributed with hpux11 have a bogus
1705 sh_link field for the ".dynamic" section. Find the
1706 string table for the ".dynsym" section instead. */
1707 if (elf_dynsymtab (abfd
) != 0)
1709 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1710 hdr
->sh_link
= dynsymhdr
->sh_link
;
1714 unsigned int i
, num_sec
;
1716 num_sec
= elf_numsections (abfd
);
1717 for (i
= 1; i
< num_sec
; i
++)
1719 dynsymhdr
= elf_elfsections (abfd
)[i
];
1720 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1722 hdr
->sh_link
= dynsymhdr
->sh_link
;
1730 case SHT_SYMTAB
: /* A symbol table. */
1731 if (elf_onesymtab (abfd
) == shindex
)
1734 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1737 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1739 if (hdr
->sh_size
!= 0)
1741 /* Some assemblers erroneously set sh_info to one with a
1742 zero sh_size. ld sees this as a global symbol count
1743 of (unsigned) -1. Fix it here. */
1748 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1749 elf_onesymtab (abfd
) = shindex
;
1750 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1751 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1752 abfd
->flags
|= HAS_SYMS
;
1754 /* Sometimes a shared object will map in the symbol table. If
1755 SHF_ALLOC is set, and this is a shared object, then we also
1756 treat this section as a BFD section. We can not base the
1757 decision purely on SHF_ALLOC, because that flag is sometimes
1758 set in a relocatable object file, which would confuse the
1760 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1761 && (abfd
->flags
& DYNAMIC
) != 0
1762 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1766 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1767 can't read symbols without that section loaded as well. It
1768 is most likely specified by the next section header. */
1769 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1771 unsigned int i
, num_sec
;
1773 num_sec
= elf_numsections (abfd
);
1774 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1776 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1777 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1778 && hdr2
->sh_link
== shindex
)
1782 for (i
= 1; i
< shindex
; i
++)
1784 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1785 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1786 && hdr2
->sh_link
== shindex
)
1790 ret
= bfd_section_from_shdr (abfd
, i
);
1794 case SHT_DYNSYM
: /* A dynamic symbol table. */
1795 if (elf_dynsymtab (abfd
) == shindex
)
1798 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1801 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1803 if (hdr
->sh_size
!= 0)
1806 /* Some linkers erroneously set sh_info to one with a
1807 zero sh_size. ld sees this as a global symbol count
1808 of (unsigned) -1. Fix it here. */
1813 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1814 elf_dynsymtab (abfd
) = shindex
;
1815 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1816 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1817 abfd
->flags
|= HAS_SYMS
;
1819 /* Besides being a symbol table, we also treat this as a regular
1820 section, so that objcopy can handle it. */
1821 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1824 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
1825 if (elf_symtab_shndx (abfd
) == shindex
)
1828 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1829 elf_symtab_shndx (abfd
) = shindex
;
1830 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1831 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1834 case SHT_STRTAB
: /* A string table. */
1835 if (hdr
->bfd_section
!= NULL
)
1838 if (ehdr
->e_shstrndx
== shindex
)
1840 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1841 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1845 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1848 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1849 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1853 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1856 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1857 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1858 elf_elfsections (abfd
)[shindex
] = hdr
;
1859 /* We also treat this as a regular section, so that objcopy
1861 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1866 /* If the string table isn't one of the above, then treat it as a
1867 regular section. We need to scan all the headers to be sure,
1868 just in case this strtab section appeared before the above. */
1869 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1871 unsigned int i
, num_sec
;
1873 num_sec
= elf_numsections (abfd
);
1874 for (i
= 1; i
< num_sec
; i
++)
1876 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1877 if (hdr2
->sh_link
== shindex
)
1879 /* Prevent endless recursion on broken objects. */
1882 if (! bfd_section_from_shdr (abfd
, i
))
1884 if (elf_onesymtab (abfd
) == i
)
1886 if (elf_dynsymtab (abfd
) == i
)
1887 goto dynsymtab_strtab
;
1891 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1896 /* *These* do a lot of work -- but build no sections! */
1898 asection
*target_sect
;
1899 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
1900 unsigned int num_sec
= elf_numsections (abfd
);
1901 struct bfd_elf_section_data
*esdt
;
1905 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1906 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1909 /* Check for a bogus link to avoid crashing. */
1910 if (hdr
->sh_link
>= num_sec
)
1912 ((*_bfd_error_handler
)
1913 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1914 abfd
, hdr
->sh_link
, name
, shindex
));
1915 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1920 /* For some incomprehensible reason Oracle distributes
1921 libraries for Solaris in which some of the objects have
1922 bogus sh_link fields. It would be nice if we could just
1923 reject them, but, unfortunately, some people need to use
1924 them. We scan through the section headers; if we find only
1925 one suitable symbol table, we clobber the sh_link to point
1926 to it. I hope this doesn't break anything.
1928 Don't do it on executable nor shared library. */
1929 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
1930 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1931 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1937 for (scan
= 1; scan
< num_sec
; scan
++)
1939 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1940 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1951 hdr
->sh_link
= found
;
1954 /* Get the symbol table. */
1955 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1956 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1957 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1960 /* If this reloc section does not use the main symbol table we
1961 don't treat it as a reloc section. BFD can't adequately
1962 represent such a section, so at least for now, we don't
1963 try. We just present it as a normal section. We also
1964 can't use it as a reloc section if it points to the null
1965 section, an invalid section, another reloc section, or its
1966 sh_link points to the null section. */
1967 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1968 || hdr
->sh_link
== SHN_UNDEF
1969 || hdr
->sh_info
== SHN_UNDEF
1970 || hdr
->sh_info
>= num_sec
1971 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1972 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1974 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1979 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1982 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1983 if (target_sect
== NULL
)
1986 esdt
= elf_section_data (target_sect
);
1987 if (hdr
->sh_type
== SHT_RELA
)
1988 p_hdr
= &esdt
->rela
.hdr
;
1990 p_hdr
= &esdt
->rel
.hdr
;
1992 /* PR 17512: file: 0b4f81b7. */
1995 amt
= sizeof (*hdr2
);
1996 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2001 elf_elfsections (abfd
)[shindex
] = hdr2
;
2002 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2003 target_sect
->flags
|= SEC_RELOC
;
2004 target_sect
->relocation
= NULL
;
2005 target_sect
->rel_filepos
= hdr
->sh_offset
;
2006 /* In the section to which the relocations apply, mark whether
2007 its relocations are of the REL or RELA variety. */
2008 if (hdr
->sh_size
!= 0)
2010 if (hdr
->sh_type
== SHT_RELA
)
2011 target_sect
->use_rela_p
= 1;
2013 abfd
->flags
|= HAS_RELOC
;
2017 case SHT_GNU_verdef
:
2018 elf_dynverdef (abfd
) = shindex
;
2019 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2020 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2023 case SHT_GNU_versym
:
2024 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2027 elf_dynversym (abfd
) = shindex
;
2028 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2029 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2032 case SHT_GNU_verneed
:
2033 elf_dynverref (abfd
) = shindex
;
2034 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2035 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2042 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2045 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2048 if (hdr
->contents
!= NULL
)
2050 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2051 unsigned int n_elt
= hdr
->sh_size
/ sizeof (* idx
);
2056 if (idx
->flags
& GRP_COMDAT
)
2057 hdr
->bfd_section
->flags
2058 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2060 /* We try to keep the same section order as it comes in. */
2063 while (--n_elt
!= 0)
2067 if (idx
->shdr
!= NULL
2068 && (s
= idx
->shdr
->bfd_section
) != NULL
2069 && elf_next_in_group (s
) != NULL
)
2071 elf_next_in_group (hdr
->bfd_section
) = s
;
2079 /* Possibly an attributes section. */
2080 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2081 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2083 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2085 _bfd_elf_parse_attributes (abfd
, hdr
);
2089 /* Check for any processor-specific section types. */
2090 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2093 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2095 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2096 /* FIXME: How to properly handle allocated section reserved
2097 for applications? */
2098 (*_bfd_error_handler
)
2099 (_("%B: don't know how to handle allocated, application "
2100 "specific section `%s' [0x%8x]"),
2101 abfd
, name
, hdr
->sh_type
);
2104 /* Allow sections reserved for applications. */
2105 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2110 else if (hdr
->sh_type
>= SHT_LOPROC
2111 && hdr
->sh_type
<= SHT_HIPROC
)
2112 /* FIXME: We should handle this section. */
2113 (*_bfd_error_handler
)
2114 (_("%B: don't know how to handle processor specific section "
2116 abfd
, name
, hdr
->sh_type
);
2117 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2119 /* Unrecognised OS-specific sections. */
2120 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2121 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2122 required to correctly process the section and the file should
2123 be rejected with an error message. */
2124 (*_bfd_error_handler
)
2125 (_("%B: don't know how to handle OS specific section "
2127 abfd
, name
, hdr
->sh_type
);
2130 /* Otherwise it should be processed. */
2131 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2136 /* FIXME: We should handle this section. */
2137 (*_bfd_error_handler
)
2138 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2139 abfd
, name
, hdr
->sh_type
);
2147 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2148 sections_being_created
[shindex
] = FALSE
;
2149 if (-- nesting
== 0)
2151 sections_being_created
= NULL
;
2152 sections_being_created_abfd
= abfd
;
2157 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2160 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2162 unsigned long r_symndx
)
2164 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2166 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2168 Elf_Internal_Shdr
*symtab_hdr
;
2169 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2170 Elf_External_Sym_Shndx eshndx
;
2172 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2173 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2174 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2177 if (cache
->abfd
!= abfd
)
2179 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2182 cache
->indx
[ent
] = r_symndx
;
2185 return &cache
->sym
[ent
];
2188 /* Given an ELF section number, retrieve the corresponding BFD
2192 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2194 if (sec_index
>= elf_numsections (abfd
))
2196 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2199 static const struct bfd_elf_special_section special_sections_b
[] =
2201 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2202 { NULL
, 0, 0, 0, 0 }
2205 static const struct bfd_elf_special_section special_sections_c
[] =
2207 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2208 { NULL
, 0, 0, 0, 0 }
2211 static const struct bfd_elf_special_section special_sections_d
[] =
2213 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2214 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2215 /* There are more DWARF sections than these, but they needn't be added here
2216 unless you have to cope with broken compilers that don't emit section
2217 attributes or you want to help the user writing assembler. */
2218 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2219 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2220 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2221 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2222 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2223 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2224 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2225 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2226 { NULL
, 0, 0, 0, 0 }
2229 static const struct bfd_elf_special_section special_sections_f
[] =
2231 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2232 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2233 { NULL
, 0, 0, 0, 0 }
2236 static const struct bfd_elf_special_section special_sections_g
[] =
2238 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2239 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2240 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2241 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2242 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2243 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2244 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2245 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2246 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2247 { NULL
, 0, 0, 0, 0 }
2250 static const struct bfd_elf_special_section special_sections_h
[] =
2252 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2253 { NULL
, 0, 0, 0, 0 }
2256 static const struct bfd_elf_special_section special_sections_i
[] =
2258 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2259 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2260 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2261 { NULL
, 0, 0, 0, 0 }
2264 static const struct bfd_elf_special_section special_sections_l
[] =
2266 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2267 { NULL
, 0, 0, 0, 0 }
2270 static const struct bfd_elf_special_section special_sections_n
[] =
2272 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2273 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2274 { NULL
, 0, 0, 0, 0 }
2277 static const struct bfd_elf_special_section special_sections_p
[] =
2279 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2280 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2281 { NULL
, 0, 0, 0, 0 }
2284 static const struct bfd_elf_special_section special_sections_r
[] =
2286 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2287 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2288 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2289 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2290 { NULL
, 0, 0, 0, 0 }
2293 static const struct bfd_elf_special_section special_sections_s
[] =
2295 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2296 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2297 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2298 /* See struct bfd_elf_special_section declaration for the semantics of
2299 this special case where .prefix_length != strlen (.prefix). */
2300 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2301 { NULL
, 0, 0, 0, 0 }
2304 static const struct bfd_elf_special_section special_sections_t
[] =
2306 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2307 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2308 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2309 { NULL
, 0, 0, 0, 0 }
2312 static const struct bfd_elf_special_section special_sections_z
[] =
2314 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2315 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2316 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2317 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2318 { NULL
, 0, 0, 0, 0 }
2321 static const struct bfd_elf_special_section
* const special_sections
[] =
2323 special_sections_b
, /* 'b' */
2324 special_sections_c
, /* 'c' */
2325 special_sections_d
, /* 'd' */
2327 special_sections_f
, /* 'f' */
2328 special_sections_g
, /* 'g' */
2329 special_sections_h
, /* 'h' */
2330 special_sections_i
, /* 'i' */
2333 special_sections_l
, /* 'l' */
2335 special_sections_n
, /* 'n' */
2337 special_sections_p
, /* 'p' */
2339 special_sections_r
, /* 'r' */
2340 special_sections_s
, /* 's' */
2341 special_sections_t
, /* 't' */
2347 special_sections_z
/* 'z' */
2350 const struct bfd_elf_special_section
*
2351 _bfd_elf_get_special_section (const char *name
,
2352 const struct bfd_elf_special_section
*spec
,
2358 len
= strlen (name
);
2360 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2363 int prefix_len
= spec
[i
].prefix_length
;
2365 if (len
< prefix_len
)
2367 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2370 suffix_len
= spec
[i
].suffix_length
;
2371 if (suffix_len
<= 0)
2373 if (name
[prefix_len
] != 0)
2375 if (suffix_len
== 0)
2377 if (name
[prefix_len
] != '.'
2378 && (suffix_len
== -2
2379 || (rela
&& spec
[i
].type
== SHT_REL
)))
2385 if (len
< prefix_len
+ suffix_len
)
2387 if (memcmp (name
+ len
- suffix_len
,
2388 spec
[i
].prefix
+ prefix_len
,
2398 const struct bfd_elf_special_section
*
2399 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2402 const struct bfd_elf_special_section
*spec
;
2403 const struct elf_backend_data
*bed
;
2405 /* See if this is one of the special sections. */
2406 if (sec
->name
== NULL
)
2409 bed
= get_elf_backend_data (abfd
);
2410 spec
= bed
->special_sections
;
2413 spec
= _bfd_elf_get_special_section (sec
->name
,
2414 bed
->special_sections
,
2420 if (sec
->name
[0] != '.')
2423 i
= sec
->name
[1] - 'b';
2424 if (i
< 0 || i
> 'z' - 'b')
2427 spec
= special_sections
[i
];
2432 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2436 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2438 struct bfd_elf_section_data
*sdata
;
2439 const struct elf_backend_data
*bed
;
2440 const struct bfd_elf_special_section
*ssect
;
2442 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2445 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2449 sec
->used_by_bfd
= sdata
;
2452 /* Indicate whether or not this section should use RELA relocations. */
2453 bed
= get_elf_backend_data (abfd
);
2454 sec
->use_rela_p
= bed
->default_use_rela_p
;
2456 /* When we read a file, we don't need to set ELF section type and
2457 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2458 anyway. We will set ELF section type and flags for all linker
2459 created sections. If user specifies BFD section flags, we will
2460 set ELF section type and flags based on BFD section flags in
2461 elf_fake_sections. Special handling for .init_array/.fini_array
2462 output sections since they may contain .ctors/.dtors input
2463 sections. We don't want _bfd_elf_init_private_section_data to
2464 copy ELF section type from .ctors/.dtors input sections. */
2465 if (abfd
->direction
!= read_direction
2466 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2468 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2471 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2472 || ssect
->type
== SHT_INIT_ARRAY
2473 || ssect
->type
== SHT_FINI_ARRAY
))
2475 elf_section_type (sec
) = ssect
->type
;
2476 elf_section_flags (sec
) = ssect
->attr
;
2480 return _bfd_generic_new_section_hook (abfd
, sec
);
2483 /* Create a new bfd section from an ELF program header.
2485 Since program segments have no names, we generate a synthetic name
2486 of the form segment<NUM>, where NUM is generally the index in the
2487 program header table. For segments that are split (see below) we
2488 generate the names segment<NUM>a and segment<NUM>b.
2490 Note that some program segments may have a file size that is different than
2491 (less than) the memory size. All this means is that at execution the
2492 system must allocate the amount of memory specified by the memory size,
2493 but only initialize it with the first "file size" bytes read from the
2494 file. This would occur for example, with program segments consisting
2495 of combined data+bss.
2497 To handle the above situation, this routine generates TWO bfd sections
2498 for the single program segment. The first has the length specified by
2499 the file size of the segment, and the second has the length specified
2500 by the difference between the two sizes. In effect, the segment is split
2501 into its initialized and uninitialized parts.
2506 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2507 Elf_Internal_Phdr
*hdr
,
2509 const char *type_name
)
2517 split
= ((hdr
->p_memsz
> 0)
2518 && (hdr
->p_filesz
> 0)
2519 && (hdr
->p_memsz
> hdr
->p_filesz
));
2521 if (hdr
->p_filesz
> 0)
2523 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2524 len
= strlen (namebuf
) + 1;
2525 name
= (char *) bfd_alloc (abfd
, len
);
2528 memcpy (name
, namebuf
, len
);
2529 newsect
= bfd_make_section (abfd
, name
);
2530 if (newsect
== NULL
)
2532 newsect
->vma
= hdr
->p_vaddr
;
2533 newsect
->lma
= hdr
->p_paddr
;
2534 newsect
->size
= hdr
->p_filesz
;
2535 newsect
->filepos
= hdr
->p_offset
;
2536 newsect
->flags
|= SEC_HAS_CONTENTS
;
2537 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2538 if (hdr
->p_type
== PT_LOAD
)
2540 newsect
->flags
|= SEC_ALLOC
;
2541 newsect
->flags
|= SEC_LOAD
;
2542 if (hdr
->p_flags
& PF_X
)
2544 /* FIXME: all we known is that it has execute PERMISSION,
2546 newsect
->flags
|= SEC_CODE
;
2549 if (!(hdr
->p_flags
& PF_W
))
2551 newsect
->flags
|= SEC_READONLY
;
2555 if (hdr
->p_memsz
> hdr
->p_filesz
)
2559 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2560 len
= strlen (namebuf
) + 1;
2561 name
= (char *) bfd_alloc (abfd
, len
);
2564 memcpy (name
, namebuf
, len
);
2565 newsect
= bfd_make_section (abfd
, name
);
2566 if (newsect
== NULL
)
2568 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2569 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2570 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2571 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2572 align
= newsect
->vma
& -newsect
->vma
;
2573 if (align
== 0 || align
> hdr
->p_align
)
2574 align
= hdr
->p_align
;
2575 newsect
->alignment_power
= bfd_log2 (align
);
2576 if (hdr
->p_type
== PT_LOAD
)
2578 /* Hack for gdb. Segments that have not been modified do
2579 not have their contents written to a core file, on the
2580 assumption that a debugger can find the contents in the
2581 executable. We flag this case by setting the fake
2582 section size to zero. Note that "real" bss sections will
2583 always have their contents dumped to the core file. */
2584 if (bfd_get_format (abfd
) == bfd_core
)
2586 newsect
->flags
|= SEC_ALLOC
;
2587 if (hdr
->p_flags
& PF_X
)
2588 newsect
->flags
|= SEC_CODE
;
2590 if (!(hdr
->p_flags
& PF_W
))
2591 newsect
->flags
|= SEC_READONLY
;
2598 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2600 const struct elf_backend_data
*bed
;
2602 switch (hdr
->p_type
)
2605 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2608 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2611 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2614 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2617 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2619 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2624 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2627 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2629 case PT_GNU_EH_FRAME
:
2630 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2634 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
2637 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
2640 /* Check for any processor-specific program segment types. */
2641 bed
= get_elf_backend_data (abfd
);
2642 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
2646 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2650 _bfd_elf_single_rel_hdr (asection
*sec
)
2652 if (elf_section_data (sec
)->rel
.hdr
)
2654 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
2655 return elf_section_data (sec
)->rel
.hdr
;
2658 return elf_section_data (sec
)->rela
.hdr
;
2661 /* Allocate and initialize a section-header for a new reloc section,
2662 containing relocations against ASECT. It is stored in RELDATA. If
2663 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2667 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2668 struct bfd_elf_section_reloc_data
*reldata
,
2670 bfd_boolean use_rela_p
)
2672 Elf_Internal_Shdr
*rel_hdr
;
2674 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2677 amt
= sizeof (Elf_Internal_Shdr
);
2678 BFD_ASSERT (reldata
->hdr
== NULL
);
2679 rel_hdr
= bfd_zalloc (abfd
, amt
);
2680 reldata
->hdr
= rel_hdr
;
2682 amt
= sizeof ".rela" + strlen (asect
->name
);
2683 name
= (char *) bfd_alloc (abfd
, amt
);
2686 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2688 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2690 if (rel_hdr
->sh_name
== (unsigned int) -1)
2692 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2693 rel_hdr
->sh_entsize
= (use_rela_p
2694 ? bed
->s
->sizeof_rela
2695 : bed
->s
->sizeof_rel
);
2696 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2697 rel_hdr
->sh_flags
= 0;
2698 rel_hdr
->sh_addr
= 0;
2699 rel_hdr
->sh_size
= 0;
2700 rel_hdr
->sh_offset
= 0;
2705 /* Return the default section type based on the passed in section flags. */
2708 bfd_elf_get_default_section_type (flagword flags
)
2710 if ((flags
& SEC_ALLOC
) != 0
2711 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2713 return SHT_PROGBITS
;
2716 struct fake_section_arg
2718 struct bfd_link_info
*link_info
;
2722 /* Set up an ELF internal section header for a section. */
2725 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
2727 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
2728 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2729 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
2730 Elf_Internal_Shdr
*this_hdr
;
2731 unsigned int sh_type
;
2735 /* We already failed; just get out of the bfd_map_over_sections
2740 this_hdr
= &esd
->this_hdr
;
2742 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2743 asect
->name
, FALSE
);
2744 if (this_hdr
->sh_name
== (unsigned int) -1)
2750 /* Don't clear sh_flags. Assembler may set additional bits. */
2752 if ((asect
->flags
& SEC_ALLOC
) != 0
2753 || asect
->user_set_vma
)
2754 this_hdr
->sh_addr
= asect
->vma
;
2756 this_hdr
->sh_addr
= 0;
2758 this_hdr
->sh_offset
= 0;
2759 this_hdr
->sh_size
= asect
->size
;
2760 this_hdr
->sh_link
= 0;
2761 /* PR 17512: file: 0eb809fe, 8b0535ee. */
2762 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
2764 (*_bfd_error_handler
)
2765 (_("%B: error: Alignment power %d of section `%A' is too big"),
2766 abfd
, asect
, asect
->alignment_power
);
2770 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2771 /* The sh_entsize and sh_info fields may have been set already by
2772 copy_private_section_data. */
2774 this_hdr
->bfd_section
= asect
;
2775 this_hdr
->contents
= NULL
;
2777 /* If the section type is unspecified, we set it based on
2779 if ((asect
->flags
& SEC_GROUP
) != 0)
2780 sh_type
= SHT_GROUP
;
2782 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
2784 if (this_hdr
->sh_type
== SHT_NULL
)
2785 this_hdr
->sh_type
= sh_type
;
2786 else if (this_hdr
->sh_type
== SHT_NOBITS
2787 && sh_type
== SHT_PROGBITS
2788 && (asect
->flags
& SEC_ALLOC
) != 0)
2790 /* Warn if we are changing a NOBITS section to PROGBITS, but
2791 allow the link to proceed. This can happen when users link
2792 non-bss input sections to bss output sections, or emit data
2793 to a bss output section via a linker script. */
2794 (*_bfd_error_handler
)
2795 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2796 this_hdr
->sh_type
= sh_type
;
2799 switch (this_hdr
->sh_type
)
2805 case SHT_INIT_ARRAY
:
2806 case SHT_FINI_ARRAY
:
2807 case SHT_PREINIT_ARRAY
:
2814 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2818 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2822 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2826 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2827 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2831 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2832 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2835 case SHT_GNU_versym
:
2836 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2839 case SHT_GNU_verdef
:
2840 this_hdr
->sh_entsize
= 0;
2841 /* objcopy or strip will copy over sh_info, but may not set
2842 cverdefs. The linker will set cverdefs, but sh_info will be
2844 if (this_hdr
->sh_info
== 0)
2845 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2847 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2848 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2851 case SHT_GNU_verneed
:
2852 this_hdr
->sh_entsize
= 0;
2853 /* objcopy or strip will copy over sh_info, but may not set
2854 cverrefs. The linker will set cverrefs, but sh_info will be
2856 if (this_hdr
->sh_info
== 0)
2857 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2859 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2860 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2864 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2868 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2872 if ((asect
->flags
& SEC_ALLOC
) != 0)
2873 this_hdr
->sh_flags
|= SHF_ALLOC
;
2874 if ((asect
->flags
& SEC_READONLY
) == 0)
2875 this_hdr
->sh_flags
|= SHF_WRITE
;
2876 if ((asect
->flags
& SEC_CODE
) != 0)
2877 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2878 if ((asect
->flags
& SEC_MERGE
) != 0)
2880 this_hdr
->sh_flags
|= SHF_MERGE
;
2881 this_hdr
->sh_entsize
= asect
->entsize
;
2882 if ((asect
->flags
& SEC_STRINGS
) != 0)
2883 this_hdr
->sh_flags
|= SHF_STRINGS
;
2885 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2886 this_hdr
->sh_flags
|= SHF_GROUP
;
2887 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2889 this_hdr
->sh_flags
|= SHF_TLS
;
2890 if (asect
->size
== 0
2891 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2893 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2895 this_hdr
->sh_size
= 0;
2898 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2899 if (this_hdr
->sh_size
!= 0)
2900 this_hdr
->sh_type
= SHT_NOBITS
;
2904 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2905 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
2907 /* If the section has relocs, set up a section header for the
2908 SHT_REL[A] section. If two relocation sections are required for
2909 this section, it is up to the processor-specific back-end to
2910 create the other. */
2911 if ((asect
->flags
& SEC_RELOC
) != 0)
2913 /* When doing a relocatable link, create both REL and RELA sections if
2916 /* Do the normal setup if we wouldn't create any sections here. */
2917 && esd
->rel
.count
+ esd
->rela
.count
> 0
2918 && (arg
->link_info
->relocatable
|| arg
->link_info
->emitrelocations
))
2920 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
2921 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, asect
, FALSE
))
2926 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
2927 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, asect
, TRUE
))
2933 else if (!_bfd_elf_init_reloc_shdr (abfd
,
2935 ? &esd
->rela
: &esd
->rel
),
2941 /* Check for processor-specific section types. */
2942 sh_type
= this_hdr
->sh_type
;
2943 if (bed
->elf_backend_fake_sections
2944 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2947 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2949 /* Don't change the header type from NOBITS if we are being
2950 called for objcopy --only-keep-debug. */
2951 this_hdr
->sh_type
= sh_type
;
2955 /* Fill in the contents of a SHT_GROUP section. Called from
2956 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2957 when ELF targets use the generic linker, ld. Called for ld -r
2958 from bfd_elf_final_link. */
2961 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2963 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2964 asection
*elt
, *first
;
2968 /* Ignore linker created group section. See elfNN_ia64_object_p in
2970 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2974 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
2976 unsigned long symindx
= 0;
2978 /* elf_group_id will have been set up by objcopy and the
2980 if (elf_group_id (sec
) != NULL
)
2981 symindx
= elf_group_id (sec
)->udata
.i
;
2985 /* If called from the assembler, swap_out_syms will have set up
2986 elf_section_syms. */
2987 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
2988 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2990 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2992 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
2994 /* The ELF backend linker sets sh_info to -2 when the group
2995 signature symbol is global, and thus the index can't be
2996 set until all local symbols are output. */
2997 asection
*igroup
= elf_sec_group (elf_next_in_group (sec
));
2998 struct bfd_elf_section_data
*sec_data
= elf_section_data (igroup
);
2999 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
3000 unsigned long extsymoff
= 0;
3001 struct elf_link_hash_entry
*h
;
3003 if (!elf_bad_symtab (igroup
->owner
))
3005 Elf_Internal_Shdr
*symtab_hdr
;
3007 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3008 extsymoff
= symtab_hdr
->sh_info
;
3010 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3011 while (h
->root
.type
== bfd_link_hash_indirect
3012 || h
->root
.type
== bfd_link_hash_warning
)
3013 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3015 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3018 /* The contents won't be allocated for "ld -r" or objcopy. */
3020 if (sec
->contents
== NULL
)
3023 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3025 /* Arrange for the section to be written out. */
3026 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3027 if (sec
->contents
== NULL
)
3034 loc
= sec
->contents
+ sec
->size
;
3036 /* Get the pointer to the first section in the group that gas
3037 squirreled away here. objcopy arranges for this to be set to the
3038 start of the input section group. */
3039 first
= elt
= elf_next_in_group (sec
);
3041 /* First element is a flag word. Rest of section is elf section
3042 indices for all the sections of the group. Write them backwards
3043 just to keep the group in the same order as given in .section
3044 directives, not that it matters. */
3051 s
= s
->output_section
;
3053 && !bfd_is_abs_section (s
))
3055 unsigned int idx
= elf_section_data (s
)->this_idx
;
3058 H_PUT_32 (abfd
, idx
, loc
);
3060 elt
= elf_next_in_group (elt
);
3065 if ((loc
-= 4) != sec
->contents
)
3068 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3071 /* Assign all ELF section numbers. The dummy first section is handled here
3072 too. The link/info pointers for the standard section types are filled
3073 in here too, while we're at it. */
3076 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3078 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3080 unsigned int section_number
, secn
;
3081 Elf_Internal_Shdr
**i_shdrp
;
3082 struct bfd_elf_section_data
*d
;
3083 bfd_boolean need_symtab
;
3087 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3089 /* SHT_GROUP sections are in relocatable files only. */
3090 if (link_info
== NULL
|| link_info
->relocatable
)
3092 /* Put SHT_GROUP sections first. */
3093 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3095 d
= elf_section_data (sec
);
3097 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3099 if (sec
->flags
& SEC_LINKER_CREATED
)
3101 /* Remove the linker created SHT_GROUP sections. */
3102 bfd_section_list_remove (abfd
, sec
);
3103 abfd
->section_count
--;
3106 d
->this_idx
= section_number
++;
3111 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3113 d
= elf_section_data (sec
);
3115 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3116 d
->this_idx
= section_number
++;
3117 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3120 d
->rel
.idx
= section_number
++;
3121 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3128 d
->rela
.idx
= section_number
++;
3129 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3135 elf_shstrtab_sec (abfd
) = section_number
++;
3136 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3137 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3139 need_symtab
= (bfd_get_symcount (abfd
) > 0
3140 || (link_info
== NULL
3141 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3145 elf_onesymtab (abfd
) = section_number
++;
3146 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3147 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3149 elf_symtab_shndx (abfd
) = section_number
++;
3150 t
->symtab_shndx_hdr
.sh_name
3151 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3152 ".symtab_shndx", FALSE
);
3153 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
3156 elf_strtab_sec (abfd
) = section_number
++;
3157 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3160 if (section_number
>= SHN_LORESERVE
)
3162 _bfd_error_handler (_("%B: too many sections: %u"),
3163 abfd
, section_number
);
3167 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
3168 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3170 elf_numsections (abfd
) = section_number
;
3171 elf_elfheader (abfd
)->e_shnum
= section_number
;
3173 /* Set up the list of section header pointers, in agreement with the
3175 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3176 sizeof (Elf_Internal_Shdr
*));
3177 if (i_shdrp
== NULL
)
3180 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3181 sizeof (Elf_Internal_Shdr
));
3182 if (i_shdrp
[0] == NULL
)
3184 bfd_release (abfd
, i_shdrp
);
3188 elf_elfsections (abfd
) = i_shdrp
;
3190 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3193 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3194 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3196 i_shdrp
[elf_symtab_shndx (abfd
)] = &t
->symtab_shndx_hdr
;
3197 t
->symtab_shndx_hdr
.sh_link
= elf_onesymtab (abfd
);
3199 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3200 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3203 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3208 d
= elf_section_data (sec
);
3210 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3211 if (d
->rel
.idx
!= 0)
3212 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3213 if (d
->rela
.idx
!= 0)
3214 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3216 /* Fill in the sh_link and sh_info fields while we're at it. */
3218 /* sh_link of a reloc section is the section index of the symbol
3219 table. sh_info is the section index of the section to which
3220 the relocation entries apply. */
3221 if (d
->rel
.idx
!= 0)
3223 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3224 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3225 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3227 if (d
->rela
.idx
!= 0)
3229 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3230 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3231 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3234 /* We need to set up sh_link for SHF_LINK_ORDER. */
3235 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3237 s
= elf_linked_to_section (sec
);
3240 /* elf_linked_to_section points to the input section. */
3241 if (link_info
!= NULL
)
3243 /* Check discarded linkonce section. */
3244 if (discarded_section (s
))
3247 (*_bfd_error_handler
)
3248 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3249 abfd
, d
->this_hdr
.bfd_section
,
3251 /* Point to the kept section if it has the same
3252 size as the discarded one. */
3253 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3256 bfd_set_error (bfd_error_bad_value
);
3262 s
= s
->output_section
;
3263 BFD_ASSERT (s
!= NULL
);
3267 /* Handle objcopy. */
3268 if (s
->output_section
== NULL
)
3270 (*_bfd_error_handler
)
3271 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3272 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3273 bfd_set_error (bfd_error_bad_value
);
3276 s
= s
->output_section
;
3278 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3283 The Intel C compiler generates SHT_IA_64_UNWIND with
3284 SHF_LINK_ORDER. But it doesn't set the sh_link or
3285 sh_info fields. Hence we could get the situation
3287 const struct elf_backend_data
*bed
3288 = get_elf_backend_data (abfd
);
3289 if (bed
->link_order_error_handler
)
3290 bed
->link_order_error_handler
3291 (_("%B: warning: sh_link not set for section `%A'"),
3296 switch (d
->this_hdr
.sh_type
)
3300 /* A reloc section which we are treating as a normal BFD
3301 section. sh_link is the section index of the symbol
3302 table. sh_info is the section index of the section to
3303 which the relocation entries apply. We assume that an
3304 allocated reloc section uses the dynamic symbol table.
3305 FIXME: How can we be sure? */
3306 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3308 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3310 /* We look up the section the relocs apply to by name. */
3312 if (d
->this_hdr
.sh_type
== SHT_REL
)
3316 s
= bfd_get_section_by_name (abfd
, name
);
3319 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3320 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3325 /* We assume that a section named .stab*str is a stabs
3326 string section. We look for a section with the same name
3327 but without the trailing ``str'', and set its sh_link
3328 field to point to this section. */
3329 if (CONST_STRNEQ (sec
->name
, ".stab")
3330 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3335 len
= strlen (sec
->name
);
3336 alc
= (char *) bfd_malloc (len
- 2);
3339 memcpy (alc
, sec
->name
, len
- 3);
3340 alc
[len
- 3] = '\0';
3341 s
= bfd_get_section_by_name (abfd
, alc
);
3345 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3347 /* This is a .stab section. */
3348 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3349 elf_section_data (s
)->this_hdr
.sh_entsize
3350 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3357 case SHT_GNU_verneed
:
3358 case SHT_GNU_verdef
:
3359 /* sh_link is the section header index of the string table
3360 used for the dynamic entries, or the symbol table, or the
3362 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3364 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3367 case SHT_GNU_LIBLIST
:
3368 /* sh_link is the section header index of the prelink library
3369 list used for the dynamic entries, or the symbol table, or
3370 the version strings. */
3371 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3372 ? ".dynstr" : ".gnu.libstr");
3374 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3379 case SHT_GNU_versym
:
3380 /* sh_link is the section header index of the symbol table
3381 this hash table or version table is for. */
3382 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3384 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3388 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3392 for (secn
= 1; secn
< section_number
; ++secn
)
3393 if (i_shdrp
[secn
] == NULL
)
3394 i_shdrp
[secn
] = i_shdrp
[0];
3396 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3397 i_shdrp
[secn
]->sh_name
);
3402 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3404 /* If the backend has a special mapping, use it. */
3405 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3406 if (bed
->elf_backend_sym_is_global
)
3407 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3409 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3410 || bfd_is_und_section (bfd_get_section (sym
))
3411 || bfd_is_com_section (bfd_get_section (sym
)));
3414 /* Don't output section symbols for sections that are not going to be
3415 output, that are duplicates or there is no BFD section. */
3418 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3420 elf_symbol_type
*type_ptr
;
3422 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3425 type_ptr
= elf_symbol_from (abfd
, sym
);
3426 return ((type_ptr
!= NULL
3427 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
3428 && bfd_is_abs_section (sym
->section
))
3429 || !(sym
->section
->owner
== abfd
3430 || (sym
->section
->output_section
->owner
== abfd
3431 && sym
->section
->output_offset
== 0)
3432 || bfd_is_abs_section (sym
->section
)));
3435 /* Map symbol from it's internal number to the external number, moving
3436 all local symbols to be at the head of the list. */
3439 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
3441 unsigned int symcount
= bfd_get_symcount (abfd
);
3442 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3443 asymbol
**sect_syms
;
3444 unsigned int num_locals
= 0;
3445 unsigned int num_globals
= 0;
3446 unsigned int num_locals2
= 0;
3447 unsigned int num_globals2
= 0;
3454 fprintf (stderr
, "elf_map_symbols\n");
3458 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3460 if (max_index
< asect
->index
)
3461 max_index
= asect
->index
;
3465 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3466 if (sect_syms
== NULL
)
3468 elf_section_syms (abfd
) = sect_syms
;
3469 elf_num_section_syms (abfd
) = max_index
;
3471 /* Init sect_syms entries for any section symbols we have already
3472 decided to output. */
3473 for (idx
= 0; idx
< symcount
; idx
++)
3475 asymbol
*sym
= syms
[idx
];
3477 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3479 && !ignore_section_sym (abfd
, sym
)
3480 && !bfd_is_abs_section (sym
->section
))
3482 asection
*sec
= sym
->section
;
3484 if (sec
->owner
!= abfd
)
3485 sec
= sec
->output_section
;
3487 sect_syms
[sec
->index
] = syms
[idx
];
3491 /* Classify all of the symbols. */
3492 for (idx
= 0; idx
< symcount
; idx
++)
3494 if (sym_is_global (abfd
, syms
[idx
]))
3496 else if (!ignore_section_sym (abfd
, syms
[idx
]))
3500 /* We will be adding a section symbol for each normal BFD section. Most
3501 sections will already have a section symbol in outsymbols, but
3502 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3503 at least in that case. */
3504 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3506 if (sect_syms
[asect
->index
] == NULL
)
3508 if (!sym_is_global (abfd
, asect
->symbol
))
3515 /* Now sort the symbols so the local symbols are first. */
3516 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
3517 sizeof (asymbol
*));
3519 if (new_syms
== NULL
)
3522 for (idx
= 0; idx
< symcount
; idx
++)
3524 asymbol
*sym
= syms
[idx
];
3527 if (sym_is_global (abfd
, sym
))
3528 i
= num_locals
+ num_globals2
++;
3529 else if (!ignore_section_sym (abfd
, sym
))
3534 sym
->udata
.i
= i
+ 1;
3536 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3538 if (sect_syms
[asect
->index
] == NULL
)
3540 asymbol
*sym
= asect
->symbol
;
3543 sect_syms
[asect
->index
] = sym
;
3544 if (!sym_is_global (abfd
, sym
))
3547 i
= num_locals
+ num_globals2
++;
3549 sym
->udata
.i
= i
+ 1;
3553 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3555 *pnum_locals
= num_locals
;
3559 /* Align to the maximum file alignment that could be required for any
3560 ELF data structure. */
3562 static inline file_ptr
3563 align_file_position (file_ptr off
, int align
)
3565 return (off
+ align
- 1) & ~(align
- 1);
3568 /* Assign a file position to a section, optionally aligning to the
3569 required section alignment. */
3572 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3576 if (align
&& i_shdrp
->sh_addralign
> 1)
3577 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3578 i_shdrp
->sh_offset
= offset
;
3579 if (i_shdrp
->bfd_section
!= NULL
)
3580 i_shdrp
->bfd_section
->filepos
= offset
;
3581 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3582 offset
+= i_shdrp
->sh_size
;
3586 /* Compute the file positions we are going to put the sections at, and
3587 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3588 is not NULL, this is being called by the ELF backend linker. */
3591 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3592 struct bfd_link_info
*link_info
)
3594 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3595 struct fake_section_arg fsargs
;
3597 struct bfd_strtab_hash
*strtab
= NULL
;
3598 Elf_Internal_Shdr
*shstrtab_hdr
;
3599 bfd_boolean need_symtab
;
3601 if (abfd
->output_has_begun
)
3604 /* Do any elf backend specific processing first. */
3605 if (bed
->elf_backend_begin_write_processing
)
3606 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3608 if (! prep_headers (abfd
))
3611 /* Post process the headers if necessary. */
3612 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3614 fsargs
.failed
= FALSE
;
3615 fsargs
.link_info
= link_info
;
3616 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
3620 if (!assign_section_numbers (abfd
, link_info
))
3623 /* The backend linker builds symbol table information itself. */
3624 need_symtab
= (link_info
== NULL
3625 && (bfd_get_symcount (abfd
) > 0
3626 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3630 /* Non-zero if doing a relocatable link. */
3631 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3633 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3638 if (link_info
== NULL
)
3640 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3645 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3646 /* sh_name was set in prep_headers. */
3647 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3648 shstrtab_hdr
->sh_flags
= 0;
3649 shstrtab_hdr
->sh_addr
= 0;
3650 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3651 shstrtab_hdr
->sh_entsize
= 0;
3652 shstrtab_hdr
->sh_link
= 0;
3653 shstrtab_hdr
->sh_info
= 0;
3654 /* sh_offset is set in assign_file_positions_except_relocs. */
3655 shstrtab_hdr
->sh_addralign
= 1;
3657 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3663 Elf_Internal_Shdr
*hdr
;
3665 off
= elf_next_file_pos (abfd
);
3667 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3668 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3670 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3671 if (hdr
->sh_size
!= 0)
3672 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3674 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3675 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3677 elf_next_file_pos (abfd
) = off
;
3679 /* Now that we know where the .strtab section goes, write it
3681 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3682 || ! _bfd_stringtab_emit (abfd
, strtab
))
3684 _bfd_stringtab_free (strtab
);
3687 abfd
->output_has_begun
= TRUE
;
3692 /* Make an initial estimate of the size of the program header. If we
3693 get the number wrong here, we'll redo section placement. */
3695 static bfd_size_type
3696 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3700 const struct elf_backend_data
*bed
;
3702 /* Assume we will need exactly two PT_LOAD segments: one for text
3703 and one for data. */
3706 s
= bfd_get_section_by_name (abfd
, ".interp");
3707 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3709 /* If we have a loadable interpreter section, we need a
3710 PT_INTERP segment. In this case, assume we also need a
3711 PT_PHDR segment, although that may not be true for all
3716 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3718 /* We need a PT_DYNAMIC segment. */
3722 if (info
!= NULL
&& info
->relro
)
3724 /* We need a PT_GNU_RELRO segment. */
3728 if (elf_eh_frame_hdr (abfd
))
3730 /* We need a PT_GNU_EH_FRAME segment. */
3734 if (elf_stack_flags (abfd
))
3736 /* We need a PT_GNU_STACK segment. */
3740 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3742 if ((s
->flags
& SEC_LOAD
) != 0
3743 && CONST_STRNEQ (s
->name
, ".note"))
3745 /* We need a PT_NOTE segment. */
3747 /* Try to create just one PT_NOTE segment
3748 for all adjacent loadable .note* sections.
3749 gABI requires that within a PT_NOTE segment
3750 (and also inside of each SHT_NOTE section)
3751 each note is padded to a multiple of 4 size,
3752 so we check whether the sections are correctly
3754 if (s
->alignment_power
== 2)
3755 while (s
->next
!= NULL
3756 && s
->next
->alignment_power
== 2
3757 && (s
->next
->flags
& SEC_LOAD
) != 0
3758 && CONST_STRNEQ (s
->next
->name
, ".note"))
3763 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3765 if (s
->flags
& SEC_THREAD_LOCAL
)
3767 /* We need a PT_TLS segment. */
3773 /* Let the backend count up any program headers it might need. */
3774 bed
= get_elf_backend_data (abfd
);
3775 if (bed
->elf_backend_additional_program_headers
)
3779 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3785 return segs
* bed
->s
->sizeof_phdr
;
3788 /* Find the segment that contains the output_section of section. */
3791 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3793 struct elf_segment_map
*m
;
3794 Elf_Internal_Phdr
*p
;
3796 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
3802 for (i
= m
->count
- 1; i
>= 0; i
--)
3803 if (m
->sections
[i
] == section
)
3810 /* Create a mapping from a set of sections to a program segment. */
3812 static struct elf_segment_map
*
3813 make_mapping (bfd
*abfd
,
3814 asection
**sections
,
3819 struct elf_segment_map
*m
;
3824 amt
= sizeof (struct elf_segment_map
);
3825 amt
+= (to
- from
- 1) * sizeof (asection
*);
3826 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3830 m
->p_type
= PT_LOAD
;
3831 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3832 m
->sections
[i
- from
] = *hdrpp
;
3833 m
->count
= to
- from
;
3835 if (from
== 0 && phdr
)
3837 /* Include the headers in the first PT_LOAD segment. */
3838 m
->includes_filehdr
= 1;
3839 m
->includes_phdrs
= 1;
3845 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3848 struct elf_segment_map
*
3849 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3851 struct elf_segment_map
*m
;
3853 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
3854 sizeof (struct elf_segment_map
));
3858 m
->p_type
= PT_DYNAMIC
;
3860 m
->sections
[0] = dynsec
;
3865 /* Possibly add or remove segments from the segment map. */
3868 elf_modify_segment_map (bfd
*abfd
,
3869 struct bfd_link_info
*info
,
3870 bfd_boolean remove_empty_load
)
3872 struct elf_segment_map
**m
;
3873 const struct elf_backend_data
*bed
;
3875 /* The placement algorithm assumes that non allocated sections are
3876 not in PT_LOAD segments. We ensure this here by removing such
3877 sections from the segment map. We also remove excluded
3878 sections. Finally, any PT_LOAD segment without sections is
3880 m
= &elf_seg_map (abfd
);
3883 unsigned int i
, new_count
;
3885 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3887 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3888 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3889 || (*m
)->p_type
!= PT_LOAD
))
3891 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3895 (*m
)->count
= new_count
;
3897 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3903 bed
= get_elf_backend_data (abfd
);
3904 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3906 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3913 /* Set up a mapping from BFD sections to program segments. */
3916 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3919 struct elf_segment_map
*m
;
3920 asection
**sections
= NULL
;
3921 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3922 bfd_boolean no_user_phdrs
;
3924 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
3927 info
->user_phdrs
= !no_user_phdrs
;
3929 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3933 struct elf_segment_map
*mfirst
;
3934 struct elf_segment_map
**pm
;
3937 unsigned int phdr_index
;
3938 bfd_vma maxpagesize
;
3940 bfd_boolean phdr_in_segment
= TRUE
;
3941 bfd_boolean writable
;
3943 asection
*first_tls
= NULL
;
3944 asection
*dynsec
, *eh_frame_hdr
;
3946 bfd_vma addr_mask
, wrap_to
= 0;
3948 /* Select the allocated sections, and sort them. */
3950 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
3951 sizeof (asection
*));
3952 if (sections
== NULL
)
3955 /* Calculate top address, avoiding undefined behaviour of shift
3956 left operator when shift count is equal to size of type
3958 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
3959 addr_mask
= (addr_mask
<< 1) + 1;
3962 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3964 if ((s
->flags
& SEC_ALLOC
) != 0)
3968 /* A wrapping section potentially clashes with header. */
3969 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
3970 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
3973 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3976 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3978 /* Build the mapping. */
3983 /* If we have a .interp section, then create a PT_PHDR segment for
3984 the program headers and a PT_INTERP segment for the .interp
3986 s
= bfd_get_section_by_name (abfd
, ".interp");
3987 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3989 amt
= sizeof (struct elf_segment_map
);
3990 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3994 m
->p_type
= PT_PHDR
;
3995 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3996 m
->p_flags
= PF_R
| PF_X
;
3997 m
->p_flags_valid
= 1;
3998 m
->includes_phdrs
= 1;
4003 amt
= sizeof (struct elf_segment_map
);
4004 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4008 m
->p_type
= PT_INTERP
;
4016 /* Look through the sections. We put sections in the same program
4017 segment when the start of the second section can be placed within
4018 a few bytes of the end of the first section. */
4022 maxpagesize
= bed
->maxpagesize
;
4023 /* PR 17512: file: c8455299.
4024 Avoid divide-by-zero errors later on.
4025 FIXME: Should we abort if the maxpagesize is zero ? */
4026 if (maxpagesize
== 0)
4029 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4031 && (dynsec
->flags
& SEC_LOAD
) == 0)
4034 /* Deal with -Ttext or something similar such that the first section
4035 is not adjacent to the program headers. This is an
4036 approximation, since at this point we don't know exactly how many
4037 program headers we will need. */
4040 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
4042 if (phdr_size
== (bfd_size_type
) -1)
4043 phdr_size
= get_program_header_size (abfd
, info
);
4044 phdr_size
+= bed
->s
->sizeof_ehdr
;
4045 if ((abfd
->flags
& D_PAGED
) == 0
4046 || (sections
[0]->lma
& addr_mask
) < phdr_size
4047 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
4048 < phdr_size
% maxpagesize
)
4049 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
4050 phdr_in_segment
= FALSE
;
4053 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4056 bfd_boolean new_segment
;
4060 /* See if this section and the last one will fit in the same
4063 if (last_hdr
== NULL
)
4065 /* If we don't have a segment yet, then we don't need a new
4066 one (we build the last one after this loop). */
4067 new_segment
= FALSE
;
4069 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4071 /* If this section has a different relation between the
4072 virtual address and the load address, then we need a new
4076 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4077 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4079 /* If this section has a load address that makes it overlap
4080 the previous section, then we need a new segment. */
4083 /* In the next test we have to be careful when last_hdr->lma is close
4084 to the end of the address space. If the aligned address wraps
4085 around to the start of the address space, then there are no more
4086 pages left in memory and it is OK to assume that the current
4087 section can be included in the current segment. */
4088 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4090 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4093 /* If putting this section in this segment would force us to
4094 skip a page in the segment, then we need a new segment. */
4097 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4098 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4100 /* We don't want to put a loadable section after a
4101 nonloadable section in the same segment.
4102 Consider .tbss sections as loadable for this purpose. */
4105 else if ((abfd
->flags
& D_PAGED
) == 0)
4107 /* If the file is not demand paged, which means that we
4108 don't require the sections to be correctly aligned in the
4109 file, then there is no other reason for a new segment. */
4110 new_segment
= FALSE
;
4113 && (hdr
->flags
& SEC_READONLY
) == 0
4114 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4115 != (hdr
->lma
& -maxpagesize
)))
4117 /* We don't want to put a writable section in a read only
4118 segment, unless they are on the same page in memory
4119 anyhow. We already know that the last section does not
4120 bring us past the current section on the page, so the
4121 only case in which the new section is not on the same
4122 page as the previous section is when the previous section
4123 ends precisely on a page boundary. */
4128 /* Otherwise, we can use the same segment. */
4129 new_segment
= FALSE
;
4132 /* Allow interested parties a chance to override our decision. */
4133 if (last_hdr
!= NULL
4135 && info
->callbacks
->override_segment_assignment
!= NULL
)
4137 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4143 if ((hdr
->flags
& SEC_READONLY
) == 0)
4146 /* .tbss sections effectively have zero size. */
4147 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4148 != SEC_THREAD_LOCAL
)
4149 last_size
= hdr
->size
;
4155 /* We need a new program segment. We must create a new program
4156 header holding all the sections from phdr_index until hdr. */
4158 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4165 if ((hdr
->flags
& SEC_READONLY
) == 0)
4171 /* .tbss sections effectively have zero size. */
4172 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4173 last_size
= hdr
->size
;
4177 phdr_in_segment
= FALSE
;
4180 /* Create a final PT_LOAD program segment, but not if it's just
4182 if (last_hdr
!= NULL
4183 && (i
- phdr_index
!= 1
4184 || ((last_hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4185 != SEC_THREAD_LOCAL
)))
4187 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4195 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4198 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4205 /* For each batch of consecutive loadable .note sections,
4206 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4207 because if we link together nonloadable .note sections and
4208 loadable .note sections, we will generate two .note sections
4209 in the output file. FIXME: Using names for section types is
4211 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4213 if ((s
->flags
& SEC_LOAD
) != 0
4214 && CONST_STRNEQ (s
->name
, ".note"))
4219 amt
= sizeof (struct elf_segment_map
);
4220 if (s
->alignment_power
== 2)
4221 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4223 if (s2
->next
->alignment_power
== 2
4224 && (s2
->next
->flags
& SEC_LOAD
) != 0
4225 && CONST_STRNEQ (s2
->next
->name
, ".note")
4226 && align_power (s2
->lma
+ s2
->size
, 2)
4232 amt
+= (count
- 1) * sizeof (asection
*);
4233 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4237 m
->p_type
= PT_NOTE
;
4241 m
->sections
[m
->count
- count
--] = s
;
4242 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4245 m
->sections
[m
->count
- 1] = s
;
4246 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4250 if (s
->flags
& SEC_THREAD_LOCAL
)
4258 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4261 amt
= sizeof (struct elf_segment_map
);
4262 amt
+= (tls_count
- 1) * sizeof (asection
*);
4263 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4268 m
->count
= tls_count
;
4269 /* Mandated PF_R. */
4271 m
->p_flags_valid
= 1;
4273 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4275 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
4278 (_("%B: TLS sections are not adjacent:"), abfd
);
4281 while (i
< (unsigned int) tls_count
)
4283 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
4285 _bfd_error_handler (_(" TLS: %A"), s
);
4289 _bfd_error_handler (_(" non-TLS: %A"), s
);
4292 bfd_set_error (bfd_error_bad_value
);
4303 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4305 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
4306 if (eh_frame_hdr
!= NULL
4307 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4309 amt
= sizeof (struct elf_segment_map
);
4310 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4314 m
->p_type
= PT_GNU_EH_FRAME
;
4316 m
->sections
[0] = eh_frame_hdr
->output_section
;
4322 if (elf_stack_flags (abfd
))
4324 amt
= sizeof (struct elf_segment_map
);
4325 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4329 m
->p_type
= PT_GNU_STACK
;
4330 m
->p_flags
= elf_stack_flags (abfd
);
4331 m
->p_align
= bed
->stack_align
;
4332 m
->p_flags_valid
= 1;
4333 m
->p_align_valid
= m
->p_align
!= 0;
4334 if (info
->stacksize
> 0)
4336 m
->p_size
= info
->stacksize
;
4337 m
->p_size_valid
= 1;
4344 if (info
!= NULL
&& info
->relro
)
4346 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
4348 if (m
->p_type
== PT_LOAD
4350 && m
->sections
[0]->vma
>= info
->relro_start
4351 && m
->sections
[0]->vma
< info
->relro_end
)
4354 while (--i
!= (unsigned) -1)
4355 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
4356 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
4359 if (i
!= (unsigned) -1)
4364 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4367 amt
= sizeof (struct elf_segment_map
);
4368 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4372 m
->p_type
= PT_GNU_RELRO
;
4374 m
->p_flags_valid
= 1;
4382 elf_seg_map (abfd
) = mfirst
;
4385 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4388 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4390 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
4395 if (sections
!= NULL
)
4400 /* Sort sections by address. */
4403 elf_sort_sections (const void *arg1
, const void *arg2
)
4405 const asection
*sec1
= *(const asection
**) arg1
;
4406 const asection
*sec2
= *(const asection
**) arg2
;
4407 bfd_size_type size1
, size2
;
4409 /* Sort by LMA first, since this is the address used to
4410 place the section into a segment. */
4411 if (sec1
->lma
< sec2
->lma
)
4413 else if (sec1
->lma
> sec2
->lma
)
4416 /* Then sort by VMA. Normally the LMA and the VMA will be
4417 the same, and this will do nothing. */
4418 if (sec1
->vma
< sec2
->vma
)
4420 else if (sec1
->vma
> sec2
->vma
)
4423 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4425 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4431 /* If the indicies are the same, do not return 0
4432 here, but continue to try the next comparison. */
4433 if (sec1
->target_index
- sec2
->target_index
!= 0)
4434 return sec1
->target_index
- sec2
->target_index
;
4439 else if (TOEND (sec2
))
4444 /* Sort by size, to put zero sized sections
4445 before others at the same address. */
4447 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4448 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4455 return sec1
->target_index
- sec2
->target_index
;
4458 /* Ian Lance Taylor writes:
4460 We shouldn't be using % with a negative signed number. That's just
4461 not good. We have to make sure either that the number is not
4462 negative, or that the number has an unsigned type. When the types
4463 are all the same size they wind up as unsigned. When file_ptr is a
4464 larger signed type, the arithmetic winds up as signed long long,
4467 What we're trying to say here is something like ``increase OFF by
4468 the least amount that will cause it to be equal to the VMA modulo
4470 /* In other words, something like:
4472 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4473 off_offset = off % bed->maxpagesize;
4474 if (vma_offset < off_offset)
4475 adjustment = vma_offset + bed->maxpagesize - off_offset;
4477 adjustment = vma_offset - off_offset;
4479 which can can be collapsed into the expression below. */
4482 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4484 /* PR binutils/16199: Handle an alignment of zero. */
4485 if (maxpagesize
== 0)
4487 return ((vma
- off
) % maxpagesize
);
4491 print_segment_map (const struct elf_segment_map
*m
)
4494 const char *pt
= get_segment_type (m
->p_type
);
4499 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4500 sprintf (buf
, "LOPROC+%7.7x",
4501 (unsigned int) (m
->p_type
- PT_LOPROC
));
4502 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4503 sprintf (buf
, "LOOS+%7.7x",
4504 (unsigned int) (m
->p_type
- PT_LOOS
));
4506 snprintf (buf
, sizeof (buf
), "%8.8x",
4507 (unsigned int) m
->p_type
);
4511 fprintf (stderr
, "%s:", pt
);
4512 for (j
= 0; j
< m
->count
; j
++)
4513 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4519 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
4524 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4526 buf
= bfd_zmalloc (len
);
4529 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
4534 /* Assign file positions to the sections based on the mapping from
4535 sections to segments. This function also sets up some fields in
4539 assign_file_positions_for_load_sections (bfd
*abfd
,
4540 struct bfd_link_info
*link_info
)
4542 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4543 struct elf_segment_map
*m
;
4544 Elf_Internal_Phdr
*phdrs
;
4545 Elf_Internal_Phdr
*p
;
4547 bfd_size_type maxpagesize
;
4550 bfd_vma header_pad
= 0;
4552 if (link_info
== NULL
4553 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
4557 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4561 header_pad
= m
->header_size
;
4566 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4567 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4571 /* PR binutils/12467. */
4572 elf_elfheader (abfd
)->e_phoff
= 0;
4573 elf_elfheader (abfd
)->e_phentsize
= 0;
4576 elf_elfheader (abfd
)->e_phnum
= alloc
;
4578 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
4579 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
4581 BFD_ASSERT (elf_program_header_size (abfd
)
4582 >= alloc
* bed
->s
->sizeof_phdr
);
4586 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
4590 /* We're writing the size in elf_program_header_size (abfd),
4591 see assign_file_positions_except_relocs, so make sure we have
4592 that amount allocated, with trailing space cleared.
4593 The variable alloc contains the computed need, while
4594 elf_program_header_size (abfd) contains the size used for the
4596 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4597 where the layout is forced to according to a larger size in the
4598 last iterations for the testcase ld-elf/header. */
4599 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
4601 phdrs
= (Elf_Internal_Phdr
*)
4603 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
4604 sizeof (Elf_Internal_Phdr
));
4605 elf_tdata (abfd
)->phdr
= phdrs
;
4610 if ((abfd
->flags
& D_PAGED
) != 0)
4611 maxpagesize
= bed
->maxpagesize
;
4613 off
= bed
->s
->sizeof_ehdr
;
4614 off
+= alloc
* bed
->s
->sizeof_phdr
;
4615 if (header_pad
< (bfd_vma
) off
)
4621 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
4623 m
= m
->next
, p
++, j
++)
4627 bfd_boolean no_contents
;
4629 /* If elf_segment_map is not from map_sections_to_segments, the
4630 sections may not be correctly ordered. NOTE: sorting should
4631 not be done to the PT_NOTE section of a corefile, which may
4632 contain several pseudo-sections artificially created by bfd.
4633 Sorting these pseudo-sections breaks things badly. */
4635 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4636 && m
->p_type
== PT_NOTE
))
4637 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4640 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4641 number of sections with contents contributing to both p_filesz
4642 and p_memsz, followed by a number of sections with no contents
4643 that just contribute to p_memsz. In this loop, OFF tracks next
4644 available file offset for PT_LOAD and PT_NOTE segments. */
4645 p
->p_type
= m
->p_type
;
4646 p
->p_flags
= m
->p_flags
;
4651 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4653 if (m
->p_paddr_valid
)
4654 p
->p_paddr
= m
->p_paddr
;
4655 else if (m
->count
== 0)
4658 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4660 if (p
->p_type
== PT_LOAD
4661 && (abfd
->flags
& D_PAGED
) != 0)
4663 /* p_align in demand paged PT_LOAD segments effectively stores
4664 the maximum page size. When copying an executable with
4665 objcopy, we set m->p_align from the input file. Use this
4666 value for maxpagesize rather than bed->maxpagesize, which
4667 may be different. Note that we use maxpagesize for PT_TLS
4668 segment alignment later in this function, so we are relying
4669 on at least one PT_LOAD segment appearing before a PT_TLS
4671 if (m
->p_align_valid
)
4672 maxpagesize
= m
->p_align
;
4674 p
->p_align
= maxpagesize
;
4676 else if (m
->p_align_valid
)
4677 p
->p_align
= m
->p_align
;
4678 else if (m
->count
== 0)
4679 p
->p_align
= 1 << bed
->s
->log_file_align
;
4683 no_contents
= FALSE
;
4685 if (p
->p_type
== PT_LOAD
4688 bfd_size_type align
;
4689 unsigned int align_power
= 0;
4691 if (m
->p_align_valid
)
4695 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4697 unsigned int secalign
;
4699 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4700 if (secalign
> align_power
)
4701 align_power
= secalign
;
4703 align
= (bfd_size_type
) 1 << align_power
;
4704 if (align
< maxpagesize
)
4705 align
= maxpagesize
;
4708 for (i
= 0; i
< m
->count
; i
++)
4709 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4710 /* If we aren't making room for this section, then
4711 it must be SHT_NOBITS regardless of what we've
4712 set via struct bfd_elf_special_section. */
4713 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4715 /* Find out whether this segment contains any loadable
4718 for (i
= 0; i
< m
->count
; i
++)
4719 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
4721 no_contents
= FALSE
;
4725 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
4729 /* We shouldn't need to align the segment on disk since
4730 the segment doesn't need file space, but the gABI
4731 arguably requires the alignment and glibc ld.so
4732 checks it. So to comply with the alignment
4733 requirement but not waste file space, we adjust
4734 p_offset for just this segment. (OFF_ADJUST is
4735 subtracted from OFF later.) This may put p_offset
4736 past the end of file, but that shouldn't matter. */
4741 /* Make sure the .dynamic section is the first section in the
4742 PT_DYNAMIC segment. */
4743 else if (p
->p_type
== PT_DYNAMIC
4745 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4748 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4750 bfd_set_error (bfd_error_bad_value
);
4753 /* Set the note section type to SHT_NOTE. */
4754 else if (p
->p_type
== PT_NOTE
)
4755 for (i
= 0; i
< m
->count
; i
++)
4756 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4762 if (m
->includes_filehdr
)
4764 if (!m
->p_flags_valid
)
4766 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4767 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4770 if (p
->p_vaddr
< (bfd_vma
) off
)
4772 (*_bfd_error_handler
)
4773 (_("%B: Not enough room for program headers, try linking with -N"),
4775 bfd_set_error (bfd_error_bad_value
);
4780 if (!m
->p_paddr_valid
)
4785 if (m
->includes_phdrs
)
4787 if (!m
->p_flags_valid
)
4790 if (!m
->includes_filehdr
)
4792 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4796 p
->p_vaddr
-= off
- p
->p_offset
;
4797 if (!m
->p_paddr_valid
)
4798 p
->p_paddr
-= off
- p
->p_offset
;
4802 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4803 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4806 p
->p_filesz
+= header_pad
;
4807 p
->p_memsz
+= header_pad
;
4811 if (p
->p_type
== PT_LOAD
4812 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4814 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4820 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4822 p
->p_filesz
+= adjust
;
4823 p
->p_memsz
+= adjust
;
4827 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4828 maps. Set filepos for sections in PT_LOAD segments, and in
4829 core files, for sections in PT_NOTE segments.
4830 assign_file_positions_for_non_load_sections will set filepos
4831 for other sections and update p_filesz for other segments. */
4832 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4835 bfd_size_type align
;
4836 Elf_Internal_Shdr
*this_hdr
;
4839 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4840 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4842 if ((p
->p_type
== PT_LOAD
4843 || p
->p_type
== PT_TLS
)
4844 && (this_hdr
->sh_type
!= SHT_NOBITS
4845 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4846 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4847 || p
->p_type
== PT_TLS
))))
4849 bfd_vma p_start
= p
->p_paddr
;
4850 bfd_vma p_end
= p_start
+ p
->p_memsz
;
4851 bfd_vma s_start
= sec
->lma
;
4852 bfd_vma adjust
= s_start
- p_end
;
4856 || p_end
< p_start
))
4858 (*_bfd_error_handler
)
4859 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
4860 (unsigned long) s_start
, (unsigned long) p_end
);
4864 p
->p_memsz
+= adjust
;
4866 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4868 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
4870 /* We have a PROGBITS section following NOBITS ones.
4871 Allocate file space for the NOBITS section(s) and
4873 adjust
= p
->p_memsz
- p
->p_filesz
;
4874 if (!write_zeros (abfd
, off
, adjust
))
4878 p
->p_filesz
+= adjust
;
4882 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4884 /* The section at i == 0 is the one that actually contains
4888 this_hdr
->sh_offset
= sec
->filepos
= off
;
4889 off
+= this_hdr
->sh_size
;
4890 p
->p_filesz
= this_hdr
->sh_size
;
4896 /* The rest are fake sections that shouldn't be written. */
4905 if (p
->p_type
== PT_LOAD
)
4907 this_hdr
->sh_offset
= sec
->filepos
= off
;
4908 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4909 off
+= this_hdr
->sh_size
;
4911 else if (this_hdr
->sh_type
== SHT_NOBITS
4912 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
4913 && this_hdr
->sh_offset
== 0)
4915 /* This is a .tbss section that didn't get a PT_LOAD.
4916 (See _bfd_elf_map_sections_to_segments "Create a
4917 final PT_LOAD".) Set sh_offset to the value it
4918 would have if we had created a zero p_filesz and
4919 p_memsz PT_LOAD header for the section. This
4920 also makes the PT_TLS header have the same
4922 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
4924 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
4927 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4929 p
->p_filesz
+= this_hdr
->sh_size
;
4930 /* A load section without SHF_ALLOC is something like
4931 a note section in a PT_NOTE segment. These take
4932 file space but are not loaded into memory. */
4933 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4934 p
->p_memsz
+= this_hdr
->sh_size
;
4936 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4938 if (p
->p_type
== PT_TLS
)
4939 p
->p_memsz
+= this_hdr
->sh_size
;
4941 /* .tbss is special. It doesn't contribute to p_memsz of
4943 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4944 p
->p_memsz
+= this_hdr
->sh_size
;
4947 if (align
> p
->p_align
4948 && !m
->p_align_valid
4949 && (p
->p_type
!= PT_LOAD
4950 || (abfd
->flags
& D_PAGED
) == 0))
4954 if (!m
->p_flags_valid
)
4957 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4959 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4966 /* Check that all sections are in a PT_LOAD segment.
4967 Don't check funky gdb generated core files. */
4968 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4970 bfd_boolean check_vma
= TRUE
;
4972 for (i
= 1; i
< m
->count
; i
++)
4973 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
4974 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
4975 ->this_hdr
), p
) != 0
4976 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
4977 ->this_hdr
), p
) != 0)
4979 /* Looks like we have overlays packed into the segment. */
4984 for (i
= 0; i
< m
->count
; i
++)
4986 Elf_Internal_Shdr
*this_hdr
;
4989 sec
= m
->sections
[i
];
4990 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4991 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
4992 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
4994 (*_bfd_error_handler
)
4995 (_("%B: section `%A' can't be allocated in segment %d"),
4997 print_segment_map (m
);
5003 elf_next_file_pos (abfd
) = off
;
5007 /* Assign file positions for the other sections. */
5010 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5011 struct bfd_link_info
*link_info
)
5013 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5014 Elf_Internal_Shdr
**i_shdrpp
;
5015 Elf_Internal_Shdr
**hdrpp
;
5016 Elf_Internal_Phdr
*phdrs
;
5017 Elf_Internal_Phdr
*p
;
5018 struct elf_segment_map
*m
;
5019 struct elf_segment_map
*hdrs_segment
;
5020 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5021 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5023 unsigned int num_sec
;
5027 i_shdrpp
= elf_elfsections (abfd
);
5028 num_sec
= elf_numsections (abfd
);
5029 off
= elf_next_file_pos (abfd
);
5030 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5032 Elf_Internal_Shdr
*hdr
;
5035 if (hdr
->bfd_section
!= NULL
5036 && (hdr
->bfd_section
->filepos
!= 0
5037 || (hdr
->sh_type
== SHT_NOBITS
5038 && hdr
->contents
== NULL
)))
5039 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5040 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5042 if (hdr
->sh_size
!= 0)
5043 (*_bfd_error_handler
)
5044 (_("%B: warning: allocated section `%s' not in segment"),
5046 (hdr
->bfd_section
== NULL
5048 : hdr
->bfd_section
->name
));
5049 /* We don't need to page align empty sections. */
5050 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5051 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5054 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5056 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5059 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5060 && hdr
->bfd_section
== NULL
)
5061 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5062 || hdr
== i_shdrpp
[elf_symtab_shndx (abfd
)]
5063 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)])
5064 hdr
->sh_offset
= -1;
5066 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5069 /* Now that we have set the section file positions, we can set up
5070 the file positions for the non PT_LOAD segments. */
5074 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5076 hdrs_segment
= NULL
;
5077 phdrs
= elf_tdata (abfd
)->phdr
;
5078 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5081 if (p
->p_type
!= PT_LOAD
)
5084 if (m
->includes_filehdr
)
5086 filehdr_vaddr
= p
->p_vaddr
;
5087 filehdr_paddr
= p
->p_paddr
;
5089 if (m
->includes_phdrs
)
5091 phdrs_vaddr
= p
->p_vaddr
;
5092 phdrs_paddr
= p
->p_paddr
;
5093 if (m
->includes_filehdr
)
5096 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5097 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5102 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5104 /* There is a segment that contains both the file headers and the
5105 program headers, so provide a symbol __ehdr_start pointing there.
5106 A program can use this to examine itself robustly. */
5108 struct elf_link_hash_entry
*hash
5109 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5110 FALSE
, FALSE
, TRUE
);
5111 /* If the symbol was referenced and not defined, define it. */
5113 && (hash
->root
.type
== bfd_link_hash_new
5114 || hash
->root
.type
== bfd_link_hash_undefined
5115 || hash
->root
.type
== bfd_link_hash_undefweak
5116 || hash
->root
.type
== bfd_link_hash_common
))
5119 if (hdrs_segment
->count
!= 0)
5120 /* The segment contains sections, so use the first one. */
5121 s
= hdrs_segment
->sections
[0];
5123 /* Use the first (i.e. lowest-addressed) section in any segment. */
5124 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5133 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5134 hash
->root
.u
.def
.section
= s
;
5138 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5139 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5142 hash
->root
.type
= bfd_link_hash_defined
;
5143 hash
->def_regular
= 1;
5148 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5150 if (p
->p_type
== PT_GNU_RELRO
)
5152 const Elf_Internal_Phdr
*lp
;
5153 struct elf_segment_map
*lm
;
5155 if (link_info
!= NULL
)
5157 /* During linking the range of the RELRO segment is passed
5159 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5161 lm
= lm
->next
, lp
++)
5163 if (lp
->p_type
== PT_LOAD
5164 && lp
->p_vaddr
< link_info
->relro_end
5166 && lm
->sections
[0]->vma
>= link_info
->relro_start
)
5170 BFD_ASSERT (lm
!= NULL
);
5174 /* Otherwise we are copying an executable or shared
5175 library, but we need to use the same linker logic. */
5176 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
5178 if (lp
->p_type
== PT_LOAD
5179 && lp
->p_paddr
== p
->p_paddr
)
5184 if (lp
< phdrs
+ count
)
5186 p
->p_vaddr
= lp
->p_vaddr
;
5187 p
->p_paddr
= lp
->p_paddr
;
5188 p
->p_offset
= lp
->p_offset
;
5189 if (link_info
!= NULL
)
5190 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
5191 else if (m
->p_size_valid
)
5192 p
->p_filesz
= m
->p_size
;
5195 p
->p_memsz
= p
->p_filesz
;
5196 /* Preserve the alignment and flags if they are valid. The
5197 gold linker generates RW/4 for the PT_GNU_RELRO section.
5198 It is better for objcopy/strip to honor these attributes
5199 otherwise gdb will choke when using separate debug files.
5201 if (!m
->p_align_valid
)
5203 if (!m
->p_flags_valid
)
5204 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
5208 memset (p
, 0, sizeof *p
);
5209 p
->p_type
= PT_NULL
;
5212 else if (p
->p_type
== PT_GNU_STACK
)
5214 if (m
->p_size_valid
)
5215 p
->p_memsz
= m
->p_size
;
5217 else if (m
->count
!= 0)
5219 if (p
->p_type
!= PT_LOAD
5220 && (p
->p_type
!= PT_NOTE
5221 || bfd_get_format (abfd
) != bfd_core
))
5223 if (m
->includes_filehdr
|| m
->includes_phdrs
)
5225 /* PR 17512: file: 2195325e. */
5226 (*_bfd_error_handler
)
5227 (_("%B: warning: non-load segment includes file header and/or program header"),
5233 p
->p_offset
= m
->sections
[0]->filepos
;
5234 for (i
= m
->count
; i
-- != 0;)
5236 asection
*sect
= m
->sections
[i
];
5237 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
5238 if (hdr
->sh_type
!= SHT_NOBITS
)
5240 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
5247 else if (m
->includes_filehdr
)
5249 p
->p_vaddr
= filehdr_vaddr
;
5250 if (! m
->p_paddr_valid
)
5251 p
->p_paddr
= filehdr_paddr
;
5253 else if (m
->includes_phdrs
)
5255 p
->p_vaddr
= phdrs_vaddr
;
5256 if (! m
->p_paddr_valid
)
5257 p
->p_paddr
= phdrs_paddr
;
5261 elf_next_file_pos (abfd
) = off
;
5266 /* Work out the file positions of all the sections. This is called by
5267 _bfd_elf_compute_section_file_positions. All the section sizes and
5268 VMAs must be known before this is called.
5270 Reloc sections come in two flavours: Those processed specially as
5271 "side-channel" data attached to a section to which they apply, and
5272 those that bfd doesn't process as relocations. The latter sort are
5273 stored in a normal bfd section by bfd_section_from_shdr. We don't
5274 consider the former sort here, unless they form part of the loadable
5275 image. Reloc sections not assigned here will be handled later by
5276 assign_file_positions_for_relocs.
5278 We also don't set the positions of the .symtab and .strtab here. */
5281 assign_file_positions_except_relocs (bfd
*abfd
,
5282 struct bfd_link_info
*link_info
)
5284 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
5285 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5286 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5288 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
5289 && bfd_get_format (abfd
) != bfd_core
)
5291 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
5292 unsigned int num_sec
= elf_numsections (abfd
);
5293 Elf_Internal_Shdr
**hdrpp
;
5297 /* Start after the ELF header. */
5298 off
= i_ehdrp
->e_ehsize
;
5300 /* We are not creating an executable, which means that we are
5301 not creating a program header, and that the actual order of
5302 the sections in the file is unimportant. */
5303 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5305 Elf_Internal_Shdr
*hdr
;
5308 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5309 && hdr
->bfd_section
== NULL
)
5310 || i
== elf_onesymtab (abfd
)
5311 || i
== elf_symtab_shndx (abfd
)
5312 || i
== elf_strtab_sec (abfd
))
5314 hdr
->sh_offset
= -1;
5317 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5320 elf_next_file_pos (abfd
) = off
;
5326 /* Assign file positions for the loaded sections based on the
5327 assignment of sections to segments. */
5328 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
5331 /* And for non-load sections. */
5332 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
5335 if (bed
->elf_backend_modify_program_headers
!= NULL
)
5337 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
5341 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
5342 if (link_info
!= NULL
5343 && link_info
->executable
5344 && link_info
->shared
)
5346 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
5347 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
5348 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
5350 /* Find the lowest p_vaddr in PT_LOAD segments. */
5351 bfd_vma p_vaddr
= (bfd_vma
) -1;
5352 for (; segment
< end_segment
; segment
++)
5353 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
5354 p_vaddr
= segment
->p_vaddr
;
5356 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5357 segments is non-zero. */
5359 i_ehdrp
->e_type
= ET_EXEC
;
5362 /* Write out the program headers. */
5363 alloc
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5364 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
5365 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
5373 prep_headers (bfd
*abfd
)
5375 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
5376 struct elf_strtab_hash
*shstrtab
;
5377 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5379 i_ehdrp
= elf_elfheader (abfd
);
5381 shstrtab
= _bfd_elf_strtab_init ();
5382 if (shstrtab
== NULL
)
5385 elf_shstrtab (abfd
) = shstrtab
;
5387 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
5388 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
5389 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
5390 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
5392 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
5393 i_ehdrp
->e_ident
[EI_DATA
] =
5394 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
5395 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
5397 if ((abfd
->flags
& DYNAMIC
) != 0)
5398 i_ehdrp
->e_type
= ET_DYN
;
5399 else if ((abfd
->flags
& EXEC_P
) != 0)
5400 i_ehdrp
->e_type
= ET_EXEC
;
5401 else if (bfd_get_format (abfd
) == bfd_core
)
5402 i_ehdrp
->e_type
= ET_CORE
;
5404 i_ehdrp
->e_type
= ET_REL
;
5406 switch (bfd_get_arch (abfd
))
5408 case bfd_arch_unknown
:
5409 i_ehdrp
->e_machine
= EM_NONE
;
5412 /* There used to be a long list of cases here, each one setting
5413 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5414 in the corresponding bfd definition. To avoid duplication,
5415 the switch was removed. Machines that need special handling
5416 can generally do it in elf_backend_final_write_processing(),
5417 unless they need the information earlier than the final write.
5418 Such need can generally be supplied by replacing the tests for
5419 e_machine with the conditions used to determine it. */
5421 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
5424 i_ehdrp
->e_version
= bed
->s
->ev_current
;
5425 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
5427 /* No program header, for now. */
5428 i_ehdrp
->e_phoff
= 0;
5429 i_ehdrp
->e_phentsize
= 0;
5430 i_ehdrp
->e_phnum
= 0;
5432 /* Each bfd section is section header entry. */
5433 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
5434 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
5436 /* If we're building an executable, we'll need a program header table. */
5437 if (abfd
->flags
& EXEC_P
)
5438 /* It all happens later. */
5442 i_ehdrp
->e_phentsize
= 0;
5443 i_ehdrp
->e_phoff
= 0;
5446 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
5447 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
5448 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
5449 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
5450 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
5451 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
5452 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5453 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
5454 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
5460 /* Assign file positions for all the reloc sections which are not part
5461 of the loadable file image, and the file position of section headers. */
5464 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
5467 unsigned int i
, num_sec
;
5468 Elf_Internal_Shdr
**shdrpp
;
5469 Elf_Internal_Ehdr
*i_ehdrp
;
5470 const struct elf_backend_data
*bed
;
5472 off
= elf_next_file_pos (abfd
);
5474 num_sec
= elf_numsections (abfd
);
5475 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
5477 Elf_Internal_Shdr
*shdrp
;
5480 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
5481 && shdrp
->sh_offset
== -1)
5482 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5485 /* Place the section headers. */
5486 i_ehdrp
= elf_elfheader (abfd
);
5487 bed
= get_elf_backend_data (abfd
);
5488 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
5489 i_ehdrp
->e_shoff
= off
;
5490 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
5491 elf_next_file_pos (abfd
) = off
;
5495 _bfd_elf_write_object_contents (bfd
*abfd
)
5497 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5498 Elf_Internal_Shdr
**i_shdrp
;
5500 unsigned int count
, num_sec
;
5501 struct elf_obj_tdata
*t
;
5503 if (! abfd
->output_has_begun
5504 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5507 i_shdrp
= elf_elfsections (abfd
);
5510 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5514 _bfd_elf_assign_file_positions_for_relocs (abfd
);
5516 /* After writing the headers, we need to write the sections too... */
5517 num_sec
= elf_numsections (abfd
);
5518 for (count
= 1; count
< num_sec
; count
++)
5520 if (bed
->elf_backend_section_processing
)
5521 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5522 if (i_shdrp
[count
]->contents
)
5524 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5526 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5527 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5532 /* Write out the section header names. */
5533 t
= elf_tdata (abfd
);
5534 if (elf_shstrtab (abfd
) != NULL
5535 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5536 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5539 if (bed
->elf_backend_final_write_processing
)
5540 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
5542 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5545 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5546 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
5547 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
5553 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5555 /* Hopefully this can be done just like an object file. */
5556 return _bfd_elf_write_object_contents (abfd
);
5559 /* Given a section, search the header to find them. */
5562 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5564 const struct elf_backend_data
*bed
;
5565 unsigned int sec_index
;
5567 if (elf_section_data (asect
) != NULL
5568 && elf_section_data (asect
)->this_idx
!= 0)
5569 return elf_section_data (asect
)->this_idx
;
5571 if (bfd_is_abs_section (asect
))
5572 sec_index
= SHN_ABS
;
5573 else if (bfd_is_com_section (asect
))
5574 sec_index
= SHN_COMMON
;
5575 else if (bfd_is_und_section (asect
))
5576 sec_index
= SHN_UNDEF
;
5578 sec_index
= SHN_BAD
;
5580 bed
= get_elf_backend_data (abfd
);
5581 if (bed
->elf_backend_section_from_bfd_section
)
5583 int retval
= sec_index
;
5585 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5589 if (sec_index
== SHN_BAD
)
5590 bfd_set_error (bfd_error_nonrepresentable_section
);
5595 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5599 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5601 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5603 flagword flags
= asym_ptr
->flags
;
5605 /* When gas creates relocations against local labels, it creates its
5606 own symbol for the section, but does put the symbol into the
5607 symbol chain, so udata is 0. When the linker is generating
5608 relocatable output, this section symbol may be for one of the
5609 input sections rather than the output section. */
5610 if (asym_ptr
->udata
.i
== 0
5611 && (flags
& BSF_SECTION_SYM
)
5612 && asym_ptr
->section
)
5617 sec
= asym_ptr
->section
;
5618 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5619 sec
= sec
->output_section
;
5620 if (sec
->owner
== abfd
5621 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5622 && elf_section_syms (abfd
)[indx
] != NULL
)
5623 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5626 idx
= asym_ptr
->udata
.i
;
5630 /* This case can occur when using --strip-symbol on a symbol
5631 which is used in a relocation entry. */
5632 (*_bfd_error_handler
)
5633 (_("%B: symbol `%s' required but not present"),
5634 abfd
, bfd_asymbol_name (asym_ptr
));
5635 bfd_set_error (bfd_error_no_symbols
);
5642 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5643 (long) asym_ptr
, asym_ptr
->name
, idx
, (long) flags
);
5651 /* Rewrite program header information. */
5654 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5656 Elf_Internal_Ehdr
*iehdr
;
5657 struct elf_segment_map
*map
;
5658 struct elf_segment_map
*map_first
;
5659 struct elf_segment_map
**pointer_to_map
;
5660 Elf_Internal_Phdr
*segment
;
5663 unsigned int num_segments
;
5664 bfd_boolean phdr_included
= FALSE
;
5665 bfd_boolean p_paddr_valid
;
5666 bfd_vma maxpagesize
;
5667 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5668 unsigned int phdr_adjust_num
= 0;
5669 const struct elf_backend_data
*bed
;
5671 bed
= get_elf_backend_data (ibfd
);
5672 iehdr
= elf_elfheader (ibfd
);
5675 pointer_to_map
= &map_first
;
5677 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5678 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5680 /* Returns the end address of the segment + 1. */
5681 #define SEGMENT_END(segment, start) \
5682 (start + (segment->p_memsz > segment->p_filesz \
5683 ? segment->p_memsz : segment->p_filesz))
5685 #define SECTION_SIZE(section, segment) \
5686 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5687 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5688 ? section->size : 0)
5690 /* Returns TRUE if the given section is contained within
5691 the given segment. VMA addresses are compared. */
5692 #define IS_CONTAINED_BY_VMA(section, segment) \
5693 (section->vma >= segment->p_vaddr \
5694 && (section->vma + SECTION_SIZE (section, segment) \
5695 <= (SEGMENT_END (segment, segment->p_vaddr))))
5697 /* Returns TRUE if the given section is contained within
5698 the given segment. LMA addresses are compared. */
5699 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5700 (section->lma >= base \
5701 && (section->lma + SECTION_SIZE (section, segment) \
5702 <= SEGMENT_END (segment, base)))
5704 /* Handle PT_NOTE segment. */
5705 #define IS_NOTE(p, s) \
5706 (p->p_type == PT_NOTE \
5707 && elf_section_type (s) == SHT_NOTE \
5708 && (bfd_vma) s->filepos >= p->p_offset \
5709 && ((bfd_vma) s->filepos + s->size \
5710 <= p->p_offset + p->p_filesz))
5712 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5714 #define IS_COREFILE_NOTE(p, s) \
5716 && bfd_get_format (ibfd) == bfd_core \
5720 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5721 linker, which generates a PT_INTERP section with p_vaddr and
5722 p_memsz set to 0. */
5723 #define IS_SOLARIS_PT_INTERP(p, s) \
5725 && p->p_paddr == 0 \
5726 && p->p_memsz == 0 \
5727 && p->p_filesz > 0 \
5728 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5730 && (bfd_vma) s->filepos >= p->p_offset \
5731 && ((bfd_vma) s->filepos + s->size \
5732 <= p->p_offset + p->p_filesz))
5734 /* Decide if the given section should be included in the given segment.
5735 A section will be included if:
5736 1. It is within the address space of the segment -- we use the LMA
5737 if that is set for the segment and the VMA otherwise,
5738 2. It is an allocated section or a NOTE section in a PT_NOTE
5740 3. There is an output section associated with it,
5741 4. The section has not already been allocated to a previous segment.
5742 5. PT_GNU_STACK segments do not include any sections.
5743 6. PT_TLS segment includes only SHF_TLS sections.
5744 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5745 8. PT_DYNAMIC should not contain empty sections at the beginning
5746 (with the possible exception of .dynamic). */
5747 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5748 ((((segment->p_paddr \
5749 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5750 : IS_CONTAINED_BY_VMA (section, segment)) \
5751 && (section->flags & SEC_ALLOC) != 0) \
5752 || IS_NOTE (segment, section)) \
5753 && segment->p_type != PT_GNU_STACK \
5754 && (segment->p_type != PT_TLS \
5755 || (section->flags & SEC_THREAD_LOCAL)) \
5756 && (segment->p_type == PT_LOAD \
5757 || segment->p_type == PT_TLS \
5758 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5759 && (segment->p_type != PT_DYNAMIC \
5760 || SECTION_SIZE (section, segment) > 0 \
5761 || (segment->p_paddr \
5762 ? segment->p_paddr != section->lma \
5763 : segment->p_vaddr != section->vma) \
5764 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5766 && !section->segment_mark)
5768 /* If the output section of a section in the input segment is NULL,
5769 it is removed from the corresponding output segment. */
5770 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5771 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5772 && section->output_section != NULL)
5774 /* Returns TRUE iff seg1 starts after the end of seg2. */
5775 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5776 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5778 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5779 their VMA address ranges and their LMA address ranges overlap.
5780 It is possible to have overlapping VMA ranges without overlapping LMA
5781 ranges. RedBoot images for example can have both .data and .bss mapped
5782 to the same VMA range, but with the .data section mapped to a different
5784 #define SEGMENT_OVERLAPS(seg1, seg2) \
5785 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5786 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5787 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5788 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5790 /* Initialise the segment mark field. */
5791 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5792 section
->segment_mark
= FALSE
;
5794 /* The Solaris linker creates program headers in which all the
5795 p_paddr fields are zero. When we try to objcopy or strip such a
5796 file, we get confused. Check for this case, and if we find it
5797 don't set the p_paddr_valid fields. */
5798 p_paddr_valid
= FALSE
;
5799 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5802 if (segment
->p_paddr
!= 0)
5804 p_paddr_valid
= TRUE
;
5808 /* Scan through the segments specified in the program header
5809 of the input BFD. For this first scan we look for overlaps
5810 in the loadable segments. These can be created by weird
5811 parameters to objcopy. Also, fix some solaris weirdness. */
5812 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5817 Elf_Internal_Phdr
*segment2
;
5819 if (segment
->p_type
== PT_INTERP
)
5820 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5821 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5823 /* Mininal change so that the normal section to segment
5824 assignment code will work. */
5825 segment
->p_vaddr
= section
->vma
;
5829 if (segment
->p_type
!= PT_LOAD
)
5831 /* Remove PT_GNU_RELRO segment. */
5832 if (segment
->p_type
== PT_GNU_RELRO
)
5833 segment
->p_type
= PT_NULL
;
5837 /* Determine if this segment overlaps any previous segments. */
5838 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5840 bfd_signed_vma extra_length
;
5842 if (segment2
->p_type
!= PT_LOAD
5843 || !SEGMENT_OVERLAPS (segment
, segment2
))
5846 /* Merge the two segments together. */
5847 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5849 /* Extend SEGMENT2 to include SEGMENT and then delete
5851 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5852 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5854 if (extra_length
> 0)
5856 segment2
->p_memsz
+= extra_length
;
5857 segment2
->p_filesz
+= extra_length
;
5860 segment
->p_type
= PT_NULL
;
5862 /* Since we have deleted P we must restart the outer loop. */
5864 segment
= elf_tdata (ibfd
)->phdr
;
5869 /* Extend SEGMENT to include SEGMENT2 and then delete
5871 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5872 - SEGMENT_END (segment
, segment
->p_vaddr
));
5874 if (extra_length
> 0)
5876 segment
->p_memsz
+= extra_length
;
5877 segment
->p_filesz
+= extra_length
;
5880 segment2
->p_type
= PT_NULL
;
5885 /* The second scan attempts to assign sections to segments. */
5886 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5890 unsigned int section_count
;
5891 asection
**sections
;
5892 asection
*output_section
;
5894 bfd_vma matching_lma
;
5895 bfd_vma suggested_lma
;
5898 asection
*first_section
;
5899 bfd_boolean first_matching_lma
;
5900 bfd_boolean first_suggested_lma
;
5902 if (segment
->p_type
== PT_NULL
)
5905 first_section
= NULL
;
5906 /* Compute how many sections might be placed into this segment. */
5907 for (section
= ibfd
->sections
, section_count
= 0;
5909 section
= section
->next
)
5911 /* Find the first section in the input segment, which may be
5912 removed from the corresponding output segment. */
5913 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5915 if (first_section
== NULL
)
5916 first_section
= section
;
5917 if (section
->output_section
!= NULL
)
5922 /* Allocate a segment map big enough to contain
5923 all of the sections we have selected. */
5924 amt
= sizeof (struct elf_segment_map
);
5925 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5926 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5930 /* Initialise the fields of the segment map. Default to
5931 using the physical address of the segment in the input BFD. */
5933 map
->p_type
= segment
->p_type
;
5934 map
->p_flags
= segment
->p_flags
;
5935 map
->p_flags_valid
= 1;
5937 /* If the first section in the input segment is removed, there is
5938 no need to preserve segment physical address in the corresponding
5940 if (!first_section
|| first_section
->output_section
!= NULL
)
5942 map
->p_paddr
= segment
->p_paddr
;
5943 map
->p_paddr_valid
= p_paddr_valid
;
5946 /* Determine if this segment contains the ELF file header
5947 and if it contains the program headers themselves. */
5948 map
->includes_filehdr
= (segment
->p_offset
== 0
5949 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5950 map
->includes_phdrs
= 0;
5952 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5954 map
->includes_phdrs
=
5955 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5956 && (segment
->p_offset
+ segment
->p_filesz
5957 >= ((bfd_vma
) iehdr
->e_phoff
5958 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5960 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5961 phdr_included
= TRUE
;
5964 if (section_count
== 0)
5966 /* Special segments, such as the PT_PHDR segment, may contain
5967 no sections, but ordinary, loadable segments should contain
5968 something. They are allowed by the ELF spec however, so only
5969 a warning is produced. */
5970 if (segment
->p_type
== PT_LOAD
)
5971 (*_bfd_error_handler
) (_("\
5972 %B: warning: Empty loadable segment detected, is this intentional ?"),
5976 *pointer_to_map
= map
;
5977 pointer_to_map
= &map
->next
;
5982 /* Now scan the sections in the input BFD again and attempt
5983 to add their corresponding output sections to the segment map.
5984 The problem here is how to handle an output section which has
5985 been moved (ie had its LMA changed). There are four possibilities:
5987 1. None of the sections have been moved.
5988 In this case we can continue to use the segment LMA from the
5991 2. All of the sections have been moved by the same amount.
5992 In this case we can change the segment's LMA to match the LMA
5993 of the first section.
5995 3. Some of the sections have been moved, others have not.
5996 In this case those sections which have not been moved can be
5997 placed in the current segment which will have to have its size,
5998 and possibly its LMA changed, and a new segment or segments will
5999 have to be created to contain the other sections.
6001 4. The sections have been moved, but not by the same amount.
6002 In this case we can change the segment's LMA to match the LMA
6003 of the first section and we will have to create a new segment
6004 or segments to contain the other sections.
6006 In order to save time, we allocate an array to hold the section
6007 pointers that we are interested in. As these sections get assigned
6008 to a segment, they are removed from this array. */
6010 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
6011 if (sections
== NULL
)
6014 /* Step One: Scan for segment vs section LMA conflicts.
6015 Also add the sections to the section array allocated above.
6016 Also add the sections to the current segment. In the common
6017 case, where the sections have not been moved, this means that
6018 we have completely filled the segment, and there is nothing
6023 first_matching_lma
= TRUE
;
6024 first_suggested_lma
= TRUE
;
6026 for (section
= ibfd
->sections
;
6028 section
= section
->next
)
6029 if (section
== first_section
)
6032 for (j
= 0; section
!= NULL
; section
= section
->next
)
6034 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
6036 output_section
= section
->output_section
;
6038 sections
[j
++] = section
;
6040 /* The Solaris native linker always sets p_paddr to 0.
6041 We try to catch that case here, and set it to the
6042 correct value. Note - some backends require that
6043 p_paddr be left as zero. */
6045 && segment
->p_vaddr
!= 0
6046 && !bed
->want_p_paddr_set_to_zero
6048 && output_section
->lma
!= 0
6049 && output_section
->vma
== (segment
->p_vaddr
6050 + (map
->includes_filehdr
6053 + (map
->includes_phdrs
6055 * iehdr
->e_phentsize
)
6057 map
->p_paddr
= segment
->p_vaddr
;
6059 /* Match up the physical address of the segment with the
6060 LMA address of the output section. */
6061 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6062 || IS_COREFILE_NOTE (segment
, section
)
6063 || (bed
->want_p_paddr_set_to_zero
6064 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
6066 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
6068 matching_lma
= output_section
->lma
;
6069 first_matching_lma
= FALSE
;
6072 /* We assume that if the section fits within the segment
6073 then it does not overlap any other section within that
6075 map
->sections
[isec
++] = output_section
;
6077 else if (first_suggested_lma
)
6079 suggested_lma
= output_section
->lma
;
6080 first_suggested_lma
= FALSE
;
6083 if (j
== section_count
)
6088 BFD_ASSERT (j
== section_count
);
6090 /* Step Two: Adjust the physical address of the current segment,
6092 if (isec
== section_count
)
6094 /* All of the sections fitted within the segment as currently
6095 specified. This is the default case. Add the segment to
6096 the list of built segments and carry on to process the next
6097 program header in the input BFD. */
6098 map
->count
= section_count
;
6099 *pointer_to_map
= map
;
6100 pointer_to_map
= &map
->next
;
6103 && !bed
->want_p_paddr_set_to_zero
6104 && matching_lma
!= map
->p_paddr
6105 && !map
->includes_filehdr
6106 && !map
->includes_phdrs
)
6107 /* There is some padding before the first section in the
6108 segment. So, we must account for that in the output
6110 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
6117 if (!first_matching_lma
)
6119 /* At least one section fits inside the current segment.
6120 Keep it, but modify its physical address to match the
6121 LMA of the first section that fitted. */
6122 map
->p_paddr
= matching_lma
;
6126 /* None of the sections fitted inside the current segment.
6127 Change the current segment's physical address to match
6128 the LMA of the first section. */
6129 map
->p_paddr
= suggested_lma
;
6132 /* Offset the segment physical address from the lma
6133 to allow for space taken up by elf headers. */
6134 if (map
->includes_filehdr
)
6136 if (map
->p_paddr
>= iehdr
->e_ehsize
)
6137 map
->p_paddr
-= iehdr
->e_ehsize
;
6140 map
->includes_filehdr
= FALSE
;
6141 map
->includes_phdrs
= FALSE
;
6145 if (map
->includes_phdrs
)
6147 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
6149 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
6151 /* iehdr->e_phnum is just an estimate of the number
6152 of program headers that we will need. Make a note
6153 here of the number we used and the segment we chose
6154 to hold these headers, so that we can adjust the
6155 offset when we know the correct value. */
6156 phdr_adjust_num
= iehdr
->e_phnum
;
6157 phdr_adjust_seg
= map
;
6160 map
->includes_phdrs
= FALSE
;
6164 /* Step Three: Loop over the sections again, this time assigning
6165 those that fit to the current segment and removing them from the
6166 sections array; but making sure not to leave large gaps. Once all
6167 possible sections have been assigned to the current segment it is
6168 added to the list of built segments and if sections still remain
6169 to be assigned, a new segment is constructed before repeating
6176 first_suggested_lma
= TRUE
;
6178 /* Fill the current segment with sections that fit. */
6179 for (j
= 0; j
< section_count
; j
++)
6181 section
= sections
[j
];
6183 if (section
== NULL
)
6186 output_section
= section
->output_section
;
6188 BFD_ASSERT (output_section
!= NULL
);
6190 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6191 || IS_COREFILE_NOTE (segment
, section
))
6193 if (map
->count
== 0)
6195 /* If the first section in a segment does not start at
6196 the beginning of the segment, then something is
6198 if (output_section
->lma
6200 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
6201 + (map
->includes_phdrs
6202 ? iehdr
->e_phnum
* iehdr
->e_phentsize
6210 prev_sec
= map
->sections
[map
->count
- 1];
6212 /* If the gap between the end of the previous section
6213 and the start of this section is more than
6214 maxpagesize then we need to start a new segment. */
6215 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
6217 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
6218 || (prev_sec
->lma
+ prev_sec
->size
6219 > output_section
->lma
))
6221 if (first_suggested_lma
)
6223 suggested_lma
= output_section
->lma
;
6224 first_suggested_lma
= FALSE
;
6231 map
->sections
[map
->count
++] = output_section
;
6234 section
->segment_mark
= TRUE
;
6236 else if (first_suggested_lma
)
6238 suggested_lma
= output_section
->lma
;
6239 first_suggested_lma
= FALSE
;
6243 BFD_ASSERT (map
->count
> 0);
6245 /* Add the current segment to the list of built segments. */
6246 *pointer_to_map
= map
;
6247 pointer_to_map
= &map
->next
;
6249 if (isec
< section_count
)
6251 /* We still have not allocated all of the sections to
6252 segments. Create a new segment here, initialise it
6253 and carry on looping. */
6254 amt
= sizeof (struct elf_segment_map
);
6255 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6256 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6263 /* Initialise the fields of the segment map. Set the physical
6264 physical address to the LMA of the first section that has
6265 not yet been assigned. */
6267 map
->p_type
= segment
->p_type
;
6268 map
->p_flags
= segment
->p_flags
;
6269 map
->p_flags_valid
= 1;
6270 map
->p_paddr
= suggested_lma
;
6271 map
->p_paddr_valid
= p_paddr_valid
;
6272 map
->includes_filehdr
= 0;
6273 map
->includes_phdrs
= 0;
6276 while (isec
< section_count
);
6281 elf_seg_map (obfd
) = map_first
;
6283 /* If we had to estimate the number of program headers that were
6284 going to be needed, then check our estimate now and adjust
6285 the offset if necessary. */
6286 if (phdr_adjust_seg
!= NULL
)
6290 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
6293 if (count
> phdr_adjust_num
)
6294 phdr_adjust_seg
->p_paddr
6295 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
6300 #undef IS_CONTAINED_BY_VMA
6301 #undef IS_CONTAINED_BY_LMA
6303 #undef IS_COREFILE_NOTE
6304 #undef IS_SOLARIS_PT_INTERP
6305 #undef IS_SECTION_IN_INPUT_SEGMENT
6306 #undef INCLUDE_SECTION_IN_SEGMENT
6307 #undef SEGMENT_AFTER_SEGMENT
6308 #undef SEGMENT_OVERLAPS
6312 /* Copy ELF program header information. */
6315 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6317 Elf_Internal_Ehdr
*iehdr
;
6318 struct elf_segment_map
*map
;
6319 struct elf_segment_map
*map_first
;
6320 struct elf_segment_map
**pointer_to_map
;
6321 Elf_Internal_Phdr
*segment
;
6323 unsigned int num_segments
;
6324 bfd_boolean phdr_included
= FALSE
;
6325 bfd_boolean p_paddr_valid
;
6327 iehdr
= elf_elfheader (ibfd
);
6330 pointer_to_map
= &map_first
;
6332 /* If all the segment p_paddr fields are zero, don't set
6333 map->p_paddr_valid. */
6334 p_paddr_valid
= FALSE
;
6335 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6336 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6339 if (segment
->p_paddr
!= 0)
6341 p_paddr_valid
= TRUE
;
6345 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6350 unsigned int section_count
;
6352 Elf_Internal_Shdr
*this_hdr
;
6353 asection
*first_section
= NULL
;
6354 asection
*lowest_section
;
6356 /* Compute how many sections are in this segment. */
6357 for (section
= ibfd
->sections
, section_count
= 0;
6359 section
= section
->next
)
6361 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6362 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6364 if (first_section
== NULL
)
6365 first_section
= section
;
6370 /* Allocate a segment map big enough to contain
6371 all of the sections we have selected. */
6372 amt
= sizeof (struct elf_segment_map
);
6373 if (section_count
!= 0)
6374 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6375 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6379 /* Initialize the fields of the output segment map with the
6382 map
->p_type
= segment
->p_type
;
6383 map
->p_flags
= segment
->p_flags
;
6384 map
->p_flags_valid
= 1;
6385 map
->p_paddr
= segment
->p_paddr
;
6386 map
->p_paddr_valid
= p_paddr_valid
;
6387 map
->p_align
= segment
->p_align
;
6388 map
->p_align_valid
= 1;
6389 map
->p_vaddr_offset
= 0;
6391 if (map
->p_type
== PT_GNU_RELRO
6392 || map
->p_type
== PT_GNU_STACK
)
6394 /* The PT_GNU_RELRO segment may contain the first a few
6395 bytes in the .got.plt section even if the whole .got.plt
6396 section isn't in the PT_GNU_RELRO segment. We won't
6397 change the size of the PT_GNU_RELRO segment.
6398 Similarly, PT_GNU_STACK size is significant on uclinux
6400 map
->p_size
= segment
->p_memsz
;
6401 map
->p_size_valid
= 1;
6404 /* Determine if this segment contains the ELF file header
6405 and if it contains the program headers themselves. */
6406 map
->includes_filehdr
= (segment
->p_offset
== 0
6407 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6409 map
->includes_phdrs
= 0;
6410 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
6412 map
->includes_phdrs
=
6413 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6414 && (segment
->p_offset
+ segment
->p_filesz
6415 >= ((bfd_vma
) iehdr
->e_phoff
6416 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6418 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6419 phdr_included
= TRUE
;
6422 lowest_section
= NULL
;
6423 if (section_count
!= 0)
6425 unsigned int isec
= 0;
6427 for (section
= first_section
;
6429 section
= section
->next
)
6431 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6432 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6434 map
->sections
[isec
++] = section
->output_section
;
6435 if ((section
->flags
& SEC_ALLOC
) != 0)
6439 if (lowest_section
== NULL
6440 || section
->lma
< lowest_section
->lma
)
6441 lowest_section
= section
;
6443 /* Section lmas are set up from PT_LOAD header
6444 p_paddr in _bfd_elf_make_section_from_shdr.
6445 If this header has a p_paddr that disagrees
6446 with the section lma, flag the p_paddr as
6448 if ((section
->flags
& SEC_LOAD
) != 0)
6449 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
6451 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
6452 if (section
->lma
- segment
->p_paddr
!= seg_off
)
6453 map
->p_paddr_valid
= FALSE
;
6455 if (isec
== section_count
)
6461 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
6462 /* We need to keep the space used by the headers fixed. */
6463 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
6465 if (!map
->includes_phdrs
6466 && !map
->includes_filehdr
6467 && map
->p_paddr_valid
)
6468 /* There is some other padding before the first section. */
6469 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
6470 - segment
->p_paddr
);
6472 map
->count
= section_count
;
6473 *pointer_to_map
= map
;
6474 pointer_to_map
= &map
->next
;
6477 elf_seg_map (obfd
) = map_first
;
6481 /* Copy private BFD data. This copies or rewrites ELF program header
6485 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
6487 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6488 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6491 if (elf_tdata (ibfd
)->phdr
== NULL
)
6494 if (ibfd
->xvec
== obfd
->xvec
)
6496 /* Check to see if any sections in the input BFD
6497 covered by ELF program header have changed. */
6498 Elf_Internal_Phdr
*segment
;
6499 asection
*section
, *osec
;
6500 unsigned int i
, num_segments
;
6501 Elf_Internal_Shdr
*this_hdr
;
6502 const struct elf_backend_data
*bed
;
6504 bed
= get_elf_backend_data (ibfd
);
6506 /* Regenerate the segment map if p_paddr is set to 0. */
6507 if (bed
->want_p_paddr_set_to_zero
)
6510 /* Initialize the segment mark field. */
6511 for (section
= obfd
->sections
; section
!= NULL
;
6512 section
= section
->next
)
6513 section
->segment_mark
= FALSE
;
6515 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6516 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6520 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6521 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6522 which severly confuses things, so always regenerate the segment
6523 map in this case. */
6524 if (segment
->p_paddr
== 0
6525 && segment
->p_memsz
== 0
6526 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6529 for (section
= ibfd
->sections
;
6530 section
!= NULL
; section
= section
->next
)
6532 /* We mark the output section so that we know it comes
6533 from the input BFD. */
6534 osec
= section
->output_section
;
6536 osec
->segment_mark
= TRUE
;
6538 /* Check if this section is covered by the segment. */
6539 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6540 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6542 /* FIXME: Check if its output section is changed or
6543 removed. What else do we need to check? */
6545 || section
->flags
!= osec
->flags
6546 || section
->lma
!= osec
->lma
6547 || section
->vma
!= osec
->vma
6548 || section
->size
!= osec
->size
6549 || section
->rawsize
!= osec
->rawsize
6550 || section
->alignment_power
!= osec
->alignment_power
)
6556 /* Check to see if any output section do not come from the
6558 for (section
= obfd
->sections
; section
!= NULL
;
6559 section
= section
->next
)
6561 if (section
->segment_mark
== FALSE
)
6564 section
->segment_mark
= FALSE
;
6567 return copy_elf_program_header (ibfd
, obfd
);
6571 if (ibfd
->xvec
== obfd
->xvec
)
6573 /* When rewriting program header, set the output maxpagesize to
6574 the maximum alignment of input PT_LOAD segments. */
6575 Elf_Internal_Phdr
*segment
;
6577 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6578 bfd_vma maxpagesize
= 0;
6580 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6583 if (segment
->p_type
== PT_LOAD
6584 && maxpagesize
< segment
->p_align
)
6586 /* PR 17512: file: f17299af. */
6587 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
6588 (*_bfd_error_handler
) (_("\
6589 %B: warning: segment alignment of 0x%llx is too large"),
6590 ibfd
, (long long) segment
->p_align
);
6592 maxpagesize
= segment
->p_align
;
6595 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
6596 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
6599 return rewrite_elf_program_header (ibfd
, obfd
);
6602 /* Initialize private output section information from input section. */
6605 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6609 struct bfd_link_info
*link_info
)
6612 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6613 bfd_boolean final_link
= link_info
!= NULL
&& !link_info
->relocatable
;
6615 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6616 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6619 BFD_ASSERT (elf_section_data (osec
) != NULL
);
6621 /* For objcopy and relocatable link, don't copy the output ELF
6622 section type from input if the output BFD section flags have been
6623 set to something different. For a final link allow some flags
6624 that the linker clears to differ. */
6625 if (elf_section_type (osec
) == SHT_NULL
6626 && (osec
->flags
== isec
->flags
6628 && ((osec
->flags
^ isec
->flags
)
6629 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
6630 elf_section_type (osec
) = elf_section_type (isec
);
6632 /* FIXME: Is this correct for all OS/PROC specific flags? */
6633 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6634 & (SHF_MASKOS
| SHF_MASKPROC
));
6636 /* Set things up for objcopy and relocatable link. The output
6637 SHT_GROUP section will have its elf_next_in_group pointing back
6638 to the input group members. Ignore linker created group section.
6639 See elfNN_ia64_object_p in elfxx-ia64.c. */
6642 if (elf_sec_group (isec
) == NULL
6643 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6645 if (elf_section_flags (isec
) & SHF_GROUP
)
6646 elf_section_flags (osec
) |= SHF_GROUP
;
6647 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6648 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
6652 ihdr
= &elf_section_data (isec
)->this_hdr
;
6654 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6655 don't use the output section of the linked-to section since it
6656 may be NULL at this point. */
6657 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6659 ohdr
= &elf_section_data (osec
)->this_hdr
;
6660 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6661 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6664 osec
->use_rela_p
= isec
->use_rela_p
;
6669 /* Copy private section information. This copies over the entsize
6670 field, and sometimes the info field. */
6673 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6678 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6680 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6681 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6684 ihdr
= &elf_section_data (isec
)->this_hdr
;
6685 ohdr
= &elf_section_data (osec
)->this_hdr
;
6687 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6689 if (ihdr
->sh_type
== SHT_SYMTAB
6690 || ihdr
->sh_type
== SHT_DYNSYM
6691 || ihdr
->sh_type
== SHT_GNU_verneed
6692 || ihdr
->sh_type
== SHT_GNU_verdef
)
6693 ohdr
->sh_info
= ihdr
->sh_info
;
6695 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6699 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6700 necessary if we are removing either the SHT_GROUP section or any of
6701 the group member sections. DISCARDED is the value that a section's
6702 output_section has if the section will be discarded, NULL when this
6703 function is called from objcopy, bfd_abs_section_ptr when called
6707 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
6711 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6712 if (elf_section_type (isec
) == SHT_GROUP
)
6714 asection
*first
= elf_next_in_group (isec
);
6715 asection
*s
= first
;
6716 bfd_size_type removed
= 0;
6720 /* If this member section is being output but the
6721 SHT_GROUP section is not, then clear the group info
6722 set up by _bfd_elf_copy_private_section_data. */
6723 if (s
->output_section
!= discarded
6724 && isec
->output_section
== discarded
)
6726 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6727 elf_group_name (s
->output_section
) = NULL
;
6729 /* Conversely, if the member section is not being output
6730 but the SHT_GROUP section is, then adjust its size. */
6731 else if (s
->output_section
== discarded
6732 && isec
->output_section
!= discarded
)
6734 s
= elf_next_in_group (s
);
6740 if (discarded
!= NULL
)
6742 /* If we've been called for ld -r, then we need to
6743 adjust the input section size. This function may
6744 be called multiple times, so save the original
6746 if (isec
->rawsize
== 0)
6747 isec
->rawsize
= isec
->size
;
6748 isec
->size
= isec
->rawsize
- removed
;
6752 /* Adjust the output section size when called from
6754 isec
->output_section
->size
-= removed
;
6762 /* Copy private header information. */
6765 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6767 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6768 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6771 /* Copy over private BFD data if it has not already been copied.
6772 This must be done here, rather than in the copy_private_bfd_data
6773 entry point, because the latter is called after the section
6774 contents have been set, which means that the program headers have
6775 already been worked out. */
6776 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6778 if (! copy_private_bfd_data (ibfd
, obfd
))
6782 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
6785 /* Copy private symbol information. If this symbol is in a section
6786 which we did not map into a BFD section, try to map the section
6787 index correctly. We use special macro definitions for the mapped
6788 section indices; these definitions are interpreted by the
6789 swap_out_syms function. */
6791 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6792 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6793 #define MAP_STRTAB (SHN_HIOS + 3)
6794 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6795 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6798 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6803 elf_symbol_type
*isym
, *osym
;
6805 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6806 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6809 isym
= elf_symbol_from (ibfd
, isymarg
);
6810 osym
= elf_symbol_from (obfd
, osymarg
);
6813 && isym
->internal_elf_sym
.st_shndx
!= 0
6815 && bfd_is_abs_section (isym
->symbol
.section
))
6819 shndx
= isym
->internal_elf_sym
.st_shndx
;
6820 if (shndx
== elf_onesymtab (ibfd
))
6821 shndx
= MAP_ONESYMTAB
;
6822 else if (shndx
== elf_dynsymtab (ibfd
))
6823 shndx
= MAP_DYNSYMTAB
;
6824 else if (shndx
== elf_strtab_sec (ibfd
))
6826 else if (shndx
== elf_shstrtab_sec (ibfd
))
6827 shndx
= MAP_SHSTRTAB
;
6828 else if (shndx
== elf_symtab_shndx (ibfd
))
6829 shndx
= MAP_SYM_SHNDX
;
6830 osym
->internal_elf_sym
.st_shndx
= shndx
;
6836 /* Swap out the symbols. */
6839 swap_out_syms (bfd
*abfd
,
6840 struct bfd_strtab_hash
**sttp
,
6843 const struct elf_backend_data
*bed
;
6846 struct bfd_strtab_hash
*stt
;
6847 Elf_Internal_Shdr
*symtab_hdr
;
6848 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6849 Elf_Internal_Shdr
*symstrtab_hdr
;
6850 bfd_byte
*outbound_syms
;
6851 bfd_byte
*outbound_shndx
;
6853 unsigned int num_locals
;
6855 bfd_boolean name_local_sections
;
6857 if (!elf_map_symbols (abfd
, &num_locals
))
6860 /* Dump out the symtabs. */
6861 stt
= _bfd_elf_stringtab_init ();
6865 bed
= get_elf_backend_data (abfd
);
6866 symcount
= bfd_get_symcount (abfd
);
6867 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6868 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6869 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6870 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6871 symtab_hdr
->sh_info
= num_locals
+ 1;
6872 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6874 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6875 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6877 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
6878 bed
->s
->sizeof_sym
);
6879 if (outbound_syms
== NULL
)
6881 _bfd_stringtab_free (stt
);
6884 symtab_hdr
->contents
= outbound_syms
;
6886 outbound_shndx
= NULL
;
6887 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6888 if (symtab_shndx_hdr
->sh_name
!= 0)
6890 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6891 outbound_shndx
= (bfd_byte
*)
6892 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
6893 if (outbound_shndx
== NULL
)
6895 _bfd_stringtab_free (stt
);
6899 symtab_shndx_hdr
->contents
= outbound_shndx
;
6900 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6901 symtab_shndx_hdr
->sh_size
= amt
;
6902 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6903 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6906 /* Now generate the data (for "contents"). */
6908 /* Fill in zeroth symbol and swap it out. */
6909 Elf_Internal_Sym sym
;
6915 sym
.st_shndx
= SHN_UNDEF
;
6916 sym
.st_target_internal
= 0;
6917 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6918 outbound_syms
+= bed
->s
->sizeof_sym
;
6919 if (outbound_shndx
!= NULL
)
6920 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6924 = (bed
->elf_backend_name_local_section_symbols
6925 && bed
->elf_backend_name_local_section_symbols (abfd
));
6927 syms
= bfd_get_outsymbols (abfd
);
6928 for (idx
= 0; idx
< symcount
; idx
++)
6930 Elf_Internal_Sym sym
;
6931 bfd_vma value
= syms
[idx
]->value
;
6932 elf_symbol_type
*type_ptr
;
6933 flagword flags
= syms
[idx
]->flags
;
6936 if (!name_local_sections
6937 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6939 /* Local section symbols have no name. */
6944 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6947 if (sym
.st_name
== (unsigned long) -1)
6949 _bfd_stringtab_free (stt
);
6954 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6956 if ((flags
& BSF_SECTION_SYM
) == 0
6957 && bfd_is_com_section (syms
[idx
]->section
))
6959 /* ELF common symbols put the alignment into the `value' field,
6960 and the size into the `size' field. This is backwards from
6961 how BFD handles it, so reverse it here. */
6962 sym
.st_size
= value
;
6963 if (type_ptr
== NULL
6964 || type_ptr
->internal_elf_sym
.st_value
== 0)
6965 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6967 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6968 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6969 (abfd
, syms
[idx
]->section
);
6973 asection
*sec
= syms
[idx
]->section
;
6976 if (sec
->output_section
)
6978 value
+= sec
->output_offset
;
6979 sec
= sec
->output_section
;
6982 /* Don't add in the section vma for relocatable output. */
6983 if (! relocatable_p
)
6985 sym
.st_value
= value
;
6986 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6988 if (bfd_is_abs_section (sec
)
6990 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6992 /* This symbol is in a real ELF section which we did
6993 not create as a BFD section. Undo the mapping done
6994 by copy_private_symbol_data. */
6995 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6999 shndx
= elf_onesymtab (abfd
);
7002 shndx
= elf_dynsymtab (abfd
);
7005 shndx
= elf_strtab_sec (abfd
);
7008 shndx
= elf_shstrtab_sec (abfd
);
7011 shndx
= elf_symtab_shndx (abfd
);
7020 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
7022 if (shndx
== SHN_BAD
)
7026 /* Writing this would be a hell of a lot easier if
7027 we had some decent documentation on bfd, and
7028 knew what to expect of the library, and what to
7029 demand of applications. For example, it
7030 appears that `objcopy' might not set the
7031 section of a symbol to be a section that is
7032 actually in the output file. */
7033 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
7036 _bfd_error_handler (_("\
7037 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7038 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
7040 bfd_set_error (bfd_error_invalid_operation
);
7041 _bfd_stringtab_free (stt
);
7045 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
7046 BFD_ASSERT (shndx
!= SHN_BAD
);
7050 sym
.st_shndx
= shndx
;
7053 if ((flags
& BSF_THREAD_LOCAL
) != 0)
7055 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
7056 type
= STT_GNU_IFUNC
;
7057 else if ((flags
& BSF_FUNCTION
) != 0)
7059 else if ((flags
& BSF_OBJECT
) != 0)
7061 else if ((flags
& BSF_RELC
) != 0)
7063 else if ((flags
& BSF_SRELC
) != 0)
7068 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
7071 /* Processor-specific types. */
7072 if (type_ptr
!= NULL
7073 && bed
->elf_backend_get_symbol_type
)
7074 type
= ((*bed
->elf_backend_get_symbol_type
)
7075 (&type_ptr
->internal_elf_sym
, type
));
7077 if (flags
& BSF_SECTION_SYM
)
7079 if (flags
& BSF_GLOBAL
)
7080 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7082 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
7084 else if (bfd_is_com_section (syms
[idx
]->section
))
7086 #ifdef USE_STT_COMMON
7087 if (type
== STT_OBJECT
)
7088 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
7091 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
7093 else if (bfd_is_und_section (syms
[idx
]->section
))
7094 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
7098 else if (flags
& BSF_FILE
)
7099 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
7102 int bind
= STB_LOCAL
;
7104 if (flags
& BSF_LOCAL
)
7106 else if (flags
& BSF_GNU_UNIQUE
)
7107 bind
= STB_GNU_UNIQUE
;
7108 else if (flags
& BSF_WEAK
)
7110 else if (flags
& BSF_GLOBAL
)
7113 sym
.st_info
= ELF_ST_INFO (bind
, type
);
7116 if (type_ptr
!= NULL
)
7118 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
7119 sym
.st_target_internal
7120 = type_ptr
->internal_elf_sym
.st_target_internal
;
7125 sym
.st_target_internal
= 0;
7128 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
7129 outbound_syms
+= bed
->s
->sizeof_sym
;
7130 if (outbound_shndx
!= NULL
)
7131 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
7135 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
7136 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7138 symstrtab_hdr
->sh_flags
= 0;
7139 symstrtab_hdr
->sh_addr
= 0;
7140 symstrtab_hdr
->sh_entsize
= 0;
7141 symstrtab_hdr
->sh_link
= 0;
7142 symstrtab_hdr
->sh_info
= 0;
7143 symstrtab_hdr
->sh_addralign
= 1;
7148 /* Return the number of bytes required to hold the symtab vector.
7150 Note that we base it on the count plus 1, since we will null terminate
7151 the vector allocated based on this size. However, the ELF symbol table
7152 always has a dummy entry as symbol #0, so it ends up even. */
7155 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
7159 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7161 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7162 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7164 symtab_size
-= sizeof (asymbol
*);
7170 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
7174 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
7176 if (elf_dynsymtab (abfd
) == 0)
7178 bfd_set_error (bfd_error_invalid_operation
);
7182 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7183 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7185 symtab_size
-= sizeof (asymbol
*);
7191 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
7194 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
7197 /* Canonicalize the relocs. */
7200 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
7207 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7209 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
7212 tblptr
= section
->relocation
;
7213 for (i
= 0; i
< section
->reloc_count
; i
++)
7214 *relptr
++ = tblptr
++;
7218 return section
->reloc_count
;
7222 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
7224 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7225 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
7228 bfd_get_symcount (abfd
) = symcount
;
7233 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
7234 asymbol
**allocation
)
7236 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7237 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
7240 bfd_get_dynamic_symcount (abfd
) = symcount
;
7244 /* Return the size required for the dynamic reloc entries. Any loadable
7245 section that was actually installed in the BFD, and has type SHT_REL
7246 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7247 dynamic reloc section. */
7250 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
7255 if (elf_dynsymtab (abfd
) == 0)
7257 bfd_set_error (bfd_error_invalid_operation
);
7261 ret
= sizeof (arelent
*);
7262 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7263 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7264 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7265 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7266 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
7267 * sizeof (arelent
*));
7272 /* Canonicalize the dynamic relocation entries. Note that we return the
7273 dynamic relocations as a single block, although they are actually
7274 associated with particular sections; the interface, which was
7275 designed for SunOS style shared libraries, expects that there is only
7276 one set of dynamic relocs. Any loadable section that was actually
7277 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7278 dynamic symbol table, is considered to be a dynamic reloc section. */
7281 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
7285 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
7289 if (elf_dynsymtab (abfd
) == 0)
7291 bfd_set_error (bfd_error_invalid_operation
);
7295 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
7297 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7299 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7300 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7301 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7306 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
7308 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
7310 for (i
= 0; i
< count
; i
++)
7321 /* Read in the version information. */
7324 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
7326 bfd_byte
*contents
= NULL
;
7327 unsigned int freeidx
= 0;
7329 if (elf_dynverref (abfd
) != 0)
7331 Elf_Internal_Shdr
*hdr
;
7332 Elf_External_Verneed
*everneed
;
7333 Elf_Internal_Verneed
*iverneed
;
7335 bfd_byte
*contents_end
;
7337 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
7339 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verneed
))
7341 error_return_bad_verref
:
7342 (*_bfd_error_handler
)
7343 (_("%B: .gnu.version_r invalid entry"), abfd
);
7344 bfd_set_error (bfd_error_bad_value
);
7345 error_return_verref
:
7346 elf_tdata (abfd
)->verref
= NULL
;
7347 elf_tdata (abfd
)->cverrefs
= 0;
7351 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7352 if (contents
== NULL
)
7353 goto error_return_verref
;
7355 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7356 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7357 goto error_return_verref
;
7359 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
7360 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
7362 if (elf_tdata (abfd
)->verref
== NULL
)
7363 goto error_return_verref
;
7365 BFD_ASSERT (sizeof (Elf_External_Verneed
)
7366 == sizeof (Elf_External_Vernaux
));
7367 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
7368 everneed
= (Elf_External_Verneed
*) contents
;
7369 iverneed
= elf_tdata (abfd
)->verref
;
7370 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
7372 Elf_External_Vernaux
*evernaux
;
7373 Elf_Internal_Vernaux
*ivernaux
;
7376 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
7378 iverneed
->vn_bfd
= abfd
;
7380 iverneed
->vn_filename
=
7381 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7383 if (iverneed
->vn_filename
== NULL
)
7384 goto error_return_bad_verref
;
7386 if (iverneed
->vn_cnt
== 0)
7387 iverneed
->vn_auxptr
= NULL
;
7390 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
7391 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
7392 sizeof (Elf_Internal_Vernaux
));
7393 if (iverneed
->vn_auxptr
== NULL
)
7394 goto error_return_verref
;
7397 if (iverneed
->vn_aux
7398 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7399 goto error_return_bad_verref
;
7401 evernaux
= ((Elf_External_Vernaux
*)
7402 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
7403 ivernaux
= iverneed
->vn_auxptr
;
7404 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
7406 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
7408 ivernaux
->vna_nodename
=
7409 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7410 ivernaux
->vna_name
);
7411 if (ivernaux
->vna_nodename
== NULL
)
7412 goto error_return_bad_verref
;
7414 if (ivernaux
->vna_other
> freeidx
)
7415 freeidx
= ivernaux
->vna_other
;
7417 ivernaux
->vna_nextptr
= NULL
;
7418 if (ivernaux
->vna_next
== 0)
7420 iverneed
->vn_cnt
= j
+ 1;
7423 if (j
+ 1 < iverneed
->vn_cnt
)
7424 ivernaux
->vna_nextptr
= ivernaux
+ 1;
7426 if (ivernaux
->vna_next
7427 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
7428 goto error_return_bad_verref
;
7430 evernaux
= ((Elf_External_Vernaux
*)
7431 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
7434 iverneed
->vn_nextref
= NULL
;
7435 if (iverneed
->vn_next
== 0)
7437 if (i
+ 1 < hdr
->sh_info
)
7438 iverneed
->vn_nextref
= iverneed
+ 1;
7440 if (iverneed
->vn_next
7441 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7442 goto error_return_bad_verref
;
7444 everneed
= ((Elf_External_Verneed
*)
7445 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
7447 elf_tdata (abfd
)->cverrefs
= i
;
7453 if (elf_dynverdef (abfd
) != 0)
7455 Elf_Internal_Shdr
*hdr
;
7456 Elf_External_Verdef
*everdef
;
7457 Elf_Internal_Verdef
*iverdef
;
7458 Elf_Internal_Verdef
*iverdefarr
;
7459 Elf_Internal_Verdef iverdefmem
;
7461 unsigned int maxidx
;
7462 bfd_byte
*contents_end_def
, *contents_end_aux
;
7464 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
7466 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
7468 error_return_bad_verdef
:
7469 (*_bfd_error_handler
)
7470 (_("%B: .gnu.version_d invalid entry"), abfd
);
7471 bfd_set_error (bfd_error_bad_value
);
7472 error_return_verdef
:
7473 elf_tdata (abfd
)->verdef
= NULL
;
7474 elf_tdata (abfd
)->cverdefs
= 0;
7478 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7479 if (contents
== NULL
)
7480 goto error_return_verdef
;
7481 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7482 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7483 goto error_return_verdef
;
7485 BFD_ASSERT (sizeof (Elf_External_Verdef
)
7486 >= sizeof (Elf_External_Verdaux
));
7487 contents_end_def
= contents
+ hdr
->sh_size
7488 - sizeof (Elf_External_Verdef
);
7489 contents_end_aux
= contents
+ hdr
->sh_size
7490 - sizeof (Elf_External_Verdaux
);
7492 /* We know the number of entries in the section but not the maximum
7493 index. Therefore we have to run through all entries and find
7495 everdef
= (Elf_External_Verdef
*) contents
;
7497 for (i
= 0; i
< hdr
->sh_info
; ++i
)
7499 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7501 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
7502 goto error_return_bad_verdef
;
7503 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
7504 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
7506 if (iverdefmem
.vd_next
== 0)
7509 if (iverdefmem
.vd_next
7510 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
7511 goto error_return_bad_verdef
;
7513 everdef
= ((Elf_External_Verdef
*)
7514 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
7517 if (default_imported_symver
)
7519 if (freeidx
> maxidx
)
7525 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7526 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
7527 if (elf_tdata (abfd
)->verdef
== NULL
)
7528 goto error_return_verdef
;
7530 elf_tdata (abfd
)->cverdefs
= maxidx
;
7532 everdef
= (Elf_External_Verdef
*) contents
;
7533 iverdefarr
= elf_tdata (abfd
)->verdef
;
7534 for (i
= 0; i
< hdr
->sh_info
; i
++)
7536 Elf_External_Verdaux
*everdaux
;
7537 Elf_Internal_Verdaux
*iverdaux
;
7540 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7542 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
7543 goto error_return_bad_verdef
;
7545 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
7546 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
7548 iverdef
->vd_bfd
= abfd
;
7550 if (iverdef
->vd_cnt
== 0)
7551 iverdef
->vd_auxptr
= NULL
;
7554 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7555 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
7556 sizeof (Elf_Internal_Verdaux
));
7557 if (iverdef
->vd_auxptr
== NULL
)
7558 goto error_return_verdef
;
7562 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
7563 goto error_return_bad_verdef
;
7565 everdaux
= ((Elf_External_Verdaux
*)
7566 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
7567 iverdaux
= iverdef
->vd_auxptr
;
7568 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
7570 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
7572 iverdaux
->vda_nodename
=
7573 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7574 iverdaux
->vda_name
);
7575 if (iverdaux
->vda_nodename
== NULL
)
7576 goto error_return_bad_verdef
;
7578 iverdaux
->vda_nextptr
= NULL
;
7579 if (iverdaux
->vda_next
== 0)
7581 iverdef
->vd_cnt
= j
+ 1;
7584 if (j
+ 1 < iverdef
->vd_cnt
)
7585 iverdaux
->vda_nextptr
= iverdaux
+ 1;
7587 if (iverdaux
->vda_next
7588 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
7589 goto error_return_bad_verdef
;
7591 everdaux
= ((Elf_External_Verdaux
*)
7592 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
7595 if (iverdef
->vd_cnt
)
7596 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
7598 iverdef
->vd_nextdef
= NULL
;
7599 if (iverdef
->vd_next
== 0)
7601 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
7602 iverdef
->vd_nextdef
= iverdef
+ 1;
7604 everdef
= ((Elf_External_Verdef
*)
7605 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
7611 else if (default_imported_symver
)
7618 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7619 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
7620 if (elf_tdata (abfd
)->verdef
== NULL
)
7623 elf_tdata (abfd
)->cverdefs
= freeidx
;
7626 /* Create a default version based on the soname. */
7627 if (default_imported_symver
)
7629 Elf_Internal_Verdef
*iverdef
;
7630 Elf_Internal_Verdaux
*iverdaux
;
7632 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
7634 iverdef
->vd_version
= VER_DEF_CURRENT
;
7635 iverdef
->vd_flags
= 0;
7636 iverdef
->vd_ndx
= freeidx
;
7637 iverdef
->vd_cnt
= 1;
7639 iverdef
->vd_bfd
= abfd
;
7641 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
7642 if (iverdef
->vd_nodename
== NULL
)
7643 goto error_return_verdef
;
7644 iverdef
->vd_nextdef
= NULL
;
7645 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
7646 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
7647 if (iverdef
->vd_auxptr
== NULL
)
7648 goto error_return_verdef
;
7650 iverdaux
= iverdef
->vd_auxptr
;
7651 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
7657 if (contents
!= NULL
)
7663 _bfd_elf_make_empty_symbol (bfd
*abfd
)
7665 elf_symbol_type
*newsym
;
7667 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
7670 newsym
->symbol
.the_bfd
= abfd
;
7671 return &newsym
->symbol
;
7675 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
7679 bfd_symbol_info (symbol
, ret
);
7682 /* Return whether a symbol name implies a local symbol. Most targets
7683 use this function for the is_local_label_name entry point, but some
7687 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
7690 /* Normal local symbols start with ``.L''. */
7691 if (name
[0] == '.' && name
[1] == 'L')
7694 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7695 DWARF debugging symbols starting with ``..''. */
7696 if (name
[0] == '.' && name
[1] == '.')
7699 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7700 emitting DWARF debugging output. I suspect this is actually a
7701 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7702 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7703 underscore to be emitted on some ELF targets). For ease of use,
7704 we treat such symbols as local. */
7705 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
7712 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7713 asymbol
*symbol ATTRIBUTE_UNUSED
)
7720 _bfd_elf_set_arch_mach (bfd
*abfd
,
7721 enum bfd_architecture arch
,
7722 unsigned long machine
)
7724 /* If this isn't the right architecture for this backend, and this
7725 isn't the generic backend, fail. */
7726 if (arch
!= get_elf_backend_data (abfd
)->arch
7727 && arch
!= bfd_arch_unknown
7728 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7731 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7734 /* Find the nearest line to a particular section and offset,
7735 for error reporting. */
7738 _bfd_elf_find_nearest_line (bfd
*abfd
,
7742 const char **filename_ptr
,
7743 const char **functionname_ptr
,
7744 unsigned int *line_ptr
,
7745 unsigned int *discriminator_ptr
)
7749 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
7750 filename_ptr
, functionname_ptr
,
7751 line_ptr
, discriminator_ptr
,
7752 dwarf_debug_sections
, 0,
7753 &elf_tdata (abfd
)->dwarf2_find_line_info
)
7754 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
7755 filename_ptr
, functionname_ptr
,
7758 if (!*functionname_ptr
)
7759 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
7760 *filename_ptr
? NULL
: filename_ptr
,
7765 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7766 &found
, filename_ptr
,
7767 functionname_ptr
, line_ptr
,
7768 &elf_tdata (abfd
)->line_info
))
7770 if (found
&& (*functionname_ptr
|| *line_ptr
))
7773 if (symbols
== NULL
)
7776 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
7777 filename_ptr
, functionname_ptr
))
7784 /* Find the line for a symbol. */
7787 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7788 const char **filename_ptr
, unsigned int *line_ptr
)
7790 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
7791 filename_ptr
, NULL
, line_ptr
, NULL
,
7792 dwarf_debug_sections
, 0,
7793 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7796 /* After a call to bfd_find_nearest_line, successive calls to
7797 bfd_find_inliner_info can be used to get source information about
7798 each level of function inlining that terminated at the address
7799 passed to bfd_find_nearest_line. Currently this is only supported
7800 for DWARF2 with appropriate DWARF3 extensions. */
7803 _bfd_elf_find_inliner_info (bfd
*abfd
,
7804 const char **filename_ptr
,
7805 const char **functionname_ptr
,
7806 unsigned int *line_ptr
)
7809 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7810 functionname_ptr
, line_ptr
,
7811 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7816 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7818 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7819 int ret
= bed
->s
->sizeof_ehdr
;
7821 if (!info
->relocatable
)
7823 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
7825 if (phdr_size
== (bfd_size_type
) -1)
7827 struct elf_segment_map
*m
;
7830 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
7831 phdr_size
+= bed
->s
->sizeof_phdr
;
7834 phdr_size
= get_program_header_size (abfd
, info
);
7837 elf_program_header_size (abfd
) = phdr_size
;
7845 _bfd_elf_set_section_contents (bfd
*abfd
,
7847 const void *location
,
7849 bfd_size_type count
)
7851 Elf_Internal_Shdr
*hdr
;
7854 if (! abfd
->output_has_begun
7855 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7858 hdr
= &elf_section_data (section
)->this_hdr
;
7859 pos
= hdr
->sh_offset
+ offset
;
7860 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7861 || bfd_bwrite (location
, count
, abfd
) != count
)
7868 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7869 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7870 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7875 /* Try to convert a non-ELF reloc into an ELF one. */
7878 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7880 /* Check whether we really have an ELF howto. */
7882 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7884 bfd_reloc_code_real_type code
;
7885 reloc_howto_type
*howto
;
7887 /* Alien reloc: Try to determine its type to replace it with an
7888 equivalent ELF reloc. */
7890 if (areloc
->howto
->pc_relative
)
7892 switch (areloc
->howto
->bitsize
)
7895 code
= BFD_RELOC_8_PCREL
;
7898 code
= BFD_RELOC_12_PCREL
;
7901 code
= BFD_RELOC_16_PCREL
;
7904 code
= BFD_RELOC_24_PCREL
;
7907 code
= BFD_RELOC_32_PCREL
;
7910 code
= BFD_RELOC_64_PCREL
;
7916 howto
= bfd_reloc_type_lookup (abfd
, code
);
7918 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7920 if (howto
->pcrel_offset
)
7921 areloc
->addend
+= areloc
->address
;
7923 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7928 switch (areloc
->howto
->bitsize
)
7934 code
= BFD_RELOC_14
;
7937 code
= BFD_RELOC_16
;
7940 code
= BFD_RELOC_26
;
7943 code
= BFD_RELOC_32
;
7946 code
= BFD_RELOC_64
;
7952 howto
= bfd_reloc_type_lookup (abfd
, code
);
7956 areloc
->howto
= howto
;
7964 (*_bfd_error_handler
)
7965 (_("%B: unsupported relocation type %s"),
7966 abfd
, areloc
->howto
->name
);
7967 bfd_set_error (bfd_error_bad_value
);
7972 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7974 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
7975 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
7977 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
7978 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7979 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
7982 return _bfd_generic_close_and_cleanup (abfd
);
7985 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7986 in the relocation's offset. Thus we cannot allow any sort of sanity
7987 range-checking to interfere. There is nothing else to do in processing
7990 bfd_reloc_status_type
7991 _bfd_elf_rel_vtable_reloc_fn
7992 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7993 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7994 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7995 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7997 return bfd_reloc_ok
;
8000 /* Elf core file support. Much of this only works on native
8001 toolchains, since we rely on knowing the
8002 machine-dependent procfs structure in order to pick
8003 out details about the corefile. */
8005 #ifdef HAVE_SYS_PROCFS_H
8006 /* Needed for new procfs interface on sparc-solaris. */
8007 # define _STRUCTURED_PROC 1
8008 # include <sys/procfs.h>
8011 /* Return a PID that identifies a "thread" for threaded cores, or the
8012 PID of the main process for non-threaded cores. */
8015 elfcore_make_pid (bfd
*abfd
)
8019 pid
= elf_tdata (abfd
)->core
->lwpid
;
8021 pid
= elf_tdata (abfd
)->core
->pid
;
8026 /* If there isn't a section called NAME, make one, using
8027 data from SECT. Note, this function will generate a
8028 reference to NAME, so you shouldn't deallocate or
8032 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
8036 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
8039 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
8043 sect2
->size
= sect
->size
;
8044 sect2
->filepos
= sect
->filepos
;
8045 sect2
->alignment_power
= sect
->alignment_power
;
8049 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
8050 actually creates up to two pseudosections:
8051 - For the single-threaded case, a section named NAME, unless
8052 such a section already exists.
8053 - For the multi-threaded case, a section named "NAME/PID", where
8054 PID is elfcore_make_pid (abfd).
8055 Both pseudosections have identical contents. */
8057 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
8063 char *threaded_name
;
8067 /* Build the section name. */
8069 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
8070 len
= strlen (buf
) + 1;
8071 threaded_name
= (char *) bfd_alloc (abfd
, len
);
8072 if (threaded_name
== NULL
)
8074 memcpy (threaded_name
, buf
, len
);
8076 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
8081 sect
->filepos
= filepos
;
8082 sect
->alignment_power
= 2;
8084 return elfcore_maybe_make_sect (abfd
, name
, sect
);
8087 /* prstatus_t exists on:
8089 linux 2.[01] + glibc
8093 #if defined (HAVE_PRSTATUS_T)
8096 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8101 if (note
->descsz
== sizeof (prstatus_t
))
8105 size
= sizeof (prstat
.pr_reg
);
8106 offset
= offsetof (prstatus_t
, pr_reg
);
8107 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8109 /* Do not overwrite the core signal if it
8110 has already been set by another thread. */
8111 if (elf_tdata (abfd
)->core
->signal
== 0)
8112 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8113 if (elf_tdata (abfd
)->core
->pid
== 0)
8114 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8116 /* pr_who exists on:
8119 pr_who doesn't exist on:
8122 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8123 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8125 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8128 #if defined (HAVE_PRSTATUS32_T)
8129 else if (note
->descsz
== sizeof (prstatus32_t
))
8131 /* 64-bit host, 32-bit corefile */
8132 prstatus32_t prstat
;
8134 size
= sizeof (prstat
.pr_reg
);
8135 offset
= offsetof (prstatus32_t
, pr_reg
);
8136 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8138 /* Do not overwrite the core signal if it
8139 has already been set by another thread. */
8140 if (elf_tdata (abfd
)->core
->signal
== 0)
8141 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8142 if (elf_tdata (abfd
)->core
->pid
== 0)
8143 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8145 /* pr_who exists on:
8148 pr_who doesn't exist on:
8151 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8152 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8154 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8157 #endif /* HAVE_PRSTATUS32_T */
8160 /* Fail - we don't know how to handle any other
8161 note size (ie. data object type). */
8165 /* Make a ".reg/999" section and a ".reg" section. */
8166 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
8167 size
, note
->descpos
+ offset
);
8169 #endif /* defined (HAVE_PRSTATUS_T) */
8171 /* Create a pseudosection containing the exact contents of NOTE. */
8173 elfcore_make_note_pseudosection (bfd
*abfd
,
8175 Elf_Internal_Note
*note
)
8177 return _bfd_elfcore_make_pseudosection (abfd
, name
,
8178 note
->descsz
, note
->descpos
);
8181 /* There isn't a consistent prfpregset_t across platforms,
8182 but it doesn't matter, because we don't have to pick this
8183 data structure apart. */
8186 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8188 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8191 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8192 type of NT_PRXFPREG. Just include the whole note's contents
8196 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8198 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
8201 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8202 with a note type of NT_X86_XSTATE. Just include the whole note's
8203 contents literally. */
8206 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
8208 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
8212 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
8214 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
8218 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
8220 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
8224 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
8226 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
8230 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
8232 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
8236 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
8238 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
8242 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8244 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
8248 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
8250 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
8254 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
8256 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
8260 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8262 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
8266 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
8268 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
8272 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
8274 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
8278 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
8280 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
8284 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
8286 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
8290 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
8292 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
8296 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
8298 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
8302 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8304 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
8308 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
8310 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
8313 #if defined (HAVE_PRPSINFO_T)
8314 typedef prpsinfo_t elfcore_psinfo_t
;
8315 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
8316 typedef prpsinfo32_t elfcore_psinfo32_t
;
8320 #if defined (HAVE_PSINFO_T)
8321 typedef psinfo_t elfcore_psinfo_t
;
8322 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
8323 typedef psinfo32_t elfcore_psinfo32_t
;
8327 /* return a malloc'ed copy of a string at START which is at
8328 most MAX bytes long, possibly without a terminating '\0'.
8329 the copy will always have a terminating '\0'. */
8332 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
8335 char *end
= (char *) memchr (start
, '\0', max
);
8343 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
8347 memcpy (dups
, start
, len
);
8353 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8355 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8357 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
8359 elfcore_psinfo_t psinfo
;
8361 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8363 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8364 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8366 elf_tdata (abfd
)->core
->program
8367 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8368 sizeof (psinfo
.pr_fname
));
8370 elf_tdata (abfd
)->core
->command
8371 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8372 sizeof (psinfo
.pr_psargs
));
8374 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8375 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
8377 /* 64-bit host, 32-bit corefile */
8378 elfcore_psinfo32_t psinfo
;
8380 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8382 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8383 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8385 elf_tdata (abfd
)->core
->program
8386 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8387 sizeof (psinfo
.pr_fname
));
8389 elf_tdata (abfd
)->core
->command
8390 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8391 sizeof (psinfo
.pr_psargs
));
8397 /* Fail - we don't know how to handle any other
8398 note size (ie. data object type). */
8402 /* Note that for some reason, a spurious space is tacked
8403 onto the end of the args in some (at least one anyway)
8404 implementations, so strip it off if it exists. */
8407 char *command
= elf_tdata (abfd
)->core
->command
;
8408 int n
= strlen (command
);
8410 if (0 < n
&& command
[n
- 1] == ' ')
8411 command
[n
- 1] = '\0';
8416 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8418 #if defined (HAVE_PSTATUS_T)
8420 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8422 if (note
->descsz
== sizeof (pstatus_t
)
8423 #if defined (HAVE_PXSTATUS_T)
8424 || note
->descsz
== sizeof (pxstatus_t
)
8430 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8432 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8434 #if defined (HAVE_PSTATUS32_T)
8435 else if (note
->descsz
== sizeof (pstatus32_t
))
8437 /* 64-bit host, 32-bit corefile */
8440 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8442 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8445 /* Could grab some more details from the "representative"
8446 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8447 NT_LWPSTATUS note, presumably. */
8451 #endif /* defined (HAVE_PSTATUS_T) */
8453 #if defined (HAVE_LWPSTATUS_T)
8455 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8457 lwpstatus_t lwpstat
;
8463 if (note
->descsz
!= sizeof (lwpstat
)
8464 #if defined (HAVE_LWPXSTATUS_T)
8465 && note
->descsz
!= sizeof (lwpxstatus_t
)
8470 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
8472 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
8473 /* Do not overwrite the core signal if it has already been set by
8475 if (elf_tdata (abfd
)->core
->signal
== 0)
8476 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
8478 /* Make a ".reg/999" section. */
8480 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
8481 len
= strlen (buf
) + 1;
8482 name
= bfd_alloc (abfd
, len
);
8485 memcpy (name
, buf
, len
);
8487 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8491 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8492 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
8493 sect
->filepos
= note
->descpos
8494 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
8497 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8498 sect
->size
= sizeof (lwpstat
.pr_reg
);
8499 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
8502 sect
->alignment_power
= 2;
8504 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8507 /* Make a ".reg2/999" section */
8509 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
8510 len
= strlen (buf
) + 1;
8511 name
= bfd_alloc (abfd
, len
);
8514 memcpy (name
, buf
, len
);
8516 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8520 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8521 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
8522 sect
->filepos
= note
->descpos
8523 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
8526 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8527 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
8528 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
8531 sect
->alignment_power
= 2;
8533 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
8535 #endif /* defined (HAVE_LWPSTATUS_T) */
8538 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8545 int is_active_thread
;
8548 if (note
->descsz
< 728)
8551 if (! CONST_STRNEQ (note
->namedata
, "win32"))
8554 type
= bfd_get_32 (abfd
, note
->descdata
);
8558 case 1 /* NOTE_INFO_PROCESS */:
8559 /* FIXME: need to add ->core->command. */
8560 /* process_info.pid */
8561 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8562 /* process_info.signal */
8563 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
8566 case 2 /* NOTE_INFO_THREAD */:
8567 /* Make a ".reg/999" section. */
8568 /* thread_info.tid */
8569 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
8571 len
= strlen (buf
) + 1;
8572 name
= (char *) bfd_alloc (abfd
, len
);
8576 memcpy (name
, buf
, len
);
8578 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8582 /* sizeof (thread_info.thread_context) */
8584 /* offsetof (thread_info.thread_context) */
8585 sect
->filepos
= note
->descpos
+ 12;
8586 sect
->alignment_power
= 2;
8588 /* thread_info.is_active_thread */
8589 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8591 if (is_active_thread
)
8592 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8596 case 3 /* NOTE_INFO_MODULE */:
8597 /* Make a ".module/xxxxxxxx" section. */
8598 /* module_info.base_address */
8599 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
8600 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
8602 len
= strlen (buf
) + 1;
8603 name
= (char *) bfd_alloc (abfd
, len
);
8607 memcpy (name
, buf
, len
);
8609 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8614 sect
->size
= note
->descsz
;
8615 sect
->filepos
= note
->descpos
;
8616 sect
->alignment_power
= 2;
8627 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8629 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8637 if (bed
->elf_backend_grok_prstatus
)
8638 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
8640 #if defined (HAVE_PRSTATUS_T)
8641 return elfcore_grok_prstatus (abfd
, note
);
8646 #if defined (HAVE_PSTATUS_T)
8648 return elfcore_grok_pstatus (abfd
, note
);
8651 #if defined (HAVE_LWPSTATUS_T)
8653 return elfcore_grok_lwpstatus (abfd
, note
);
8656 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
8657 return elfcore_grok_prfpreg (abfd
, note
);
8659 case NT_WIN32PSTATUS
:
8660 return elfcore_grok_win32pstatus (abfd
, note
);
8662 case NT_PRXFPREG
: /* Linux SSE extension */
8663 if (note
->namesz
== 6
8664 && strcmp (note
->namedata
, "LINUX") == 0)
8665 return elfcore_grok_prxfpreg (abfd
, note
);
8669 case NT_X86_XSTATE
: /* Linux XSAVE extension */
8670 if (note
->namesz
== 6
8671 && strcmp (note
->namedata
, "LINUX") == 0)
8672 return elfcore_grok_xstatereg (abfd
, note
);
8677 if (note
->namesz
== 6
8678 && strcmp (note
->namedata
, "LINUX") == 0)
8679 return elfcore_grok_ppc_vmx (abfd
, note
);
8684 if (note
->namesz
== 6
8685 && strcmp (note
->namedata
, "LINUX") == 0)
8686 return elfcore_grok_ppc_vsx (abfd
, note
);
8690 case NT_S390_HIGH_GPRS
:
8691 if (note
->namesz
== 6
8692 && strcmp (note
->namedata
, "LINUX") == 0)
8693 return elfcore_grok_s390_high_gprs (abfd
, note
);
8698 if (note
->namesz
== 6
8699 && strcmp (note
->namedata
, "LINUX") == 0)
8700 return elfcore_grok_s390_timer (abfd
, note
);
8704 case NT_S390_TODCMP
:
8705 if (note
->namesz
== 6
8706 && strcmp (note
->namedata
, "LINUX") == 0)
8707 return elfcore_grok_s390_todcmp (abfd
, note
);
8711 case NT_S390_TODPREG
:
8712 if (note
->namesz
== 6
8713 && strcmp (note
->namedata
, "LINUX") == 0)
8714 return elfcore_grok_s390_todpreg (abfd
, note
);
8719 if (note
->namesz
== 6
8720 && strcmp (note
->namedata
, "LINUX") == 0)
8721 return elfcore_grok_s390_ctrs (abfd
, note
);
8725 case NT_S390_PREFIX
:
8726 if (note
->namesz
== 6
8727 && strcmp (note
->namedata
, "LINUX") == 0)
8728 return elfcore_grok_s390_prefix (abfd
, note
);
8732 case NT_S390_LAST_BREAK
:
8733 if (note
->namesz
== 6
8734 && strcmp (note
->namedata
, "LINUX") == 0)
8735 return elfcore_grok_s390_last_break (abfd
, note
);
8739 case NT_S390_SYSTEM_CALL
:
8740 if (note
->namesz
== 6
8741 && strcmp (note
->namedata
, "LINUX") == 0)
8742 return elfcore_grok_s390_system_call (abfd
, note
);
8747 if (note
->namesz
== 6
8748 && strcmp (note
->namedata
, "LINUX") == 0)
8749 return elfcore_grok_s390_tdb (abfd
, note
);
8753 case NT_S390_VXRS_LOW
:
8754 if (note
->namesz
== 6
8755 && strcmp (note
->namedata
, "LINUX") == 0)
8756 return elfcore_grok_s390_vxrs_low (abfd
, note
);
8760 case NT_S390_VXRS_HIGH
:
8761 if (note
->namesz
== 6
8762 && strcmp (note
->namedata
, "LINUX") == 0)
8763 return elfcore_grok_s390_vxrs_high (abfd
, note
);
8768 if (note
->namesz
== 6
8769 && strcmp (note
->namedata
, "LINUX") == 0)
8770 return elfcore_grok_arm_vfp (abfd
, note
);
8775 if (note
->namesz
== 6
8776 && strcmp (note
->namedata
, "LINUX") == 0)
8777 return elfcore_grok_aarch_tls (abfd
, note
);
8781 case NT_ARM_HW_BREAK
:
8782 if (note
->namesz
== 6
8783 && strcmp (note
->namedata
, "LINUX") == 0)
8784 return elfcore_grok_aarch_hw_break (abfd
, note
);
8788 case NT_ARM_HW_WATCH
:
8789 if (note
->namesz
== 6
8790 && strcmp (note
->namedata
, "LINUX") == 0)
8791 return elfcore_grok_aarch_hw_watch (abfd
, note
);
8797 if (bed
->elf_backend_grok_psinfo
)
8798 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
8800 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8801 return elfcore_grok_psinfo (abfd
, note
);
8808 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8813 sect
->size
= note
->descsz
;
8814 sect
->filepos
= note
->descpos
;
8815 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8821 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
8825 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
8831 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
8833 struct elf_obj_tdata
*t
;
8835 if (note
->descsz
== 0)
8838 t
= elf_tdata (abfd
);
8839 t
->build_id
= bfd_alloc (abfd
, sizeof (*t
->build_id
) - 1 + note
->descsz
);
8840 if (t
->build_id
== NULL
)
8843 t
->build_id
->size
= note
->descsz
;
8844 memcpy (t
->build_id
->data
, note
->descdata
, note
->descsz
);
8850 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8857 case NT_GNU_BUILD_ID
:
8858 return elfobj_grok_gnu_build_id (abfd
, note
);
8863 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
8865 struct sdt_note
*cur
=
8866 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
8869 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
8870 cur
->size
= (bfd_size_type
) note
->descsz
;
8871 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
8873 elf_tdata (abfd
)->sdt_note_head
= cur
;
8879 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8884 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
8892 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
8896 cp
= strchr (note
->namedata
, '@');
8899 *lwpidp
= atoi(cp
+ 1);
8906 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8908 /* Signal number at offset 0x08. */
8909 elf_tdata (abfd
)->core
->signal
8910 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8912 /* Process ID at offset 0x50. */
8913 elf_tdata (abfd
)->core
->pid
8914 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8916 /* Command name at 0x7c (max 32 bytes, including nul). */
8917 elf_tdata (abfd
)->core
->command
8918 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8920 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8925 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8929 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8930 elf_tdata (abfd
)->core
->lwpid
= lwp
;
8932 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
8934 /* NetBSD-specific core "procinfo". Note that we expect to
8935 find this note before any of the others, which is fine,
8936 since the kernel writes this note out first when it
8937 creates a core file. */
8939 return elfcore_grok_netbsd_procinfo (abfd
, note
);
8942 /* As of Jan 2002 there are no other machine-independent notes
8943 defined for NetBSD core files. If the note type is less
8944 than the start of the machine-dependent note types, we don't
8947 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8951 switch (bfd_get_arch (abfd
))
8953 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8954 PT_GETFPREGS == mach+2. */
8956 case bfd_arch_alpha
:
8957 case bfd_arch_sparc
:
8960 case NT_NETBSDCORE_FIRSTMACH
+0:
8961 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8963 case NT_NETBSDCORE_FIRSTMACH
+2:
8964 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8970 /* On all other arch's, PT_GETREGS == mach+1 and
8971 PT_GETFPREGS == mach+3. */
8976 case NT_NETBSDCORE_FIRSTMACH
+1:
8977 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8979 case NT_NETBSDCORE_FIRSTMACH
+3:
8980 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8990 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8992 /* Signal number at offset 0x08. */
8993 elf_tdata (abfd
)->core
->signal
8994 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8996 /* Process ID at offset 0x20. */
8997 elf_tdata (abfd
)->core
->pid
8998 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
9000 /* Command name at 0x48 (max 32 bytes, including nul). */
9001 elf_tdata (abfd
)->core
->command
9002 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
9008 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9010 if (note
->type
== NT_OPENBSD_PROCINFO
)
9011 return elfcore_grok_openbsd_procinfo (abfd
, note
);
9013 if (note
->type
== NT_OPENBSD_REGS
)
9014 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9016 if (note
->type
== NT_OPENBSD_FPREGS
)
9017 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9019 if (note
->type
== NT_OPENBSD_XFPREGS
)
9020 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9022 if (note
->type
== NT_OPENBSD_AUXV
)
9024 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9029 sect
->size
= note
->descsz
;
9030 sect
->filepos
= note
->descpos
;
9031 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9036 if (note
->type
== NT_OPENBSD_WCOOKIE
)
9038 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
9043 sect
->size
= note
->descsz
;
9044 sect
->filepos
= note
->descpos
;
9045 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9054 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
9056 void *ddata
= note
->descdata
;
9063 /* nto_procfs_status 'pid' field is at offset 0. */
9064 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
9066 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
9067 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
9069 /* nto_procfs_status 'flags' field is at offset 8. */
9070 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
9072 /* nto_procfs_status 'what' field is at offset 14. */
9073 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
9075 elf_tdata (abfd
)->core
->signal
= sig
;
9076 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9079 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
9080 do not come from signals so we make sure we set the current
9081 thread just in case. */
9082 if (flags
& 0x00000080)
9083 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9085 /* Make a ".qnx_core_status/%d" section. */
9086 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
9088 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9093 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9097 sect
->size
= note
->descsz
;
9098 sect
->filepos
= note
->descpos
;
9099 sect
->alignment_power
= 2;
9101 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
9105 elfcore_grok_nto_regs (bfd
*abfd
,
9106 Elf_Internal_Note
*note
,
9114 /* Make a "(base)/%d" section. */
9115 sprintf (buf
, "%s/%ld", base
, tid
);
9117 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9122 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9126 sect
->size
= note
->descsz
;
9127 sect
->filepos
= note
->descpos
;
9128 sect
->alignment_power
= 2;
9130 /* This is the current thread. */
9131 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
9132 return elfcore_maybe_make_sect (abfd
, base
, sect
);
9137 #define BFD_QNT_CORE_INFO 7
9138 #define BFD_QNT_CORE_STATUS 8
9139 #define BFD_QNT_CORE_GREG 9
9140 #define BFD_QNT_CORE_FPREG 10
9143 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9145 /* Every GREG section has a STATUS section before it. Store the
9146 tid from the previous call to pass down to the next gregs
9148 static long tid
= 1;
9152 case BFD_QNT_CORE_INFO
:
9153 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
9154 case BFD_QNT_CORE_STATUS
:
9155 return elfcore_grok_nto_status (abfd
, note
, &tid
);
9156 case BFD_QNT_CORE_GREG
:
9157 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
9158 case BFD_QNT_CORE_FPREG
:
9159 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
9166 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9172 /* Use note name as section name. */
9174 name
= (char *) bfd_alloc (abfd
, len
);
9177 memcpy (name
, note
->namedata
, len
);
9178 name
[len
- 1] = '\0';
9180 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9184 sect
->size
= note
->descsz
;
9185 sect
->filepos
= note
->descpos
;
9186 sect
->alignment_power
= 1;
9191 /* Function: elfcore_write_note
9194 buffer to hold note, and current size of buffer
9198 size of data for note
9200 Writes note to end of buffer. ELF64 notes are written exactly as
9201 for ELF32, despite the current (as of 2006) ELF gabi specifying
9202 that they ought to have 8-byte namesz and descsz field, and have
9203 8-byte alignment. Other writers, eg. Linux kernel, do the same.
9206 Pointer to realloc'd buffer, *BUFSIZ updated. */
9209 elfcore_write_note (bfd
*abfd
,
9217 Elf_External_Note
*xnp
;
9224 namesz
= strlen (name
) + 1;
9226 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
9228 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
9231 dest
= buf
+ *bufsiz
;
9232 *bufsiz
+= newspace
;
9233 xnp
= (Elf_External_Note
*) dest
;
9234 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
9235 H_PUT_32 (abfd
, size
, xnp
->descsz
);
9236 H_PUT_32 (abfd
, type
, xnp
->type
);
9240 memcpy (dest
, name
, namesz
);
9248 memcpy (dest
, input
, size
);
9259 elfcore_write_prpsinfo (bfd
*abfd
,
9265 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9267 if (bed
->elf_backend_write_core_note
!= NULL
)
9270 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9271 NT_PRPSINFO
, fname
, psargs
);
9276 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9277 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9278 if (bed
->s
->elfclass
== ELFCLASS32
)
9280 #if defined (HAVE_PSINFO32_T)
9282 int note_type
= NT_PSINFO
;
9285 int note_type
= NT_PRPSINFO
;
9288 memset (&data
, 0, sizeof (data
));
9289 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9290 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9291 return elfcore_write_note (abfd
, buf
, bufsiz
,
9292 "CORE", note_type
, &data
, sizeof (data
));
9297 #if defined (HAVE_PSINFO_T)
9299 int note_type
= NT_PSINFO
;
9302 int note_type
= NT_PRPSINFO
;
9305 memset (&data
, 0, sizeof (data
));
9306 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9307 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9308 return elfcore_write_note (abfd
, buf
, bufsiz
,
9309 "CORE", note_type
, &data
, sizeof (data
));
9311 #endif /* PSINFO_T or PRPSINFO_T */
9318 elfcore_write_linux_prpsinfo32
9319 (bfd
*abfd
, char *buf
, int *bufsiz
,
9320 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9322 struct elf_external_linux_prpsinfo32 data
;
9324 memset (&data
, 0, sizeof (data
));
9325 LINUX_PRPSINFO32_SWAP_FIELDS (abfd
, prpsinfo
, data
);
9327 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
9328 &data
, sizeof (data
));
9332 elfcore_write_linux_prpsinfo64
9333 (bfd
*abfd
, char *buf
, int *bufsiz
,
9334 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9336 struct elf_external_linux_prpsinfo64 data
;
9338 memset (&data
, 0, sizeof (data
));
9339 LINUX_PRPSINFO64_SWAP_FIELDS (abfd
, prpsinfo
, data
);
9341 return elfcore_write_note (abfd
, buf
, bufsiz
,
9342 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
9346 elfcore_write_prstatus (bfd
*abfd
,
9353 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9355 if (bed
->elf_backend_write_core_note
!= NULL
)
9358 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9360 pid
, cursig
, gregs
);
9365 #if defined (HAVE_PRSTATUS_T)
9366 #if defined (HAVE_PRSTATUS32_T)
9367 if (bed
->s
->elfclass
== ELFCLASS32
)
9369 prstatus32_t prstat
;
9371 memset (&prstat
, 0, sizeof (prstat
));
9372 prstat
.pr_pid
= pid
;
9373 prstat
.pr_cursig
= cursig
;
9374 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9375 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9376 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9383 memset (&prstat
, 0, sizeof (prstat
));
9384 prstat
.pr_pid
= pid
;
9385 prstat
.pr_cursig
= cursig
;
9386 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9387 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9388 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9390 #endif /* HAVE_PRSTATUS_T */
9396 #if defined (HAVE_LWPSTATUS_T)
9398 elfcore_write_lwpstatus (bfd
*abfd
,
9405 lwpstatus_t lwpstat
;
9406 const char *note_name
= "CORE";
9408 memset (&lwpstat
, 0, sizeof (lwpstat
));
9409 lwpstat
.pr_lwpid
= pid
>> 16;
9410 lwpstat
.pr_cursig
= cursig
;
9411 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9412 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
9413 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9415 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
9416 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
9418 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
9419 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
9422 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9423 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
9425 #endif /* HAVE_LWPSTATUS_T */
9427 #if defined (HAVE_PSTATUS_T)
9429 elfcore_write_pstatus (bfd
*abfd
,
9433 int cursig ATTRIBUTE_UNUSED
,
9434 const void *gregs ATTRIBUTE_UNUSED
)
9436 const char *note_name
= "CORE";
9437 #if defined (HAVE_PSTATUS32_T)
9438 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9440 if (bed
->s
->elfclass
== ELFCLASS32
)
9444 memset (&pstat
, 0, sizeof (pstat
));
9445 pstat
.pr_pid
= pid
& 0xffff;
9446 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9447 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9455 memset (&pstat
, 0, sizeof (pstat
));
9456 pstat
.pr_pid
= pid
& 0xffff;
9457 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9458 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9462 #endif /* HAVE_PSTATUS_T */
9465 elfcore_write_prfpreg (bfd
*abfd
,
9471 const char *note_name
= "CORE";
9472 return elfcore_write_note (abfd
, buf
, bufsiz
,
9473 note_name
, NT_FPREGSET
, fpregs
, size
);
9477 elfcore_write_prxfpreg (bfd
*abfd
,
9480 const void *xfpregs
,
9483 char *note_name
= "LINUX";
9484 return elfcore_write_note (abfd
, buf
, bufsiz
,
9485 note_name
, NT_PRXFPREG
, xfpregs
, size
);
9489 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
9490 const void *xfpregs
, int size
)
9492 char *note_name
= "LINUX";
9493 return elfcore_write_note (abfd
, buf
, bufsiz
,
9494 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
9498 elfcore_write_ppc_vmx (bfd
*abfd
,
9501 const void *ppc_vmx
,
9504 char *note_name
= "LINUX";
9505 return elfcore_write_note (abfd
, buf
, bufsiz
,
9506 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
9510 elfcore_write_ppc_vsx (bfd
*abfd
,
9513 const void *ppc_vsx
,
9516 char *note_name
= "LINUX";
9517 return elfcore_write_note (abfd
, buf
, bufsiz
,
9518 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
9522 elfcore_write_s390_high_gprs (bfd
*abfd
,
9525 const void *s390_high_gprs
,
9528 char *note_name
= "LINUX";
9529 return elfcore_write_note (abfd
, buf
, bufsiz
,
9530 note_name
, NT_S390_HIGH_GPRS
,
9531 s390_high_gprs
, size
);
9535 elfcore_write_s390_timer (bfd
*abfd
,
9538 const void *s390_timer
,
9541 char *note_name
= "LINUX";
9542 return elfcore_write_note (abfd
, buf
, bufsiz
,
9543 note_name
, NT_S390_TIMER
, s390_timer
, size
);
9547 elfcore_write_s390_todcmp (bfd
*abfd
,
9550 const void *s390_todcmp
,
9553 char *note_name
= "LINUX";
9554 return elfcore_write_note (abfd
, buf
, bufsiz
,
9555 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
9559 elfcore_write_s390_todpreg (bfd
*abfd
,
9562 const void *s390_todpreg
,
9565 char *note_name
= "LINUX";
9566 return elfcore_write_note (abfd
, buf
, bufsiz
,
9567 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
9571 elfcore_write_s390_ctrs (bfd
*abfd
,
9574 const void *s390_ctrs
,
9577 char *note_name
= "LINUX";
9578 return elfcore_write_note (abfd
, buf
, bufsiz
,
9579 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
9583 elfcore_write_s390_prefix (bfd
*abfd
,
9586 const void *s390_prefix
,
9589 char *note_name
= "LINUX";
9590 return elfcore_write_note (abfd
, buf
, bufsiz
,
9591 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
9595 elfcore_write_s390_last_break (bfd
*abfd
,
9598 const void *s390_last_break
,
9601 char *note_name
= "LINUX";
9602 return elfcore_write_note (abfd
, buf
, bufsiz
,
9603 note_name
, NT_S390_LAST_BREAK
,
9604 s390_last_break
, size
);
9608 elfcore_write_s390_system_call (bfd
*abfd
,
9611 const void *s390_system_call
,
9614 char *note_name
= "LINUX";
9615 return elfcore_write_note (abfd
, buf
, bufsiz
,
9616 note_name
, NT_S390_SYSTEM_CALL
,
9617 s390_system_call
, size
);
9621 elfcore_write_s390_tdb (bfd
*abfd
,
9624 const void *s390_tdb
,
9627 char *note_name
= "LINUX";
9628 return elfcore_write_note (abfd
, buf
, bufsiz
,
9629 note_name
, NT_S390_TDB
, s390_tdb
, size
);
9633 elfcore_write_s390_vxrs_low (bfd
*abfd
,
9636 const void *s390_vxrs_low
,
9639 char *note_name
= "LINUX";
9640 return elfcore_write_note (abfd
, buf
, bufsiz
,
9641 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
9645 elfcore_write_s390_vxrs_high (bfd
*abfd
,
9648 const void *s390_vxrs_high
,
9651 char *note_name
= "LINUX";
9652 return elfcore_write_note (abfd
, buf
, bufsiz
,
9653 note_name
, NT_S390_VXRS_HIGH
,
9654 s390_vxrs_high
, size
);
9658 elfcore_write_arm_vfp (bfd
*abfd
,
9661 const void *arm_vfp
,
9664 char *note_name
= "LINUX";
9665 return elfcore_write_note (abfd
, buf
, bufsiz
,
9666 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
9670 elfcore_write_aarch_tls (bfd
*abfd
,
9673 const void *aarch_tls
,
9676 char *note_name
= "LINUX";
9677 return elfcore_write_note (abfd
, buf
, bufsiz
,
9678 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
9682 elfcore_write_aarch_hw_break (bfd
*abfd
,
9685 const void *aarch_hw_break
,
9688 char *note_name
= "LINUX";
9689 return elfcore_write_note (abfd
, buf
, bufsiz
,
9690 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
9694 elfcore_write_aarch_hw_watch (bfd
*abfd
,
9697 const void *aarch_hw_watch
,
9700 char *note_name
= "LINUX";
9701 return elfcore_write_note (abfd
, buf
, bufsiz
,
9702 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
9706 elfcore_write_register_note (bfd
*abfd
,
9709 const char *section
,
9713 if (strcmp (section
, ".reg2") == 0)
9714 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
9715 if (strcmp (section
, ".reg-xfp") == 0)
9716 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
9717 if (strcmp (section
, ".reg-xstate") == 0)
9718 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
9719 if (strcmp (section
, ".reg-ppc-vmx") == 0)
9720 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
9721 if (strcmp (section
, ".reg-ppc-vsx") == 0)
9722 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
9723 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
9724 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
9725 if (strcmp (section
, ".reg-s390-timer") == 0)
9726 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
9727 if (strcmp (section
, ".reg-s390-todcmp") == 0)
9728 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
9729 if (strcmp (section
, ".reg-s390-todpreg") == 0)
9730 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
9731 if (strcmp (section
, ".reg-s390-ctrs") == 0)
9732 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
9733 if (strcmp (section
, ".reg-s390-prefix") == 0)
9734 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
9735 if (strcmp (section
, ".reg-s390-last-break") == 0)
9736 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
9737 if (strcmp (section
, ".reg-s390-system-call") == 0)
9738 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
9739 if (strcmp (section
, ".reg-s390-tdb") == 0)
9740 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
9741 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
9742 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
9743 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
9744 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
9745 if (strcmp (section
, ".reg-arm-vfp") == 0)
9746 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
9747 if (strcmp (section
, ".reg-aarch-tls") == 0)
9748 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
9749 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
9750 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
9751 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
9752 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
9757 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
9762 while (p
< buf
+ size
)
9764 /* FIXME: bad alignment assumption. */
9765 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
9766 Elf_Internal_Note in
;
9768 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
9771 in
.type
= H_GET_32 (abfd
, xnp
->type
);
9773 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
9774 in
.namedata
= xnp
->name
;
9775 if (in
.namesz
> buf
- in
.namedata
+ size
)
9778 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
9779 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
9780 in
.descpos
= offset
+ (in
.descdata
- buf
);
9782 && (in
.descdata
>= buf
+ size
9783 || in
.descsz
> buf
- in
.descdata
+ size
))
9786 switch (bfd_get_format (abfd
))
9793 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
9796 const char * string
;
9798 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
9802 GROKER_ELEMENT ("", elfcore_grok_note
),
9803 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
9804 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
9805 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
9806 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
9808 #undef GROKER_ELEMENT
9811 for (i
= ARRAY_SIZE (grokers
); i
--;)
9813 if (in
.namesz
>= grokers
[i
].len
9814 && strncmp (in
.namedata
, grokers
[i
].string
,
9815 grokers
[i
].len
) == 0)
9817 if (! grokers
[i
].func (abfd
, & in
))
9826 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
9828 if (! elfobj_grok_gnu_note (abfd
, &in
))
9831 else if (in
.namesz
== sizeof "stapsdt"
9832 && strcmp (in
.namedata
, "stapsdt") == 0)
9834 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
9840 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
9847 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
9854 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
9857 buf
= (char *) bfd_malloc (size
+ 1);
9861 /* PR 17512: file: ec08f814
9862 0-termintate the buffer so that string searches will not overflow. */
9865 if (bfd_bread (buf
, size
, abfd
) != size
9866 || !elf_parse_notes (abfd
, buf
, size
, offset
))
9876 /* Providing external access to the ELF program header table. */
9878 /* Return an upper bound on the number of bytes required to store a
9879 copy of ABFD's program header table entries. Return -1 if an error
9880 occurs; bfd_get_error will return an appropriate code. */
9883 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
9885 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9887 bfd_set_error (bfd_error_wrong_format
);
9891 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
9894 /* Copy ABFD's program header table entries to *PHDRS. The entries
9895 will be stored as an array of Elf_Internal_Phdr structures, as
9896 defined in include/elf/internal.h. To find out how large the
9897 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9899 Return the number of program header table entries read, or -1 if an
9900 error occurs; bfd_get_error will return an appropriate code. */
9903 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
9907 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9909 bfd_set_error (bfd_error_wrong_format
);
9913 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
9914 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
9915 num_phdrs
* sizeof (Elf_Internal_Phdr
));
9920 enum elf_reloc_type_class
9921 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9922 const asection
*rel_sec ATTRIBUTE_UNUSED
,
9923 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
9925 return reloc_class_normal
;
9928 /* For RELA architectures, return the relocation value for a
9929 relocation against a local symbol. */
9932 _bfd_elf_rela_local_sym (bfd
*abfd
,
9933 Elf_Internal_Sym
*sym
,
9935 Elf_Internal_Rela
*rel
)
9937 asection
*sec
= *psec
;
9940 relocation
= (sec
->output_section
->vma
9941 + sec
->output_offset
9943 if ((sec
->flags
& SEC_MERGE
)
9944 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
9945 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
9948 _bfd_merged_section_offset (abfd
, psec
,
9949 elf_section_data (sec
)->sec_info
,
9950 sym
->st_value
+ rel
->r_addend
);
9953 /* If we have changed the section, and our original section is
9954 marked with SEC_EXCLUDE, it means that the original
9955 SEC_MERGE section has been completely subsumed in some
9956 other SEC_MERGE section. In this case, we need to leave
9957 some info around for --emit-relocs. */
9958 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
9959 sec
->kept_section
= *psec
;
9962 rel
->r_addend
-= relocation
;
9963 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
9969 _bfd_elf_rel_local_sym (bfd
*abfd
,
9970 Elf_Internal_Sym
*sym
,
9974 asection
*sec
= *psec
;
9976 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
9977 return sym
->st_value
+ addend
;
9979 return _bfd_merged_section_offset (abfd
, psec
,
9980 elf_section_data (sec
)->sec_info
,
9981 sym
->st_value
+ addend
);
9985 _bfd_elf_section_offset (bfd
*abfd
,
9986 struct bfd_link_info
*info
,
9990 switch (sec
->sec_info_type
)
9992 case SEC_INFO_TYPE_STABS
:
9993 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
9995 case SEC_INFO_TYPE_EH_FRAME
:
9996 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
9998 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
10000 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10001 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
10002 offset
= sec
->size
- offset
- address_size
;
10008 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
10009 reconstruct an ELF file by reading the segments out of remote memory
10010 based on the ELF file header at EHDR_VMA and the ELF program headers it
10011 points to. If not null, *LOADBASEP is filled in with the difference
10012 between the VMAs from which the segments were read, and the VMAs the
10013 file headers (and hence BFD's idea of each section's VMA) put them at.
10015 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
10016 remote memory at target address VMA into the local buffer at MYADDR; it
10017 should return zero on success or an `errno' code on failure. TEMPL must
10018 be a BFD for an ELF target with the word size and byte order found in
10019 the remote memory. */
10022 bfd_elf_bfd_from_remote_memory
10025 bfd_size_type size
,
10026 bfd_vma
*loadbasep
,
10027 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
10029 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
10030 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
10034 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
10035 long symcount ATTRIBUTE_UNUSED
,
10036 asymbol
**syms ATTRIBUTE_UNUSED
,
10041 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10044 const char *relplt_name
;
10045 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
10049 Elf_Internal_Shdr
*hdr
;
10055 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
10058 if (dynsymcount
<= 0)
10061 if (!bed
->plt_sym_val
)
10064 relplt_name
= bed
->relplt_name
;
10065 if (relplt_name
== NULL
)
10066 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
10067 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
10068 if (relplt
== NULL
)
10071 hdr
= &elf_section_data (relplt
)->this_hdr
;
10072 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
10073 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
10076 plt
= bfd_get_section_by_name (abfd
, ".plt");
10080 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
10081 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
10084 count
= relplt
->size
/ hdr
->sh_entsize
;
10085 size
= count
* sizeof (asymbol
);
10086 p
= relplt
->relocation
;
10087 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10089 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
10090 if (p
->addend
!= 0)
10093 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
10095 size
+= sizeof ("+0x") - 1 + 8;
10100 s
= *ret
= (asymbol
*) bfd_malloc (size
);
10104 names
= (char *) (s
+ count
);
10105 p
= relplt
->relocation
;
10107 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10112 addr
= bed
->plt_sym_val (i
, plt
, p
);
10113 if (addr
== (bfd_vma
) -1)
10116 *s
= **p
->sym_ptr_ptr
;
10117 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
10118 we are defining a symbol, ensure one of them is set. */
10119 if ((s
->flags
& BSF_LOCAL
) == 0)
10120 s
->flags
|= BSF_GLOBAL
;
10121 s
->flags
|= BSF_SYNTHETIC
;
10123 s
->value
= addr
- plt
->vma
;
10126 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
10127 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
10129 if (p
->addend
!= 0)
10133 memcpy (names
, "+0x", sizeof ("+0x") - 1);
10134 names
+= sizeof ("+0x") - 1;
10135 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
10136 for (a
= buf
; *a
== '0'; ++a
)
10139 memcpy (names
, a
, len
);
10142 memcpy (names
, "@plt", sizeof ("@plt"));
10143 names
+= sizeof ("@plt");
10150 /* It is only used by x86-64 so far. */
10151 asection _bfd_elf_large_com_section
10152 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
10153 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
10156 _bfd_elf_post_process_headers (bfd
* abfd
,
10157 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
10159 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
10161 i_ehdrp
= elf_elfheader (abfd
);
10163 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
10165 /* To make things simpler for the loader on Linux systems we set the
10166 osabi field to ELFOSABI_GNU if the binary contains symbols of
10167 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
10168 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
10169 && elf_tdata (abfd
)->has_gnu_symbols
)
10170 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
10174 /* Return TRUE for ELF symbol types that represent functions.
10175 This is the default version of this function, which is sufficient for
10176 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
10179 _bfd_elf_is_function_type (unsigned int type
)
10181 return (type
== STT_FUNC
10182 || type
== STT_GNU_IFUNC
);
10185 /* If the ELF symbol SYM might be a function in SEC, return the
10186 function size and set *CODE_OFF to the function's entry point,
10187 otherwise return zero. */
10190 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
10193 bfd_size_type size
;
10195 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
10196 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
10197 || sym
->section
!= sec
)
10200 *code_off
= sym
->value
;
10202 if (!(sym
->flags
& BSF_SYNTHETIC
))
10203 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;