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
;
1045 int compression_header_size
;
1046 bfd_boolean compressed
1047 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1048 &compression_header_size
);
1052 /* Compressed section. Check if we should decompress. */
1053 if ((abfd
->flags
& BFD_DECOMPRESS
))
1054 action
= decompress
;
1057 /* Compress the uncompressed section or convert from/to .zdebug*
1058 section. Check if we should compress. */
1059 if (action
== nothing
)
1061 if (newsect
->size
!= 0
1062 && (abfd
->flags
& BFD_COMPRESS
)
1063 && compression_header_size
>= 0
1065 || ((compression_header_size
> 0)
1066 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1072 if (action
== compress
)
1074 if (!bfd_init_section_compress_status (abfd
, newsect
))
1076 (*_bfd_error_handler
)
1077 (_("%B: unable to initialize compress status for section %s"),
1084 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1086 (*_bfd_error_handler
)
1087 (_("%B: unable to initialize decompress status for section %s"),
1094 if (action
== decompress
1095 || (action
== compress
1096 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0))
1100 unsigned int len
= strlen (name
);
1102 new_name
= bfd_alloc (abfd
, len
);
1103 if (new_name
== NULL
)
1106 memcpy (new_name
+ 1, name
+ 2, len
- 1);
1109 else if (action
== compress
1110 && newsect
->compress_status
== COMPRESS_SECTION_DONE
)
1112 /* PR binutils/18087: Compression does not always make a section
1113 smaller. So only rename the section when compression has
1114 actually taken place. */
1117 unsigned int len
= strlen (name
);
1119 new_name
= bfd_alloc (abfd
, len
+ 2);
1120 if (new_name
== NULL
)
1124 memcpy (new_name
+ 2, name
+ 1, len
);
1127 if (new_name
!= NULL
)
1128 bfd_rename_section (abfd
, newsect
, new_name
);
1134 const char *const bfd_elf_section_type_names
[] = {
1135 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1136 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1137 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1140 /* ELF relocs are against symbols. If we are producing relocatable
1141 output, and the reloc is against an external symbol, and nothing
1142 has given us any additional addend, the resulting reloc will also
1143 be against the same symbol. In such a case, we don't want to
1144 change anything about the way the reloc is handled, since it will
1145 all be done at final link time. Rather than put special case code
1146 into bfd_perform_relocation, all the reloc types use this howto
1147 function. It just short circuits the reloc if producing
1148 relocatable output against an external symbol. */
1150 bfd_reloc_status_type
1151 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1152 arelent
*reloc_entry
,
1154 void *data ATTRIBUTE_UNUSED
,
1155 asection
*input_section
,
1157 char **error_message ATTRIBUTE_UNUSED
)
1159 if (output_bfd
!= NULL
1160 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1161 && (! reloc_entry
->howto
->partial_inplace
1162 || reloc_entry
->addend
== 0))
1164 reloc_entry
->address
+= input_section
->output_offset
;
1165 return bfd_reloc_ok
;
1168 return bfd_reloc_continue
;
1171 /* Copy the program header and other data from one object module to
1175 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1177 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1178 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1181 if (!elf_flags_init (obfd
))
1183 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1184 elf_flags_init (obfd
) = TRUE
;
1187 elf_gp (obfd
) = elf_gp (ibfd
);
1189 /* Also copy the EI_OSABI field. */
1190 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1191 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1193 /* Copy object attributes. */
1194 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1199 get_segment_type (unsigned int p_type
)
1204 case PT_NULL
: pt
= "NULL"; break;
1205 case PT_LOAD
: pt
= "LOAD"; break;
1206 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1207 case PT_INTERP
: pt
= "INTERP"; break;
1208 case PT_NOTE
: pt
= "NOTE"; break;
1209 case PT_SHLIB
: pt
= "SHLIB"; break;
1210 case PT_PHDR
: pt
= "PHDR"; break;
1211 case PT_TLS
: pt
= "TLS"; break;
1212 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1213 case PT_GNU_STACK
: pt
= "STACK"; break;
1214 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1215 default: pt
= NULL
; break;
1220 /* Print out the program headers. */
1223 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1225 FILE *f
= (FILE *) farg
;
1226 Elf_Internal_Phdr
*p
;
1228 bfd_byte
*dynbuf
= NULL
;
1230 p
= elf_tdata (abfd
)->phdr
;
1235 fprintf (f
, _("\nProgram Header:\n"));
1236 c
= elf_elfheader (abfd
)->e_phnum
;
1237 for (i
= 0; i
< c
; i
++, p
++)
1239 const char *pt
= get_segment_type (p
->p_type
);
1244 sprintf (buf
, "0x%lx", p
->p_type
);
1247 fprintf (f
, "%8s off 0x", pt
);
1248 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1249 fprintf (f
, " vaddr 0x");
1250 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1251 fprintf (f
, " paddr 0x");
1252 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1253 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1254 fprintf (f
, " filesz 0x");
1255 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1256 fprintf (f
, " memsz 0x");
1257 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1258 fprintf (f
, " flags %c%c%c",
1259 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1260 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1261 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1262 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1263 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1268 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1271 unsigned int elfsec
;
1272 unsigned long shlink
;
1273 bfd_byte
*extdyn
, *extdynend
;
1275 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1277 fprintf (f
, _("\nDynamic Section:\n"));
1279 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1282 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1283 if (elfsec
== SHN_BAD
)
1285 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1287 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1288 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1291 /* PR 17512: file: 6f427532. */
1292 if (s
->size
< extdynsize
)
1294 extdynend
= extdyn
+ s
->size
;
1295 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1297 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1299 Elf_Internal_Dyn dyn
;
1300 const char *name
= "";
1302 bfd_boolean stringp
;
1303 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1305 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1307 if (dyn
.d_tag
== DT_NULL
)
1314 if (bed
->elf_backend_get_target_dtag
)
1315 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1317 if (!strcmp (name
, ""))
1319 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1324 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1325 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1326 case DT_PLTGOT
: name
= "PLTGOT"; break;
1327 case DT_HASH
: name
= "HASH"; break;
1328 case DT_STRTAB
: name
= "STRTAB"; break;
1329 case DT_SYMTAB
: name
= "SYMTAB"; break;
1330 case DT_RELA
: name
= "RELA"; break;
1331 case DT_RELASZ
: name
= "RELASZ"; break;
1332 case DT_RELAENT
: name
= "RELAENT"; break;
1333 case DT_STRSZ
: name
= "STRSZ"; break;
1334 case DT_SYMENT
: name
= "SYMENT"; break;
1335 case DT_INIT
: name
= "INIT"; break;
1336 case DT_FINI
: name
= "FINI"; break;
1337 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1338 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1339 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1340 case DT_REL
: name
= "REL"; break;
1341 case DT_RELSZ
: name
= "RELSZ"; break;
1342 case DT_RELENT
: name
= "RELENT"; break;
1343 case DT_PLTREL
: name
= "PLTREL"; break;
1344 case DT_DEBUG
: name
= "DEBUG"; break;
1345 case DT_TEXTREL
: name
= "TEXTREL"; break;
1346 case DT_JMPREL
: name
= "JMPREL"; break;
1347 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1348 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1349 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1350 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1351 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1352 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1353 case DT_FLAGS
: name
= "FLAGS"; break;
1354 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1355 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1356 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1357 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1358 case DT_MOVEENT
: name
= "MOVEENT"; break;
1359 case DT_MOVESZ
: name
= "MOVESZ"; break;
1360 case DT_FEATURE
: name
= "FEATURE"; break;
1361 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1362 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1363 case DT_SYMINENT
: name
= "SYMINENT"; break;
1364 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1365 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1366 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1367 case DT_PLTPAD
: name
= "PLTPAD"; break;
1368 case DT_MOVETAB
: name
= "MOVETAB"; break;
1369 case DT_SYMINFO
: name
= "SYMINFO"; break;
1370 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1371 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1372 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1373 case DT_VERSYM
: name
= "VERSYM"; break;
1374 case DT_VERDEF
: name
= "VERDEF"; break;
1375 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1376 case DT_VERNEED
: name
= "VERNEED"; break;
1377 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1378 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1379 case DT_USED
: name
= "USED"; break;
1380 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1381 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1384 fprintf (f
, " %-20s ", name
);
1388 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1393 unsigned int tagv
= dyn
.d_un
.d_val
;
1395 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1398 fprintf (f
, "%s", string
);
1407 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1408 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1410 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1414 if (elf_dynverdef (abfd
) != 0)
1416 Elf_Internal_Verdef
*t
;
1418 fprintf (f
, _("\nVersion definitions:\n"));
1419 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1421 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1422 t
->vd_flags
, t
->vd_hash
,
1423 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1424 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1426 Elf_Internal_Verdaux
*a
;
1429 for (a
= t
->vd_auxptr
->vda_nextptr
;
1433 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1439 if (elf_dynverref (abfd
) != 0)
1441 Elf_Internal_Verneed
*t
;
1443 fprintf (f
, _("\nVersion References:\n"));
1444 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1446 Elf_Internal_Vernaux
*a
;
1448 fprintf (f
, _(" required from %s:\n"),
1449 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1450 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1451 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1452 a
->vna_flags
, a
->vna_other
,
1453 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1465 /* Get version string. */
1468 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1469 bfd_boolean
*hidden
)
1471 const char *version_string
= NULL
;
1472 if (elf_dynversym (abfd
) != 0
1473 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1475 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1477 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1478 vernum
&= VERSYM_VERSION
;
1481 version_string
= "";
1482 else if (vernum
== 1)
1483 version_string
= "Base";
1484 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1486 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1489 Elf_Internal_Verneed
*t
;
1491 version_string
= "";
1492 for (t
= elf_tdata (abfd
)->verref
;
1496 Elf_Internal_Vernaux
*a
;
1498 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1500 if (a
->vna_other
== vernum
)
1502 version_string
= a
->vna_nodename
;
1509 return version_string
;
1512 /* Display ELF-specific fields of a symbol. */
1515 bfd_elf_print_symbol (bfd
*abfd
,
1518 bfd_print_symbol_type how
)
1520 FILE *file
= (FILE *) filep
;
1523 case bfd_print_symbol_name
:
1524 fprintf (file
, "%s", symbol
->name
);
1526 case bfd_print_symbol_more
:
1527 fprintf (file
, "elf ");
1528 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1529 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1531 case bfd_print_symbol_all
:
1533 const char *section_name
;
1534 const char *name
= NULL
;
1535 const struct elf_backend_data
*bed
;
1536 unsigned char st_other
;
1538 const char *version_string
;
1541 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1543 bed
= get_elf_backend_data (abfd
);
1544 if (bed
->elf_backend_print_symbol_all
)
1545 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1549 name
= symbol
->name
;
1550 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1553 fprintf (file
, " %s\t", section_name
);
1554 /* Print the "other" value for a symbol. For common symbols,
1555 we've already printed the size; now print the alignment.
1556 For other symbols, we have no specified alignment, and
1557 we've printed the address; now print the size. */
1558 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1559 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1561 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1562 bfd_fprintf_vma (abfd
, file
, val
);
1564 /* If we have version information, print it. */
1565 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1571 fprintf (file
, " %-11s", version_string
);
1576 fprintf (file
, " (%s)", version_string
);
1577 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1582 /* If the st_other field is not zero, print it. */
1583 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1588 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1589 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1590 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1592 /* Some other non-defined flags are also present, so print
1594 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1597 fprintf (file
, " %s", name
);
1603 /* Allocate an ELF string table--force the first byte to be zero. */
1605 struct bfd_strtab_hash
*
1606 _bfd_elf_stringtab_init (void)
1608 struct bfd_strtab_hash
*ret
;
1610 ret
= _bfd_stringtab_init ();
1615 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1616 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1617 if (loc
== (bfd_size_type
) -1)
1619 _bfd_stringtab_free (ret
);
1626 /* ELF .o/exec file reading */
1628 /* Create a new bfd section from an ELF section header. */
1631 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1633 Elf_Internal_Shdr
*hdr
;
1634 Elf_Internal_Ehdr
*ehdr
;
1635 const struct elf_backend_data
*bed
;
1637 bfd_boolean ret
= TRUE
;
1638 static bfd_boolean
* sections_being_created
= NULL
;
1639 static bfd
* sections_being_created_abfd
= NULL
;
1640 static unsigned int nesting
= 0;
1642 if (shindex
>= elf_numsections (abfd
))
1647 /* PR17512: A corrupt ELF binary might contain a recursive group of
1648 sections, with each the string indicies pointing to the next in the
1649 loop. Detect this here, by refusing to load a section that we are
1650 already in the process of loading. We only trigger this test if
1651 we have nested at least three sections deep as normal ELF binaries
1652 can expect to recurse at least once.
1654 FIXME: It would be better if this array was attached to the bfd,
1655 rather than being held in a static pointer. */
1657 if (sections_being_created_abfd
!= abfd
)
1658 sections_being_created
= NULL
;
1659 if (sections_being_created
== NULL
)
1661 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
1662 sections_being_created
= (bfd_boolean
*)
1663 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
1664 sections_being_created_abfd
= abfd
;
1666 if (sections_being_created
[shindex
])
1668 (*_bfd_error_handler
)
1669 (_("%B: warning: loop in section dependencies detected"), abfd
);
1672 sections_being_created
[shindex
] = TRUE
;
1675 hdr
= elf_elfsections (abfd
)[shindex
];
1676 ehdr
= elf_elfheader (abfd
);
1677 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1682 bed
= get_elf_backend_data (abfd
);
1683 switch (hdr
->sh_type
)
1686 /* Inactive section. Throw it away. */
1689 case SHT_PROGBITS
: /* Normal section with contents. */
1690 case SHT_NOBITS
: /* .bss section. */
1691 case SHT_HASH
: /* .hash section. */
1692 case SHT_NOTE
: /* .note section. */
1693 case SHT_INIT_ARRAY
: /* .init_array section. */
1694 case SHT_FINI_ARRAY
: /* .fini_array section. */
1695 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1696 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1697 case SHT_GNU_HASH
: /* .gnu.hash section. */
1698 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1701 case SHT_DYNAMIC
: /* Dynamic linking information. */
1702 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1705 if (hdr
->sh_link
> elf_numsections (abfd
))
1707 /* PR 10478: Accept Solaris binaries with a sh_link
1708 field set to SHN_BEFORE or SHN_AFTER. */
1709 switch (bfd_get_arch (abfd
))
1712 case bfd_arch_sparc
:
1713 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
1714 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
1716 /* Otherwise fall through. */
1721 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1723 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1725 Elf_Internal_Shdr
*dynsymhdr
;
1727 /* The shared libraries distributed with hpux11 have a bogus
1728 sh_link field for the ".dynamic" section. Find the
1729 string table for the ".dynsym" section instead. */
1730 if (elf_dynsymtab (abfd
) != 0)
1732 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1733 hdr
->sh_link
= dynsymhdr
->sh_link
;
1737 unsigned int i
, num_sec
;
1739 num_sec
= elf_numsections (abfd
);
1740 for (i
= 1; i
< num_sec
; i
++)
1742 dynsymhdr
= elf_elfsections (abfd
)[i
];
1743 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1745 hdr
->sh_link
= dynsymhdr
->sh_link
;
1753 case SHT_SYMTAB
: /* A symbol table. */
1754 if (elf_onesymtab (abfd
) == shindex
)
1757 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1760 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1762 if (hdr
->sh_size
!= 0)
1764 /* Some assemblers erroneously set sh_info to one with a
1765 zero sh_size. ld sees this as a global symbol count
1766 of (unsigned) -1. Fix it here. */
1771 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1772 elf_onesymtab (abfd
) = shindex
;
1773 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1774 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1775 abfd
->flags
|= HAS_SYMS
;
1777 /* Sometimes a shared object will map in the symbol table. If
1778 SHF_ALLOC is set, and this is a shared object, then we also
1779 treat this section as a BFD section. We can not base the
1780 decision purely on SHF_ALLOC, because that flag is sometimes
1781 set in a relocatable object file, which would confuse the
1783 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1784 && (abfd
->flags
& DYNAMIC
) != 0
1785 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1789 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1790 can't read symbols without that section loaded as well. It
1791 is most likely specified by the next section header. */
1792 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1794 unsigned int i
, num_sec
;
1796 num_sec
= elf_numsections (abfd
);
1797 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1799 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1800 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1801 && hdr2
->sh_link
== shindex
)
1805 for (i
= 1; i
< shindex
; i
++)
1807 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1808 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1809 && hdr2
->sh_link
== shindex
)
1813 ret
= bfd_section_from_shdr (abfd
, i
);
1817 case SHT_DYNSYM
: /* A dynamic symbol table. */
1818 if (elf_dynsymtab (abfd
) == shindex
)
1821 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1824 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1826 if (hdr
->sh_size
!= 0)
1829 /* Some linkers erroneously set sh_info to one with a
1830 zero sh_size. ld sees this as a global symbol count
1831 of (unsigned) -1. Fix it here. */
1836 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1837 elf_dynsymtab (abfd
) = shindex
;
1838 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1839 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1840 abfd
->flags
|= HAS_SYMS
;
1842 /* Besides being a symbol table, we also treat this as a regular
1843 section, so that objcopy can handle it. */
1844 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1847 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
1848 if (elf_symtab_shndx (abfd
) == shindex
)
1851 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1852 elf_symtab_shndx (abfd
) = shindex
;
1853 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1854 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1857 case SHT_STRTAB
: /* A string table. */
1858 if (hdr
->bfd_section
!= NULL
)
1861 if (ehdr
->e_shstrndx
== shindex
)
1863 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1864 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1868 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1871 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1872 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1876 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1879 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1880 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1881 elf_elfsections (abfd
)[shindex
] = hdr
;
1882 /* We also treat this as a regular section, so that objcopy
1884 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1889 /* If the string table isn't one of the above, then treat it as a
1890 regular section. We need to scan all the headers to be sure,
1891 just in case this strtab section appeared before the above. */
1892 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1894 unsigned int i
, num_sec
;
1896 num_sec
= elf_numsections (abfd
);
1897 for (i
= 1; i
< num_sec
; i
++)
1899 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1900 if (hdr2
->sh_link
== shindex
)
1902 /* Prevent endless recursion on broken objects. */
1905 if (! bfd_section_from_shdr (abfd
, i
))
1907 if (elf_onesymtab (abfd
) == i
)
1909 if (elf_dynsymtab (abfd
) == i
)
1910 goto dynsymtab_strtab
;
1914 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1919 /* *These* do a lot of work -- but build no sections! */
1921 asection
*target_sect
;
1922 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
1923 unsigned int num_sec
= elf_numsections (abfd
);
1924 struct bfd_elf_section_data
*esdt
;
1928 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1929 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1932 /* Check for a bogus link to avoid crashing. */
1933 if (hdr
->sh_link
>= num_sec
)
1935 ((*_bfd_error_handler
)
1936 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1937 abfd
, hdr
->sh_link
, name
, shindex
));
1938 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1943 /* For some incomprehensible reason Oracle distributes
1944 libraries for Solaris in which some of the objects have
1945 bogus sh_link fields. It would be nice if we could just
1946 reject them, but, unfortunately, some people need to use
1947 them. We scan through the section headers; if we find only
1948 one suitable symbol table, we clobber the sh_link to point
1949 to it. I hope this doesn't break anything.
1951 Don't do it on executable nor shared library. */
1952 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
1953 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1954 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1960 for (scan
= 1; scan
< num_sec
; scan
++)
1962 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1963 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1974 hdr
->sh_link
= found
;
1977 /* Get the symbol table. */
1978 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1979 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1980 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1983 /* If this reloc section does not use the main symbol table we
1984 don't treat it as a reloc section. BFD can't adequately
1985 represent such a section, so at least for now, we don't
1986 try. We just present it as a normal section. We also
1987 can't use it as a reloc section if it points to the null
1988 section, an invalid section, another reloc section, or its
1989 sh_link points to the null section. */
1990 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1991 || hdr
->sh_link
== SHN_UNDEF
1992 || hdr
->sh_info
== SHN_UNDEF
1993 || hdr
->sh_info
>= num_sec
1994 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1995 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1997 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2002 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2005 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2006 if (target_sect
== NULL
)
2009 esdt
= elf_section_data (target_sect
);
2010 if (hdr
->sh_type
== SHT_RELA
)
2011 p_hdr
= &esdt
->rela
.hdr
;
2013 p_hdr
= &esdt
->rel
.hdr
;
2015 /* PR 17512: file: 0b4f81b7. */
2018 amt
= sizeof (*hdr2
);
2019 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2024 elf_elfsections (abfd
)[shindex
] = hdr2
;
2025 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2026 target_sect
->flags
|= SEC_RELOC
;
2027 target_sect
->relocation
= NULL
;
2028 target_sect
->rel_filepos
= hdr
->sh_offset
;
2029 /* In the section to which the relocations apply, mark whether
2030 its relocations are of the REL or RELA variety. */
2031 if (hdr
->sh_size
!= 0)
2033 if (hdr
->sh_type
== SHT_RELA
)
2034 target_sect
->use_rela_p
= 1;
2036 abfd
->flags
|= HAS_RELOC
;
2040 case SHT_GNU_verdef
:
2041 elf_dynverdef (abfd
) = shindex
;
2042 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2043 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2046 case SHT_GNU_versym
:
2047 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2050 elf_dynversym (abfd
) = shindex
;
2051 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2052 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2055 case SHT_GNU_verneed
:
2056 elf_dynverref (abfd
) = shindex
;
2057 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2058 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2065 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2068 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2071 if (hdr
->contents
!= NULL
)
2073 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2074 unsigned int n_elt
= hdr
->sh_size
/ sizeof (* idx
);
2079 if (idx
->flags
& GRP_COMDAT
)
2080 hdr
->bfd_section
->flags
2081 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2083 /* We try to keep the same section order as it comes in. */
2086 while (--n_elt
!= 0)
2090 if (idx
->shdr
!= NULL
2091 && (s
= idx
->shdr
->bfd_section
) != NULL
2092 && elf_next_in_group (s
) != NULL
)
2094 elf_next_in_group (hdr
->bfd_section
) = s
;
2102 /* Possibly an attributes section. */
2103 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2104 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2106 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2108 _bfd_elf_parse_attributes (abfd
, hdr
);
2112 /* Check for any processor-specific section types. */
2113 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2116 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2118 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2119 /* FIXME: How to properly handle allocated section reserved
2120 for applications? */
2121 (*_bfd_error_handler
)
2122 (_("%B: don't know how to handle allocated, application "
2123 "specific section `%s' [0x%8x]"),
2124 abfd
, name
, hdr
->sh_type
);
2127 /* Allow sections reserved for applications. */
2128 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2133 else if (hdr
->sh_type
>= SHT_LOPROC
2134 && hdr
->sh_type
<= SHT_HIPROC
)
2135 /* FIXME: We should handle this section. */
2136 (*_bfd_error_handler
)
2137 (_("%B: don't know how to handle processor specific section "
2139 abfd
, name
, hdr
->sh_type
);
2140 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2142 /* Unrecognised OS-specific sections. */
2143 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2144 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2145 required to correctly process the section and the file should
2146 be rejected with an error message. */
2147 (*_bfd_error_handler
)
2148 (_("%B: don't know how to handle OS specific section "
2150 abfd
, name
, hdr
->sh_type
);
2153 /* Otherwise it should be processed. */
2154 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2159 /* FIXME: We should handle this section. */
2160 (*_bfd_error_handler
)
2161 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2162 abfd
, name
, hdr
->sh_type
);
2170 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2171 sections_being_created
[shindex
] = FALSE
;
2172 if (-- nesting
== 0)
2174 sections_being_created
= NULL
;
2175 sections_being_created_abfd
= abfd
;
2180 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2183 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2185 unsigned long r_symndx
)
2187 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2189 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2191 Elf_Internal_Shdr
*symtab_hdr
;
2192 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2193 Elf_External_Sym_Shndx eshndx
;
2195 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2196 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2197 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2200 if (cache
->abfd
!= abfd
)
2202 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2205 cache
->indx
[ent
] = r_symndx
;
2208 return &cache
->sym
[ent
];
2211 /* Given an ELF section number, retrieve the corresponding BFD
2215 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2217 if (sec_index
>= elf_numsections (abfd
))
2219 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2222 static const struct bfd_elf_special_section special_sections_b
[] =
2224 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2225 { NULL
, 0, 0, 0, 0 }
2228 static const struct bfd_elf_special_section special_sections_c
[] =
2230 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2231 { NULL
, 0, 0, 0, 0 }
2234 static const struct bfd_elf_special_section special_sections_d
[] =
2236 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2237 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2238 /* There are more DWARF sections than these, but they needn't be added here
2239 unless you have to cope with broken compilers that don't emit section
2240 attributes or you want to help the user writing assembler. */
2241 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2242 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2243 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2244 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2245 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2246 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2247 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2248 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2249 { NULL
, 0, 0, 0, 0 }
2252 static const struct bfd_elf_special_section special_sections_f
[] =
2254 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2255 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2256 { NULL
, 0, 0, 0, 0 }
2259 static const struct bfd_elf_special_section special_sections_g
[] =
2261 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2262 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2263 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2264 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2265 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2266 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2267 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2268 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2269 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2270 { NULL
, 0, 0, 0, 0 }
2273 static const struct bfd_elf_special_section special_sections_h
[] =
2275 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2276 { NULL
, 0, 0, 0, 0 }
2279 static const struct bfd_elf_special_section special_sections_i
[] =
2281 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2282 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2283 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2284 { NULL
, 0, 0, 0, 0 }
2287 static const struct bfd_elf_special_section special_sections_l
[] =
2289 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2290 { NULL
, 0, 0, 0, 0 }
2293 static const struct bfd_elf_special_section special_sections_n
[] =
2295 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2296 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2297 { NULL
, 0, 0, 0, 0 }
2300 static const struct bfd_elf_special_section special_sections_p
[] =
2302 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2303 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2304 { NULL
, 0, 0, 0, 0 }
2307 static const struct bfd_elf_special_section special_sections_r
[] =
2309 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2310 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2311 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2312 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2313 { NULL
, 0, 0, 0, 0 }
2316 static const struct bfd_elf_special_section special_sections_s
[] =
2318 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2319 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2320 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2321 /* See struct bfd_elf_special_section declaration for the semantics of
2322 this special case where .prefix_length != strlen (.prefix). */
2323 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2324 { NULL
, 0, 0, 0, 0 }
2327 static const struct bfd_elf_special_section special_sections_t
[] =
2329 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2330 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2331 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2332 { NULL
, 0, 0, 0, 0 }
2335 static const struct bfd_elf_special_section special_sections_z
[] =
2337 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2338 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2339 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2340 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2341 { NULL
, 0, 0, 0, 0 }
2344 static const struct bfd_elf_special_section
* const special_sections
[] =
2346 special_sections_b
, /* 'b' */
2347 special_sections_c
, /* 'c' */
2348 special_sections_d
, /* 'd' */
2350 special_sections_f
, /* 'f' */
2351 special_sections_g
, /* 'g' */
2352 special_sections_h
, /* 'h' */
2353 special_sections_i
, /* 'i' */
2356 special_sections_l
, /* 'l' */
2358 special_sections_n
, /* 'n' */
2360 special_sections_p
, /* 'p' */
2362 special_sections_r
, /* 'r' */
2363 special_sections_s
, /* 's' */
2364 special_sections_t
, /* 't' */
2370 special_sections_z
/* 'z' */
2373 const struct bfd_elf_special_section
*
2374 _bfd_elf_get_special_section (const char *name
,
2375 const struct bfd_elf_special_section
*spec
,
2381 len
= strlen (name
);
2383 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2386 int prefix_len
= spec
[i
].prefix_length
;
2388 if (len
< prefix_len
)
2390 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2393 suffix_len
= spec
[i
].suffix_length
;
2394 if (suffix_len
<= 0)
2396 if (name
[prefix_len
] != 0)
2398 if (suffix_len
== 0)
2400 if (name
[prefix_len
] != '.'
2401 && (suffix_len
== -2
2402 || (rela
&& spec
[i
].type
== SHT_REL
)))
2408 if (len
< prefix_len
+ suffix_len
)
2410 if (memcmp (name
+ len
- suffix_len
,
2411 spec
[i
].prefix
+ prefix_len
,
2421 const struct bfd_elf_special_section
*
2422 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2425 const struct bfd_elf_special_section
*spec
;
2426 const struct elf_backend_data
*bed
;
2428 /* See if this is one of the special sections. */
2429 if (sec
->name
== NULL
)
2432 bed
= get_elf_backend_data (abfd
);
2433 spec
= bed
->special_sections
;
2436 spec
= _bfd_elf_get_special_section (sec
->name
,
2437 bed
->special_sections
,
2443 if (sec
->name
[0] != '.')
2446 i
= sec
->name
[1] - 'b';
2447 if (i
< 0 || i
> 'z' - 'b')
2450 spec
= special_sections
[i
];
2455 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2459 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2461 struct bfd_elf_section_data
*sdata
;
2462 const struct elf_backend_data
*bed
;
2463 const struct bfd_elf_special_section
*ssect
;
2465 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2468 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2472 sec
->used_by_bfd
= sdata
;
2475 /* Indicate whether or not this section should use RELA relocations. */
2476 bed
= get_elf_backend_data (abfd
);
2477 sec
->use_rela_p
= bed
->default_use_rela_p
;
2479 /* When we read a file, we don't need to set ELF section type and
2480 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2481 anyway. We will set ELF section type and flags for all linker
2482 created sections. If user specifies BFD section flags, we will
2483 set ELF section type and flags based on BFD section flags in
2484 elf_fake_sections. Special handling for .init_array/.fini_array
2485 output sections since they may contain .ctors/.dtors input
2486 sections. We don't want _bfd_elf_init_private_section_data to
2487 copy ELF section type from .ctors/.dtors input sections. */
2488 if (abfd
->direction
!= read_direction
2489 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2491 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2494 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2495 || ssect
->type
== SHT_INIT_ARRAY
2496 || ssect
->type
== SHT_FINI_ARRAY
))
2498 elf_section_type (sec
) = ssect
->type
;
2499 elf_section_flags (sec
) = ssect
->attr
;
2503 return _bfd_generic_new_section_hook (abfd
, sec
);
2506 /* Create a new bfd section from an ELF program header.
2508 Since program segments have no names, we generate a synthetic name
2509 of the form segment<NUM>, where NUM is generally the index in the
2510 program header table. For segments that are split (see below) we
2511 generate the names segment<NUM>a and segment<NUM>b.
2513 Note that some program segments may have a file size that is different than
2514 (less than) the memory size. All this means is that at execution the
2515 system must allocate the amount of memory specified by the memory size,
2516 but only initialize it with the first "file size" bytes read from the
2517 file. This would occur for example, with program segments consisting
2518 of combined data+bss.
2520 To handle the above situation, this routine generates TWO bfd sections
2521 for the single program segment. The first has the length specified by
2522 the file size of the segment, and the second has the length specified
2523 by the difference between the two sizes. In effect, the segment is split
2524 into its initialized and uninitialized parts.
2529 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2530 Elf_Internal_Phdr
*hdr
,
2532 const char *type_name
)
2540 split
= ((hdr
->p_memsz
> 0)
2541 && (hdr
->p_filesz
> 0)
2542 && (hdr
->p_memsz
> hdr
->p_filesz
));
2544 if (hdr
->p_filesz
> 0)
2546 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2547 len
= strlen (namebuf
) + 1;
2548 name
= (char *) bfd_alloc (abfd
, len
);
2551 memcpy (name
, namebuf
, len
);
2552 newsect
= bfd_make_section (abfd
, name
);
2553 if (newsect
== NULL
)
2555 newsect
->vma
= hdr
->p_vaddr
;
2556 newsect
->lma
= hdr
->p_paddr
;
2557 newsect
->size
= hdr
->p_filesz
;
2558 newsect
->filepos
= hdr
->p_offset
;
2559 newsect
->flags
|= SEC_HAS_CONTENTS
;
2560 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2561 if (hdr
->p_type
== PT_LOAD
)
2563 newsect
->flags
|= SEC_ALLOC
;
2564 newsect
->flags
|= SEC_LOAD
;
2565 if (hdr
->p_flags
& PF_X
)
2567 /* FIXME: all we known is that it has execute PERMISSION,
2569 newsect
->flags
|= SEC_CODE
;
2572 if (!(hdr
->p_flags
& PF_W
))
2574 newsect
->flags
|= SEC_READONLY
;
2578 if (hdr
->p_memsz
> hdr
->p_filesz
)
2582 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2583 len
= strlen (namebuf
) + 1;
2584 name
= (char *) bfd_alloc (abfd
, len
);
2587 memcpy (name
, namebuf
, len
);
2588 newsect
= bfd_make_section (abfd
, name
);
2589 if (newsect
== NULL
)
2591 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2592 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2593 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2594 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2595 align
= newsect
->vma
& -newsect
->vma
;
2596 if (align
== 0 || align
> hdr
->p_align
)
2597 align
= hdr
->p_align
;
2598 newsect
->alignment_power
= bfd_log2 (align
);
2599 if (hdr
->p_type
== PT_LOAD
)
2601 /* Hack for gdb. Segments that have not been modified do
2602 not have their contents written to a core file, on the
2603 assumption that a debugger can find the contents in the
2604 executable. We flag this case by setting the fake
2605 section size to zero. Note that "real" bss sections will
2606 always have their contents dumped to the core file. */
2607 if (bfd_get_format (abfd
) == bfd_core
)
2609 newsect
->flags
|= SEC_ALLOC
;
2610 if (hdr
->p_flags
& PF_X
)
2611 newsect
->flags
|= SEC_CODE
;
2613 if (!(hdr
->p_flags
& PF_W
))
2614 newsect
->flags
|= SEC_READONLY
;
2621 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2623 const struct elf_backend_data
*bed
;
2625 switch (hdr
->p_type
)
2628 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2631 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2634 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2637 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2640 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2642 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2647 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2650 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2652 case PT_GNU_EH_FRAME
:
2653 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2657 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
2660 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
2663 /* Check for any processor-specific program segment types. */
2664 bed
= get_elf_backend_data (abfd
);
2665 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
2669 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2673 _bfd_elf_single_rel_hdr (asection
*sec
)
2675 if (elf_section_data (sec
)->rel
.hdr
)
2677 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
2678 return elf_section_data (sec
)->rel
.hdr
;
2681 return elf_section_data (sec
)->rela
.hdr
;
2684 /* Allocate and initialize a section-header for a new reloc section,
2685 containing relocations against ASECT. It is stored in RELDATA. If
2686 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2690 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2691 struct bfd_elf_section_reloc_data
*reldata
,
2693 bfd_boolean use_rela_p
)
2695 Elf_Internal_Shdr
*rel_hdr
;
2697 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2700 amt
= sizeof (Elf_Internal_Shdr
);
2701 BFD_ASSERT (reldata
->hdr
== NULL
);
2702 rel_hdr
= bfd_zalloc (abfd
, amt
);
2703 reldata
->hdr
= rel_hdr
;
2705 amt
= sizeof ".rela" + strlen (asect
->name
);
2706 name
= (char *) bfd_alloc (abfd
, amt
);
2709 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2711 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2713 if (rel_hdr
->sh_name
== (unsigned int) -1)
2715 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2716 rel_hdr
->sh_entsize
= (use_rela_p
2717 ? bed
->s
->sizeof_rela
2718 : bed
->s
->sizeof_rel
);
2719 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2720 rel_hdr
->sh_flags
= 0;
2721 rel_hdr
->sh_addr
= 0;
2722 rel_hdr
->sh_size
= 0;
2723 rel_hdr
->sh_offset
= 0;
2728 /* Return the default section type based on the passed in section flags. */
2731 bfd_elf_get_default_section_type (flagword flags
)
2733 if ((flags
& SEC_ALLOC
) != 0
2734 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2736 return SHT_PROGBITS
;
2739 struct fake_section_arg
2741 struct bfd_link_info
*link_info
;
2745 /* Set up an ELF internal section header for a section. */
2748 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
2750 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
2751 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2752 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
2753 Elf_Internal_Shdr
*this_hdr
;
2754 unsigned int sh_type
;
2758 /* We already failed; just get out of the bfd_map_over_sections
2763 this_hdr
= &esd
->this_hdr
;
2765 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2766 asect
->name
, FALSE
);
2767 if (this_hdr
->sh_name
== (unsigned int) -1)
2773 /* Don't clear sh_flags. Assembler may set additional bits. */
2775 if ((asect
->flags
& SEC_ALLOC
) != 0
2776 || asect
->user_set_vma
)
2777 this_hdr
->sh_addr
= asect
->vma
;
2779 this_hdr
->sh_addr
= 0;
2781 this_hdr
->sh_offset
= 0;
2782 this_hdr
->sh_size
= asect
->size
;
2783 this_hdr
->sh_link
= 0;
2784 /* PR 17512: file: 0eb809fe, 8b0535ee. */
2785 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
2787 (*_bfd_error_handler
)
2788 (_("%B: error: Alignment power %d of section `%A' is too big"),
2789 abfd
, asect
, asect
->alignment_power
);
2793 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2794 /* The sh_entsize and sh_info fields may have been set already by
2795 copy_private_section_data. */
2797 this_hdr
->bfd_section
= asect
;
2798 this_hdr
->contents
= NULL
;
2800 /* If the section type is unspecified, we set it based on
2802 if ((asect
->flags
& SEC_GROUP
) != 0)
2803 sh_type
= SHT_GROUP
;
2805 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
2807 if (this_hdr
->sh_type
== SHT_NULL
)
2808 this_hdr
->sh_type
= sh_type
;
2809 else if (this_hdr
->sh_type
== SHT_NOBITS
2810 && sh_type
== SHT_PROGBITS
2811 && (asect
->flags
& SEC_ALLOC
) != 0)
2813 /* Warn if we are changing a NOBITS section to PROGBITS, but
2814 allow the link to proceed. This can happen when users link
2815 non-bss input sections to bss output sections, or emit data
2816 to a bss output section via a linker script. */
2817 (*_bfd_error_handler
)
2818 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2819 this_hdr
->sh_type
= sh_type
;
2822 switch (this_hdr
->sh_type
)
2828 case SHT_INIT_ARRAY
:
2829 case SHT_FINI_ARRAY
:
2830 case SHT_PREINIT_ARRAY
:
2837 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2841 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2845 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2849 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2850 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2854 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2855 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2858 case SHT_GNU_versym
:
2859 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2862 case SHT_GNU_verdef
:
2863 this_hdr
->sh_entsize
= 0;
2864 /* objcopy or strip will copy over sh_info, but may not set
2865 cverdefs. The linker will set cverdefs, but sh_info will be
2867 if (this_hdr
->sh_info
== 0)
2868 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2870 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2871 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2874 case SHT_GNU_verneed
:
2875 this_hdr
->sh_entsize
= 0;
2876 /* objcopy or strip will copy over sh_info, but may not set
2877 cverrefs. The linker will set cverrefs, but sh_info will be
2879 if (this_hdr
->sh_info
== 0)
2880 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2882 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2883 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2887 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2891 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2895 if ((asect
->flags
& SEC_ALLOC
) != 0)
2896 this_hdr
->sh_flags
|= SHF_ALLOC
;
2897 if ((asect
->flags
& SEC_READONLY
) == 0)
2898 this_hdr
->sh_flags
|= SHF_WRITE
;
2899 if ((asect
->flags
& SEC_CODE
) != 0)
2900 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2901 if ((asect
->flags
& SEC_MERGE
) != 0)
2903 this_hdr
->sh_flags
|= SHF_MERGE
;
2904 this_hdr
->sh_entsize
= asect
->entsize
;
2905 if ((asect
->flags
& SEC_STRINGS
) != 0)
2906 this_hdr
->sh_flags
|= SHF_STRINGS
;
2908 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2909 this_hdr
->sh_flags
|= SHF_GROUP
;
2910 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2912 this_hdr
->sh_flags
|= SHF_TLS
;
2913 if (asect
->size
== 0
2914 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2916 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2918 this_hdr
->sh_size
= 0;
2921 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2922 if (this_hdr
->sh_size
!= 0)
2923 this_hdr
->sh_type
= SHT_NOBITS
;
2927 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2928 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
2930 /* If the section has relocs, set up a section header for the
2931 SHT_REL[A] section. If two relocation sections are required for
2932 this section, it is up to the processor-specific back-end to
2933 create the other. */
2934 if ((asect
->flags
& SEC_RELOC
) != 0)
2936 /* When doing a relocatable link, create both REL and RELA sections if
2939 /* Do the normal setup if we wouldn't create any sections here. */
2940 && esd
->rel
.count
+ esd
->rela
.count
> 0
2941 && (arg
->link_info
->relocatable
|| arg
->link_info
->emitrelocations
))
2943 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
2944 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, asect
, FALSE
))
2949 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
2950 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, asect
, TRUE
))
2956 else if (!_bfd_elf_init_reloc_shdr (abfd
,
2958 ? &esd
->rela
: &esd
->rel
),
2964 /* Check for processor-specific section types. */
2965 sh_type
= this_hdr
->sh_type
;
2966 if (bed
->elf_backend_fake_sections
2967 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2970 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2972 /* Don't change the header type from NOBITS if we are being
2973 called for objcopy --only-keep-debug. */
2974 this_hdr
->sh_type
= sh_type
;
2978 /* Fill in the contents of a SHT_GROUP section. Called from
2979 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2980 when ELF targets use the generic linker, ld. Called for ld -r
2981 from bfd_elf_final_link. */
2984 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2986 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2987 asection
*elt
, *first
;
2991 /* Ignore linker created group section. See elfNN_ia64_object_p in
2993 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2997 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
2999 unsigned long symindx
= 0;
3001 /* elf_group_id will have been set up by objcopy and the
3003 if (elf_group_id (sec
) != NULL
)
3004 symindx
= elf_group_id (sec
)->udata
.i
;
3008 /* If called from the assembler, swap_out_syms will have set up
3009 elf_section_syms. */
3010 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3011 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3013 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3015 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3017 /* The ELF backend linker sets sh_info to -2 when the group
3018 signature symbol is global, and thus the index can't be
3019 set until all local symbols are output. */
3020 asection
*igroup
= elf_sec_group (elf_next_in_group (sec
));
3021 struct bfd_elf_section_data
*sec_data
= elf_section_data (igroup
);
3022 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
3023 unsigned long extsymoff
= 0;
3024 struct elf_link_hash_entry
*h
;
3026 if (!elf_bad_symtab (igroup
->owner
))
3028 Elf_Internal_Shdr
*symtab_hdr
;
3030 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3031 extsymoff
= symtab_hdr
->sh_info
;
3033 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3034 while (h
->root
.type
== bfd_link_hash_indirect
3035 || h
->root
.type
== bfd_link_hash_warning
)
3036 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3038 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3041 /* The contents won't be allocated for "ld -r" or objcopy. */
3043 if (sec
->contents
== NULL
)
3046 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3048 /* Arrange for the section to be written out. */
3049 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3050 if (sec
->contents
== NULL
)
3057 loc
= sec
->contents
+ sec
->size
;
3059 /* Get the pointer to the first section in the group that gas
3060 squirreled away here. objcopy arranges for this to be set to the
3061 start of the input section group. */
3062 first
= elt
= elf_next_in_group (sec
);
3064 /* First element is a flag word. Rest of section is elf section
3065 indices for all the sections of the group. Write them backwards
3066 just to keep the group in the same order as given in .section
3067 directives, not that it matters. */
3074 s
= s
->output_section
;
3076 && !bfd_is_abs_section (s
))
3078 unsigned int idx
= elf_section_data (s
)->this_idx
;
3081 H_PUT_32 (abfd
, idx
, loc
);
3083 elt
= elf_next_in_group (elt
);
3088 if ((loc
-= 4) != sec
->contents
)
3091 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3094 /* Return the section which RELOC_SEC applies to. */
3097 _bfd_elf_get_reloc_section (asection
*reloc_sec
)
3103 if (reloc_sec
== NULL
)
3106 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3107 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3110 /* We look up the section the relocs apply to by name. */
3111 name
= reloc_sec
->name
;
3112 if (type
== SHT_REL
)
3117 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3118 section apply to .got.plt section. */
3119 abfd
= reloc_sec
->owner
;
3120 if (get_elf_backend_data (abfd
)->want_got_plt
3121 && strcmp (name
, ".plt") == 0)
3123 /* .got.plt is a linker created input section. It may be mapped
3124 to some other output section. Try two likely sections. */
3126 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3127 if (reloc_sec
!= NULL
)
3132 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3136 /* Assign all ELF section numbers. The dummy first section is handled here
3137 too. The link/info pointers for the standard section types are filled
3138 in here too, while we're at it. */
3141 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3143 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3145 unsigned int section_number
, secn
;
3146 Elf_Internal_Shdr
**i_shdrp
;
3147 struct bfd_elf_section_data
*d
;
3148 bfd_boolean need_symtab
;
3152 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3154 /* SHT_GROUP sections are in relocatable files only. */
3155 if (link_info
== NULL
|| link_info
->relocatable
)
3157 /* Put SHT_GROUP sections first. */
3158 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3160 d
= elf_section_data (sec
);
3162 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3164 if (sec
->flags
& SEC_LINKER_CREATED
)
3166 /* Remove the linker created SHT_GROUP sections. */
3167 bfd_section_list_remove (abfd
, sec
);
3168 abfd
->section_count
--;
3171 d
->this_idx
= section_number
++;
3176 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3178 d
= elf_section_data (sec
);
3180 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3181 d
->this_idx
= section_number
++;
3182 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3185 d
->rel
.idx
= section_number
++;
3186 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3193 d
->rela
.idx
= section_number
++;
3194 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3200 elf_shstrtab_sec (abfd
) = section_number
++;
3201 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3202 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3204 need_symtab
= (bfd_get_symcount (abfd
) > 0
3205 || (link_info
== NULL
3206 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3210 elf_onesymtab (abfd
) = section_number
++;
3211 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3212 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3214 elf_symtab_shndx (abfd
) = section_number
++;
3215 t
->symtab_shndx_hdr
.sh_name
3216 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3217 ".symtab_shndx", FALSE
);
3218 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
3221 elf_strtab_sec (abfd
) = section_number
++;
3222 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3225 if (section_number
>= SHN_LORESERVE
)
3227 _bfd_error_handler (_("%B: too many sections: %u"),
3228 abfd
, section_number
);
3232 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
3233 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3235 elf_numsections (abfd
) = section_number
;
3236 elf_elfheader (abfd
)->e_shnum
= section_number
;
3238 /* Set up the list of section header pointers, in agreement with the
3240 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3241 sizeof (Elf_Internal_Shdr
*));
3242 if (i_shdrp
== NULL
)
3245 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3246 sizeof (Elf_Internal_Shdr
));
3247 if (i_shdrp
[0] == NULL
)
3249 bfd_release (abfd
, i_shdrp
);
3253 elf_elfsections (abfd
) = i_shdrp
;
3255 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3258 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3259 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3261 i_shdrp
[elf_symtab_shndx (abfd
)] = &t
->symtab_shndx_hdr
;
3262 t
->symtab_shndx_hdr
.sh_link
= elf_onesymtab (abfd
);
3264 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3265 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3268 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3272 d
= elf_section_data (sec
);
3274 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3275 if (d
->rel
.idx
!= 0)
3276 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3277 if (d
->rela
.idx
!= 0)
3278 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3280 /* Fill in the sh_link and sh_info fields while we're at it. */
3282 /* sh_link of a reloc section is the section index of the symbol
3283 table. sh_info is the section index of the section to which
3284 the relocation entries apply. */
3285 if (d
->rel
.idx
!= 0)
3287 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3288 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3289 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3291 if (d
->rela
.idx
!= 0)
3293 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3294 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3295 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3298 /* We need to set up sh_link for SHF_LINK_ORDER. */
3299 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3301 s
= elf_linked_to_section (sec
);
3304 /* elf_linked_to_section points to the input section. */
3305 if (link_info
!= NULL
)
3307 /* Check discarded linkonce section. */
3308 if (discarded_section (s
))
3311 (*_bfd_error_handler
)
3312 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3313 abfd
, d
->this_hdr
.bfd_section
,
3315 /* Point to the kept section if it has the same
3316 size as the discarded one. */
3317 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3320 bfd_set_error (bfd_error_bad_value
);
3326 s
= s
->output_section
;
3327 BFD_ASSERT (s
!= NULL
);
3331 /* Handle objcopy. */
3332 if (s
->output_section
== NULL
)
3334 (*_bfd_error_handler
)
3335 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3336 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3337 bfd_set_error (bfd_error_bad_value
);
3340 s
= s
->output_section
;
3342 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3347 The Intel C compiler generates SHT_IA_64_UNWIND with
3348 SHF_LINK_ORDER. But it doesn't set the sh_link or
3349 sh_info fields. Hence we could get the situation
3351 const struct elf_backend_data
*bed
3352 = get_elf_backend_data (abfd
);
3353 if (bed
->link_order_error_handler
)
3354 bed
->link_order_error_handler
3355 (_("%B: warning: sh_link not set for section `%A'"),
3360 switch (d
->this_hdr
.sh_type
)
3364 /* A reloc section which we are treating as a normal BFD
3365 section. sh_link is the section index of the symbol
3366 table. sh_info is the section index of the section to
3367 which the relocation entries apply. We assume that an
3368 allocated reloc section uses the dynamic symbol table.
3369 FIXME: How can we be sure? */
3370 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3372 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3374 s
= get_elf_backend_data (abfd
)->get_reloc_section (sec
);
3377 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3378 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3383 /* We assume that a section named .stab*str is a stabs
3384 string section. We look for a section with the same name
3385 but without the trailing ``str'', and set its sh_link
3386 field to point to this section. */
3387 if (CONST_STRNEQ (sec
->name
, ".stab")
3388 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3393 len
= strlen (sec
->name
);
3394 alc
= (char *) bfd_malloc (len
- 2);
3397 memcpy (alc
, sec
->name
, len
- 3);
3398 alc
[len
- 3] = '\0';
3399 s
= bfd_get_section_by_name (abfd
, alc
);
3403 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3405 /* This is a .stab section. */
3406 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3407 elf_section_data (s
)->this_hdr
.sh_entsize
3408 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3415 case SHT_GNU_verneed
:
3416 case SHT_GNU_verdef
:
3417 /* sh_link is the section header index of the string table
3418 used for the dynamic entries, or the symbol table, or the
3420 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3422 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3425 case SHT_GNU_LIBLIST
:
3426 /* sh_link is the section header index of the prelink library
3427 list used for the dynamic entries, or the symbol table, or
3428 the version strings. */
3429 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3430 ? ".dynstr" : ".gnu.libstr");
3432 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3437 case SHT_GNU_versym
:
3438 /* sh_link is the section header index of the symbol table
3439 this hash table or version table is for. */
3440 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3442 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3446 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3450 for (secn
= 1; secn
< section_number
; ++secn
)
3451 if (i_shdrp
[secn
] == NULL
)
3452 i_shdrp
[secn
] = i_shdrp
[0];
3454 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3455 i_shdrp
[secn
]->sh_name
);
3460 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3462 /* If the backend has a special mapping, use it. */
3463 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3464 if (bed
->elf_backend_sym_is_global
)
3465 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3467 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3468 || bfd_is_und_section (bfd_get_section (sym
))
3469 || bfd_is_com_section (bfd_get_section (sym
)));
3472 /* Don't output section symbols for sections that are not going to be
3473 output, that are duplicates or there is no BFD section. */
3476 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3478 elf_symbol_type
*type_ptr
;
3480 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3483 type_ptr
= elf_symbol_from (abfd
, sym
);
3484 return ((type_ptr
!= NULL
3485 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
3486 && bfd_is_abs_section (sym
->section
))
3487 || !(sym
->section
->owner
== abfd
3488 || (sym
->section
->output_section
->owner
== abfd
3489 && sym
->section
->output_offset
== 0)
3490 || bfd_is_abs_section (sym
->section
)));
3493 /* Map symbol from it's internal number to the external number, moving
3494 all local symbols to be at the head of the list. */
3497 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
3499 unsigned int symcount
= bfd_get_symcount (abfd
);
3500 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3501 asymbol
**sect_syms
;
3502 unsigned int num_locals
= 0;
3503 unsigned int num_globals
= 0;
3504 unsigned int num_locals2
= 0;
3505 unsigned int num_globals2
= 0;
3512 fprintf (stderr
, "elf_map_symbols\n");
3516 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3518 if (max_index
< asect
->index
)
3519 max_index
= asect
->index
;
3523 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3524 if (sect_syms
== NULL
)
3526 elf_section_syms (abfd
) = sect_syms
;
3527 elf_num_section_syms (abfd
) = max_index
;
3529 /* Init sect_syms entries for any section symbols we have already
3530 decided to output. */
3531 for (idx
= 0; idx
< symcount
; idx
++)
3533 asymbol
*sym
= syms
[idx
];
3535 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3537 && !ignore_section_sym (abfd
, sym
)
3538 && !bfd_is_abs_section (sym
->section
))
3540 asection
*sec
= sym
->section
;
3542 if (sec
->owner
!= abfd
)
3543 sec
= sec
->output_section
;
3545 sect_syms
[sec
->index
] = syms
[idx
];
3549 /* Classify all of the symbols. */
3550 for (idx
= 0; idx
< symcount
; idx
++)
3552 if (sym_is_global (abfd
, syms
[idx
]))
3554 else if (!ignore_section_sym (abfd
, syms
[idx
]))
3558 /* We will be adding a section symbol for each normal BFD section. Most
3559 sections will already have a section symbol in outsymbols, but
3560 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3561 at least in that case. */
3562 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3564 if (sect_syms
[asect
->index
] == NULL
)
3566 if (!sym_is_global (abfd
, asect
->symbol
))
3573 /* Now sort the symbols so the local symbols are first. */
3574 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
3575 sizeof (asymbol
*));
3577 if (new_syms
== NULL
)
3580 for (idx
= 0; idx
< symcount
; idx
++)
3582 asymbol
*sym
= syms
[idx
];
3585 if (sym_is_global (abfd
, sym
))
3586 i
= num_locals
+ num_globals2
++;
3587 else if (!ignore_section_sym (abfd
, sym
))
3592 sym
->udata
.i
= i
+ 1;
3594 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3596 if (sect_syms
[asect
->index
] == NULL
)
3598 asymbol
*sym
= asect
->symbol
;
3601 sect_syms
[asect
->index
] = sym
;
3602 if (!sym_is_global (abfd
, sym
))
3605 i
= num_locals
+ num_globals2
++;
3607 sym
->udata
.i
= i
+ 1;
3611 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3613 *pnum_locals
= num_locals
;
3617 /* Align to the maximum file alignment that could be required for any
3618 ELF data structure. */
3620 static inline file_ptr
3621 align_file_position (file_ptr off
, int align
)
3623 return (off
+ align
- 1) & ~(align
- 1);
3626 /* Assign a file position to a section, optionally aligning to the
3627 required section alignment. */
3630 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3634 if (align
&& i_shdrp
->sh_addralign
> 1)
3635 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3636 i_shdrp
->sh_offset
= offset
;
3637 if (i_shdrp
->bfd_section
!= NULL
)
3638 i_shdrp
->bfd_section
->filepos
= offset
;
3639 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3640 offset
+= i_shdrp
->sh_size
;
3644 /* Compute the file positions we are going to put the sections at, and
3645 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3646 is not NULL, this is being called by the ELF backend linker. */
3649 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3650 struct bfd_link_info
*link_info
)
3652 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3653 struct fake_section_arg fsargs
;
3655 struct bfd_strtab_hash
*strtab
= NULL
;
3656 Elf_Internal_Shdr
*shstrtab_hdr
;
3657 bfd_boolean need_symtab
;
3659 if (abfd
->output_has_begun
)
3662 /* Do any elf backend specific processing first. */
3663 if (bed
->elf_backend_begin_write_processing
)
3664 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3666 if (! prep_headers (abfd
))
3669 /* Post process the headers if necessary. */
3670 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3672 fsargs
.failed
= FALSE
;
3673 fsargs
.link_info
= link_info
;
3674 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
3678 if (!assign_section_numbers (abfd
, link_info
))
3681 /* The backend linker builds symbol table information itself. */
3682 need_symtab
= (link_info
== NULL
3683 && (bfd_get_symcount (abfd
) > 0
3684 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3688 /* Non-zero if doing a relocatable link. */
3689 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3691 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3696 if (link_info
== NULL
)
3698 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3703 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3704 /* sh_name was set in prep_headers. */
3705 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3706 shstrtab_hdr
->sh_flags
= 0;
3707 shstrtab_hdr
->sh_addr
= 0;
3708 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3709 shstrtab_hdr
->sh_entsize
= 0;
3710 shstrtab_hdr
->sh_link
= 0;
3711 shstrtab_hdr
->sh_info
= 0;
3712 /* sh_offset is set in assign_file_positions_except_relocs. */
3713 shstrtab_hdr
->sh_addralign
= 1;
3715 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3721 Elf_Internal_Shdr
*hdr
;
3723 off
= elf_next_file_pos (abfd
);
3725 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3726 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3728 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3729 if (hdr
->sh_size
!= 0)
3730 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3732 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3733 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3735 elf_next_file_pos (abfd
) = off
;
3737 /* Now that we know where the .strtab section goes, write it
3739 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3740 || ! _bfd_stringtab_emit (abfd
, strtab
))
3742 _bfd_stringtab_free (strtab
);
3745 abfd
->output_has_begun
= TRUE
;
3750 /* Make an initial estimate of the size of the program header. If we
3751 get the number wrong here, we'll redo section placement. */
3753 static bfd_size_type
3754 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3758 const struct elf_backend_data
*bed
;
3760 /* Assume we will need exactly two PT_LOAD segments: one for text
3761 and one for data. */
3764 s
= bfd_get_section_by_name (abfd
, ".interp");
3765 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3767 /* If we have a loadable interpreter section, we need a
3768 PT_INTERP segment. In this case, assume we also need a
3769 PT_PHDR segment, although that may not be true for all
3774 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3776 /* We need a PT_DYNAMIC segment. */
3780 if (info
!= NULL
&& info
->relro
)
3782 /* We need a PT_GNU_RELRO segment. */
3786 if (elf_eh_frame_hdr (abfd
))
3788 /* We need a PT_GNU_EH_FRAME segment. */
3792 if (elf_stack_flags (abfd
))
3794 /* We need a PT_GNU_STACK segment. */
3798 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3800 if ((s
->flags
& SEC_LOAD
) != 0
3801 && CONST_STRNEQ (s
->name
, ".note"))
3803 /* We need a PT_NOTE segment. */
3805 /* Try to create just one PT_NOTE segment
3806 for all adjacent loadable .note* sections.
3807 gABI requires that within a PT_NOTE segment
3808 (and also inside of each SHT_NOTE section)
3809 each note is padded to a multiple of 4 size,
3810 so we check whether the sections are correctly
3812 if (s
->alignment_power
== 2)
3813 while (s
->next
!= NULL
3814 && s
->next
->alignment_power
== 2
3815 && (s
->next
->flags
& SEC_LOAD
) != 0
3816 && CONST_STRNEQ (s
->next
->name
, ".note"))
3821 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3823 if (s
->flags
& SEC_THREAD_LOCAL
)
3825 /* We need a PT_TLS segment. */
3831 /* Let the backend count up any program headers it might need. */
3832 bed
= get_elf_backend_data (abfd
);
3833 if (bed
->elf_backend_additional_program_headers
)
3837 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3843 return segs
* bed
->s
->sizeof_phdr
;
3846 /* Find the segment that contains the output_section of section. */
3849 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3851 struct elf_segment_map
*m
;
3852 Elf_Internal_Phdr
*p
;
3854 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
3860 for (i
= m
->count
- 1; i
>= 0; i
--)
3861 if (m
->sections
[i
] == section
)
3868 /* Create a mapping from a set of sections to a program segment. */
3870 static struct elf_segment_map
*
3871 make_mapping (bfd
*abfd
,
3872 asection
**sections
,
3877 struct elf_segment_map
*m
;
3882 amt
= sizeof (struct elf_segment_map
);
3883 amt
+= (to
- from
- 1) * sizeof (asection
*);
3884 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3888 m
->p_type
= PT_LOAD
;
3889 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3890 m
->sections
[i
- from
] = *hdrpp
;
3891 m
->count
= to
- from
;
3893 if (from
== 0 && phdr
)
3895 /* Include the headers in the first PT_LOAD segment. */
3896 m
->includes_filehdr
= 1;
3897 m
->includes_phdrs
= 1;
3903 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3906 struct elf_segment_map
*
3907 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3909 struct elf_segment_map
*m
;
3911 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
3912 sizeof (struct elf_segment_map
));
3916 m
->p_type
= PT_DYNAMIC
;
3918 m
->sections
[0] = dynsec
;
3923 /* Possibly add or remove segments from the segment map. */
3926 elf_modify_segment_map (bfd
*abfd
,
3927 struct bfd_link_info
*info
,
3928 bfd_boolean remove_empty_load
)
3930 struct elf_segment_map
**m
;
3931 const struct elf_backend_data
*bed
;
3933 /* The placement algorithm assumes that non allocated sections are
3934 not in PT_LOAD segments. We ensure this here by removing such
3935 sections from the segment map. We also remove excluded
3936 sections. Finally, any PT_LOAD segment without sections is
3938 m
= &elf_seg_map (abfd
);
3941 unsigned int i
, new_count
;
3943 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3945 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3946 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3947 || (*m
)->p_type
!= PT_LOAD
))
3949 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3953 (*m
)->count
= new_count
;
3955 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3961 bed
= get_elf_backend_data (abfd
);
3962 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3964 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3971 /* Set up a mapping from BFD sections to program segments. */
3974 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3977 struct elf_segment_map
*m
;
3978 asection
**sections
= NULL
;
3979 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3980 bfd_boolean no_user_phdrs
;
3982 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
3985 info
->user_phdrs
= !no_user_phdrs
;
3987 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3991 struct elf_segment_map
*mfirst
;
3992 struct elf_segment_map
**pm
;
3995 unsigned int phdr_index
;
3996 bfd_vma maxpagesize
;
3998 bfd_boolean phdr_in_segment
= TRUE
;
3999 bfd_boolean writable
;
4001 asection
*first_tls
= NULL
;
4002 asection
*dynsec
, *eh_frame_hdr
;
4004 bfd_vma addr_mask
, wrap_to
= 0;
4006 /* Select the allocated sections, and sort them. */
4008 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4009 sizeof (asection
*));
4010 if (sections
== NULL
)
4013 /* Calculate top address, avoiding undefined behaviour of shift
4014 left operator when shift count is equal to size of type
4016 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4017 addr_mask
= (addr_mask
<< 1) + 1;
4020 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4022 if ((s
->flags
& SEC_ALLOC
) != 0)
4026 /* A wrapping section potentially clashes with header. */
4027 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4028 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4031 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4034 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4036 /* Build the mapping. */
4041 /* If we have a .interp section, then create a PT_PHDR segment for
4042 the program headers and a PT_INTERP segment for the .interp
4044 s
= bfd_get_section_by_name (abfd
, ".interp");
4045 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4047 amt
= sizeof (struct elf_segment_map
);
4048 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4052 m
->p_type
= PT_PHDR
;
4053 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
4054 m
->p_flags
= PF_R
| PF_X
;
4055 m
->p_flags_valid
= 1;
4056 m
->includes_phdrs
= 1;
4061 amt
= sizeof (struct elf_segment_map
);
4062 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4066 m
->p_type
= PT_INTERP
;
4074 /* Look through the sections. We put sections in the same program
4075 segment when the start of the second section can be placed within
4076 a few bytes of the end of the first section. */
4080 maxpagesize
= bed
->maxpagesize
;
4081 /* PR 17512: file: c8455299.
4082 Avoid divide-by-zero errors later on.
4083 FIXME: Should we abort if the maxpagesize is zero ? */
4084 if (maxpagesize
== 0)
4087 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4089 && (dynsec
->flags
& SEC_LOAD
) == 0)
4092 /* Deal with -Ttext or something similar such that the first section
4093 is not adjacent to the program headers. This is an
4094 approximation, since at this point we don't know exactly how many
4095 program headers we will need. */
4098 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
4100 if (phdr_size
== (bfd_size_type
) -1)
4101 phdr_size
= get_program_header_size (abfd
, info
);
4102 phdr_size
+= bed
->s
->sizeof_ehdr
;
4103 if ((abfd
->flags
& D_PAGED
) == 0
4104 || (sections
[0]->lma
& addr_mask
) < phdr_size
4105 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
4106 < phdr_size
% maxpagesize
)
4107 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
4108 phdr_in_segment
= FALSE
;
4111 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4114 bfd_boolean new_segment
;
4118 /* See if this section and the last one will fit in the same
4121 if (last_hdr
== NULL
)
4123 /* If we don't have a segment yet, then we don't need a new
4124 one (we build the last one after this loop). */
4125 new_segment
= FALSE
;
4127 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4129 /* If this section has a different relation between the
4130 virtual address and the load address, then we need a new
4134 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4135 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4137 /* If this section has a load address that makes it overlap
4138 the previous section, then we need a new segment. */
4141 /* In the next test we have to be careful when last_hdr->lma is close
4142 to the end of the address space. If the aligned address wraps
4143 around to the start of the address space, then there are no more
4144 pages left in memory and it is OK to assume that the current
4145 section can be included in the current segment. */
4146 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4148 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4151 /* If putting this section in this segment would force us to
4152 skip a page in the segment, then we need a new segment. */
4155 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4156 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4158 /* We don't want to put a loadable section after a
4159 nonloadable section in the same segment.
4160 Consider .tbss sections as loadable for this purpose. */
4163 else if ((abfd
->flags
& D_PAGED
) == 0)
4165 /* If the file is not demand paged, which means that we
4166 don't require the sections to be correctly aligned in the
4167 file, then there is no other reason for a new segment. */
4168 new_segment
= FALSE
;
4171 && (hdr
->flags
& SEC_READONLY
) == 0
4172 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4173 != (hdr
->lma
& -maxpagesize
)))
4175 /* We don't want to put a writable section in a read only
4176 segment, unless they are on the same page in memory
4177 anyhow. We already know that the last section does not
4178 bring us past the current section on the page, so the
4179 only case in which the new section is not on the same
4180 page as the previous section is when the previous section
4181 ends precisely on a page boundary. */
4186 /* Otherwise, we can use the same segment. */
4187 new_segment
= FALSE
;
4190 /* Allow interested parties a chance to override our decision. */
4191 if (last_hdr
!= NULL
4193 && info
->callbacks
->override_segment_assignment
!= NULL
)
4195 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4201 if ((hdr
->flags
& SEC_READONLY
) == 0)
4204 /* .tbss sections effectively have zero size. */
4205 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4206 != SEC_THREAD_LOCAL
)
4207 last_size
= hdr
->size
;
4213 /* We need a new program segment. We must create a new program
4214 header holding all the sections from phdr_index until hdr. */
4216 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4223 if ((hdr
->flags
& SEC_READONLY
) == 0)
4229 /* .tbss sections effectively have zero size. */
4230 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4231 last_size
= hdr
->size
;
4235 phdr_in_segment
= FALSE
;
4238 /* Create a final PT_LOAD program segment, but not if it's just
4240 if (last_hdr
!= NULL
4241 && (i
- phdr_index
!= 1
4242 || ((last_hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4243 != SEC_THREAD_LOCAL
)))
4245 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4253 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4256 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4263 /* For each batch of consecutive loadable .note sections,
4264 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4265 because if we link together nonloadable .note sections and
4266 loadable .note sections, we will generate two .note sections
4267 in the output file. FIXME: Using names for section types is
4269 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4271 if ((s
->flags
& SEC_LOAD
) != 0
4272 && CONST_STRNEQ (s
->name
, ".note"))
4277 amt
= sizeof (struct elf_segment_map
);
4278 if (s
->alignment_power
== 2)
4279 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4281 if (s2
->next
->alignment_power
== 2
4282 && (s2
->next
->flags
& SEC_LOAD
) != 0
4283 && CONST_STRNEQ (s2
->next
->name
, ".note")
4284 && align_power (s2
->lma
+ s2
->size
, 2)
4290 amt
+= (count
- 1) * sizeof (asection
*);
4291 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4295 m
->p_type
= PT_NOTE
;
4299 m
->sections
[m
->count
- count
--] = s
;
4300 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4303 m
->sections
[m
->count
- 1] = s
;
4304 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4308 if (s
->flags
& SEC_THREAD_LOCAL
)
4316 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4319 amt
= sizeof (struct elf_segment_map
);
4320 amt
+= (tls_count
- 1) * sizeof (asection
*);
4321 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4326 m
->count
= tls_count
;
4327 /* Mandated PF_R. */
4329 m
->p_flags_valid
= 1;
4331 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4333 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
4336 (_("%B: TLS sections are not adjacent:"), abfd
);
4339 while (i
< (unsigned int) tls_count
)
4341 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
4343 _bfd_error_handler (_(" TLS: %A"), s
);
4347 _bfd_error_handler (_(" non-TLS: %A"), s
);
4350 bfd_set_error (bfd_error_bad_value
);
4361 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4363 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
4364 if (eh_frame_hdr
!= NULL
4365 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4367 amt
= sizeof (struct elf_segment_map
);
4368 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4372 m
->p_type
= PT_GNU_EH_FRAME
;
4374 m
->sections
[0] = eh_frame_hdr
->output_section
;
4380 if (elf_stack_flags (abfd
))
4382 amt
= sizeof (struct elf_segment_map
);
4383 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4387 m
->p_type
= PT_GNU_STACK
;
4388 m
->p_flags
= elf_stack_flags (abfd
);
4389 m
->p_align
= bed
->stack_align
;
4390 m
->p_flags_valid
= 1;
4391 m
->p_align_valid
= m
->p_align
!= 0;
4392 if (info
->stacksize
> 0)
4394 m
->p_size
= info
->stacksize
;
4395 m
->p_size_valid
= 1;
4402 if (info
!= NULL
&& info
->relro
)
4404 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
4406 if (m
->p_type
== PT_LOAD
4408 && m
->sections
[0]->vma
>= info
->relro_start
4409 && m
->sections
[0]->vma
< info
->relro_end
)
4412 while (--i
!= (unsigned) -1)
4413 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
4414 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
4417 if (i
!= (unsigned) -1)
4422 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4425 amt
= sizeof (struct elf_segment_map
);
4426 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4430 m
->p_type
= PT_GNU_RELRO
;
4432 m
->p_flags_valid
= 1;
4440 elf_seg_map (abfd
) = mfirst
;
4443 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4446 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4448 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
4453 if (sections
!= NULL
)
4458 /* Sort sections by address. */
4461 elf_sort_sections (const void *arg1
, const void *arg2
)
4463 const asection
*sec1
= *(const asection
**) arg1
;
4464 const asection
*sec2
= *(const asection
**) arg2
;
4465 bfd_size_type size1
, size2
;
4467 /* Sort by LMA first, since this is the address used to
4468 place the section into a segment. */
4469 if (sec1
->lma
< sec2
->lma
)
4471 else if (sec1
->lma
> sec2
->lma
)
4474 /* Then sort by VMA. Normally the LMA and the VMA will be
4475 the same, and this will do nothing. */
4476 if (sec1
->vma
< sec2
->vma
)
4478 else if (sec1
->vma
> sec2
->vma
)
4481 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4483 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4489 /* If the indicies are the same, do not return 0
4490 here, but continue to try the next comparison. */
4491 if (sec1
->target_index
- sec2
->target_index
!= 0)
4492 return sec1
->target_index
- sec2
->target_index
;
4497 else if (TOEND (sec2
))
4502 /* Sort by size, to put zero sized sections
4503 before others at the same address. */
4505 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4506 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4513 return sec1
->target_index
- sec2
->target_index
;
4516 /* Ian Lance Taylor writes:
4518 We shouldn't be using % with a negative signed number. That's just
4519 not good. We have to make sure either that the number is not
4520 negative, or that the number has an unsigned type. When the types
4521 are all the same size they wind up as unsigned. When file_ptr is a
4522 larger signed type, the arithmetic winds up as signed long long,
4525 What we're trying to say here is something like ``increase OFF by
4526 the least amount that will cause it to be equal to the VMA modulo
4528 /* In other words, something like:
4530 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4531 off_offset = off % bed->maxpagesize;
4532 if (vma_offset < off_offset)
4533 adjustment = vma_offset + bed->maxpagesize - off_offset;
4535 adjustment = vma_offset - off_offset;
4537 which can can be collapsed into the expression below. */
4540 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4542 /* PR binutils/16199: Handle an alignment of zero. */
4543 if (maxpagesize
== 0)
4545 return ((vma
- off
) % maxpagesize
);
4549 print_segment_map (const struct elf_segment_map
*m
)
4552 const char *pt
= get_segment_type (m
->p_type
);
4557 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4558 sprintf (buf
, "LOPROC+%7.7x",
4559 (unsigned int) (m
->p_type
- PT_LOPROC
));
4560 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4561 sprintf (buf
, "LOOS+%7.7x",
4562 (unsigned int) (m
->p_type
- PT_LOOS
));
4564 snprintf (buf
, sizeof (buf
), "%8.8x",
4565 (unsigned int) m
->p_type
);
4569 fprintf (stderr
, "%s:", pt
);
4570 for (j
= 0; j
< m
->count
; j
++)
4571 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4577 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
4582 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4584 buf
= bfd_zmalloc (len
);
4587 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
4592 /* Assign file positions to the sections based on the mapping from
4593 sections to segments. This function also sets up some fields in
4597 assign_file_positions_for_load_sections (bfd
*abfd
,
4598 struct bfd_link_info
*link_info
)
4600 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4601 struct elf_segment_map
*m
;
4602 Elf_Internal_Phdr
*phdrs
;
4603 Elf_Internal_Phdr
*p
;
4605 bfd_size_type maxpagesize
;
4608 bfd_vma header_pad
= 0;
4610 if (link_info
== NULL
4611 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
4615 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4619 header_pad
= m
->header_size
;
4624 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4625 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4629 /* PR binutils/12467. */
4630 elf_elfheader (abfd
)->e_phoff
= 0;
4631 elf_elfheader (abfd
)->e_phentsize
= 0;
4634 elf_elfheader (abfd
)->e_phnum
= alloc
;
4636 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
4637 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
4639 BFD_ASSERT (elf_program_header_size (abfd
)
4640 >= alloc
* bed
->s
->sizeof_phdr
);
4644 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
4648 /* We're writing the size in elf_program_header_size (abfd),
4649 see assign_file_positions_except_relocs, so make sure we have
4650 that amount allocated, with trailing space cleared.
4651 The variable alloc contains the computed need, while
4652 elf_program_header_size (abfd) contains the size used for the
4654 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4655 where the layout is forced to according to a larger size in the
4656 last iterations for the testcase ld-elf/header. */
4657 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
4659 phdrs
= (Elf_Internal_Phdr
*)
4661 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
4662 sizeof (Elf_Internal_Phdr
));
4663 elf_tdata (abfd
)->phdr
= phdrs
;
4668 if ((abfd
->flags
& D_PAGED
) != 0)
4669 maxpagesize
= bed
->maxpagesize
;
4671 off
= bed
->s
->sizeof_ehdr
;
4672 off
+= alloc
* bed
->s
->sizeof_phdr
;
4673 if (header_pad
< (bfd_vma
) off
)
4679 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
4681 m
= m
->next
, p
++, j
++)
4685 bfd_boolean no_contents
;
4687 /* If elf_segment_map is not from map_sections_to_segments, the
4688 sections may not be correctly ordered. NOTE: sorting should
4689 not be done to the PT_NOTE section of a corefile, which may
4690 contain several pseudo-sections artificially created by bfd.
4691 Sorting these pseudo-sections breaks things badly. */
4693 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4694 && m
->p_type
== PT_NOTE
))
4695 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4698 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4699 number of sections with contents contributing to both p_filesz
4700 and p_memsz, followed by a number of sections with no contents
4701 that just contribute to p_memsz. In this loop, OFF tracks next
4702 available file offset for PT_LOAD and PT_NOTE segments. */
4703 p
->p_type
= m
->p_type
;
4704 p
->p_flags
= m
->p_flags
;
4709 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4711 if (m
->p_paddr_valid
)
4712 p
->p_paddr
= m
->p_paddr
;
4713 else if (m
->count
== 0)
4716 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4718 if (p
->p_type
== PT_LOAD
4719 && (abfd
->flags
& D_PAGED
) != 0)
4721 /* p_align in demand paged PT_LOAD segments effectively stores
4722 the maximum page size. When copying an executable with
4723 objcopy, we set m->p_align from the input file. Use this
4724 value for maxpagesize rather than bed->maxpagesize, which
4725 may be different. Note that we use maxpagesize for PT_TLS
4726 segment alignment later in this function, so we are relying
4727 on at least one PT_LOAD segment appearing before a PT_TLS
4729 if (m
->p_align_valid
)
4730 maxpagesize
= m
->p_align
;
4732 p
->p_align
= maxpagesize
;
4734 else if (m
->p_align_valid
)
4735 p
->p_align
= m
->p_align
;
4736 else if (m
->count
== 0)
4737 p
->p_align
= 1 << bed
->s
->log_file_align
;
4741 no_contents
= FALSE
;
4743 if (p
->p_type
== PT_LOAD
4746 bfd_size_type align
;
4747 unsigned int align_power
= 0;
4749 if (m
->p_align_valid
)
4753 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4755 unsigned int secalign
;
4757 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4758 if (secalign
> align_power
)
4759 align_power
= secalign
;
4761 align
= (bfd_size_type
) 1 << align_power
;
4762 if (align
< maxpagesize
)
4763 align
= maxpagesize
;
4766 for (i
= 0; i
< m
->count
; i
++)
4767 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4768 /* If we aren't making room for this section, then
4769 it must be SHT_NOBITS regardless of what we've
4770 set via struct bfd_elf_special_section. */
4771 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4773 /* Find out whether this segment contains any loadable
4776 for (i
= 0; i
< m
->count
; i
++)
4777 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
4779 no_contents
= FALSE
;
4783 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
4787 /* We shouldn't need to align the segment on disk since
4788 the segment doesn't need file space, but the gABI
4789 arguably requires the alignment and glibc ld.so
4790 checks it. So to comply with the alignment
4791 requirement but not waste file space, we adjust
4792 p_offset for just this segment. (OFF_ADJUST is
4793 subtracted from OFF later.) This may put p_offset
4794 past the end of file, but that shouldn't matter. */
4799 /* Make sure the .dynamic section is the first section in the
4800 PT_DYNAMIC segment. */
4801 else if (p
->p_type
== PT_DYNAMIC
4803 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4806 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4808 bfd_set_error (bfd_error_bad_value
);
4811 /* Set the note section type to SHT_NOTE. */
4812 else if (p
->p_type
== PT_NOTE
)
4813 for (i
= 0; i
< m
->count
; i
++)
4814 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4820 if (m
->includes_filehdr
)
4822 if (!m
->p_flags_valid
)
4824 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4825 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4828 if (p
->p_vaddr
< (bfd_vma
) off
)
4830 (*_bfd_error_handler
)
4831 (_("%B: Not enough room for program headers, try linking with -N"),
4833 bfd_set_error (bfd_error_bad_value
);
4838 if (!m
->p_paddr_valid
)
4843 if (m
->includes_phdrs
)
4845 if (!m
->p_flags_valid
)
4848 if (!m
->includes_filehdr
)
4850 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4854 p
->p_vaddr
-= off
- p
->p_offset
;
4855 if (!m
->p_paddr_valid
)
4856 p
->p_paddr
-= off
- p
->p_offset
;
4860 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4861 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4864 p
->p_filesz
+= header_pad
;
4865 p
->p_memsz
+= header_pad
;
4869 if (p
->p_type
== PT_LOAD
4870 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4872 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4878 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4880 p
->p_filesz
+= adjust
;
4881 p
->p_memsz
+= adjust
;
4885 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4886 maps. Set filepos for sections in PT_LOAD segments, and in
4887 core files, for sections in PT_NOTE segments.
4888 assign_file_positions_for_non_load_sections will set filepos
4889 for other sections and update p_filesz for other segments. */
4890 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4893 bfd_size_type align
;
4894 Elf_Internal_Shdr
*this_hdr
;
4897 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4898 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4900 if ((p
->p_type
== PT_LOAD
4901 || p
->p_type
== PT_TLS
)
4902 && (this_hdr
->sh_type
!= SHT_NOBITS
4903 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4904 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4905 || p
->p_type
== PT_TLS
))))
4907 bfd_vma p_start
= p
->p_paddr
;
4908 bfd_vma p_end
= p_start
+ p
->p_memsz
;
4909 bfd_vma s_start
= sec
->lma
;
4910 bfd_vma adjust
= s_start
- p_end
;
4914 || p_end
< p_start
))
4916 (*_bfd_error_handler
)
4917 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
4918 (unsigned long) s_start
, (unsigned long) p_end
);
4922 p
->p_memsz
+= adjust
;
4924 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4926 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
4928 /* We have a PROGBITS section following NOBITS ones.
4929 Allocate file space for the NOBITS section(s) and
4931 adjust
= p
->p_memsz
- p
->p_filesz
;
4932 if (!write_zeros (abfd
, off
, adjust
))
4936 p
->p_filesz
+= adjust
;
4940 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4942 /* The section at i == 0 is the one that actually contains
4946 this_hdr
->sh_offset
= sec
->filepos
= off
;
4947 off
+= this_hdr
->sh_size
;
4948 p
->p_filesz
= this_hdr
->sh_size
;
4954 /* The rest are fake sections that shouldn't be written. */
4963 if (p
->p_type
== PT_LOAD
)
4965 this_hdr
->sh_offset
= sec
->filepos
= off
;
4966 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4967 off
+= this_hdr
->sh_size
;
4969 else if (this_hdr
->sh_type
== SHT_NOBITS
4970 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
4971 && this_hdr
->sh_offset
== 0)
4973 /* This is a .tbss section that didn't get a PT_LOAD.
4974 (See _bfd_elf_map_sections_to_segments "Create a
4975 final PT_LOAD".) Set sh_offset to the value it
4976 would have if we had created a zero p_filesz and
4977 p_memsz PT_LOAD header for the section. This
4978 also makes the PT_TLS header have the same
4980 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
4982 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
4985 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4987 p
->p_filesz
+= this_hdr
->sh_size
;
4988 /* A load section without SHF_ALLOC is something like
4989 a note section in a PT_NOTE segment. These take
4990 file space but are not loaded into memory. */
4991 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4992 p
->p_memsz
+= this_hdr
->sh_size
;
4994 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4996 if (p
->p_type
== PT_TLS
)
4997 p
->p_memsz
+= this_hdr
->sh_size
;
4999 /* .tbss is special. It doesn't contribute to p_memsz of
5001 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5002 p
->p_memsz
+= this_hdr
->sh_size
;
5005 if (align
> p
->p_align
5006 && !m
->p_align_valid
5007 && (p
->p_type
!= PT_LOAD
5008 || (abfd
->flags
& D_PAGED
) == 0))
5012 if (!m
->p_flags_valid
)
5015 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5017 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5024 /* Check that all sections are in a PT_LOAD segment.
5025 Don't check funky gdb generated core files. */
5026 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5028 bfd_boolean check_vma
= TRUE
;
5030 for (i
= 1; i
< m
->count
; i
++)
5031 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5032 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5033 ->this_hdr
), p
) != 0
5034 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5035 ->this_hdr
), p
) != 0)
5037 /* Looks like we have overlays packed into the segment. */
5042 for (i
= 0; i
< m
->count
; i
++)
5044 Elf_Internal_Shdr
*this_hdr
;
5047 sec
= m
->sections
[i
];
5048 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5049 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5050 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5052 (*_bfd_error_handler
)
5053 (_("%B: section `%A' can't be allocated in segment %d"),
5055 print_segment_map (m
);
5061 elf_next_file_pos (abfd
) = off
;
5065 /* Assign file positions for the other sections. */
5068 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5069 struct bfd_link_info
*link_info
)
5071 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5072 Elf_Internal_Shdr
**i_shdrpp
;
5073 Elf_Internal_Shdr
**hdrpp
;
5074 Elf_Internal_Phdr
*phdrs
;
5075 Elf_Internal_Phdr
*p
;
5076 struct elf_segment_map
*m
;
5077 struct elf_segment_map
*hdrs_segment
;
5078 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5079 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5081 unsigned int num_sec
;
5085 i_shdrpp
= elf_elfsections (abfd
);
5086 num_sec
= elf_numsections (abfd
);
5087 off
= elf_next_file_pos (abfd
);
5088 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5090 Elf_Internal_Shdr
*hdr
;
5093 if (hdr
->bfd_section
!= NULL
5094 && (hdr
->bfd_section
->filepos
!= 0
5095 || (hdr
->sh_type
== SHT_NOBITS
5096 && hdr
->contents
== NULL
)))
5097 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5098 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5100 if (hdr
->sh_size
!= 0)
5101 (*_bfd_error_handler
)
5102 (_("%B: warning: allocated section `%s' not in segment"),
5104 (hdr
->bfd_section
== NULL
5106 : hdr
->bfd_section
->name
));
5107 /* We don't need to page align empty sections. */
5108 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5109 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5112 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5114 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5117 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5118 && hdr
->bfd_section
== NULL
)
5119 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5120 || hdr
== i_shdrpp
[elf_symtab_shndx (abfd
)]
5121 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)])
5122 hdr
->sh_offset
= -1;
5124 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5127 /* Now that we have set the section file positions, we can set up
5128 the file positions for the non PT_LOAD segments. */
5132 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5134 hdrs_segment
= NULL
;
5135 phdrs
= elf_tdata (abfd
)->phdr
;
5136 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5139 if (p
->p_type
!= PT_LOAD
)
5142 if (m
->includes_filehdr
)
5144 filehdr_vaddr
= p
->p_vaddr
;
5145 filehdr_paddr
= p
->p_paddr
;
5147 if (m
->includes_phdrs
)
5149 phdrs_vaddr
= p
->p_vaddr
;
5150 phdrs_paddr
= p
->p_paddr
;
5151 if (m
->includes_filehdr
)
5154 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5155 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5160 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5162 /* There is a segment that contains both the file headers and the
5163 program headers, so provide a symbol __ehdr_start pointing there.
5164 A program can use this to examine itself robustly. */
5166 struct elf_link_hash_entry
*hash
5167 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5168 FALSE
, FALSE
, TRUE
);
5169 /* If the symbol was referenced and not defined, define it. */
5171 && (hash
->root
.type
== bfd_link_hash_new
5172 || hash
->root
.type
== bfd_link_hash_undefined
5173 || hash
->root
.type
== bfd_link_hash_undefweak
5174 || hash
->root
.type
== bfd_link_hash_common
))
5177 if (hdrs_segment
->count
!= 0)
5178 /* The segment contains sections, so use the first one. */
5179 s
= hdrs_segment
->sections
[0];
5181 /* Use the first (i.e. lowest-addressed) section in any segment. */
5182 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5191 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5192 hash
->root
.u
.def
.section
= s
;
5196 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5197 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5200 hash
->root
.type
= bfd_link_hash_defined
;
5201 hash
->def_regular
= 1;
5206 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5208 if (p
->p_type
== PT_GNU_RELRO
)
5210 const Elf_Internal_Phdr
*lp
;
5211 struct elf_segment_map
*lm
;
5213 if (link_info
!= NULL
)
5215 /* During linking the range of the RELRO segment is passed
5217 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5219 lm
= lm
->next
, lp
++)
5221 if (lp
->p_type
== PT_LOAD
5222 && lp
->p_vaddr
< link_info
->relro_end
5224 && lm
->sections
[0]->vma
>= link_info
->relro_start
)
5228 BFD_ASSERT (lm
!= NULL
);
5232 /* Otherwise we are copying an executable or shared
5233 library, but we need to use the same linker logic. */
5234 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
5236 if (lp
->p_type
== PT_LOAD
5237 && lp
->p_paddr
== p
->p_paddr
)
5242 if (lp
< phdrs
+ count
)
5244 p
->p_vaddr
= lp
->p_vaddr
;
5245 p
->p_paddr
= lp
->p_paddr
;
5246 p
->p_offset
= lp
->p_offset
;
5247 if (link_info
!= NULL
)
5248 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
5249 else if (m
->p_size_valid
)
5250 p
->p_filesz
= m
->p_size
;
5253 p
->p_memsz
= p
->p_filesz
;
5254 /* Preserve the alignment and flags if they are valid. The
5255 gold linker generates RW/4 for the PT_GNU_RELRO section.
5256 It is better for objcopy/strip to honor these attributes
5257 otherwise gdb will choke when using separate debug files.
5259 if (!m
->p_align_valid
)
5261 if (!m
->p_flags_valid
)
5262 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
5266 memset (p
, 0, sizeof *p
);
5267 p
->p_type
= PT_NULL
;
5270 else if (p
->p_type
== PT_GNU_STACK
)
5272 if (m
->p_size_valid
)
5273 p
->p_memsz
= m
->p_size
;
5275 else if (m
->count
!= 0)
5277 if (p
->p_type
!= PT_LOAD
5278 && (p
->p_type
!= PT_NOTE
5279 || bfd_get_format (abfd
) != bfd_core
))
5281 if (m
->includes_filehdr
|| m
->includes_phdrs
)
5283 /* PR 17512: file: 2195325e. */
5284 (*_bfd_error_handler
)
5285 (_("%B: warning: non-load segment includes file header and/or program header"),
5291 p
->p_offset
= m
->sections
[0]->filepos
;
5292 for (i
= m
->count
; i
-- != 0;)
5294 asection
*sect
= m
->sections
[i
];
5295 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
5296 if (hdr
->sh_type
!= SHT_NOBITS
)
5298 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
5305 else if (m
->includes_filehdr
)
5307 p
->p_vaddr
= filehdr_vaddr
;
5308 if (! m
->p_paddr_valid
)
5309 p
->p_paddr
= filehdr_paddr
;
5311 else if (m
->includes_phdrs
)
5313 p
->p_vaddr
= phdrs_vaddr
;
5314 if (! m
->p_paddr_valid
)
5315 p
->p_paddr
= phdrs_paddr
;
5319 elf_next_file_pos (abfd
) = off
;
5324 /* Work out the file positions of all the sections. This is called by
5325 _bfd_elf_compute_section_file_positions. All the section sizes and
5326 VMAs must be known before this is called.
5328 Reloc sections come in two flavours: Those processed specially as
5329 "side-channel" data attached to a section to which they apply, and
5330 those that bfd doesn't process as relocations. The latter sort are
5331 stored in a normal bfd section by bfd_section_from_shdr. We don't
5332 consider the former sort here, unless they form part of the loadable
5333 image. Reloc sections not assigned here will be handled later by
5334 assign_file_positions_for_relocs.
5336 We also don't set the positions of the .symtab and .strtab here. */
5339 assign_file_positions_except_relocs (bfd
*abfd
,
5340 struct bfd_link_info
*link_info
)
5342 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
5343 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5344 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5346 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
5347 && bfd_get_format (abfd
) != bfd_core
)
5349 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
5350 unsigned int num_sec
= elf_numsections (abfd
);
5351 Elf_Internal_Shdr
**hdrpp
;
5355 /* Start after the ELF header. */
5356 off
= i_ehdrp
->e_ehsize
;
5358 /* We are not creating an executable, which means that we are
5359 not creating a program header, and that the actual order of
5360 the sections in the file is unimportant. */
5361 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5363 Elf_Internal_Shdr
*hdr
;
5366 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5367 && hdr
->bfd_section
== NULL
)
5368 || i
== elf_onesymtab (abfd
)
5369 || i
== elf_symtab_shndx (abfd
)
5370 || i
== elf_strtab_sec (abfd
))
5372 hdr
->sh_offset
= -1;
5375 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5378 elf_next_file_pos (abfd
) = off
;
5384 /* Assign file positions for the loaded sections based on the
5385 assignment of sections to segments. */
5386 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
5389 /* And for non-load sections. */
5390 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
5393 if (bed
->elf_backend_modify_program_headers
!= NULL
)
5395 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
5399 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
5400 if (link_info
!= NULL
5401 && link_info
->executable
5402 && link_info
->shared
)
5404 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
5405 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
5406 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
5408 /* Find the lowest p_vaddr in PT_LOAD segments. */
5409 bfd_vma p_vaddr
= (bfd_vma
) -1;
5410 for (; segment
< end_segment
; segment
++)
5411 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
5412 p_vaddr
= segment
->p_vaddr
;
5414 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5415 segments is non-zero. */
5417 i_ehdrp
->e_type
= ET_EXEC
;
5420 /* Write out the program headers. */
5421 alloc
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5422 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
5423 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
5431 prep_headers (bfd
*abfd
)
5433 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
5434 struct elf_strtab_hash
*shstrtab
;
5435 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5437 i_ehdrp
= elf_elfheader (abfd
);
5439 shstrtab
= _bfd_elf_strtab_init ();
5440 if (shstrtab
== NULL
)
5443 elf_shstrtab (abfd
) = shstrtab
;
5445 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
5446 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
5447 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
5448 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
5450 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
5451 i_ehdrp
->e_ident
[EI_DATA
] =
5452 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
5453 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
5455 if ((abfd
->flags
& DYNAMIC
) != 0)
5456 i_ehdrp
->e_type
= ET_DYN
;
5457 else if ((abfd
->flags
& EXEC_P
) != 0)
5458 i_ehdrp
->e_type
= ET_EXEC
;
5459 else if (bfd_get_format (abfd
) == bfd_core
)
5460 i_ehdrp
->e_type
= ET_CORE
;
5462 i_ehdrp
->e_type
= ET_REL
;
5464 switch (bfd_get_arch (abfd
))
5466 case bfd_arch_unknown
:
5467 i_ehdrp
->e_machine
= EM_NONE
;
5470 /* There used to be a long list of cases here, each one setting
5471 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5472 in the corresponding bfd definition. To avoid duplication,
5473 the switch was removed. Machines that need special handling
5474 can generally do it in elf_backend_final_write_processing(),
5475 unless they need the information earlier than the final write.
5476 Such need can generally be supplied by replacing the tests for
5477 e_machine with the conditions used to determine it. */
5479 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
5482 i_ehdrp
->e_version
= bed
->s
->ev_current
;
5483 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
5485 /* No program header, for now. */
5486 i_ehdrp
->e_phoff
= 0;
5487 i_ehdrp
->e_phentsize
= 0;
5488 i_ehdrp
->e_phnum
= 0;
5490 /* Each bfd section is section header entry. */
5491 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
5492 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
5494 /* If we're building an executable, we'll need a program header table. */
5495 if (abfd
->flags
& EXEC_P
)
5496 /* It all happens later. */
5500 i_ehdrp
->e_phentsize
= 0;
5501 i_ehdrp
->e_phoff
= 0;
5504 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
5505 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
5506 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
5507 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
5508 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
5509 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
5510 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5511 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
5512 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
5518 /* Assign file positions for all the reloc sections which are not part
5519 of the loadable file image, and the file position of section headers. */
5522 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
5525 unsigned int i
, num_sec
;
5526 Elf_Internal_Shdr
**shdrpp
;
5527 Elf_Internal_Ehdr
*i_ehdrp
;
5528 const struct elf_backend_data
*bed
;
5530 off
= elf_next_file_pos (abfd
);
5532 num_sec
= elf_numsections (abfd
);
5533 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
5535 Elf_Internal_Shdr
*shdrp
;
5538 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
5539 && shdrp
->sh_offset
== -1)
5540 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5543 /* Place the section headers. */
5544 i_ehdrp
= elf_elfheader (abfd
);
5545 bed
= get_elf_backend_data (abfd
);
5546 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
5547 i_ehdrp
->e_shoff
= off
;
5548 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
5549 elf_next_file_pos (abfd
) = off
;
5553 _bfd_elf_write_object_contents (bfd
*abfd
)
5555 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5556 Elf_Internal_Shdr
**i_shdrp
;
5558 unsigned int count
, num_sec
;
5559 struct elf_obj_tdata
*t
;
5561 if (! abfd
->output_has_begun
5562 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5565 i_shdrp
= elf_elfsections (abfd
);
5568 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5572 _bfd_elf_assign_file_positions_for_relocs (abfd
);
5574 /* After writing the headers, we need to write the sections too... */
5575 num_sec
= elf_numsections (abfd
);
5576 for (count
= 1; count
< num_sec
; count
++)
5578 if (bed
->elf_backend_section_processing
)
5579 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5580 if (i_shdrp
[count
]->contents
)
5582 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5584 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5585 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5590 /* Write out the section header names. */
5591 t
= elf_tdata (abfd
);
5592 if (elf_shstrtab (abfd
) != NULL
5593 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5594 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5597 if (bed
->elf_backend_final_write_processing
)
5598 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
5600 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5603 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5604 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
5605 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
5611 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5613 /* Hopefully this can be done just like an object file. */
5614 return _bfd_elf_write_object_contents (abfd
);
5617 /* Given a section, search the header to find them. */
5620 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5622 const struct elf_backend_data
*bed
;
5623 unsigned int sec_index
;
5625 if (elf_section_data (asect
) != NULL
5626 && elf_section_data (asect
)->this_idx
!= 0)
5627 return elf_section_data (asect
)->this_idx
;
5629 if (bfd_is_abs_section (asect
))
5630 sec_index
= SHN_ABS
;
5631 else if (bfd_is_com_section (asect
))
5632 sec_index
= SHN_COMMON
;
5633 else if (bfd_is_und_section (asect
))
5634 sec_index
= SHN_UNDEF
;
5636 sec_index
= SHN_BAD
;
5638 bed
= get_elf_backend_data (abfd
);
5639 if (bed
->elf_backend_section_from_bfd_section
)
5641 int retval
= sec_index
;
5643 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5647 if (sec_index
== SHN_BAD
)
5648 bfd_set_error (bfd_error_nonrepresentable_section
);
5653 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5657 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5659 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5661 flagword flags
= asym_ptr
->flags
;
5663 /* When gas creates relocations against local labels, it creates its
5664 own symbol for the section, but does put the symbol into the
5665 symbol chain, so udata is 0. When the linker is generating
5666 relocatable output, this section symbol may be for one of the
5667 input sections rather than the output section. */
5668 if (asym_ptr
->udata
.i
== 0
5669 && (flags
& BSF_SECTION_SYM
)
5670 && asym_ptr
->section
)
5675 sec
= asym_ptr
->section
;
5676 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5677 sec
= sec
->output_section
;
5678 if (sec
->owner
== abfd
5679 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5680 && elf_section_syms (abfd
)[indx
] != NULL
)
5681 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5684 idx
= asym_ptr
->udata
.i
;
5688 /* This case can occur when using --strip-symbol on a symbol
5689 which is used in a relocation entry. */
5690 (*_bfd_error_handler
)
5691 (_("%B: symbol `%s' required but not present"),
5692 abfd
, bfd_asymbol_name (asym_ptr
));
5693 bfd_set_error (bfd_error_no_symbols
);
5700 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5701 (long) asym_ptr
, asym_ptr
->name
, idx
, (long) flags
);
5709 /* Rewrite program header information. */
5712 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5714 Elf_Internal_Ehdr
*iehdr
;
5715 struct elf_segment_map
*map
;
5716 struct elf_segment_map
*map_first
;
5717 struct elf_segment_map
**pointer_to_map
;
5718 Elf_Internal_Phdr
*segment
;
5721 unsigned int num_segments
;
5722 bfd_boolean phdr_included
= FALSE
;
5723 bfd_boolean p_paddr_valid
;
5724 bfd_vma maxpagesize
;
5725 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5726 unsigned int phdr_adjust_num
= 0;
5727 const struct elf_backend_data
*bed
;
5729 bed
= get_elf_backend_data (ibfd
);
5730 iehdr
= elf_elfheader (ibfd
);
5733 pointer_to_map
= &map_first
;
5735 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5736 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5738 /* Returns the end address of the segment + 1. */
5739 #define SEGMENT_END(segment, start) \
5740 (start + (segment->p_memsz > segment->p_filesz \
5741 ? segment->p_memsz : segment->p_filesz))
5743 #define SECTION_SIZE(section, segment) \
5744 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5745 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5746 ? section->size : 0)
5748 /* Returns TRUE if the given section is contained within
5749 the given segment. VMA addresses are compared. */
5750 #define IS_CONTAINED_BY_VMA(section, segment) \
5751 (section->vma >= segment->p_vaddr \
5752 && (section->vma + SECTION_SIZE (section, segment) \
5753 <= (SEGMENT_END (segment, segment->p_vaddr))))
5755 /* Returns TRUE if the given section is contained within
5756 the given segment. LMA addresses are compared. */
5757 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5758 (section->lma >= base \
5759 && (section->lma + SECTION_SIZE (section, segment) \
5760 <= SEGMENT_END (segment, base)))
5762 /* Handle PT_NOTE segment. */
5763 #define IS_NOTE(p, s) \
5764 (p->p_type == PT_NOTE \
5765 && elf_section_type (s) == SHT_NOTE \
5766 && (bfd_vma) s->filepos >= p->p_offset \
5767 && ((bfd_vma) s->filepos + s->size \
5768 <= p->p_offset + p->p_filesz))
5770 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5772 #define IS_COREFILE_NOTE(p, s) \
5774 && bfd_get_format (ibfd) == bfd_core \
5778 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5779 linker, which generates a PT_INTERP section with p_vaddr and
5780 p_memsz set to 0. */
5781 #define IS_SOLARIS_PT_INTERP(p, s) \
5783 && p->p_paddr == 0 \
5784 && p->p_memsz == 0 \
5785 && p->p_filesz > 0 \
5786 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5788 && (bfd_vma) s->filepos >= p->p_offset \
5789 && ((bfd_vma) s->filepos + s->size \
5790 <= p->p_offset + p->p_filesz))
5792 /* Decide if the given section should be included in the given segment.
5793 A section will be included if:
5794 1. It is within the address space of the segment -- we use the LMA
5795 if that is set for the segment and the VMA otherwise,
5796 2. It is an allocated section or a NOTE section in a PT_NOTE
5798 3. There is an output section associated with it,
5799 4. The section has not already been allocated to a previous segment.
5800 5. PT_GNU_STACK segments do not include any sections.
5801 6. PT_TLS segment includes only SHF_TLS sections.
5802 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5803 8. PT_DYNAMIC should not contain empty sections at the beginning
5804 (with the possible exception of .dynamic). */
5805 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5806 ((((segment->p_paddr \
5807 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5808 : IS_CONTAINED_BY_VMA (section, segment)) \
5809 && (section->flags & SEC_ALLOC) != 0) \
5810 || IS_NOTE (segment, section)) \
5811 && segment->p_type != PT_GNU_STACK \
5812 && (segment->p_type != PT_TLS \
5813 || (section->flags & SEC_THREAD_LOCAL)) \
5814 && (segment->p_type == PT_LOAD \
5815 || segment->p_type == PT_TLS \
5816 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5817 && (segment->p_type != PT_DYNAMIC \
5818 || SECTION_SIZE (section, segment) > 0 \
5819 || (segment->p_paddr \
5820 ? segment->p_paddr != section->lma \
5821 : segment->p_vaddr != section->vma) \
5822 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5824 && !section->segment_mark)
5826 /* If the output section of a section in the input segment is NULL,
5827 it is removed from the corresponding output segment. */
5828 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5829 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5830 && section->output_section != NULL)
5832 /* Returns TRUE iff seg1 starts after the end of seg2. */
5833 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5834 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5836 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5837 their VMA address ranges and their LMA address ranges overlap.
5838 It is possible to have overlapping VMA ranges without overlapping LMA
5839 ranges. RedBoot images for example can have both .data and .bss mapped
5840 to the same VMA range, but with the .data section mapped to a different
5842 #define SEGMENT_OVERLAPS(seg1, seg2) \
5843 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5844 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5845 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5846 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5848 /* Initialise the segment mark field. */
5849 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5850 section
->segment_mark
= FALSE
;
5852 /* The Solaris linker creates program headers in which all the
5853 p_paddr fields are zero. When we try to objcopy or strip such a
5854 file, we get confused. Check for this case, and if we find it
5855 don't set the p_paddr_valid fields. */
5856 p_paddr_valid
= FALSE
;
5857 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5860 if (segment
->p_paddr
!= 0)
5862 p_paddr_valid
= TRUE
;
5866 /* Scan through the segments specified in the program header
5867 of the input BFD. For this first scan we look for overlaps
5868 in the loadable segments. These can be created by weird
5869 parameters to objcopy. Also, fix some solaris weirdness. */
5870 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5875 Elf_Internal_Phdr
*segment2
;
5877 if (segment
->p_type
== PT_INTERP
)
5878 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5879 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5881 /* Mininal change so that the normal section to segment
5882 assignment code will work. */
5883 segment
->p_vaddr
= section
->vma
;
5887 if (segment
->p_type
!= PT_LOAD
)
5889 /* Remove PT_GNU_RELRO segment. */
5890 if (segment
->p_type
== PT_GNU_RELRO
)
5891 segment
->p_type
= PT_NULL
;
5895 /* Determine if this segment overlaps any previous segments. */
5896 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5898 bfd_signed_vma extra_length
;
5900 if (segment2
->p_type
!= PT_LOAD
5901 || !SEGMENT_OVERLAPS (segment
, segment2
))
5904 /* Merge the two segments together. */
5905 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5907 /* Extend SEGMENT2 to include SEGMENT and then delete
5909 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5910 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5912 if (extra_length
> 0)
5914 segment2
->p_memsz
+= extra_length
;
5915 segment2
->p_filesz
+= extra_length
;
5918 segment
->p_type
= PT_NULL
;
5920 /* Since we have deleted P we must restart the outer loop. */
5922 segment
= elf_tdata (ibfd
)->phdr
;
5927 /* Extend SEGMENT to include SEGMENT2 and then delete
5929 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5930 - SEGMENT_END (segment
, segment
->p_vaddr
));
5932 if (extra_length
> 0)
5934 segment
->p_memsz
+= extra_length
;
5935 segment
->p_filesz
+= extra_length
;
5938 segment2
->p_type
= PT_NULL
;
5943 /* The second scan attempts to assign sections to segments. */
5944 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5948 unsigned int section_count
;
5949 asection
**sections
;
5950 asection
*output_section
;
5952 bfd_vma matching_lma
;
5953 bfd_vma suggested_lma
;
5956 asection
*first_section
;
5957 bfd_boolean first_matching_lma
;
5958 bfd_boolean first_suggested_lma
;
5960 if (segment
->p_type
== PT_NULL
)
5963 first_section
= NULL
;
5964 /* Compute how many sections might be placed into this segment. */
5965 for (section
= ibfd
->sections
, section_count
= 0;
5967 section
= section
->next
)
5969 /* Find the first section in the input segment, which may be
5970 removed from the corresponding output segment. */
5971 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5973 if (first_section
== NULL
)
5974 first_section
= section
;
5975 if (section
->output_section
!= NULL
)
5980 /* Allocate a segment map big enough to contain
5981 all of the sections we have selected. */
5982 amt
= sizeof (struct elf_segment_map
);
5983 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5984 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5988 /* Initialise the fields of the segment map. Default to
5989 using the physical address of the segment in the input BFD. */
5991 map
->p_type
= segment
->p_type
;
5992 map
->p_flags
= segment
->p_flags
;
5993 map
->p_flags_valid
= 1;
5995 /* If the first section in the input segment is removed, there is
5996 no need to preserve segment physical address in the corresponding
5998 if (!first_section
|| first_section
->output_section
!= NULL
)
6000 map
->p_paddr
= segment
->p_paddr
;
6001 map
->p_paddr_valid
= p_paddr_valid
;
6004 /* Determine if this segment contains the ELF file header
6005 and if it contains the program headers themselves. */
6006 map
->includes_filehdr
= (segment
->p_offset
== 0
6007 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6008 map
->includes_phdrs
= 0;
6010 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
6012 map
->includes_phdrs
=
6013 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6014 && (segment
->p_offset
+ segment
->p_filesz
6015 >= ((bfd_vma
) iehdr
->e_phoff
6016 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6018 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6019 phdr_included
= TRUE
;
6022 if (section_count
== 0)
6024 /* Special segments, such as the PT_PHDR segment, may contain
6025 no sections, but ordinary, loadable segments should contain
6026 something. They are allowed by the ELF spec however, so only
6027 a warning is produced. */
6028 if (segment
->p_type
== PT_LOAD
)
6029 (*_bfd_error_handler
) (_("\
6030 %B: warning: Empty loadable segment detected, is this intentional ?"),
6034 *pointer_to_map
= map
;
6035 pointer_to_map
= &map
->next
;
6040 /* Now scan the sections in the input BFD again and attempt
6041 to add their corresponding output sections to the segment map.
6042 The problem here is how to handle an output section which has
6043 been moved (ie had its LMA changed). There are four possibilities:
6045 1. None of the sections have been moved.
6046 In this case we can continue to use the segment LMA from the
6049 2. All of the sections have been moved by the same amount.
6050 In this case we can change the segment's LMA to match the LMA
6051 of the first section.
6053 3. Some of the sections have been moved, others have not.
6054 In this case those sections which have not been moved can be
6055 placed in the current segment which will have to have its size,
6056 and possibly its LMA changed, and a new segment or segments will
6057 have to be created to contain the other sections.
6059 4. The sections have been moved, but not by the same amount.
6060 In this case we can change the segment's LMA to match the LMA
6061 of the first section and we will have to create a new segment
6062 or segments to contain the other sections.
6064 In order to save time, we allocate an array to hold the section
6065 pointers that we are interested in. As these sections get assigned
6066 to a segment, they are removed from this array. */
6068 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
6069 if (sections
== NULL
)
6072 /* Step One: Scan for segment vs section LMA conflicts.
6073 Also add the sections to the section array allocated above.
6074 Also add the sections to the current segment. In the common
6075 case, where the sections have not been moved, this means that
6076 we have completely filled the segment, and there is nothing
6081 first_matching_lma
= TRUE
;
6082 first_suggested_lma
= TRUE
;
6084 for (section
= ibfd
->sections
;
6086 section
= section
->next
)
6087 if (section
== first_section
)
6090 for (j
= 0; section
!= NULL
; section
= section
->next
)
6092 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
6094 output_section
= section
->output_section
;
6096 sections
[j
++] = section
;
6098 /* The Solaris native linker always sets p_paddr to 0.
6099 We try to catch that case here, and set it to the
6100 correct value. Note - some backends require that
6101 p_paddr be left as zero. */
6103 && segment
->p_vaddr
!= 0
6104 && !bed
->want_p_paddr_set_to_zero
6106 && output_section
->lma
!= 0
6107 && output_section
->vma
== (segment
->p_vaddr
6108 + (map
->includes_filehdr
6111 + (map
->includes_phdrs
6113 * iehdr
->e_phentsize
)
6115 map
->p_paddr
= segment
->p_vaddr
;
6117 /* Match up the physical address of the segment with the
6118 LMA address of the output section. */
6119 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6120 || IS_COREFILE_NOTE (segment
, section
)
6121 || (bed
->want_p_paddr_set_to_zero
6122 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
6124 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
6126 matching_lma
= output_section
->lma
;
6127 first_matching_lma
= FALSE
;
6130 /* We assume that if the section fits within the segment
6131 then it does not overlap any other section within that
6133 map
->sections
[isec
++] = output_section
;
6135 else if (first_suggested_lma
)
6137 suggested_lma
= output_section
->lma
;
6138 first_suggested_lma
= FALSE
;
6141 if (j
== section_count
)
6146 BFD_ASSERT (j
== section_count
);
6148 /* Step Two: Adjust the physical address of the current segment,
6150 if (isec
== section_count
)
6152 /* All of the sections fitted within the segment as currently
6153 specified. This is the default case. Add the segment to
6154 the list of built segments and carry on to process the next
6155 program header in the input BFD. */
6156 map
->count
= section_count
;
6157 *pointer_to_map
= map
;
6158 pointer_to_map
= &map
->next
;
6161 && !bed
->want_p_paddr_set_to_zero
6162 && matching_lma
!= map
->p_paddr
6163 && !map
->includes_filehdr
6164 && !map
->includes_phdrs
)
6165 /* There is some padding before the first section in the
6166 segment. So, we must account for that in the output
6168 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
6175 if (!first_matching_lma
)
6177 /* At least one section fits inside the current segment.
6178 Keep it, but modify its physical address to match the
6179 LMA of the first section that fitted. */
6180 map
->p_paddr
= matching_lma
;
6184 /* None of the sections fitted inside the current segment.
6185 Change the current segment's physical address to match
6186 the LMA of the first section. */
6187 map
->p_paddr
= suggested_lma
;
6190 /* Offset the segment physical address from the lma
6191 to allow for space taken up by elf headers. */
6192 if (map
->includes_filehdr
)
6194 if (map
->p_paddr
>= iehdr
->e_ehsize
)
6195 map
->p_paddr
-= iehdr
->e_ehsize
;
6198 map
->includes_filehdr
= FALSE
;
6199 map
->includes_phdrs
= FALSE
;
6203 if (map
->includes_phdrs
)
6205 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
6207 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
6209 /* iehdr->e_phnum is just an estimate of the number
6210 of program headers that we will need. Make a note
6211 here of the number we used and the segment we chose
6212 to hold these headers, so that we can adjust the
6213 offset when we know the correct value. */
6214 phdr_adjust_num
= iehdr
->e_phnum
;
6215 phdr_adjust_seg
= map
;
6218 map
->includes_phdrs
= FALSE
;
6222 /* Step Three: Loop over the sections again, this time assigning
6223 those that fit to the current segment and removing them from the
6224 sections array; but making sure not to leave large gaps. Once all
6225 possible sections have been assigned to the current segment it is
6226 added to the list of built segments and if sections still remain
6227 to be assigned, a new segment is constructed before repeating
6234 first_suggested_lma
= TRUE
;
6236 /* Fill the current segment with sections that fit. */
6237 for (j
= 0; j
< section_count
; j
++)
6239 section
= sections
[j
];
6241 if (section
== NULL
)
6244 output_section
= section
->output_section
;
6246 BFD_ASSERT (output_section
!= NULL
);
6248 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6249 || IS_COREFILE_NOTE (segment
, section
))
6251 if (map
->count
== 0)
6253 /* If the first section in a segment does not start at
6254 the beginning of the segment, then something is
6256 if (output_section
->lma
6258 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
6259 + (map
->includes_phdrs
6260 ? iehdr
->e_phnum
* iehdr
->e_phentsize
6268 prev_sec
= map
->sections
[map
->count
- 1];
6270 /* If the gap between the end of the previous section
6271 and the start of this section is more than
6272 maxpagesize then we need to start a new segment. */
6273 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
6275 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
6276 || (prev_sec
->lma
+ prev_sec
->size
6277 > output_section
->lma
))
6279 if (first_suggested_lma
)
6281 suggested_lma
= output_section
->lma
;
6282 first_suggested_lma
= FALSE
;
6289 map
->sections
[map
->count
++] = output_section
;
6292 section
->segment_mark
= TRUE
;
6294 else if (first_suggested_lma
)
6296 suggested_lma
= output_section
->lma
;
6297 first_suggested_lma
= FALSE
;
6301 BFD_ASSERT (map
->count
> 0);
6303 /* Add the current segment to the list of built segments. */
6304 *pointer_to_map
= map
;
6305 pointer_to_map
= &map
->next
;
6307 if (isec
< section_count
)
6309 /* We still have not allocated all of the sections to
6310 segments. Create a new segment here, initialise it
6311 and carry on looping. */
6312 amt
= sizeof (struct elf_segment_map
);
6313 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6314 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6321 /* Initialise the fields of the segment map. Set the physical
6322 physical address to the LMA of the first section that has
6323 not yet been assigned. */
6325 map
->p_type
= segment
->p_type
;
6326 map
->p_flags
= segment
->p_flags
;
6327 map
->p_flags_valid
= 1;
6328 map
->p_paddr
= suggested_lma
;
6329 map
->p_paddr_valid
= p_paddr_valid
;
6330 map
->includes_filehdr
= 0;
6331 map
->includes_phdrs
= 0;
6334 while (isec
< section_count
);
6339 elf_seg_map (obfd
) = map_first
;
6341 /* If we had to estimate the number of program headers that were
6342 going to be needed, then check our estimate now and adjust
6343 the offset if necessary. */
6344 if (phdr_adjust_seg
!= NULL
)
6348 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
6351 if (count
> phdr_adjust_num
)
6352 phdr_adjust_seg
->p_paddr
6353 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
6358 #undef IS_CONTAINED_BY_VMA
6359 #undef IS_CONTAINED_BY_LMA
6361 #undef IS_COREFILE_NOTE
6362 #undef IS_SOLARIS_PT_INTERP
6363 #undef IS_SECTION_IN_INPUT_SEGMENT
6364 #undef INCLUDE_SECTION_IN_SEGMENT
6365 #undef SEGMENT_AFTER_SEGMENT
6366 #undef SEGMENT_OVERLAPS
6370 /* Copy ELF program header information. */
6373 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6375 Elf_Internal_Ehdr
*iehdr
;
6376 struct elf_segment_map
*map
;
6377 struct elf_segment_map
*map_first
;
6378 struct elf_segment_map
**pointer_to_map
;
6379 Elf_Internal_Phdr
*segment
;
6381 unsigned int num_segments
;
6382 bfd_boolean phdr_included
= FALSE
;
6383 bfd_boolean p_paddr_valid
;
6385 iehdr
= elf_elfheader (ibfd
);
6388 pointer_to_map
= &map_first
;
6390 /* If all the segment p_paddr fields are zero, don't set
6391 map->p_paddr_valid. */
6392 p_paddr_valid
= FALSE
;
6393 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6394 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6397 if (segment
->p_paddr
!= 0)
6399 p_paddr_valid
= TRUE
;
6403 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6408 unsigned int section_count
;
6410 Elf_Internal_Shdr
*this_hdr
;
6411 asection
*first_section
= NULL
;
6412 asection
*lowest_section
;
6414 /* Compute how many sections are in this segment. */
6415 for (section
= ibfd
->sections
, section_count
= 0;
6417 section
= section
->next
)
6419 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6420 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6422 if (first_section
== NULL
)
6423 first_section
= section
;
6428 /* Allocate a segment map big enough to contain
6429 all of the sections we have selected. */
6430 amt
= sizeof (struct elf_segment_map
);
6431 if (section_count
!= 0)
6432 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6433 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6437 /* Initialize the fields of the output segment map with the
6440 map
->p_type
= segment
->p_type
;
6441 map
->p_flags
= segment
->p_flags
;
6442 map
->p_flags_valid
= 1;
6443 map
->p_paddr
= segment
->p_paddr
;
6444 map
->p_paddr_valid
= p_paddr_valid
;
6445 map
->p_align
= segment
->p_align
;
6446 map
->p_align_valid
= 1;
6447 map
->p_vaddr_offset
= 0;
6449 if (map
->p_type
== PT_GNU_RELRO
6450 || map
->p_type
== PT_GNU_STACK
)
6452 /* The PT_GNU_RELRO segment may contain the first a few
6453 bytes in the .got.plt section even if the whole .got.plt
6454 section isn't in the PT_GNU_RELRO segment. We won't
6455 change the size of the PT_GNU_RELRO segment.
6456 Similarly, PT_GNU_STACK size is significant on uclinux
6458 map
->p_size
= segment
->p_memsz
;
6459 map
->p_size_valid
= 1;
6462 /* Determine if this segment contains the ELF file header
6463 and if it contains the program headers themselves. */
6464 map
->includes_filehdr
= (segment
->p_offset
== 0
6465 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6467 map
->includes_phdrs
= 0;
6468 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
6470 map
->includes_phdrs
=
6471 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6472 && (segment
->p_offset
+ segment
->p_filesz
6473 >= ((bfd_vma
) iehdr
->e_phoff
6474 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6476 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6477 phdr_included
= TRUE
;
6480 lowest_section
= NULL
;
6481 if (section_count
!= 0)
6483 unsigned int isec
= 0;
6485 for (section
= first_section
;
6487 section
= section
->next
)
6489 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6490 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6492 map
->sections
[isec
++] = section
->output_section
;
6493 if ((section
->flags
& SEC_ALLOC
) != 0)
6497 if (lowest_section
== NULL
6498 || section
->lma
< lowest_section
->lma
)
6499 lowest_section
= section
;
6501 /* Section lmas are set up from PT_LOAD header
6502 p_paddr in _bfd_elf_make_section_from_shdr.
6503 If this header has a p_paddr that disagrees
6504 with the section lma, flag the p_paddr as
6506 if ((section
->flags
& SEC_LOAD
) != 0)
6507 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
6509 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
6510 if (section
->lma
- segment
->p_paddr
!= seg_off
)
6511 map
->p_paddr_valid
= FALSE
;
6513 if (isec
== section_count
)
6519 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
6520 /* We need to keep the space used by the headers fixed. */
6521 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
6523 if (!map
->includes_phdrs
6524 && !map
->includes_filehdr
6525 && map
->p_paddr_valid
)
6526 /* There is some other padding before the first section. */
6527 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
6528 - segment
->p_paddr
);
6530 map
->count
= section_count
;
6531 *pointer_to_map
= map
;
6532 pointer_to_map
= &map
->next
;
6535 elf_seg_map (obfd
) = map_first
;
6539 /* Copy private BFD data. This copies or rewrites ELF program header
6543 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
6545 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6546 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6549 if (elf_tdata (ibfd
)->phdr
== NULL
)
6552 if (ibfd
->xvec
== obfd
->xvec
)
6554 /* Check to see if any sections in the input BFD
6555 covered by ELF program header have changed. */
6556 Elf_Internal_Phdr
*segment
;
6557 asection
*section
, *osec
;
6558 unsigned int i
, num_segments
;
6559 Elf_Internal_Shdr
*this_hdr
;
6560 const struct elf_backend_data
*bed
;
6562 bed
= get_elf_backend_data (ibfd
);
6564 /* Regenerate the segment map if p_paddr is set to 0. */
6565 if (bed
->want_p_paddr_set_to_zero
)
6568 /* Initialize the segment mark field. */
6569 for (section
= obfd
->sections
; section
!= NULL
;
6570 section
= section
->next
)
6571 section
->segment_mark
= FALSE
;
6573 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6574 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6578 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6579 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6580 which severly confuses things, so always regenerate the segment
6581 map in this case. */
6582 if (segment
->p_paddr
== 0
6583 && segment
->p_memsz
== 0
6584 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6587 for (section
= ibfd
->sections
;
6588 section
!= NULL
; section
= section
->next
)
6590 /* We mark the output section so that we know it comes
6591 from the input BFD. */
6592 osec
= section
->output_section
;
6594 osec
->segment_mark
= TRUE
;
6596 /* Check if this section is covered by the segment. */
6597 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6598 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6600 /* FIXME: Check if its output section is changed or
6601 removed. What else do we need to check? */
6603 || section
->flags
!= osec
->flags
6604 || section
->lma
!= osec
->lma
6605 || section
->vma
!= osec
->vma
6606 || section
->size
!= osec
->size
6607 || section
->rawsize
!= osec
->rawsize
6608 || section
->alignment_power
!= osec
->alignment_power
)
6614 /* Check to see if any output section do not come from the
6616 for (section
= obfd
->sections
; section
!= NULL
;
6617 section
= section
->next
)
6619 if (section
->segment_mark
== FALSE
)
6622 section
->segment_mark
= FALSE
;
6625 return copy_elf_program_header (ibfd
, obfd
);
6629 if (ibfd
->xvec
== obfd
->xvec
)
6631 /* When rewriting program header, set the output maxpagesize to
6632 the maximum alignment of input PT_LOAD segments. */
6633 Elf_Internal_Phdr
*segment
;
6635 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6636 bfd_vma maxpagesize
= 0;
6638 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6641 if (segment
->p_type
== PT_LOAD
6642 && maxpagesize
< segment
->p_align
)
6644 /* PR 17512: file: f17299af. */
6645 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
6646 (*_bfd_error_handler
) (_("\
6647 %B: warning: segment alignment of 0x%llx is too large"),
6648 ibfd
, (long long) segment
->p_align
);
6650 maxpagesize
= segment
->p_align
;
6653 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
6654 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
6657 return rewrite_elf_program_header (ibfd
, obfd
);
6660 /* Initialize private output section information from input section. */
6663 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6667 struct bfd_link_info
*link_info
)
6670 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6671 bfd_boolean final_link
= link_info
!= NULL
&& !link_info
->relocatable
;
6673 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6674 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6677 BFD_ASSERT (elf_section_data (osec
) != NULL
);
6679 /* For objcopy and relocatable link, don't copy the output ELF
6680 section type from input if the output BFD section flags have been
6681 set to something different. For a final link allow some flags
6682 that the linker clears to differ. */
6683 if (elf_section_type (osec
) == SHT_NULL
6684 && (osec
->flags
== isec
->flags
6686 && ((osec
->flags
^ isec
->flags
)
6687 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
6688 elf_section_type (osec
) = elf_section_type (isec
);
6690 /* FIXME: Is this correct for all OS/PROC specific flags? */
6691 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6692 & (SHF_MASKOS
| SHF_MASKPROC
));
6694 /* Set things up for objcopy and relocatable link. The output
6695 SHT_GROUP section will have its elf_next_in_group pointing back
6696 to the input group members. Ignore linker created group section.
6697 See elfNN_ia64_object_p in elfxx-ia64.c. */
6700 if (elf_sec_group (isec
) == NULL
6701 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6703 if (elf_section_flags (isec
) & SHF_GROUP
)
6704 elf_section_flags (osec
) |= SHF_GROUP
;
6705 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6706 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
6709 /* If not decompress, preserve SHF_COMPRESSED. */
6710 if ((ibfd
->flags
& BFD_DECOMPRESS
) == 0)
6711 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6715 ihdr
= &elf_section_data (isec
)->this_hdr
;
6717 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6718 don't use the output section of the linked-to section since it
6719 may be NULL at this point. */
6720 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6722 ohdr
= &elf_section_data (osec
)->this_hdr
;
6723 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6724 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6727 osec
->use_rela_p
= isec
->use_rela_p
;
6732 /* Copy private section information. This copies over the entsize
6733 field, and sometimes the info field. */
6736 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6741 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6743 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6744 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6747 ihdr
= &elf_section_data (isec
)->this_hdr
;
6748 ohdr
= &elf_section_data (osec
)->this_hdr
;
6750 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6752 if (ihdr
->sh_type
== SHT_SYMTAB
6753 || ihdr
->sh_type
== SHT_DYNSYM
6754 || ihdr
->sh_type
== SHT_GNU_verneed
6755 || ihdr
->sh_type
== SHT_GNU_verdef
)
6756 ohdr
->sh_info
= ihdr
->sh_info
;
6758 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6762 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6763 necessary if we are removing either the SHT_GROUP section or any of
6764 the group member sections. DISCARDED is the value that a section's
6765 output_section has if the section will be discarded, NULL when this
6766 function is called from objcopy, bfd_abs_section_ptr when called
6770 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
6774 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6775 if (elf_section_type (isec
) == SHT_GROUP
)
6777 asection
*first
= elf_next_in_group (isec
);
6778 asection
*s
= first
;
6779 bfd_size_type removed
= 0;
6783 /* If this member section is being output but the
6784 SHT_GROUP section is not, then clear the group info
6785 set up by _bfd_elf_copy_private_section_data. */
6786 if (s
->output_section
!= discarded
6787 && isec
->output_section
== discarded
)
6789 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6790 elf_group_name (s
->output_section
) = NULL
;
6792 /* Conversely, if the member section is not being output
6793 but the SHT_GROUP section is, then adjust its size. */
6794 else if (s
->output_section
== discarded
6795 && isec
->output_section
!= discarded
)
6797 s
= elf_next_in_group (s
);
6803 if (discarded
!= NULL
)
6805 /* If we've been called for ld -r, then we need to
6806 adjust the input section size. This function may
6807 be called multiple times, so save the original
6809 if (isec
->rawsize
== 0)
6810 isec
->rawsize
= isec
->size
;
6811 isec
->size
= isec
->rawsize
- removed
;
6815 /* Adjust the output section size when called from
6817 isec
->output_section
->size
-= removed
;
6825 /* Copy private header information. */
6828 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6830 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6831 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6834 /* Copy over private BFD data if it has not already been copied.
6835 This must be done here, rather than in the copy_private_bfd_data
6836 entry point, because the latter is called after the section
6837 contents have been set, which means that the program headers have
6838 already been worked out. */
6839 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6841 if (! copy_private_bfd_data (ibfd
, obfd
))
6845 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
6848 /* Copy private symbol information. If this symbol is in a section
6849 which we did not map into a BFD section, try to map the section
6850 index correctly. We use special macro definitions for the mapped
6851 section indices; these definitions are interpreted by the
6852 swap_out_syms function. */
6854 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6855 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6856 #define MAP_STRTAB (SHN_HIOS + 3)
6857 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6858 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6861 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6866 elf_symbol_type
*isym
, *osym
;
6868 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6869 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6872 isym
= elf_symbol_from (ibfd
, isymarg
);
6873 osym
= elf_symbol_from (obfd
, osymarg
);
6876 && isym
->internal_elf_sym
.st_shndx
!= 0
6878 && bfd_is_abs_section (isym
->symbol
.section
))
6882 shndx
= isym
->internal_elf_sym
.st_shndx
;
6883 if (shndx
== elf_onesymtab (ibfd
))
6884 shndx
= MAP_ONESYMTAB
;
6885 else if (shndx
== elf_dynsymtab (ibfd
))
6886 shndx
= MAP_DYNSYMTAB
;
6887 else if (shndx
== elf_strtab_sec (ibfd
))
6889 else if (shndx
== elf_shstrtab_sec (ibfd
))
6890 shndx
= MAP_SHSTRTAB
;
6891 else if (shndx
== elf_symtab_shndx (ibfd
))
6892 shndx
= MAP_SYM_SHNDX
;
6893 osym
->internal_elf_sym
.st_shndx
= shndx
;
6899 /* Swap out the symbols. */
6902 swap_out_syms (bfd
*abfd
,
6903 struct bfd_strtab_hash
**sttp
,
6906 const struct elf_backend_data
*bed
;
6909 struct bfd_strtab_hash
*stt
;
6910 Elf_Internal_Shdr
*symtab_hdr
;
6911 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6912 Elf_Internal_Shdr
*symstrtab_hdr
;
6913 bfd_byte
*outbound_syms
;
6914 bfd_byte
*outbound_shndx
;
6916 unsigned int num_locals
;
6918 bfd_boolean name_local_sections
;
6920 if (!elf_map_symbols (abfd
, &num_locals
))
6923 /* Dump out the symtabs. */
6924 stt
= _bfd_elf_stringtab_init ();
6928 bed
= get_elf_backend_data (abfd
);
6929 symcount
= bfd_get_symcount (abfd
);
6930 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6931 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6932 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6933 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6934 symtab_hdr
->sh_info
= num_locals
+ 1;
6935 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6937 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6938 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6940 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
6941 bed
->s
->sizeof_sym
);
6942 if (outbound_syms
== NULL
)
6944 _bfd_stringtab_free (stt
);
6947 symtab_hdr
->contents
= outbound_syms
;
6949 outbound_shndx
= NULL
;
6950 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6951 if (symtab_shndx_hdr
->sh_name
!= 0)
6953 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6954 outbound_shndx
= (bfd_byte
*)
6955 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
6956 if (outbound_shndx
== NULL
)
6958 _bfd_stringtab_free (stt
);
6962 symtab_shndx_hdr
->contents
= outbound_shndx
;
6963 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6964 symtab_shndx_hdr
->sh_size
= amt
;
6965 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6966 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6969 /* Now generate the data (for "contents"). */
6971 /* Fill in zeroth symbol and swap it out. */
6972 Elf_Internal_Sym sym
;
6978 sym
.st_shndx
= SHN_UNDEF
;
6979 sym
.st_target_internal
= 0;
6980 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6981 outbound_syms
+= bed
->s
->sizeof_sym
;
6982 if (outbound_shndx
!= NULL
)
6983 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6987 = (bed
->elf_backend_name_local_section_symbols
6988 && bed
->elf_backend_name_local_section_symbols (abfd
));
6990 syms
= bfd_get_outsymbols (abfd
);
6991 for (idx
= 0; idx
< symcount
; idx
++)
6993 Elf_Internal_Sym sym
;
6994 bfd_vma value
= syms
[idx
]->value
;
6995 elf_symbol_type
*type_ptr
;
6996 flagword flags
= syms
[idx
]->flags
;
6999 if (!name_local_sections
7000 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
7002 /* Local section symbols have no name. */
7007 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
7010 if (sym
.st_name
== (unsigned long) -1)
7012 _bfd_stringtab_free (stt
);
7017 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
7019 if ((flags
& BSF_SECTION_SYM
) == 0
7020 && bfd_is_com_section (syms
[idx
]->section
))
7022 /* ELF common symbols put the alignment into the `value' field,
7023 and the size into the `size' field. This is backwards from
7024 how BFD handles it, so reverse it here. */
7025 sym
.st_size
= value
;
7026 if (type_ptr
== NULL
7027 || type_ptr
->internal_elf_sym
.st_value
== 0)
7028 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
7030 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
7031 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
7032 (abfd
, syms
[idx
]->section
);
7036 asection
*sec
= syms
[idx
]->section
;
7039 if (sec
->output_section
)
7041 value
+= sec
->output_offset
;
7042 sec
= sec
->output_section
;
7045 /* Don't add in the section vma for relocatable output. */
7046 if (! relocatable_p
)
7048 sym
.st_value
= value
;
7049 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
7051 if (bfd_is_abs_section (sec
)
7053 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
7055 /* This symbol is in a real ELF section which we did
7056 not create as a BFD section. Undo the mapping done
7057 by copy_private_symbol_data. */
7058 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
7062 shndx
= elf_onesymtab (abfd
);
7065 shndx
= elf_dynsymtab (abfd
);
7068 shndx
= elf_strtab_sec (abfd
);
7071 shndx
= elf_shstrtab_sec (abfd
);
7074 shndx
= elf_symtab_shndx (abfd
);
7083 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
7085 if (shndx
== SHN_BAD
)
7089 /* Writing this would be a hell of a lot easier if
7090 we had some decent documentation on bfd, and
7091 knew what to expect of the library, and what to
7092 demand of applications. For example, it
7093 appears that `objcopy' might not set the
7094 section of a symbol to be a section that is
7095 actually in the output file. */
7096 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
7099 _bfd_error_handler (_("\
7100 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7101 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
7103 bfd_set_error (bfd_error_invalid_operation
);
7104 _bfd_stringtab_free (stt
);
7108 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
7109 BFD_ASSERT (shndx
!= SHN_BAD
);
7113 sym
.st_shndx
= shndx
;
7116 if ((flags
& BSF_THREAD_LOCAL
) != 0)
7118 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
7119 type
= STT_GNU_IFUNC
;
7120 else if ((flags
& BSF_FUNCTION
) != 0)
7122 else if ((flags
& BSF_OBJECT
) != 0)
7124 else if ((flags
& BSF_RELC
) != 0)
7126 else if ((flags
& BSF_SRELC
) != 0)
7131 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
7134 /* Processor-specific types. */
7135 if (type_ptr
!= NULL
7136 && bed
->elf_backend_get_symbol_type
)
7137 type
= ((*bed
->elf_backend_get_symbol_type
)
7138 (&type_ptr
->internal_elf_sym
, type
));
7140 if (flags
& BSF_SECTION_SYM
)
7142 if (flags
& BSF_GLOBAL
)
7143 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7145 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
7147 else if (bfd_is_com_section (syms
[idx
]->section
))
7149 #ifdef USE_STT_COMMON
7150 if (type
== STT_OBJECT
)
7151 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
7154 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
7156 else if (bfd_is_und_section (syms
[idx
]->section
))
7157 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
7161 else if (flags
& BSF_FILE
)
7162 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
7165 int bind
= STB_LOCAL
;
7167 if (flags
& BSF_LOCAL
)
7169 else if (flags
& BSF_GNU_UNIQUE
)
7170 bind
= STB_GNU_UNIQUE
;
7171 else if (flags
& BSF_WEAK
)
7173 else if (flags
& BSF_GLOBAL
)
7176 sym
.st_info
= ELF_ST_INFO (bind
, type
);
7179 if (type_ptr
!= NULL
)
7181 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
7182 sym
.st_target_internal
7183 = type_ptr
->internal_elf_sym
.st_target_internal
;
7188 sym
.st_target_internal
= 0;
7191 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
7192 outbound_syms
+= bed
->s
->sizeof_sym
;
7193 if (outbound_shndx
!= NULL
)
7194 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
7198 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
7199 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7201 symstrtab_hdr
->sh_flags
= 0;
7202 symstrtab_hdr
->sh_addr
= 0;
7203 symstrtab_hdr
->sh_entsize
= 0;
7204 symstrtab_hdr
->sh_link
= 0;
7205 symstrtab_hdr
->sh_info
= 0;
7206 symstrtab_hdr
->sh_addralign
= 1;
7211 /* Return the number of bytes required to hold the symtab vector.
7213 Note that we base it on the count plus 1, since we will null terminate
7214 the vector allocated based on this size. However, the ELF symbol table
7215 always has a dummy entry as symbol #0, so it ends up even. */
7218 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
7222 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7224 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7225 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7227 symtab_size
-= sizeof (asymbol
*);
7233 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
7237 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
7239 if (elf_dynsymtab (abfd
) == 0)
7241 bfd_set_error (bfd_error_invalid_operation
);
7245 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7246 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7248 symtab_size
-= sizeof (asymbol
*);
7254 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
7257 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
7260 /* Canonicalize the relocs. */
7263 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
7270 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7272 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
7275 tblptr
= section
->relocation
;
7276 for (i
= 0; i
< section
->reloc_count
; i
++)
7277 *relptr
++ = tblptr
++;
7281 return section
->reloc_count
;
7285 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
7287 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7288 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
7291 bfd_get_symcount (abfd
) = symcount
;
7296 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
7297 asymbol
**allocation
)
7299 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7300 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
7303 bfd_get_dynamic_symcount (abfd
) = symcount
;
7307 /* Return the size required for the dynamic reloc entries. Any loadable
7308 section that was actually installed in the BFD, and has type SHT_REL
7309 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7310 dynamic reloc section. */
7313 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
7318 if (elf_dynsymtab (abfd
) == 0)
7320 bfd_set_error (bfd_error_invalid_operation
);
7324 ret
= sizeof (arelent
*);
7325 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7326 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7327 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7328 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7329 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
7330 * sizeof (arelent
*));
7335 /* Canonicalize the dynamic relocation entries. Note that we return the
7336 dynamic relocations as a single block, although they are actually
7337 associated with particular sections; the interface, which was
7338 designed for SunOS style shared libraries, expects that there is only
7339 one set of dynamic relocs. Any loadable section that was actually
7340 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7341 dynamic symbol table, is considered to be a dynamic reloc section. */
7344 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
7348 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
7352 if (elf_dynsymtab (abfd
) == 0)
7354 bfd_set_error (bfd_error_invalid_operation
);
7358 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
7360 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7362 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7363 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7364 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7369 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
7371 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
7373 for (i
= 0; i
< count
; i
++)
7384 /* Read in the version information. */
7387 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
7389 bfd_byte
*contents
= NULL
;
7390 unsigned int freeidx
= 0;
7392 if (elf_dynverref (abfd
) != 0)
7394 Elf_Internal_Shdr
*hdr
;
7395 Elf_External_Verneed
*everneed
;
7396 Elf_Internal_Verneed
*iverneed
;
7398 bfd_byte
*contents_end
;
7400 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
7402 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verneed
))
7404 error_return_bad_verref
:
7405 (*_bfd_error_handler
)
7406 (_("%B: .gnu.version_r invalid entry"), abfd
);
7407 bfd_set_error (bfd_error_bad_value
);
7408 error_return_verref
:
7409 elf_tdata (abfd
)->verref
= NULL
;
7410 elf_tdata (abfd
)->cverrefs
= 0;
7414 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7415 if (contents
== NULL
)
7416 goto error_return_verref
;
7418 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7419 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7420 goto error_return_verref
;
7422 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
7423 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
7425 if (elf_tdata (abfd
)->verref
== NULL
)
7426 goto error_return_verref
;
7428 BFD_ASSERT (sizeof (Elf_External_Verneed
)
7429 == sizeof (Elf_External_Vernaux
));
7430 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
7431 everneed
= (Elf_External_Verneed
*) contents
;
7432 iverneed
= elf_tdata (abfd
)->verref
;
7433 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
7435 Elf_External_Vernaux
*evernaux
;
7436 Elf_Internal_Vernaux
*ivernaux
;
7439 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
7441 iverneed
->vn_bfd
= abfd
;
7443 iverneed
->vn_filename
=
7444 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7446 if (iverneed
->vn_filename
== NULL
)
7447 goto error_return_bad_verref
;
7449 if (iverneed
->vn_cnt
== 0)
7450 iverneed
->vn_auxptr
= NULL
;
7453 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
7454 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
7455 sizeof (Elf_Internal_Vernaux
));
7456 if (iverneed
->vn_auxptr
== NULL
)
7457 goto error_return_verref
;
7460 if (iverneed
->vn_aux
7461 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7462 goto error_return_bad_verref
;
7464 evernaux
= ((Elf_External_Vernaux
*)
7465 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
7466 ivernaux
= iverneed
->vn_auxptr
;
7467 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
7469 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
7471 ivernaux
->vna_nodename
=
7472 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7473 ivernaux
->vna_name
);
7474 if (ivernaux
->vna_nodename
== NULL
)
7475 goto error_return_bad_verref
;
7477 if (ivernaux
->vna_other
> freeidx
)
7478 freeidx
= ivernaux
->vna_other
;
7480 ivernaux
->vna_nextptr
= NULL
;
7481 if (ivernaux
->vna_next
== 0)
7483 iverneed
->vn_cnt
= j
+ 1;
7486 if (j
+ 1 < iverneed
->vn_cnt
)
7487 ivernaux
->vna_nextptr
= ivernaux
+ 1;
7489 if (ivernaux
->vna_next
7490 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
7491 goto error_return_bad_verref
;
7493 evernaux
= ((Elf_External_Vernaux
*)
7494 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
7497 iverneed
->vn_nextref
= NULL
;
7498 if (iverneed
->vn_next
== 0)
7500 if (i
+ 1 < hdr
->sh_info
)
7501 iverneed
->vn_nextref
= iverneed
+ 1;
7503 if (iverneed
->vn_next
7504 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7505 goto error_return_bad_verref
;
7507 everneed
= ((Elf_External_Verneed
*)
7508 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
7510 elf_tdata (abfd
)->cverrefs
= i
;
7516 if (elf_dynverdef (abfd
) != 0)
7518 Elf_Internal_Shdr
*hdr
;
7519 Elf_External_Verdef
*everdef
;
7520 Elf_Internal_Verdef
*iverdef
;
7521 Elf_Internal_Verdef
*iverdefarr
;
7522 Elf_Internal_Verdef iverdefmem
;
7524 unsigned int maxidx
;
7525 bfd_byte
*contents_end_def
, *contents_end_aux
;
7527 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
7529 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
7531 error_return_bad_verdef
:
7532 (*_bfd_error_handler
)
7533 (_("%B: .gnu.version_d invalid entry"), abfd
);
7534 bfd_set_error (bfd_error_bad_value
);
7535 error_return_verdef
:
7536 elf_tdata (abfd
)->verdef
= NULL
;
7537 elf_tdata (abfd
)->cverdefs
= 0;
7541 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7542 if (contents
== NULL
)
7543 goto error_return_verdef
;
7544 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7545 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7546 goto error_return_verdef
;
7548 BFD_ASSERT (sizeof (Elf_External_Verdef
)
7549 >= sizeof (Elf_External_Verdaux
));
7550 contents_end_def
= contents
+ hdr
->sh_size
7551 - sizeof (Elf_External_Verdef
);
7552 contents_end_aux
= contents
+ hdr
->sh_size
7553 - sizeof (Elf_External_Verdaux
);
7555 /* We know the number of entries in the section but not the maximum
7556 index. Therefore we have to run through all entries and find
7558 everdef
= (Elf_External_Verdef
*) contents
;
7560 for (i
= 0; i
< hdr
->sh_info
; ++i
)
7562 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7564 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
7565 goto error_return_bad_verdef
;
7566 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
7567 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
7569 if (iverdefmem
.vd_next
== 0)
7572 if (iverdefmem
.vd_next
7573 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
7574 goto error_return_bad_verdef
;
7576 everdef
= ((Elf_External_Verdef
*)
7577 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
7580 if (default_imported_symver
)
7582 if (freeidx
> maxidx
)
7588 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7589 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
7590 if (elf_tdata (abfd
)->verdef
== NULL
)
7591 goto error_return_verdef
;
7593 elf_tdata (abfd
)->cverdefs
= maxidx
;
7595 everdef
= (Elf_External_Verdef
*) contents
;
7596 iverdefarr
= elf_tdata (abfd
)->verdef
;
7597 for (i
= 0; i
< hdr
->sh_info
; i
++)
7599 Elf_External_Verdaux
*everdaux
;
7600 Elf_Internal_Verdaux
*iverdaux
;
7603 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7605 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
7606 goto error_return_bad_verdef
;
7608 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
7609 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
7611 iverdef
->vd_bfd
= abfd
;
7613 if (iverdef
->vd_cnt
== 0)
7614 iverdef
->vd_auxptr
= NULL
;
7617 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7618 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
7619 sizeof (Elf_Internal_Verdaux
));
7620 if (iverdef
->vd_auxptr
== NULL
)
7621 goto error_return_verdef
;
7625 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
7626 goto error_return_bad_verdef
;
7628 everdaux
= ((Elf_External_Verdaux
*)
7629 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
7630 iverdaux
= iverdef
->vd_auxptr
;
7631 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
7633 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
7635 iverdaux
->vda_nodename
=
7636 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7637 iverdaux
->vda_name
);
7638 if (iverdaux
->vda_nodename
== NULL
)
7639 goto error_return_bad_verdef
;
7641 iverdaux
->vda_nextptr
= NULL
;
7642 if (iverdaux
->vda_next
== 0)
7644 iverdef
->vd_cnt
= j
+ 1;
7647 if (j
+ 1 < iverdef
->vd_cnt
)
7648 iverdaux
->vda_nextptr
= iverdaux
+ 1;
7650 if (iverdaux
->vda_next
7651 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
7652 goto error_return_bad_verdef
;
7654 everdaux
= ((Elf_External_Verdaux
*)
7655 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
7658 if (iverdef
->vd_cnt
)
7659 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
7661 iverdef
->vd_nextdef
= NULL
;
7662 if (iverdef
->vd_next
== 0)
7664 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
7665 iverdef
->vd_nextdef
= iverdef
+ 1;
7667 everdef
= ((Elf_External_Verdef
*)
7668 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
7674 else if (default_imported_symver
)
7681 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7682 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
7683 if (elf_tdata (abfd
)->verdef
== NULL
)
7686 elf_tdata (abfd
)->cverdefs
= freeidx
;
7689 /* Create a default version based on the soname. */
7690 if (default_imported_symver
)
7692 Elf_Internal_Verdef
*iverdef
;
7693 Elf_Internal_Verdaux
*iverdaux
;
7695 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
7697 iverdef
->vd_version
= VER_DEF_CURRENT
;
7698 iverdef
->vd_flags
= 0;
7699 iverdef
->vd_ndx
= freeidx
;
7700 iverdef
->vd_cnt
= 1;
7702 iverdef
->vd_bfd
= abfd
;
7704 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
7705 if (iverdef
->vd_nodename
== NULL
)
7706 goto error_return_verdef
;
7707 iverdef
->vd_nextdef
= NULL
;
7708 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
7709 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
7710 if (iverdef
->vd_auxptr
== NULL
)
7711 goto error_return_verdef
;
7713 iverdaux
= iverdef
->vd_auxptr
;
7714 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
7720 if (contents
!= NULL
)
7726 _bfd_elf_make_empty_symbol (bfd
*abfd
)
7728 elf_symbol_type
*newsym
;
7730 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
7733 newsym
->symbol
.the_bfd
= abfd
;
7734 return &newsym
->symbol
;
7738 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
7742 bfd_symbol_info (symbol
, ret
);
7745 /* Return whether a symbol name implies a local symbol. Most targets
7746 use this function for the is_local_label_name entry point, but some
7750 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
7753 /* Normal local symbols start with ``.L''. */
7754 if (name
[0] == '.' && name
[1] == 'L')
7757 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7758 DWARF debugging symbols starting with ``..''. */
7759 if (name
[0] == '.' && name
[1] == '.')
7762 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7763 emitting DWARF debugging output. I suspect this is actually a
7764 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7765 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7766 underscore to be emitted on some ELF targets). For ease of use,
7767 we treat such symbols as local. */
7768 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
7771 /* Treat assembler generated local labels as local. */
7772 if (name
[0] == 'L' && name
[strlen (name
) - 1] < 32)
7779 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7780 asymbol
*symbol ATTRIBUTE_UNUSED
)
7787 _bfd_elf_set_arch_mach (bfd
*abfd
,
7788 enum bfd_architecture arch
,
7789 unsigned long machine
)
7791 /* If this isn't the right architecture for this backend, and this
7792 isn't the generic backend, fail. */
7793 if (arch
!= get_elf_backend_data (abfd
)->arch
7794 && arch
!= bfd_arch_unknown
7795 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7798 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7801 /* Find the nearest line to a particular section and offset,
7802 for error reporting. */
7805 _bfd_elf_find_nearest_line (bfd
*abfd
,
7809 const char **filename_ptr
,
7810 const char **functionname_ptr
,
7811 unsigned int *line_ptr
,
7812 unsigned int *discriminator_ptr
)
7816 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
7817 filename_ptr
, functionname_ptr
,
7818 line_ptr
, discriminator_ptr
,
7819 dwarf_debug_sections
, 0,
7820 &elf_tdata (abfd
)->dwarf2_find_line_info
)
7821 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
7822 filename_ptr
, functionname_ptr
,
7825 if (!*functionname_ptr
)
7826 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
7827 *filename_ptr
? NULL
: filename_ptr
,
7832 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7833 &found
, filename_ptr
,
7834 functionname_ptr
, line_ptr
,
7835 &elf_tdata (abfd
)->line_info
))
7837 if (found
&& (*functionname_ptr
|| *line_ptr
))
7840 if (symbols
== NULL
)
7843 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
7844 filename_ptr
, functionname_ptr
))
7851 /* Find the line for a symbol. */
7854 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7855 const char **filename_ptr
, unsigned int *line_ptr
)
7857 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
7858 filename_ptr
, NULL
, line_ptr
, NULL
,
7859 dwarf_debug_sections
, 0,
7860 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7863 /* After a call to bfd_find_nearest_line, successive calls to
7864 bfd_find_inliner_info can be used to get source information about
7865 each level of function inlining that terminated at the address
7866 passed to bfd_find_nearest_line. Currently this is only supported
7867 for DWARF2 with appropriate DWARF3 extensions. */
7870 _bfd_elf_find_inliner_info (bfd
*abfd
,
7871 const char **filename_ptr
,
7872 const char **functionname_ptr
,
7873 unsigned int *line_ptr
)
7876 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7877 functionname_ptr
, line_ptr
,
7878 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7883 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7885 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7886 int ret
= bed
->s
->sizeof_ehdr
;
7888 if (!info
->relocatable
)
7890 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
7892 if (phdr_size
== (bfd_size_type
) -1)
7894 struct elf_segment_map
*m
;
7897 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
7898 phdr_size
+= bed
->s
->sizeof_phdr
;
7901 phdr_size
= get_program_header_size (abfd
, info
);
7904 elf_program_header_size (abfd
) = phdr_size
;
7912 _bfd_elf_set_section_contents (bfd
*abfd
,
7914 const void *location
,
7916 bfd_size_type count
)
7918 Elf_Internal_Shdr
*hdr
;
7921 if (! abfd
->output_has_begun
7922 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7925 hdr
= &elf_section_data (section
)->this_hdr
;
7926 pos
= hdr
->sh_offset
+ offset
;
7927 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7928 || bfd_bwrite (location
, count
, abfd
) != count
)
7935 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7936 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7937 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7942 /* Try to convert a non-ELF reloc into an ELF one. */
7945 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7947 /* Check whether we really have an ELF howto. */
7949 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7951 bfd_reloc_code_real_type code
;
7952 reloc_howto_type
*howto
;
7954 /* Alien reloc: Try to determine its type to replace it with an
7955 equivalent ELF reloc. */
7957 if (areloc
->howto
->pc_relative
)
7959 switch (areloc
->howto
->bitsize
)
7962 code
= BFD_RELOC_8_PCREL
;
7965 code
= BFD_RELOC_12_PCREL
;
7968 code
= BFD_RELOC_16_PCREL
;
7971 code
= BFD_RELOC_24_PCREL
;
7974 code
= BFD_RELOC_32_PCREL
;
7977 code
= BFD_RELOC_64_PCREL
;
7983 howto
= bfd_reloc_type_lookup (abfd
, code
);
7985 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7987 if (howto
->pcrel_offset
)
7988 areloc
->addend
+= areloc
->address
;
7990 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7995 switch (areloc
->howto
->bitsize
)
8001 code
= BFD_RELOC_14
;
8004 code
= BFD_RELOC_16
;
8007 code
= BFD_RELOC_26
;
8010 code
= BFD_RELOC_32
;
8013 code
= BFD_RELOC_64
;
8019 howto
= bfd_reloc_type_lookup (abfd
, code
);
8023 areloc
->howto
= howto
;
8031 (*_bfd_error_handler
)
8032 (_("%B: unsupported relocation type %s"),
8033 abfd
, areloc
->howto
->name
);
8034 bfd_set_error (bfd_error_bad_value
);
8039 _bfd_elf_close_and_cleanup (bfd
*abfd
)
8041 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
8042 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
8044 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
8045 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
8046 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
8049 return _bfd_generic_close_and_cleanup (abfd
);
8052 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8053 in the relocation's offset. Thus we cannot allow any sort of sanity
8054 range-checking to interfere. There is nothing else to do in processing
8057 bfd_reloc_status_type
8058 _bfd_elf_rel_vtable_reloc_fn
8059 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
8060 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
8061 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
8062 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
8064 return bfd_reloc_ok
;
8067 /* Elf core file support. Much of this only works on native
8068 toolchains, since we rely on knowing the
8069 machine-dependent procfs structure in order to pick
8070 out details about the corefile. */
8072 #ifdef HAVE_SYS_PROCFS_H
8073 /* Needed for new procfs interface on sparc-solaris. */
8074 # define _STRUCTURED_PROC 1
8075 # include <sys/procfs.h>
8078 /* Return a PID that identifies a "thread" for threaded cores, or the
8079 PID of the main process for non-threaded cores. */
8082 elfcore_make_pid (bfd
*abfd
)
8086 pid
= elf_tdata (abfd
)->core
->lwpid
;
8088 pid
= elf_tdata (abfd
)->core
->pid
;
8093 /* If there isn't a section called NAME, make one, using
8094 data from SECT. Note, this function will generate a
8095 reference to NAME, so you shouldn't deallocate or
8099 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
8103 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
8106 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
8110 sect2
->size
= sect
->size
;
8111 sect2
->filepos
= sect
->filepos
;
8112 sect2
->alignment_power
= sect
->alignment_power
;
8116 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
8117 actually creates up to two pseudosections:
8118 - For the single-threaded case, a section named NAME, unless
8119 such a section already exists.
8120 - For the multi-threaded case, a section named "NAME/PID", where
8121 PID is elfcore_make_pid (abfd).
8122 Both pseudosections have identical contents. */
8124 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
8130 char *threaded_name
;
8134 /* Build the section name. */
8136 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
8137 len
= strlen (buf
) + 1;
8138 threaded_name
= (char *) bfd_alloc (abfd
, len
);
8139 if (threaded_name
== NULL
)
8141 memcpy (threaded_name
, buf
, len
);
8143 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
8148 sect
->filepos
= filepos
;
8149 sect
->alignment_power
= 2;
8151 return elfcore_maybe_make_sect (abfd
, name
, sect
);
8154 /* prstatus_t exists on:
8156 linux 2.[01] + glibc
8160 #if defined (HAVE_PRSTATUS_T)
8163 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8168 if (note
->descsz
== sizeof (prstatus_t
))
8172 size
= sizeof (prstat
.pr_reg
);
8173 offset
= offsetof (prstatus_t
, pr_reg
);
8174 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8176 /* Do not overwrite the core signal if it
8177 has already been set by another thread. */
8178 if (elf_tdata (abfd
)->core
->signal
== 0)
8179 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8180 if (elf_tdata (abfd
)->core
->pid
== 0)
8181 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8183 /* pr_who exists on:
8186 pr_who doesn't exist on:
8189 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8190 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8192 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8195 #if defined (HAVE_PRSTATUS32_T)
8196 else if (note
->descsz
== sizeof (prstatus32_t
))
8198 /* 64-bit host, 32-bit corefile */
8199 prstatus32_t prstat
;
8201 size
= sizeof (prstat
.pr_reg
);
8202 offset
= offsetof (prstatus32_t
, pr_reg
);
8203 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8205 /* Do not overwrite the core signal if it
8206 has already been set by another thread. */
8207 if (elf_tdata (abfd
)->core
->signal
== 0)
8208 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8209 if (elf_tdata (abfd
)->core
->pid
== 0)
8210 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8212 /* pr_who exists on:
8215 pr_who doesn't exist on:
8218 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8219 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8221 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8224 #endif /* HAVE_PRSTATUS32_T */
8227 /* Fail - we don't know how to handle any other
8228 note size (ie. data object type). */
8232 /* Make a ".reg/999" section and a ".reg" section. */
8233 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
8234 size
, note
->descpos
+ offset
);
8236 #endif /* defined (HAVE_PRSTATUS_T) */
8238 /* Create a pseudosection containing the exact contents of NOTE. */
8240 elfcore_make_note_pseudosection (bfd
*abfd
,
8242 Elf_Internal_Note
*note
)
8244 return _bfd_elfcore_make_pseudosection (abfd
, name
,
8245 note
->descsz
, note
->descpos
);
8248 /* There isn't a consistent prfpregset_t across platforms,
8249 but it doesn't matter, because we don't have to pick this
8250 data structure apart. */
8253 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8255 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8258 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8259 type of NT_PRXFPREG. Just include the whole note's contents
8263 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8265 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
8268 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8269 with a note type of NT_X86_XSTATE. Just include the whole note's
8270 contents literally. */
8273 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
8275 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
8279 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
8281 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
8285 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
8287 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
8291 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
8293 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
8297 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
8299 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
8303 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
8305 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
8309 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8311 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
8315 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
8317 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
8321 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
8323 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
8327 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8329 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
8333 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
8335 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
8339 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
8341 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
8345 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
8347 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
8351 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
8353 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
8357 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
8359 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
8363 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
8365 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
8369 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8371 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
8375 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
8377 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
8380 #if defined (HAVE_PRPSINFO_T)
8381 typedef prpsinfo_t elfcore_psinfo_t
;
8382 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
8383 typedef prpsinfo32_t elfcore_psinfo32_t
;
8387 #if defined (HAVE_PSINFO_T)
8388 typedef psinfo_t elfcore_psinfo_t
;
8389 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
8390 typedef psinfo32_t elfcore_psinfo32_t
;
8394 /* return a malloc'ed copy of a string at START which is at
8395 most MAX bytes long, possibly without a terminating '\0'.
8396 the copy will always have a terminating '\0'. */
8399 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
8402 char *end
= (char *) memchr (start
, '\0', max
);
8410 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
8414 memcpy (dups
, start
, len
);
8420 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8422 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8424 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
8426 elfcore_psinfo_t psinfo
;
8428 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8430 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8431 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8433 elf_tdata (abfd
)->core
->program
8434 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8435 sizeof (psinfo
.pr_fname
));
8437 elf_tdata (abfd
)->core
->command
8438 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8439 sizeof (psinfo
.pr_psargs
));
8441 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8442 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
8444 /* 64-bit host, 32-bit corefile */
8445 elfcore_psinfo32_t psinfo
;
8447 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8449 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8450 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8452 elf_tdata (abfd
)->core
->program
8453 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8454 sizeof (psinfo
.pr_fname
));
8456 elf_tdata (abfd
)->core
->command
8457 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8458 sizeof (psinfo
.pr_psargs
));
8464 /* Fail - we don't know how to handle any other
8465 note size (ie. data object type). */
8469 /* Note that for some reason, a spurious space is tacked
8470 onto the end of the args in some (at least one anyway)
8471 implementations, so strip it off if it exists. */
8474 char *command
= elf_tdata (abfd
)->core
->command
;
8475 int n
= strlen (command
);
8477 if (0 < n
&& command
[n
- 1] == ' ')
8478 command
[n
- 1] = '\0';
8483 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8485 #if defined (HAVE_PSTATUS_T)
8487 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8489 if (note
->descsz
== sizeof (pstatus_t
)
8490 #if defined (HAVE_PXSTATUS_T)
8491 || note
->descsz
== sizeof (pxstatus_t
)
8497 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8499 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8501 #if defined (HAVE_PSTATUS32_T)
8502 else if (note
->descsz
== sizeof (pstatus32_t
))
8504 /* 64-bit host, 32-bit corefile */
8507 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8509 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8512 /* Could grab some more details from the "representative"
8513 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8514 NT_LWPSTATUS note, presumably. */
8518 #endif /* defined (HAVE_PSTATUS_T) */
8520 #if defined (HAVE_LWPSTATUS_T)
8522 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8524 lwpstatus_t lwpstat
;
8530 if (note
->descsz
!= sizeof (lwpstat
)
8531 #if defined (HAVE_LWPXSTATUS_T)
8532 && note
->descsz
!= sizeof (lwpxstatus_t
)
8537 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
8539 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
8540 /* Do not overwrite the core signal if it has already been set by
8542 if (elf_tdata (abfd
)->core
->signal
== 0)
8543 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
8545 /* Make a ".reg/999" section. */
8547 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
8548 len
= strlen (buf
) + 1;
8549 name
= bfd_alloc (abfd
, len
);
8552 memcpy (name
, buf
, len
);
8554 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8558 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8559 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
8560 sect
->filepos
= note
->descpos
8561 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
8564 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8565 sect
->size
= sizeof (lwpstat
.pr_reg
);
8566 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
8569 sect
->alignment_power
= 2;
8571 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8574 /* Make a ".reg2/999" section */
8576 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
8577 len
= strlen (buf
) + 1;
8578 name
= bfd_alloc (abfd
, len
);
8581 memcpy (name
, buf
, len
);
8583 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8587 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8588 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
8589 sect
->filepos
= note
->descpos
8590 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
8593 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8594 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
8595 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
8598 sect
->alignment_power
= 2;
8600 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
8602 #endif /* defined (HAVE_LWPSTATUS_T) */
8605 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8612 int is_active_thread
;
8615 if (note
->descsz
< 728)
8618 if (! CONST_STRNEQ (note
->namedata
, "win32"))
8621 type
= bfd_get_32 (abfd
, note
->descdata
);
8625 case 1 /* NOTE_INFO_PROCESS */:
8626 /* FIXME: need to add ->core->command. */
8627 /* process_info.pid */
8628 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8629 /* process_info.signal */
8630 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
8633 case 2 /* NOTE_INFO_THREAD */:
8634 /* Make a ".reg/999" section. */
8635 /* thread_info.tid */
8636 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
8638 len
= strlen (buf
) + 1;
8639 name
= (char *) bfd_alloc (abfd
, len
);
8643 memcpy (name
, buf
, len
);
8645 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8649 /* sizeof (thread_info.thread_context) */
8651 /* offsetof (thread_info.thread_context) */
8652 sect
->filepos
= note
->descpos
+ 12;
8653 sect
->alignment_power
= 2;
8655 /* thread_info.is_active_thread */
8656 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8658 if (is_active_thread
)
8659 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8663 case 3 /* NOTE_INFO_MODULE */:
8664 /* Make a ".module/xxxxxxxx" section. */
8665 /* module_info.base_address */
8666 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
8667 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
8669 len
= strlen (buf
) + 1;
8670 name
= (char *) bfd_alloc (abfd
, len
);
8674 memcpy (name
, buf
, len
);
8676 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8681 sect
->size
= note
->descsz
;
8682 sect
->filepos
= note
->descpos
;
8683 sect
->alignment_power
= 2;
8694 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8696 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8704 if (bed
->elf_backend_grok_prstatus
)
8705 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
8707 #if defined (HAVE_PRSTATUS_T)
8708 return elfcore_grok_prstatus (abfd
, note
);
8713 #if defined (HAVE_PSTATUS_T)
8715 return elfcore_grok_pstatus (abfd
, note
);
8718 #if defined (HAVE_LWPSTATUS_T)
8720 return elfcore_grok_lwpstatus (abfd
, note
);
8723 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
8724 return elfcore_grok_prfpreg (abfd
, note
);
8726 case NT_WIN32PSTATUS
:
8727 return elfcore_grok_win32pstatus (abfd
, note
);
8729 case NT_PRXFPREG
: /* Linux SSE extension */
8730 if (note
->namesz
== 6
8731 && strcmp (note
->namedata
, "LINUX") == 0)
8732 return elfcore_grok_prxfpreg (abfd
, note
);
8736 case NT_X86_XSTATE
: /* Linux XSAVE extension */
8737 if (note
->namesz
== 6
8738 && strcmp (note
->namedata
, "LINUX") == 0)
8739 return elfcore_grok_xstatereg (abfd
, note
);
8744 if (note
->namesz
== 6
8745 && strcmp (note
->namedata
, "LINUX") == 0)
8746 return elfcore_grok_ppc_vmx (abfd
, note
);
8751 if (note
->namesz
== 6
8752 && strcmp (note
->namedata
, "LINUX") == 0)
8753 return elfcore_grok_ppc_vsx (abfd
, note
);
8757 case NT_S390_HIGH_GPRS
:
8758 if (note
->namesz
== 6
8759 && strcmp (note
->namedata
, "LINUX") == 0)
8760 return elfcore_grok_s390_high_gprs (abfd
, note
);
8765 if (note
->namesz
== 6
8766 && strcmp (note
->namedata
, "LINUX") == 0)
8767 return elfcore_grok_s390_timer (abfd
, note
);
8771 case NT_S390_TODCMP
:
8772 if (note
->namesz
== 6
8773 && strcmp (note
->namedata
, "LINUX") == 0)
8774 return elfcore_grok_s390_todcmp (abfd
, note
);
8778 case NT_S390_TODPREG
:
8779 if (note
->namesz
== 6
8780 && strcmp (note
->namedata
, "LINUX") == 0)
8781 return elfcore_grok_s390_todpreg (abfd
, note
);
8786 if (note
->namesz
== 6
8787 && strcmp (note
->namedata
, "LINUX") == 0)
8788 return elfcore_grok_s390_ctrs (abfd
, note
);
8792 case NT_S390_PREFIX
:
8793 if (note
->namesz
== 6
8794 && strcmp (note
->namedata
, "LINUX") == 0)
8795 return elfcore_grok_s390_prefix (abfd
, note
);
8799 case NT_S390_LAST_BREAK
:
8800 if (note
->namesz
== 6
8801 && strcmp (note
->namedata
, "LINUX") == 0)
8802 return elfcore_grok_s390_last_break (abfd
, note
);
8806 case NT_S390_SYSTEM_CALL
:
8807 if (note
->namesz
== 6
8808 && strcmp (note
->namedata
, "LINUX") == 0)
8809 return elfcore_grok_s390_system_call (abfd
, note
);
8814 if (note
->namesz
== 6
8815 && strcmp (note
->namedata
, "LINUX") == 0)
8816 return elfcore_grok_s390_tdb (abfd
, note
);
8820 case NT_S390_VXRS_LOW
:
8821 if (note
->namesz
== 6
8822 && strcmp (note
->namedata
, "LINUX") == 0)
8823 return elfcore_grok_s390_vxrs_low (abfd
, note
);
8827 case NT_S390_VXRS_HIGH
:
8828 if (note
->namesz
== 6
8829 && strcmp (note
->namedata
, "LINUX") == 0)
8830 return elfcore_grok_s390_vxrs_high (abfd
, note
);
8835 if (note
->namesz
== 6
8836 && strcmp (note
->namedata
, "LINUX") == 0)
8837 return elfcore_grok_arm_vfp (abfd
, note
);
8842 if (note
->namesz
== 6
8843 && strcmp (note
->namedata
, "LINUX") == 0)
8844 return elfcore_grok_aarch_tls (abfd
, note
);
8848 case NT_ARM_HW_BREAK
:
8849 if (note
->namesz
== 6
8850 && strcmp (note
->namedata
, "LINUX") == 0)
8851 return elfcore_grok_aarch_hw_break (abfd
, note
);
8855 case NT_ARM_HW_WATCH
:
8856 if (note
->namesz
== 6
8857 && strcmp (note
->namedata
, "LINUX") == 0)
8858 return elfcore_grok_aarch_hw_watch (abfd
, note
);
8864 if (bed
->elf_backend_grok_psinfo
)
8865 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
8867 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8868 return elfcore_grok_psinfo (abfd
, note
);
8875 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8880 sect
->size
= note
->descsz
;
8881 sect
->filepos
= note
->descpos
;
8882 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8888 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
8892 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
8898 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
8900 struct elf_obj_tdata
*t
;
8902 if (note
->descsz
== 0)
8905 t
= elf_tdata (abfd
);
8906 t
->build_id
= bfd_alloc (abfd
, sizeof (*t
->build_id
) - 1 + note
->descsz
);
8907 if (t
->build_id
== NULL
)
8910 t
->build_id
->size
= note
->descsz
;
8911 memcpy (t
->build_id
->data
, note
->descdata
, note
->descsz
);
8917 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8924 case NT_GNU_BUILD_ID
:
8925 return elfobj_grok_gnu_build_id (abfd
, note
);
8930 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
8932 struct sdt_note
*cur
=
8933 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
8936 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
8937 cur
->size
= (bfd_size_type
) note
->descsz
;
8938 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
8940 elf_tdata (abfd
)->sdt_note_head
= cur
;
8946 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8951 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
8959 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
8963 cp
= strchr (note
->namedata
, '@');
8966 *lwpidp
= atoi(cp
+ 1);
8973 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8975 /* Signal number at offset 0x08. */
8976 elf_tdata (abfd
)->core
->signal
8977 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8979 /* Process ID at offset 0x50. */
8980 elf_tdata (abfd
)->core
->pid
8981 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8983 /* Command name at 0x7c (max 32 bytes, including nul). */
8984 elf_tdata (abfd
)->core
->command
8985 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8987 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8992 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8996 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8997 elf_tdata (abfd
)->core
->lwpid
= lwp
;
8999 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
9001 /* NetBSD-specific core "procinfo". Note that we expect to
9002 find this note before any of the others, which is fine,
9003 since the kernel writes this note out first when it
9004 creates a core file. */
9006 return elfcore_grok_netbsd_procinfo (abfd
, note
);
9009 /* As of Jan 2002 there are no other machine-independent notes
9010 defined for NetBSD core files. If the note type is less
9011 than the start of the machine-dependent note types, we don't
9014 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
9018 switch (bfd_get_arch (abfd
))
9020 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
9021 PT_GETFPREGS == mach+2. */
9023 case bfd_arch_alpha
:
9024 case bfd_arch_sparc
:
9027 case NT_NETBSDCORE_FIRSTMACH
+0:
9028 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9030 case NT_NETBSDCORE_FIRSTMACH
+2:
9031 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9037 /* On all other arch's, PT_GETREGS == mach+1 and
9038 PT_GETFPREGS == mach+3. */
9043 case NT_NETBSDCORE_FIRSTMACH
+1:
9044 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9046 case NT_NETBSDCORE_FIRSTMACH
+3:
9047 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9057 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9059 /* Signal number at offset 0x08. */
9060 elf_tdata (abfd
)->core
->signal
9061 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
9063 /* Process ID at offset 0x20. */
9064 elf_tdata (abfd
)->core
->pid
9065 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
9067 /* Command name at 0x48 (max 32 bytes, including nul). */
9068 elf_tdata (abfd
)->core
->command
9069 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
9075 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9077 if (note
->type
== NT_OPENBSD_PROCINFO
)
9078 return elfcore_grok_openbsd_procinfo (abfd
, note
);
9080 if (note
->type
== NT_OPENBSD_REGS
)
9081 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9083 if (note
->type
== NT_OPENBSD_FPREGS
)
9084 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9086 if (note
->type
== NT_OPENBSD_XFPREGS
)
9087 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9089 if (note
->type
== NT_OPENBSD_AUXV
)
9091 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9096 sect
->size
= note
->descsz
;
9097 sect
->filepos
= note
->descpos
;
9098 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9103 if (note
->type
== NT_OPENBSD_WCOOKIE
)
9105 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
9110 sect
->size
= note
->descsz
;
9111 sect
->filepos
= note
->descpos
;
9112 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9121 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
9123 void *ddata
= note
->descdata
;
9130 /* nto_procfs_status 'pid' field is at offset 0. */
9131 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
9133 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
9134 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
9136 /* nto_procfs_status 'flags' field is at offset 8. */
9137 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
9139 /* nto_procfs_status 'what' field is at offset 14. */
9140 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
9142 elf_tdata (abfd
)->core
->signal
= sig
;
9143 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9146 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
9147 do not come from signals so we make sure we set the current
9148 thread just in case. */
9149 if (flags
& 0x00000080)
9150 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9152 /* Make a ".qnx_core_status/%d" section. */
9153 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
9155 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9160 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9164 sect
->size
= note
->descsz
;
9165 sect
->filepos
= note
->descpos
;
9166 sect
->alignment_power
= 2;
9168 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
9172 elfcore_grok_nto_regs (bfd
*abfd
,
9173 Elf_Internal_Note
*note
,
9181 /* Make a "(base)/%d" section. */
9182 sprintf (buf
, "%s/%ld", base
, tid
);
9184 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9189 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9193 sect
->size
= note
->descsz
;
9194 sect
->filepos
= note
->descpos
;
9195 sect
->alignment_power
= 2;
9197 /* This is the current thread. */
9198 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
9199 return elfcore_maybe_make_sect (abfd
, base
, sect
);
9204 #define BFD_QNT_CORE_INFO 7
9205 #define BFD_QNT_CORE_STATUS 8
9206 #define BFD_QNT_CORE_GREG 9
9207 #define BFD_QNT_CORE_FPREG 10
9210 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9212 /* Every GREG section has a STATUS section before it. Store the
9213 tid from the previous call to pass down to the next gregs
9215 static long tid
= 1;
9219 case BFD_QNT_CORE_INFO
:
9220 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
9221 case BFD_QNT_CORE_STATUS
:
9222 return elfcore_grok_nto_status (abfd
, note
, &tid
);
9223 case BFD_QNT_CORE_GREG
:
9224 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
9225 case BFD_QNT_CORE_FPREG
:
9226 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
9233 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9239 /* Use note name as section name. */
9241 name
= (char *) bfd_alloc (abfd
, len
);
9244 memcpy (name
, note
->namedata
, len
);
9245 name
[len
- 1] = '\0';
9247 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9251 sect
->size
= note
->descsz
;
9252 sect
->filepos
= note
->descpos
;
9253 sect
->alignment_power
= 1;
9258 /* Function: elfcore_write_note
9261 buffer to hold note, and current size of buffer
9265 size of data for note
9267 Writes note to end of buffer. ELF64 notes are written exactly as
9268 for ELF32, despite the current (as of 2006) ELF gabi specifying
9269 that they ought to have 8-byte namesz and descsz field, and have
9270 8-byte alignment. Other writers, eg. Linux kernel, do the same.
9273 Pointer to realloc'd buffer, *BUFSIZ updated. */
9276 elfcore_write_note (bfd
*abfd
,
9284 Elf_External_Note
*xnp
;
9291 namesz
= strlen (name
) + 1;
9293 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
9295 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
9298 dest
= buf
+ *bufsiz
;
9299 *bufsiz
+= newspace
;
9300 xnp
= (Elf_External_Note
*) dest
;
9301 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
9302 H_PUT_32 (abfd
, size
, xnp
->descsz
);
9303 H_PUT_32 (abfd
, type
, xnp
->type
);
9307 memcpy (dest
, name
, namesz
);
9315 memcpy (dest
, input
, size
);
9326 elfcore_write_prpsinfo (bfd
*abfd
,
9332 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9334 if (bed
->elf_backend_write_core_note
!= NULL
)
9337 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9338 NT_PRPSINFO
, fname
, psargs
);
9343 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9344 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9345 if (bed
->s
->elfclass
== ELFCLASS32
)
9347 #if defined (HAVE_PSINFO32_T)
9349 int note_type
= NT_PSINFO
;
9352 int note_type
= NT_PRPSINFO
;
9355 memset (&data
, 0, sizeof (data
));
9356 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9357 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9358 return elfcore_write_note (abfd
, buf
, bufsiz
,
9359 "CORE", note_type
, &data
, sizeof (data
));
9364 #if defined (HAVE_PSINFO_T)
9366 int note_type
= NT_PSINFO
;
9369 int note_type
= NT_PRPSINFO
;
9372 memset (&data
, 0, sizeof (data
));
9373 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9374 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9375 return elfcore_write_note (abfd
, buf
, bufsiz
,
9376 "CORE", note_type
, &data
, sizeof (data
));
9378 #endif /* PSINFO_T or PRPSINFO_T */
9385 elfcore_write_linux_prpsinfo32
9386 (bfd
*abfd
, char *buf
, int *bufsiz
,
9387 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9389 struct elf_external_linux_prpsinfo32 data
;
9391 memset (&data
, 0, sizeof (data
));
9392 LINUX_PRPSINFO32_SWAP_FIELDS (abfd
, prpsinfo
, data
);
9394 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
9395 &data
, sizeof (data
));
9399 elfcore_write_linux_prpsinfo64
9400 (bfd
*abfd
, char *buf
, int *bufsiz
,
9401 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9403 struct elf_external_linux_prpsinfo64 data
;
9405 memset (&data
, 0, sizeof (data
));
9406 LINUX_PRPSINFO64_SWAP_FIELDS (abfd
, prpsinfo
, data
);
9408 return elfcore_write_note (abfd
, buf
, bufsiz
,
9409 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
9413 elfcore_write_prstatus (bfd
*abfd
,
9420 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9422 if (bed
->elf_backend_write_core_note
!= NULL
)
9425 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9427 pid
, cursig
, gregs
);
9432 #if defined (HAVE_PRSTATUS_T)
9433 #if defined (HAVE_PRSTATUS32_T)
9434 if (bed
->s
->elfclass
== ELFCLASS32
)
9436 prstatus32_t prstat
;
9438 memset (&prstat
, 0, sizeof (prstat
));
9439 prstat
.pr_pid
= pid
;
9440 prstat
.pr_cursig
= cursig
;
9441 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9442 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9443 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9450 memset (&prstat
, 0, sizeof (prstat
));
9451 prstat
.pr_pid
= pid
;
9452 prstat
.pr_cursig
= cursig
;
9453 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9454 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9455 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9457 #endif /* HAVE_PRSTATUS_T */
9463 #if defined (HAVE_LWPSTATUS_T)
9465 elfcore_write_lwpstatus (bfd
*abfd
,
9472 lwpstatus_t lwpstat
;
9473 const char *note_name
= "CORE";
9475 memset (&lwpstat
, 0, sizeof (lwpstat
));
9476 lwpstat
.pr_lwpid
= pid
>> 16;
9477 lwpstat
.pr_cursig
= cursig
;
9478 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9479 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
9480 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9482 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
9483 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
9485 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
9486 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
9489 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9490 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
9492 #endif /* HAVE_LWPSTATUS_T */
9494 #if defined (HAVE_PSTATUS_T)
9496 elfcore_write_pstatus (bfd
*abfd
,
9500 int cursig ATTRIBUTE_UNUSED
,
9501 const void *gregs ATTRIBUTE_UNUSED
)
9503 const char *note_name
= "CORE";
9504 #if defined (HAVE_PSTATUS32_T)
9505 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9507 if (bed
->s
->elfclass
== ELFCLASS32
)
9511 memset (&pstat
, 0, sizeof (pstat
));
9512 pstat
.pr_pid
= pid
& 0xffff;
9513 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9514 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9522 memset (&pstat
, 0, sizeof (pstat
));
9523 pstat
.pr_pid
= pid
& 0xffff;
9524 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9525 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9529 #endif /* HAVE_PSTATUS_T */
9532 elfcore_write_prfpreg (bfd
*abfd
,
9538 const char *note_name
= "CORE";
9539 return elfcore_write_note (abfd
, buf
, bufsiz
,
9540 note_name
, NT_FPREGSET
, fpregs
, size
);
9544 elfcore_write_prxfpreg (bfd
*abfd
,
9547 const void *xfpregs
,
9550 char *note_name
= "LINUX";
9551 return elfcore_write_note (abfd
, buf
, bufsiz
,
9552 note_name
, NT_PRXFPREG
, xfpregs
, size
);
9556 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
9557 const void *xfpregs
, int size
)
9559 char *note_name
= "LINUX";
9560 return elfcore_write_note (abfd
, buf
, bufsiz
,
9561 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
9565 elfcore_write_ppc_vmx (bfd
*abfd
,
9568 const void *ppc_vmx
,
9571 char *note_name
= "LINUX";
9572 return elfcore_write_note (abfd
, buf
, bufsiz
,
9573 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
9577 elfcore_write_ppc_vsx (bfd
*abfd
,
9580 const void *ppc_vsx
,
9583 char *note_name
= "LINUX";
9584 return elfcore_write_note (abfd
, buf
, bufsiz
,
9585 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
9589 elfcore_write_s390_high_gprs (bfd
*abfd
,
9592 const void *s390_high_gprs
,
9595 char *note_name
= "LINUX";
9596 return elfcore_write_note (abfd
, buf
, bufsiz
,
9597 note_name
, NT_S390_HIGH_GPRS
,
9598 s390_high_gprs
, size
);
9602 elfcore_write_s390_timer (bfd
*abfd
,
9605 const void *s390_timer
,
9608 char *note_name
= "LINUX";
9609 return elfcore_write_note (abfd
, buf
, bufsiz
,
9610 note_name
, NT_S390_TIMER
, s390_timer
, size
);
9614 elfcore_write_s390_todcmp (bfd
*abfd
,
9617 const void *s390_todcmp
,
9620 char *note_name
= "LINUX";
9621 return elfcore_write_note (abfd
, buf
, bufsiz
,
9622 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
9626 elfcore_write_s390_todpreg (bfd
*abfd
,
9629 const void *s390_todpreg
,
9632 char *note_name
= "LINUX";
9633 return elfcore_write_note (abfd
, buf
, bufsiz
,
9634 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
9638 elfcore_write_s390_ctrs (bfd
*abfd
,
9641 const void *s390_ctrs
,
9644 char *note_name
= "LINUX";
9645 return elfcore_write_note (abfd
, buf
, bufsiz
,
9646 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
9650 elfcore_write_s390_prefix (bfd
*abfd
,
9653 const void *s390_prefix
,
9656 char *note_name
= "LINUX";
9657 return elfcore_write_note (abfd
, buf
, bufsiz
,
9658 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
9662 elfcore_write_s390_last_break (bfd
*abfd
,
9665 const void *s390_last_break
,
9668 char *note_name
= "LINUX";
9669 return elfcore_write_note (abfd
, buf
, bufsiz
,
9670 note_name
, NT_S390_LAST_BREAK
,
9671 s390_last_break
, size
);
9675 elfcore_write_s390_system_call (bfd
*abfd
,
9678 const void *s390_system_call
,
9681 char *note_name
= "LINUX";
9682 return elfcore_write_note (abfd
, buf
, bufsiz
,
9683 note_name
, NT_S390_SYSTEM_CALL
,
9684 s390_system_call
, size
);
9688 elfcore_write_s390_tdb (bfd
*abfd
,
9691 const void *s390_tdb
,
9694 char *note_name
= "LINUX";
9695 return elfcore_write_note (abfd
, buf
, bufsiz
,
9696 note_name
, NT_S390_TDB
, s390_tdb
, size
);
9700 elfcore_write_s390_vxrs_low (bfd
*abfd
,
9703 const void *s390_vxrs_low
,
9706 char *note_name
= "LINUX";
9707 return elfcore_write_note (abfd
, buf
, bufsiz
,
9708 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
9712 elfcore_write_s390_vxrs_high (bfd
*abfd
,
9715 const void *s390_vxrs_high
,
9718 char *note_name
= "LINUX";
9719 return elfcore_write_note (abfd
, buf
, bufsiz
,
9720 note_name
, NT_S390_VXRS_HIGH
,
9721 s390_vxrs_high
, size
);
9725 elfcore_write_arm_vfp (bfd
*abfd
,
9728 const void *arm_vfp
,
9731 char *note_name
= "LINUX";
9732 return elfcore_write_note (abfd
, buf
, bufsiz
,
9733 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
9737 elfcore_write_aarch_tls (bfd
*abfd
,
9740 const void *aarch_tls
,
9743 char *note_name
= "LINUX";
9744 return elfcore_write_note (abfd
, buf
, bufsiz
,
9745 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
9749 elfcore_write_aarch_hw_break (bfd
*abfd
,
9752 const void *aarch_hw_break
,
9755 char *note_name
= "LINUX";
9756 return elfcore_write_note (abfd
, buf
, bufsiz
,
9757 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
9761 elfcore_write_aarch_hw_watch (bfd
*abfd
,
9764 const void *aarch_hw_watch
,
9767 char *note_name
= "LINUX";
9768 return elfcore_write_note (abfd
, buf
, bufsiz
,
9769 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
9773 elfcore_write_register_note (bfd
*abfd
,
9776 const char *section
,
9780 if (strcmp (section
, ".reg2") == 0)
9781 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
9782 if (strcmp (section
, ".reg-xfp") == 0)
9783 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
9784 if (strcmp (section
, ".reg-xstate") == 0)
9785 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
9786 if (strcmp (section
, ".reg-ppc-vmx") == 0)
9787 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
9788 if (strcmp (section
, ".reg-ppc-vsx") == 0)
9789 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
9790 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
9791 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
9792 if (strcmp (section
, ".reg-s390-timer") == 0)
9793 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
9794 if (strcmp (section
, ".reg-s390-todcmp") == 0)
9795 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
9796 if (strcmp (section
, ".reg-s390-todpreg") == 0)
9797 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
9798 if (strcmp (section
, ".reg-s390-ctrs") == 0)
9799 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
9800 if (strcmp (section
, ".reg-s390-prefix") == 0)
9801 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
9802 if (strcmp (section
, ".reg-s390-last-break") == 0)
9803 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
9804 if (strcmp (section
, ".reg-s390-system-call") == 0)
9805 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
9806 if (strcmp (section
, ".reg-s390-tdb") == 0)
9807 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
9808 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
9809 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
9810 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
9811 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
9812 if (strcmp (section
, ".reg-arm-vfp") == 0)
9813 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
9814 if (strcmp (section
, ".reg-aarch-tls") == 0)
9815 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
9816 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
9817 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
9818 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
9819 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
9824 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
9829 while (p
< buf
+ size
)
9831 /* FIXME: bad alignment assumption. */
9832 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
9833 Elf_Internal_Note in
;
9835 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
9838 in
.type
= H_GET_32 (abfd
, xnp
->type
);
9840 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
9841 in
.namedata
= xnp
->name
;
9842 if (in
.namesz
> buf
- in
.namedata
+ size
)
9845 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
9846 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
9847 in
.descpos
= offset
+ (in
.descdata
- buf
);
9849 && (in
.descdata
>= buf
+ size
9850 || in
.descsz
> buf
- in
.descdata
+ size
))
9853 switch (bfd_get_format (abfd
))
9860 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
9863 const char * string
;
9865 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
9869 GROKER_ELEMENT ("", elfcore_grok_note
),
9870 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
9871 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
9872 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
9873 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
9875 #undef GROKER_ELEMENT
9878 for (i
= ARRAY_SIZE (grokers
); i
--;)
9880 if (in
.namesz
>= grokers
[i
].len
9881 && strncmp (in
.namedata
, grokers
[i
].string
,
9882 grokers
[i
].len
) == 0)
9884 if (! grokers
[i
].func (abfd
, & in
))
9893 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
9895 if (! elfobj_grok_gnu_note (abfd
, &in
))
9898 else if (in
.namesz
== sizeof "stapsdt"
9899 && strcmp (in
.namedata
, "stapsdt") == 0)
9901 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
9907 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
9914 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
9921 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
9924 buf
= (char *) bfd_malloc (size
+ 1);
9928 /* PR 17512: file: ec08f814
9929 0-termintate the buffer so that string searches will not overflow. */
9932 if (bfd_bread (buf
, size
, abfd
) != size
9933 || !elf_parse_notes (abfd
, buf
, size
, offset
))
9943 /* Providing external access to the ELF program header table. */
9945 /* Return an upper bound on the number of bytes required to store a
9946 copy of ABFD's program header table entries. Return -1 if an error
9947 occurs; bfd_get_error will return an appropriate code. */
9950 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
9952 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9954 bfd_set_error (bfd_error_wrong_format
);
9958 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
9961 /* Copy ABFD's program header table entries to *PHDRS. The entries
9962 will be stored as an array of Elf_Internal_Phdr structures, as
9963 defined in include/elf/internal.h. To find out how large the
9964 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9966 Return the number of program header table entries read, or -1 if an
9967 error occurs; bfd_get_error will return an appropriate code. */
9970 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
9974 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9976 bfd_set_error (bfd_error_wrong_format
);
9980 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
9981 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
9982 num_phdrs
* sizeof (Elf_Internal_Phdr
));
9987 enum elf_reloc_type_class
9988 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9989 const asection
*rel_sec ATTRIBUTE_UNUSED
,
9990 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
9992 return reloc_class_normal
;
9995 /* For RELA architectures, return the relocation value for a
9996 relocation against a local symbol. */
9999 _bfd_elf_rela_local_sym (bfd
*abfd
,
10000 Elf_Internal_Sym
*sym
,
10002 Elf_Internal_Rela
*rel
)
10004 asection
*sec
= *psec
;
10005 bfd_vma relocation
;
10007 relocation
= (sec
->output_section
->vma
10008 + sec
->output_offset
10010 if ((sec
->flags
& SEC_MERGE
)
10011 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
10012 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
10015 _bfd_merged_section_offset (abfd
, psec
,
10016 elf_section_data (sec
)->sec_info
,
10017 sym
->st_value
+ rel
->r_addend
);
10020 /* If we have changed the section, and our original section is
10021 marked with SEC_EXCLUDE, it means that the original
10022 SEC_MERGE section has been completely subsumed in some
10023 other SEC_MERGE section. In this case, we need to leave
10024 some info around for --emit-relocs. */
10025 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
10026 sec
->kept_section
= *psec
;
10029 rel
->r_addend
-= relocation
;
10030 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
10036 _bfd_elf_rel_local_sym (bfd
*abfd
,
10037 Elf_Internal_Sym
*sym
,
10041 asection
*sec
= *psec
;
10043 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
10044 return sym
->st_value
+ addend
;
10046 return _bfd_merged_section_offset (abfd
, psec
,
10047 elf_section_data (sec
)->sec_info
,
10048 sym
->st_value
+ addend
);
10052 _bfd_elf_section_offset (bfd
*abfd
,
10053 struct bfd_link_info
*info
,
10057 switch (sec
->sec_info_type
)
10059 case SEC_INFO_TYPE_STABS
:
10060 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
10062 case SEC_INFO_TYPE_EH_FRAME
:
10063 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
10065 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
10067 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10068 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
10069 offset
= sec
->size
- offset
- address_size
;
10075 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
10076 reconstruct an ELF file by reading the segments out of remote memory
10077 based on the ELF file header at EHDR_VMA and the ELF program headers it
10078 points to. If not null, *LOADBASEP is filled in with the difference
10079 between the VMAs from which the segments were read, and the VMAs the
10080 file headers (and hence BFD's idea of each section's VMA) put them at.
10082 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
10083 remote memory at target address VMA into the local buffer at MYADDR; it
10084 should return zero on success or an `errno' code on failure. TEMPL must
10085 be a BFD for an ELF target with the word size and byte order found in
10086 the remote memory. */
10089 bfd_elf_bfd_from_remote_memory
10092 bfd_size_type size
,
10093 bfd_vma
*loadbasep
,
10094 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
10096 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
10097 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
10101 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
10102 long symcount ATTRIBUTE_UNUSED
,
10103 asymbol
**syms ATTRIBUTE_UNUSED
,
10108 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10111 const char *relplt_name
;
10112 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
10116 Elf_Internal_Shdr
*hdr
;
10122 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
10125 if (dynsymcount
<= 0)
10128 if (!bed
->plt_sym_val
)
10131 relplt_name
= bed
->relplt_name
;
10132 if (relplt_name
== NULL
)
10133 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
10134 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
10135 if (relplt
== NULL
)
10138 hdr
= &elf_section_data (relplt
)->this_hdr
;
10139 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
10140 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
10143 plt
= bfd_get_section_by_name (abfd
, ".plt");
10147 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
10148 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
10151 count
= relplt
->size
/ hdr
->sh_entsize
;
10152 size
= count
* sizeof (asymbol
);
10153 p
= relplt
->relocation
;
10154 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10156 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
10157 if (p
->addend
!= 0)
10160 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
10162 size
+= sizeof ("+0x") - 1 + 8;
10167 s
= *ret
= (asymbol
*) bfd_malloc (size
);
10171 names
= (char *) (s
+ count
);
10172 p
= relplt
->relocation
;
10174 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10179 addr
= bed
->plt_sym_val (i
, plt
, p
);
10180 if (addr
== (bfd_vma
) -1)
10183 *s
= **p
->sym_ptr_ptr
;
10184 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
10185 we are defining a symbol, ensure one of them is set. */
10186 if ((s
->flags
& BSF_LOCAL
) == 0)
10187 s
->flags
|= BSF_GLOBAL
;
10188 s
->flags
|= BSF_SYNTHETIC
;
10190 s
->value
= addr
- plt
->vma
;
10193 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
10194 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
10196 if (p
->addend
!= 0)
10200 memcpy (names
, "+0x", sizeof ("+0x") - 1);
10201 names
+= sizeof ("+0x") - 1;
10202 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
10203 for (a
= buf
; *a
== '0'; ++a
)
10206 memcpy (names
, a
, len
);
10209 memcpy (names
, "@plt", sizeof ("@plt"));
10210 names
+= sizeof ("@plt");
10217 /* It is only used by x86-64 so far. */
10218 asection _bfd_elf_large_com_section
10219 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
10220 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
10223 _bfd_elf_post_process_headers (bfd
* abfd
,
10224 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
10226 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
10228 i_ehdrp
= elf_elfheader (abfd
);
10230 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
10232 /* To make things simpler for the loader on Linux systems we set the
10233 osabi field to ELFOSABI_GNU if the binary contains symbols of
10234 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
10235 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
10236 && elf_tdata (abfd
)->has_gnu_symbols
)
10237 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
10241 /* Return TRUE for ELF symbol types that represent functions.
10242 This is the default version of this function, which is sufficient for
10243 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
10246 _bfd_elf_is_function_type (unsigned int type
)
10248 return (type
== STT_FUNC
10249 || type
== STT_GNU_IFUNC
);
10252 /* If the ELF symbol SYM might be a function in SEC, return the
10253 function size and set *CODE_OFF to the function's entry point,
10254 otherwise return zero. */
10257 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
10260 bfd_size_type size
;
10262 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
10263 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
10264 || sym
->section
!= sec
)
10267 *code_off
= sym
->value
;
10269 if (!(sym
->flags
& BSF_SYNTHETIC
))
10270 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;