1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2016 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
33 haven't bothered yet. */
35 /* For sparc64-cross-sparc32. */
43 #include "libiberty.h"
44 #include "safe-ctype.h"
45 #include "elf-linux-core.h"
51 static int elf_sort_sections (const void *, const void *);
52 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
53 static bfd_boolean
prep_headers (bfd
*);
54 static bfd_boolean
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int) ;
55 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
56 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
59 /* Swap version information in and out. The version information is
60 currently size independent. If that ever changes, this code will
61 need to move into elfcode.h. */
63 /* Swap in a Verdef structure. */
66 _bfd_elf_swap_verdef_in (bfd
*abfd
,
67 const Elf_External_Verdef
*src
,
68 Elf_Internal_Verdef
*dst
)
70 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
71 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
72 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
73 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
74 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
75 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
76 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
79 /* Swap out a Verdef structure. */
82 _bfd_elf_swap_verdef_out (bfd
*abfd
,
83 const Elf_Internal_Verdef
*src
,
84 Elf_External_Verdef
*dst
)
86 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
99 const Elf_External_Verdaux
*src
,
100 Elf_Internal_Verdaux
*dst
)
102 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
103 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
106 /* Swap out a Verdaux structure. */
109 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
110 const Elf_Internal_Verdaux
*src
,
111 Elf_External_Verdaux
*dst
)
113 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
114 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
117 /* Swap in a Verneed structure. */
120 _bfd_elf_swap_verneed_in (bfd
*abfd
,
121 const Elf_External_Verneed
*src
,
122 Elf_Internal_Verneed
*dst
)
124 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
125 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
126 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
127 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
128 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
131 /* Swap out a Verneed structure. */
134 _bfd_elf_swap_verneed_out (bfd
*abfd
,
135 const Elf_Internal_Verneed
*src
,
136 Elf_External_Verneed
*dst
)
138 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
139 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
140 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
141 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
142 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
145 /* Swap in a Vernaux structure. */
148 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
149 const Elf_External_Vernaux
*src
,
150 Elf_Internal_Vernaux
*dst
)
152 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
153 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
154 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
155 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
156 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
159 /* Swap out a Vernaux structure. */
162 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
163 const Elf_Internal_Vernaux
*src
,
164 Elf_External_Vernaux
*dst
)
166 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
167 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
168 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
169 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
170 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
173 /* Swap in a Versym structure. */
176 _bfd_elf_swap_versym_in (bfd
*abfd
,
177 const Elf_External_Versym
*src
,
178 Elf_Internal_Versym
*dst
)
180 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
183 /* Swap out a Versym structure. */
186 _bfd_elf_swap_versym_out (bfd
*abfd
,
187 const Elf_Internal_Versym
*src
,
188 Elf_External_Versym
*dst
)
190 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
193 /* Standard ELF hash function. Do not change this function; you will
194 cause invalid hash tables to be generated. */
197 bfd_elf_hash (const char *namearg
)
199 const unsigned char *name
= (const unsigned char *) namearg
;
204 while ((ch
= *name
++) != '\0')
207 if ((g
= (h
& 0xf0000000)) != 0)
210 /* The ELF ABI says `h &= ~g', but this is equivalent in
211 this case and on some machines one insn instead of two. */
215 return h
& 0xffffffff;
218 /* DT_GNU_HASH hash function. Do not change this function; you will
219 cause invalid hash tables to be generated. */
222 bfd_elf_gnu_hash (const char *namearg
)
224 const unsigned char *name
= (const unsigned char *) namearg
;
225 unsigned long h
= 5381;
228 while ((ch
= *name
++) != '\0')
229 h
= (h
<< 5) + h
+ ch
;
230 return h
& 0xffffffff;
233 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
234 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
236 bfd_elf_allocate_object (bfd
*abfd
,
238 enum elf_target_id object_id
)
240 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
241 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
242 if (abfd
->tdata
.any
== NULL
)
245 elf_object_id (abfd
) = object_id
;
246 if (abfd
->direction
!= read_direction
)
248 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
251 elf_tdata (abfd
)->o
= o
;
252 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
259 bfd_elf_make_object (bfd
*abfd
)
261 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
262 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
267 bfd_elf_mkcorefile (bfd
*abfd
)
269 /* I think this can be done just like an object file. */
270 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
272 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
273 return elf_tdata (abfd
)->core
!= NULL
;
277 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
279 Elf_Internal_Shdr
**i_shdrp
;
280 bfd_byte
*shstrtab
= NULL
;
282 bfd_size_type shstrtabsize
;
284 i_shdrp
= elf_elfsections (abfd
);
286 || shindex
>= elf_numsections (abfd
)
287 || i_shdrp
[shindex
] == 0)
290 shstrtab
= i_shdrp
[shindex
]->contents
;
291 if (shstrtab
== NULL
)
293 /* No cached one, attempt to read, and cache what we read. */
294 offset
= i_shdrp
[shindex
]->sh_offset
;
295 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
297 /* Allocate and clear an extra byte at the end, to prevent crashes
298 in case the string table is not terminated. */
299 if (shstrtabsize
+ 1 <= 1
300 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
301 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
303 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
305 if (bfd_get_error () != bfd_error_system_call
)
306 bfd_set_error (bfd_error_file_truncated
);
307 bfd_release (abfd
, shstrtab
);
309 /* Once we've failed to read it, make sure we don't keep
310 trying. Otherwise, we'll keep allocating space for
311 the string table over and over. */
312 i_shdrp
[shindex
]->sh_size
= 0;
315 shstrtab
[shstrtabsize
] = '\0';
316 i_shdrp
[shindex
]->contents
= shstrtab
;
318 return (char *) shstrtab
;
322 bfd_elf_string_from_elf_section (bfd
*abfd
,
323 unsigned int shindex
,
324 unsigned int strindex
)
326 Elf_Internal_Shdr
*hdr
;
331 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
334 hdr
= elf_elfsections (abfd
)[shindex
];
336 if (hdr
->contents
== NULL
)
338 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
340 /* PR 17512: file: f057ec89. */
341 _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 (elf_symtab_shndx_list (ibfd
) != NULL
)
405 elf_section_list
* entry
;
406 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
408 /* Find an index section that is linked to this symtab section. */
409 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
410 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
412 shndx_hdr
= & entry
->hdr
;
416 if (shndx_hdr
== NULL
)
418 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
419 /* Not really accurate, but this was how the old code used to work. */
420 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
421 /* Otherwise we do nothing. The assumption is that
422 the index table will not be needed. */
426 /* Read the symbols. */
428 alloc_extshndx
= NULL
;
430 bed
= get_elf_backend_data (ibfd
);
431 extsym_size
= bed
->s
->sizeof_sym
;
432 amt
= symcount
* extsym_size
;
433 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
434 if (extsym_buf
== NULL
)
436 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
437 extsym_buf
= alloc_ext
;
439 if (extsym_buf
== NULL
440 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
441 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
447 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
451 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
452 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
453 if (extshndx_buf
== NULL
)
455 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
456 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
457 extshndx_buf
= alloc_extshndx
;
459 if (extshndx_buf
== NULL
460 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
461 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
468 if (intsym_buf
== NULL
)
470 alloc_intsym
= (Elf_Internal_Sym
*)
471 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
472 intsym_buf
= alloc_intsym
;
473 if (intsym_buf
== NULL
)
477 /* Convert the symbols to internal form. */
478 isymend
= intsym_buf
+ symcount
;
479 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
480 shndx
= extshndx_buf
;
482 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
483 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
485 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
486 (*_bfd_error_handler
) (_("%B symbol number %lu references "
487 "nonexistent SHT_SYMTAB_SHNDX section"),
488 ibfd
, (unsigned long) symoffset
);
489 if (alloc_intsym
!= NULL
)
496 if (alloc_ext
!= NULL
)
498 if (alloc_extshndx
!= NULL
)
499 free (alloc_extshndx
);
504 /* Look up a symbol name. */
506 bfd_elf_sym_name (bfd
*abfd
,
507 Elf_Internal_Shdr
*symtab_hdr
,
508 Elf_Internal_Sym
*isym
,
512 unsigned int iname
= isym
->st_name
;
513 unsigned int shindex
= symtab_hdr
->sh_link
;
515 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
516 /* Check for a bogus st_shndx to avoid crashing. */
517 && isym
->st_shndx
< elf_numsections (abfd
))
519 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
520 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
523 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
526 else if (sym_sec
&& *name
== '\0')
527 name
= bfd_section_name (abfd
, sym_sec
);
532 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
533 sections. The first element is the flags, the rest are section
536 typedef union elf_internal_group
{
537 Elf_Internal_Shdr
*shdr
;
539 } Elf_Internal_Group
;
541 /* Return the name of the group signature symbol. Why isn't the
542 signature just a string? */
545 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
547 Elf_Internal_Shdr
*hdr
;
548 unsigned char esym
[sizeof (Elf64_External_Sym
)];
549 Elf_External_Sym_Shndx eshndx
;
550 Elf_Internal_Sym isym
;
552 /* First we need to ensure the symbol table is available. Make sure
553 that it is a symbol table section. */
554 if (ghdr
->sh_link
>= elf_numsections (abfd
))
556 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
557 if (hdr
->sh_type
!= SHT_SYMTAB
558 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
561 /* Go read the symbol. */
562 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
563 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
564 &isym
, esym
, &eshndx
) == NULL
)
567 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
570 /* Set next_in_group list pointer, and group name for NEWSECT. */
573 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
575 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
577 /* If num_group is zero, read in all SHT_GROUP sections. The count
578 is set to -1 if there are no SHT_GROUP sections. */
581 unsigned int i
, shnum
;
583 /* First count the number of groups. If we have a SHT_GROUP
584 section with just a flag word (ie. sh_size is 4), ignore it. */
585 shnum
= elf_numsections (abfd
);
588 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
589 ( (shdr)->sh_type == SHT_GROUP \
590 && (shdr)->sh_size >= minsize \
591 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
592 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
594 for (i
= 0; i
< shnum
; i
++)
596 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
598 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
604 num_group
= (unsigned) -1;
605 elf_tdata (abfd
)->num_group
= num_group
;
609 /* We keep a list of elf section headers for group sections,
610 so we can find them quickly. */
613 elf_tdata (abfd
)->num_group
= num_group
;
614 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
615 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
616 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
620 for (i
= 0; i
< shnum
; i
++)
622 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
624 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
627 Elf_Internal_Group
*dest
;
629 /* Add to list of sections. */
630 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
633 /* Read the raw contents. */
634 BFD_ASSERT (sizeof (*dest
) >= 4);
635 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
636 shdr
->contents
= (unsigned char *)
637 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
638 /* PR binutils/4110: Handle corrupt group headers. */
639 if (shdr
->contents
== NULL
)
642 (_("%B: corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
643 bfd_set_error (bfd_error_bad_value
);
648 memset (shdr
->contents
, 0, amt
);
650 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
651 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
655 (_("%B: invalid size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
656 bfd_set_error (bfd_error_bad_value
);
658 /* PR 17510: If the group contents are even partially
659 corrupt, do not allow any of the contents to be used. */
660 memset (shdr
->contents
, 0, amt
);
664 /* Translate raw contents, a flag word followed by an
665 array of elf section indices all in target byte order,
666 to the flag word followed by an array of elf section
668 src
= shdr
->contents
+ shdr
->sh_size
;
669 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
677 idx
= H_GET_32 (abfd
, src
);
678 if (src
== shdr
->contents
)
681 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
682 shdr
->bfd_section
->flags
683 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
688 ((*_bfd_error_handler
)
689 (_("%B: invalid SHT_GROUP entry"), abfd
));
692 dest
->shdr
= elf_elfsections (abfd
)[idx
];
697 /* PR 17510: Corrupt binaries might contain invalid groups. */
698 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
700 elf_tdata (abfd
)->num_group
= num_group
;
702 /* If all groups are invalid then fail. */
705 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
706 elf_tdata (abfd
)->num_group
= num_group
= -1;
707 (*_bfd_error_handler
) (_("%B: no valid group sections found"), abfd
);
708 bfd_set_error (bfd_error_bad_value
);
714 if (num_group
!= (unsigned) -1)
718 for (i
= 0; i
< num_group
; i
++)
720 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
721 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
722 unsigned int n_elt
= shdr
->sh_size
/ 4;
724 /* Look through this group's sections to see if current
725 section is a member. */
727 if ((++idx
)->shdr
== hdr
)
731 /* We are a member of this group. Go looking through
732 other members to see if any others are linked via
734 idx
= (Elf_Internal_Group
*) shdr
->contents
;
735 n_elt
= shdr
->sh_size
/ 4;
737 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
738 && elf_next_in_group (s
) != NULL
)
742 /* Snarf the group name from other member, and
743 insert current section in circular list. */
744 elf_group_name (newsect
) = elf_group_name (s
);
745 elf_next_in_group (newsect
) = elf_next_in_group (s
);
746 elf_next_in_group (s
) = newsect
;
752 gname
= group_signature (abfd
, shdr
);
755 elf_group_name (newsect
) = gname
;
757 /* Start a circular list with one element. */
758 elf_next_in_group (newsect
) = newsect
;
761 /* If the group section has been created, point to the
763 if (shdr
->bfd_section
!= NULL
)
764 elf_next_in_group (shdr
->bfd_section
) = newsect
;
772 if (elf_group_name (newsect
) == NULL
)
774 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
782 _bfd_elf_setup_sections (bfd
*abfd
)
785 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
786 bfd_boolean result
= TRUE
;
789 /* Process SHF_LINK_ORDER. */
790 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
792 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
793 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
795 unsigned int elfsec
= this_hdr
->sh_link
;
796 /* FIXME: The old Intel compiler and old strip/objcopy may
797 not set the sh_link or sh_info fields. Hence we could
798 get the situation where elfsec is 0. */
801 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
802 if (bed
->link_order_error_handler
)
803 bed
->link_order_error_handler
804 (_("%B: warning: sh_link not set for section `%A'"),
809 asection
*linksec
= NULL
;
811 if (elfsec
< elf_numsections (abfd
))
813 this_hdr
= elf_elfsections (abfd
)[elfsec
];
814 linksec
= this_hdr
->bfd_section
;
818 Some strip/objcopy may leave an incorrect value in
819 sh_link. We don't want to proceed. */
822 (*_bfd_error_handler
)
823 (_("%B: sh_link [%d] in section `%A' is incorrect"),
824 s
->owner
, s
, elfsec
);
828 elf_linked_to_section (s
) = linksec
;
833 /* Process section groups. */
834 if (num_group
== (unsigned) -1)
837 for (i
= 0; i
< num_group
; i
++)
839 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
840 Elf_Internal_Group
*idx
;
843 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
844 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
846 (*_bfd_error_handler
)
847 (_("%B: section group entry number %u is corrupt"),
853 idx
= (Elf_Internal_Group
*) shdr
->contents
;
854 n_elt
= shdr
->sh_size
/ 4;
857 if ((++idx
)->shdr
->bfd_section
)
858 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
859 else if (idx
->shdr
->sh_type
== SHT_RELA
860 || idx
->shdr
->sh_type
== SHT_REL
)
861 /* We won't include relocation sections in section groups in
862 output object files. We adjust the group section size here
863 so that relocatable link will work correctly when
864 relocation sections are in section group in input object
866 shdr
->bfd_section
->size
-= 4;
869 /* There are some unknown sections in the group. */
870 (*_bfd_error_handler
)
871 (_("%B: unknown [%d] section `%s' in group [%s]"),
873 (unsigned int) idx
->shdr
->sh_type
,
874 bfd_elf_string_from_elf_section (abfd
,
875 (elf_elfheader (abfd
)
878 shdr
->bfd_section
->name
);
886 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
888 return elf_next_in_group (sec
) != NULL
;
892 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
894 unsigned int len
= strlen (name
);
895 char *new_name
= bfd_alloc (abfd
, len
+ 2);
896 if (new_name
== NULL
)
900 memcpy (new_name
+ 2, name
+ 1, len
);
905 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
907 unsigned int len
= strlen (name
);
908 char *new_name
= bfd_alloc (abfd
, len
);
909 if (new_name
== NULL
)
912 memcpy (new_name
+ 1, name
+ 2, len
- 1);
916 /* Make a BFD section from an ELF section. We store a pointer to the
917 BFD section in the bfd_section field of the header. */
920 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
921 Elf_Internal_Shdr
*hdr
,
927 const struct elf_backend_data
*bed
;
929 if (hdr
->bfd_section
!= NULL
)
932 newsect
= bfd_make_section_anyway (abfd
, name
);
936 hdr
->bfd_section
= newsect
;
937 elf_section_data (newsect
)->this_hdr
= *hdr
;
938 elf_section_data (newsect
)->this_idx
= shindex
;
940 /* Always use the real type/flags. */
941 elf_section_type (newsect
) = hdr
->sh_type
;
942 elf_section_flags (newsect
) = hdr
->sh_flags
;
944 newsect
->filepos
= hdr
->sh_offset
;
946 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
947 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
948 || ! bfd_set_section_alignment (abfd
, newsect
,
949 bfd_log2 (hdr
->sh_addralign
)))
952 flags
= SEC_NO_FLAGS
;
953 if (hdr
->sh_type
!= SHT_NOBITS
)
954 flags
|= SEC_HAS_CONTENTS
;
955 if (hdr
->sh_type
== SHT_GROUP
)
956 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
957 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
960 if (hdr
->sh_type
!= SHT_NOBITS
)
963 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
964 flags
|= SEC_READONLY
;
965 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
967 else if ((flags
& SEC_LOAD
) != 0)
969 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
972 newsect
->entsize
= hdr
->sh_entsize
;
973 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
974 flags
|= SEC_STRINGS
;
976 if (hdr
->sh_flags
& SHF_GROUP
)
977 if (!setup_group (abfd
, hdr
, newsect
))
979 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
980 flags
|= SEC_THREAD_LOCAL
;
981 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
982 flags
|= SEC_EXCLUDE
;
984 if ((flags
& SEC_ALLOC
) == 0)
986 /* The debugging sections appear to be recognized only by name,
987 not any sort of flag. Their SEC_ALLOC bits are cleared. */
994 else if (name
[1] == 'g' && name
[2] == 'n')
995 p
= ".gnu.linkonce.wi.", n
= 17;
996 else if (name
[1] == 'g' && name
[2] == 'd')
997 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
998 else if (name
[1] == 'l')
1000 else if (name
[1] == 's')
1002 else if (name
[1] == 'z')
1003 p
= ".zdebug", n
= 7;
1006 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
1007 flags
|= SEC_DEBUGGING
;
1011 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1012 only link a single copy of the section. This is used to support
1013 g++. g++ will emit each template expansion in its own section.
1014 The symbols will be defined as weak, so that multiple definitions
1015 are permitted. The GNU linker extension is to actually discard
1016 all but one of the sections. */
1017 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1018 && elf_next_in_group (newsect
) == NULL
)
1019 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1021 bed
= get_elf_backend_data (abfd
);
1022 if (bed
->elf_backend_section_flags
)
1023 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1026 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
1029 /* We do not parse the PT_NOTE segments as we are interested even in the
1030 separate debug info files which may have the segments offsets corrupted.
1031 PT_NOTEs from the core files are currently not parsed using BFD. */
1032 if (hdr
->sh_type
== SHT_NOTE
)
1036 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1039 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
, -1);
1043 if ((flags
& SEC_ALLOC
) != 0)
1045 Elf_Internal_Phdr
*phdr
;
1046 unsigned int i
, nload
;
1048 /* Some ELF linkers produce binaries with all the program header
1049 p_paddr fields zero. If we have such a binary with more than
1050 one PT_LOAD header, then leave the section lma equal to vma
1051 so that we don't create sections with overlapping lma. */
1052 phdr
= elf_tdata (abfd
)->phdr
;
1053 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1054 if (phdr
->p_paddr
!= 0)
1056 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1058 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1061 phdr
= elf_tdata (abfd
)->phdr
;
1062 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1064 if (((phdr
->p_type
== PT_LOAD
1065 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1066 || phdr
->p_type
== PT_TLS
)
1067 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1069 if ((flags
& SEC_LOAD
) == 0)
1070 newsect
->lma
= (phdr
->p_paddr
1071 + hdr
->sh_addr
- phdr
->p_vaddr
);
1073 /* We used to use the same adjustment for SEC_LOAD
1074 sections, but that doesn't work if the segment
1075 is packed with code from multiple VMAs.
1076 Instead we calculate the section LMA based on
1077 the segment LMA. It is assumed that the
1078 segment will contain sections with contiguous
1079 LMAs, even if the VMAs are not. */
1080 newsect
->lma
= (phdr
->p_paddr
1081 + hdr
->sh_offset
- phdr
->p_offset
);
1083 /* With contiguous segments, we can't tell from file
1084 offsets whether a section with zero size should
1085 be placed at the end of one segment or the
1086 beginning of the next. Decide based on vaddr. */
1087 if (hdr
->sh_addr
>= phdr
->p_vaddr
1088 && (hdr
->sh_addr
+ hdr
->sh_size
1089 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1095 /* Compress/decompress DWARF debug sections with names: .debug_* and
1096 .zdebug_*, after the section flags is set. */
1097 if ((flags
& SEC_DEBUGGING
)
1098 && ((name
[1] == 'd' && name
[6] == '_')
1099 || (name
[1] == 'z' && name
[7] == '_')))
1101 enum { nothing
, compress
, decompress
} action
= nothing
;
1102 int compression_header_size
;
1103 bfd_size_type uncompressed_size
;
1104 bfd_boolean compressed
1105 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1106 &compression_header_size
,
1107 &uncompressed_size
);
1111 /* Compressed section. Check if we should decompress. */
1112 if ((abfd
->flags
& BFD_DECOMPRESS
))
1113 action
= decompress
;
1116 /* Compress the uncompressed section or convert from/to .zdebug*
1117 section. Check if we should compress. */
1118 if (action
== nothing
)
1120 if (newsect
->size
!= 0
1121 && (abfd
->flags
& BFD_COMPRESS
)
1122 && compression_header_size
>= 0
1123 && uncompressed_size
> 0
1125 || ((compression_header_size
> 0)
1126 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1132 if (action
== compress
)
1134 if (!bfd_init_section_compress_status (abfd
, newsect
))
1136 (*_bfd_error_handler
)
1137 (_("%B: unable to initialize compress status for section %s"),
1144 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1146 (*_bfd_error_handler
)
1147 (_("%B: unable to initialize decompress status for section %s"),
1153 if (abfd
->is_linker_input
)
1156 && (action
== decompress
1157 || (action
== compress
1158 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1160 /* Convert section name from .zdebug_* to .debug_* so
1161 that linker will consider this section as a debug
1163 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1164 if (new_name
== NULL
)
1166 bfd_rename_section (abfd
, newsect
, new_name
);
1170 /* For objdump, don't rename the section. For objcopy, delay
1171 section rename to elf_fake_sections. */
1172 newsect
->flags
|= SEC_ELF_RENAME
;
1178 const char *const bfd_elf_section_type_names
[] = {
1179 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1180 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1181 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1184 /* ELF relocs are against symbols. If we are producing relocatable
1185 output, and the reloc is against an external symbol, and nothing
1186 has given us any additional addend, the resulting reloc will also
1187 be against the same symbol. In such a case, we don't want to
1188 change anything about the way the reloc is handled, since it will
1189 all be done at final link time. Rather than put special case code
1190 into bfd_perform_relocation, all the reloc types use this howto
1191 function. It just short circuits the reloc if producing
1192 relocatable output against an external symbol. */
1194 bfd_reloc_status_type
1195 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1196 arelent
*reloc_entry
,
1198 void *data ATTRIBUTE_UNUSED
,
1199 asection
*input_section
,
1201 char **error_message ATTRIBUTE_UNUSED
)
1203 if (output_bfd
!= NULL
1204 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1205 && (! reloc_entry
->howto
->partial_inplace
1206 || reloc_entry
->addend
== 0))
1208 reloc_entry
->address
+= input_section
->output_offset
;
1209 return bfd_reloc_ok
;
1212 return bfd_reloc_continue
;
1215 /* Copy the program header and other data from one object module to
1219 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1221 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1222 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1225 if (!elf_flags_init (obfd
))
1227 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1228 elf_flags_init (obfd
) = TRUE
;
1231 elf_gp (obfd
) = elf_gp (ibfd
);
1233 /* Also copy the EI_OSABI field. */
1234 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1235 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1237 /* Copy object attributes. */
1238 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1240 /* This is an feature for objcopy --only-keep-debug: When a section's type
1241 is changed to NOBITS, we preserve the sh_link and sh_info fields so that
1242 they can be matched up with the original. */
1243 Elf_Internal_Shdr
** iheaders
= elf_elfsections (ibfd
);
1244 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1246 if (iheaders
!= NULL
&& oheaders
!= NULL
)
1250 for (i
= 0; i
< elf_numsections (obfd
); i
++)
1253 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1256 || oheader
->sh_type
!= SHT_NOBITS
1257 || oheader
->sh_size
== 0
1258 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1261 /* Scan for the matching section in the input bfd.
1262 FIXME: We could use something better than a linear scan here.
1263 Unfortunately we cannot compare names as the output string table
1264 is empty, so instead we check size, address and type. */
1265 for (j
= 0; j
< elf_numsections (ibfd
); j
++)
1267 Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1269 /* Since --only-keep-debug turns all non-debug sections
1270 into SHT_NOBITS sections, the output SHT_NOBITS type
1271 matches any input type. */
1272 if ((oheader
->sh_type
== SHT_NOBITS
1273 || iheader
->sh_type
== oheader
->sh_type
)
1274 && iheader
->sh_flags
== oheader
->sh_flags
1275 && iheader
->sh_addralign
== oheader
->sh_addralign
1276 && iheader
->sh_entsize
== oheader
->sh_entsize
1277 && iheader
->sh_size
== oheader
->sh_size
1278 && iheader
->sh_addr
== oheader
->sh_addr
1279 && (iheader
->sh_info
!= oheader
->sh_info
1280 || iheader
->sh_link
!= oheader
->sh_link
))
1282 /* Note: Strictly speaking these assignments are wrong.
1283 The sh_link and sh_info fields should point to the
1284 relevent sections in the output BFD, which may not be in
1285 the same location as they were in the input BFD. But the
1286 whole point of this action is to preserve the original
1287 values of the sh_link and sh_info fields, so that they
1288 can be matched up with the section headers in the
1289 original file. So strictly speaking we may be creating
1290 an invalid ELF file, but it is only for a file that just
1291 contains debug info and only for sections without any
1293 if (oheader
->sh_link
== 0)
1294 oheader
->sh_link
= iheader
->sh_link
;
1295 if (oheader
->sh_info
== 0)
1296 oheader
->sh_info
= iheader
->sh_info
;
1307 get_segment_type (unsigned int p_type
)
1312 case PT_NULL
: pt
= "NULL"; break;
1313 case PT_LOAD
: pt
= "LOAD"; break;
1314 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1315 case PT_INTERP
: pt
= "INTERP"; break;
1316 case PT_NOTE
: pt
= "NOTE"; break;
1317 case PT_SHLIB
: pt
= "SHLIB"; break;
1318 case PT_PHDR
: pt
= "PHDR"; break;
1319 case PT_TLS
: pt
= "TLS"; break;
1320 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1321 case PT_GNU_STACK
: pt
= "STACK"; break;
1322 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1323 default: pt
= NULL
; break;
1328 /* Print out the program headers. */
1331 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1333 FILE *f
= (FILE *) farg
;
1334 Elf_Internal_Phdr
*p
;
1336 bfd_byte
*dynbuf
= NULL
;
1338 p
= elf_tdata (abfd
)->phdr
;
1343 fprintf (f
, _("\nProgram Header:\n"));
1344 c
= elf_elfheader (abfd
)->e_phnum
;
1345 for (i
= 0; i
< c
; i
++, p
++)
1347 const char *pt
= get_segment_type (p
->p_type
);
1352 sprintf (buf
, "0x%lx", p
->p_type
);
1355 fprintf (f
, "%8s off 0x", pt
);
1356 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1357 fprintf (f
, " vaddr 0x");
1358 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1359 fprintf (f
, " paddr 0x");
1360 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1361 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1362 fprintf (f
, " filesz 0x");
1363 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1364 fprintf (f
, " memsz 0x");
1365 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1366 fprintf (f
, " flags %c%c%c",
1367 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1368 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1369 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1370 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1371 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1376 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1379 unsigned int elfsec
;
1380 unsigned long shlink
;
1381 bfd_byte
*extdyn
, *extdynend
;
1383 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1385 fprintf (f
, _("\nDynamic Section:\n"));
1387 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1390 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1391 if (elfsec
== SHN_BAD
)
1393 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1395 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1396 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1399 /* PR 17512: file: 6f427532. */
1400 if (s
->size
< extdynsize
)
1402 extdynend
= extdyn
+ s
->size
;
1403 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1405 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1407 Elf_Internal_Dyn dyn
;
1408 const char *name
= "";
1410 bfd_boolean stringp
;
1411 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1413 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1415 if (dyn
.d_tag
== DT_NULL
)
1422 if (bed
->elf_backend_get_target_dtag
)
1423 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1425 if (!strcmp (name
, ""))
1427 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1432 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1433 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1434 case DT_PLTGOT
: name
= "PLTGOT"; break;
1435 case DT_HASH
: name
= "HASH"; break;
1436 case DT_STRTAB
: name
= "STRTAB"; break;
1437 case DT_SYMTAB
: name
= "SYMTAB"; break;
1438 case DT_RELA
: name
= "RELA"; break;
1439 case DT_RELASZ
: name
= "RELASZ"; break;
1440 case DT_RELAENT
: name
= "RELAENT"; break;
1441 case DT_STRSZ
: name
= "STRSZ"; break;
1442 case DT_SYMENT
: name
= "SYMENT"; break;
1443 case DT_INIT
: name
= "INIT"; break;
1444 case DT_FINI
: name
= "FINI"; break;
1445 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1446 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1447 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1448 case DT_REL
: name
= "REL"; break;
1449 case DT_RELSZ
: name
= "RELSZ"; break;
1450 case DT_RELENT
: name
= "RELENT"; break;
1451 case DT_PLTREL
: name
= "PLTREL"; break;
1452 case DT_DEBUG
: name
= "DEBUG"; break;
1453 case DT_TEXTREL
: name
= "TEXTREL"; break;
1454 case DT_JMPREL
: name
= "JMPREL"; break;
1455 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1456 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1457 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1458 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1459 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1460 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1461 case DT_FLAGS
: name
= "FLAGS"; break;
1462 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1463 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1464 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1465 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1466 case DT_MOVEENT
: name
= "MOVEENT"; break;
1467 case DT_MOVESZ
: name
= "MOVESZ"; break;
1468 case DT_FEATURE
: name
= "FEATURE"; break;
1469 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1470 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1471 case DT_SYMINENT
: name
= "SYMINENT"; break;
1472 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1473 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1474 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1475 case DT_PLTPAD
: name
= "PLTPAD"; break;
1476 case DT_MOVETAB
: name
= "MOVETAB"; break;
1477 case DT_SYMINFO
: name
= "SYMINFO"; break;
1478 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1479 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1480 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1481 case DT_VERSYM
: name
= "VERSYM"; break;
1482 case DT_VERDEF
: name
= "VERDEF"; break;
1483 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1484 case DT_VERNEED
: name
= "VERNEED"; break;
1485 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1486 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1487 case DT_USED
: name
= "USED"; break;
1488 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1489 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1492 fprintf (f
, " %-20s ", name
);
1496 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1501 unsigned int tagv
= dyn
.d_un
.d_val
;
1503 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1506 fprintf (f
, "%s", string
);
1515 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1516 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1518 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1522 if (elf_dynverdef (abfd
) != 0)
1524 Elf_Internal_Verdef
*t
;
1526 fprintf (f
, _("\nVersion definitions:\n"));
1527 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1529 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1530 t
->vd_flags
, t
->vd_hash
,
1531 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1532 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1534 Elf_Internal_Verdaux
*a
;
1537 for (a
= t
->vd_auxptr
->vda_nextptr
;
1541 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1547 if (elf_dynverref (abfd
) != 0)
1549 Elf_Internal_Verneed
*t
;
1551 fprintf (f
, _("\nVersion References:\n"));
1552 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1554 Elf_Internal_Vernaux
*a
;
1556 fprintf (f
, _(" required from %s:\n"),
1557 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1558 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1559 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1560 a
->vna_flags
, a
->vna_other
,
1561 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1573 /* Get version string. */
1576 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1577 bfd_boolean
*hidden
)
1579 const char *version_string
= NULL
;
1580 if (elf_dynversym (abfd
) != 0
1581 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1583 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1585 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1586 vernum
&= VERSYM_VERSION
;
1589 version_string
= "";
1590 else if (vernum
== 1)
1591 version_string
= "Base";
1592 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1594 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1597 Elf_Internal_Verneed
*t
;
1599 version_string
= "";
1600 for (t
= elf_tdata (abfd
)->verref
;
1604 Elf_Internal_Vernaux
*a
;
1606 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1608 if (a
->vna_other
== vernum
)
1610 version_string
= a
->vna_nodename
;
1617 return version_string
;
1620 /* Display ELF-specific fields of a symbol. */
1623 bfd_elf_print_symbol (bfd
*abfd
,
1626 bfd_print_symbol_type how
)
1628 FILE *file
= (FILE *) filep
;
1631 case bfd_print_symbol_name
:
1632 fprintf (file
, "%s", symbol
->name
);
1634 case bfd_print_symbol_more
:
1635 fprintf (file
, "elf ");
1636 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1637 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1639 case bfd_print_symbol_all
:
1641 const char *section_name
;
1642 const char *name
= NULL
;
1643 const struct elf_backend_data
*bed
;
1644 unsigned char st_other
;
1646 const char *version_string
;
1649 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1651 bed
= get_elf_backend_data (abfd
);
1652 if (bed
->elf_backend_print_symbol_all
)
1653 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1657 name
= symbol
->name
;
1658 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1661 fprintf (file
, " %s\t", section_name
);
1662 /* Print the "other" value for a symbol. For common symbols,
1663 we've already printed the size; now print the alignment.
1664 For other symbols, we have no specified alignment, and
1665 we've printed the address; now print the size. */
1666 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1667 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1669 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1670 bfd_fprintf_vma (abfd
, file
, val
);
1672 /* If we have version information, print it. */
1673 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1679 fprintf (file
, " %-11s", version_string
);
1684 fprintf (file
, " (%s)", version_string
);
1685 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1690 /* If the st_other field is not zero, print it. */
1691 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1696 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1697 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1698 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1700 /* Some other non-defined flags are also present, so print
1702 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1705 fprintf (file
, " %s", name
);
1711 /* ELF .o/exec file reading */
1713 /* Create a new bfd section from an ELF section header. */
1716 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1718 Elf_Internal_Shdr
*hdr
;
1719 Elf_Internal_Ehdr
*ehdr
;
1720 const struct elf_backend_data
*bed
;
1722 bfd_boolean ret
= TRUE
;
1723 static bfd_boolean
* sections_being_created
= NULL
;
1724 static bfd
* sections_being_created_abfd
= NULL
;
1725 static unsigned int nesting
= 0;
1727 if (shindex
>= elf_numsections (abfd
))
1732 /* PR17512: A corrupt ELF binary might contain a recursive group of
1733 sections, with each the string indicies pointing to the next in the
1734 loop. Detect this here, by refusing to load a section that we are
1735 already in the process of loading. We only trigger this test if
1736 we have nested at least three sections deep as normal ELF binaries
1737 can expect to recurse at least once.
1739 FIXME: It would be better if this array was attached to the bfd,
1740 rather than being held in a static pointer. */
1742 if (sections_being_created_abfd
!= abfd
)
1743 sections_being_created
= NULL
;
1744 if (sections_being_created
== NULL
)
1746 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
1747 sections_being_created
= (bfd_boolean
*)
1748 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
1749 sections_being_created_abfd
= abfd
;
1751 if (sections_being_created
[shindex
])
1753 (*_bfd_error_handler
)
1754 (_("%B: warning: loop in section dependencies detected"), abfd
);
1757 sections_being_created
[shindex
] = TRUE
;
1760 hdr
= elf_elfsections (abfd
)[shindex
];
1761 ehdr
= elf_elfheader (abfd
);
1762 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1767 bed
= get_elf_backend_data (abfd
);
1768 switch (hdr
->sh_type
)
1771 /* Inactive section. Throw it away. */
1774 case SHT_PROGBITS
: /* Normal section with contents. */
1775 case SHT_NOBITS
: /* .bss section. */
1776 case SHT_HASH
: /* .hash section. */
1777 case SHT_NOTE
: /* .note section. */
1778 case SHT_INIT_ARRAY
: /* .init_array section. */
1779 case SHT_FINI_ARRAY
: /* .fini_array section. */
1780 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1781 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1782 case SHT_GNU_HASH
: /* .gnu.hash section. */
1783 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1786 case SHT_DYNAMIC
: /* Dynamic linking information. */
1787 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1790 if (hdr
->sh_link
> elf_numsections (abfd
))
1792 /* PR 10478: Accept Solaris binaries with a sh_link
1793 field set to SHN_BEFORE or SHN_AFTER. */
1794 switch (bfd_get_arch (abfd
))
1797 case bfd_arch_sparc
:
1798 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
1799 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
1801 /* Otherwise fall through. */
1806 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1808 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1810 Elf_Internal_Shdr
*dynsymhdr
;
1812 /* The shared libraries distributed with hpux11 have a bogus
1813 sh_link field for the ".dynamic" section. Find the
1814 string table for the ".dynsym" section instead. */
1815 if (elf_dynsymtab (abfd
) != 0)
1817 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1818 hdr
->sh_link
= dynsymhdr
->sh_link
;
1822 unsigned int i
, num_sec
;
1824 num_sec
= elf_numsections (abfd
);
1825 for (i
= 1; i
< num_sec
; i
++)
1827 dynsymhdr
= elf_elfsections (abfd
)[i
];
1828 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1830 hdr
->sh_link
= dynsymhdr
->sh_link
;
1838 case SHT_SYMTAB
: /* A symbol table. */
1839 if (elf_onesymtab (abfd
) == shindex
)
1842 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1845 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1847 if (hdr
->sh_size
!= 0)
1849 /* Some assemblers erroneously set sh_info to one with a
1850 zero sh_size. ld sees this as a global symbol count
1851 of (unsigned) -1. Fix it here. */
1856 /* PR 18854: A binary might contain more than one symbol table.
1857 Unusual, but possible. Warn, but continue. */
1858 if (elf_onesymtab (abfd
) != 0)
1860 (*_bfd_error_handler
)
1861 (_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"),
1865 elf_onesymtab (abfd
) = shindex
;
1866 elf_symtab_hdr (abfd
) = *hdr
;
1867 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
1868 abfd
->flags
|= HAS_SYMS
;
1870 /* Sometimes a shared object will map in the symbol table. If
1871 SHF_ALLOC is set, and this is a shared object, then we also
1872 treat this section as a BFD section. We can not base the
1873 decision purely on SHF_ALLOC, because that flag is sometimes
1874 set in a relocatable object file, which would confuse the
1876 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1877 && (abfd
->flags
& DYNAMIC
) != 0
1878 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1882 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1883 can't read symbols without that section loaded as well. It
1884 is most likely specified by the next section header. */
1886 elf_section_list
* entry
;
1887 unsigned int i
, num_sec
;
1889 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
1890 if (entry
->hdr
.sh_link
== shindex
)
1893 num_sec
= elf_numsections (abfd
);
1894 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1896 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1898 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1899 && hdr2
->sh_link
== shindex
)
1904 for (i
= 1; i
< shindex
; i
++)
1906 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1908 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1909 && hdr2
->sh_link
== shindex
)
1914 ret
= bfd_section_from_shdr (abfd
, i
);
1915 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
1919 case SHT_DYNSYM
: /* A dynamic symbol table. */
1920 if (elf_dynsymtab (abfd
) == shindex
)
1923 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1926 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1928 if (hdr
->sh_size
!= 0)
1931 /* Some linkers erroneously set sh_info to one with a
1932 zero sh_size. ld sees this as a global symbol count
1933 of (unsigned) -1. Fix it here. */
1938 /* PR 18854: A binary might contain more than one dynamic symbol table.
1939 Unusual, but possible. Warn, but continue. */
1940 if (elf_dynsymtab (abfd
) != 0)
1942 (*_bfd_error_handler
)
1943 (_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"),
1947 elf_dynsymtab (abfd
) = shindex
;
1948 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1949 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1950 abfd
->flags
|= HAS_SYMS
;
1952 /* Besides being a symbol table, we also treat this as a regular
1953 section, so that objcopy can handle it. */
1954 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1957 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
1959 elf_section_list
* entry
;
1961 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
1962 if (entry
->ndx
== shindex
)
1965 entry
= bfd_alloc (abfd
, sizeof * entry
);
1968 entry
->ndx
= shindex
;
1970 entry
->next
= elf_symtab_shndx_list (abfd
);
1971 elf_symtab_shndx_list (abfd
) = entry
;
1972 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
1976 case SHT_STRTAB
: /* A string table. */
1977 if (hdr
->bfd_section
!= NULL
)
1980 if (ehdr
->e_shstrndx
== shindex
)
1982 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1983 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1987 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1990 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1991 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1995 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1998 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1999 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2000 elf_elfsections (abfd
)[shindex
] = hdr
;
2001 /* We also treat this as a regular section, so that objcopy
2003 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2008 /* If the string table isn't one of the above, then treat it as a
2009 regular section. We need to scan all the headers to be sure,
2010 just in case this strtab section appeared before the above. */
2011 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2013 unsigned int i
, num_sec
;
2015 num_sec
= elf_numsections (abfd
);
2016 for (i
= 1; i
< num_sec
; i
++)
2018 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2019 if (hdr2
->sh_link
== shindex
)
2021 /* Prevent endless recursion on broken objects. */
2024 if (! bfd_section_from_shdr (abfd
, i
))
2026 if (elf_onesymtab (abfd
) == i
)
2028 if (elf_dynsymtab (abfd
) == i
)
2029 goto dynsymtab_strtab
;
2033 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2038 /* *These* do a lot of work -- but build no sections! */
2040 asection
*target_sect
;
2041 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2042 unsigned int num_sec
= elf_numsections (abfd
);
2043 struct bfd_elf_section_data
*esdt
;
2047 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2048 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2051 /* Check for a bogus link to avoid crashing. */
2052 if (hdr
->sh_link
>= num_sec
)
2054 ((*_bfd_error_handler
)
2055 (_("%B: invalid link %lu for reloc section %s (index %u)"),
2056 abfd
, hdr
->sh_link
, name
, shindex
));
2057 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2062 /* For some incomprehensible reason Oracle distributes
2063 libraries for Solaris in which some of the objects have
2064 bogus sh_link fields. It would be nice if we could just
2065 reject them, but, unfortunately, some people need to use
2066 them. We scan through the section headers; if we find only
2067 one suitable symbol table, we clobber the sh_link to point
2068 to it. I hope this doesn't break anything.
2070 Don't do it on executable nor shared library. */
2071 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2072 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2073 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2079 for (scan
= 1; scan
< num_sec
; scan
++)
2081 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2082 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2093 hdr
->sh_link
= found
;
2096 /* Get the symbol table. */
2097 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2098 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2099 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2102 /* If this reloc section does not use the main symbol table we
2103 don't treat it as a reloc section. BFD can't adequately
2104 represent such a section, so at least for now, we don't
2105 try. We just present it as a normal section. We also
2106 can't use it as a reloc section if it points to the null
2107 section, an invalid section, another reloc section, or its
2108 sh_link points to the null section. */
2109 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2110 || hdr
->sh_link
== SHN_UNDEF
2111 || hdr
->sh_info
== SHN_UNDEF
2112 || hdr
->sh_info
>= num_sec
2113 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2114 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2116 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2121 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2124 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2125 if (target_sect
== NULL
)
2128 esdt
= elf_section_data (target_sect
);
2129 if (hdr
->sh_type
== SHT_RELA
)
2130 p_hdr
= &esdt
->rela
.hdr
;
2132 p_hdr
= &esdt
->rel
.hdr
;
2134 /* PR 17512: file: 0b4f81b7. */
2137 amt
= sizeof (*hdr2
);
2138 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2143 elf_elfsections (abfd
)[shindex
] = hdr2
;
2144 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2145 target_sect
->flags
|= SEC_RELOC
;
2146 target_sect
->relocation
= NULL
;
2147 target_sect
->rel_filepos
= hdr
->sh_offset
;
2148 /* In the section to which the relocations apply, mark whether
2149 its relocations are of the REL or RELA variety. */
2150 if (hdr
->sh_size
!= 0)
2152 if (hdr
->sh_type
== SHT_RELA
)
2153 target_sect
->use_rela_p
= 1;
2155 abfd
->flags
|= HAS_RELOC
;
2159 case SHT_GNU_verdef
:
2160 elf_dynverdef (abfd
) = shindex
;
2161 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2162 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2165 case SHT_GNU_versym
:
2166 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2169 elf_dynversym (abfd
) = shindex
;
2170 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2171 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2174 case SHT_GNU_verneed
:
2175 elf_dynverref (abfd
) = shindex
;
2176 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2177 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2184 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2187 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2190 if (hdr
->contents
!= NULL
)
2192 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2193 unsigned int n_elt
= hdr
->sh_size
/ sizeof (* idx
);
2198 if (idx
->flags
& GRP_COMDAT
)
2199 hdr
->bfd_section
->flags
2200 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2202 /* We try to keep the same section order as it comes in. */
2205 while (--n_elt
!= 0)
2209 if (idx
->shdr
!= NULL
2210 && (s
= idx
->shdr
->bfd_section
) != NULL
2211 && elf_next_in_group (s
) != NULL
)
2213 elf_next_in_group (hdr
->bfd_section
) = s
;
2221 /* Possibly an attributes section. */
2222 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2223 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2225 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2227 _bfd_elf_parse_attributes (abfd
, hdr
);
2231 /* Check for any processor-specific section types. */
2232 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2235 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2237 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2238 /* FIXME: How to properly handle allocated section reserved
2239 for applications? */
2240 (*_bfd_error_handler
)
2241 (_("%B: don't know how to handle allocated, application "
2242 "specific section `%s' [0x%8x]"),
2243 abfd
, name
, hdr
->sh_type
);
2246 /* Allow sections reserved for applications. */
2247 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2252 else if (hdr
->sh_type
>= SHT_LOPROC
2253 && hdr
->sh_type
<= SHT_HIPROC
)
2254 /* FIXME: We should handle this section. */
2255 (*_bfd_error_handler
)
2256 (_("%B: don't know how to handle processor specific section "
2258 abfd
, name
, hdr
->sh_type
);
2259 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2261 /* Unrecognised OS-specific sections. */
2262 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2263 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2264 required to correctly process the section and the file should
2265 be rejected with an error message. */
2266 (*_bfd_error_handler
)
2267 (_("%B: don't know how to handle OS specific section "
2269 abfd
, name
, hdr
->sh_type
);
2272 /* Otherwise it should be processed. */
2273 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2278 /* FIXME: We should handle this section. */
2279 (*_bfd_error_handler
)
2280 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2281 abfd
, name
, hdr
->sh_type
);
2289 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2290 sections_being_created
[shindex
] = FALSE
;
2291 if (-- nesting
== 0)
2293 sections_being_created
= NULL
;
2294 sections_being_created_abfd
= abfd
;
2299 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2302 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2304 unsigned long r_symndx
)
2306 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2308 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2310 Elf_Internal_Shdr
*symtab_hdr
;
2311 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2312 Elf_External_Sym_Shndx eshndx
;
2314 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2315 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2316 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2319 if (cache
->abfd
!= abfd
)
2321 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2324 cache
->indx
[ent
] = r_symndx
;
2327 return &cache
->sym
[ent
];
2330 /* Given an ELF section number, retrieve the corresponding BFD
2334 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2336 if (sec_index
>= elf_numsections (abfd
))
2338 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2341 static const struct bfd_elf_special_section special_sections_b
[] =
2343 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2344 { NULL
, 0, 0, 0, 0 }
2347 static const struct bfd_elf_special_section special_sections_c
[] =
2349 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2350 { NULL
, 0, 0, 0, 0 }
2353 static const struct bfd_elf_special_section special_sections_d
[] =
2355 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2356 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2357 /* There are more DWARF sections than these, but they needn't be added here
2358 unless you have to cope with broken compilers that don't emit section
2359 attributes or you want to help the user writing assembler. */
2360 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2361 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2362 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2363 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2364 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2365 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2366 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2367 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2368 { NULL
, 0, 0, 0, 0 }
2371 static const struct bfd_elf_special_section special_sections_f
[] =
2373 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2374 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2375 { NULL
, 0, 0, 0, 0 }
2378 static const struct bfd_elf_special_section special_sections_g
[] =
2380 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2381 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2382 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2383 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2384 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2385 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2386 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2387 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2388 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2389 { NULL
, 0, 0, 0, 0 }
2392 static const struct bfd_elf_special_section special_sections_h
[] =
2394 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2395 { NULL
, 0, 0, 0, 0 }
2398 static const struct bfd_elf_special_section special_sections_i
[] =
2400 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2401 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2402 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2403 { NULL
, 0, 0, 0, 0 }
2406 static const struct bfd_elf_special_section special_sections_l
[] =
2408 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2409 { NULL
, 0, 0, 0, 0 }
2412 static const struct bfd_elf_special_section special_sections_n
[] =
2414 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2415 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2416 { NULL
, 0, 0, 0, 0 }
2419 static const struct bfd_elf_special_section special_sections_p
[] =
2421 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2422 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2423 { NULL
, 0, 0, 0, 0 }
2426 static const struct bfd_elf_special_section special_sections_r
[] =
2428 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2429 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2430 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2431 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2432 { NULL
, 0, 0, 0, 0 }
2435 static const struct bfd_elf_special_section special_sections_s
[] =
2437 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2438 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2439 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2440 /* See struct bfd_elf_special_section declaration for the semantics of
2441 this special case where .prefix_length != strlen (.prefix). */
2442 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2443 { NULL
, 0, 0, 0, 0 }
2446 static const struct bfd_elf_special_section special_sections_t
[] =
2448 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2449 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2450 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2451 { NULL
, 0, 0, 0, 0 }
2454 static const struct bfd_elf_special_section special_sections_z
[] =
2456 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2457 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2458 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2459 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2460 { NULL
, 0, 0, 0, 0 }
2463 static const struct bfd_elf_special_section
* const special_sections
[] =
2465 special_sections_b
, /* 'b' */
2466 special_sections_c
, /* 'c' */
2467 special_sections_d
, /* 'd' */
2469 special_sections_f
, /* 'f' */
2470 special_sections_g
, /* 'g' */
2471 special_sections_h
, /* 'h' */
2472 special_sections_i
, /* 'i' */
2475 special_sections_l
, /* 'l' */
2477 special_sections_n
, /* 'n' */
2479 special_sections_p
, /* 'p' */
2481 special_sections_r
, /* 'r' */
2482 special_sections_s
, /* 's' */
2483 special_sections_t
, /* 't' */
2489 special_sections_z
/* 'z' */
2492 const struct bfd_elf_special_section
*
2493 _bfd_elf_get_special_section (const char *name
,
2494 const struct bfd_elf_special_section
*spec
,
2500 len
= strlen (name
);
2502 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2505 int prefix_len
= spec
[i
].prefix_length
;
2507 if (len
< prefix_len
)
2509 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2512 suffix_len
= spec
[i
].suffix_length
;
2513 if (suffix_len
<= 0)
2515 if (name
[prefix_len
] != 0)
2517 if (suffix_len
== 0)
2519 if (name
[prefix_len
] != '.'
2520 && (suffix_len
== -2
2521 || (rela
&& spec
[i
].type
== SHT_REL
)))
2527 if (len
< prefix_len
+ suffix_len
)
2529 if (memcmp (name
+ len
- suffix_len
,
2530 spec
[i
].prefix
+ prefix_len
,
2540 const struct bfd_elf_special_section
*
2541 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2544 const struct bfd_elf_special_section
*spec
;
2545 const struct elf_backend_data
*bed
;
2547 /* See if this is one of the special sections. */
2548 if (sec
->name
== NULL
)
2551 bed
= get_elf_backend_data (abfd
);
2552 spec
= bed
->special_sections
;
2555 spec
= _bfd_elf_get_special_section (sec
->name
,
2556 bed
->special_sections
,
2562 if (sec
->name
[0] != '.')
2565 i
= sec
->name
[1] - 'b';
2566 if (i
< 0 || i
> 'z' - 'b')
2569 spec
= special_sections
[i
];
2574 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2578 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2580 struct bfd_elf_section_data
*sdata
;
2581 const struct elf_backend_data
*bed
;
2582 const struct bfd_elf_special_section
*ssect
;
2584 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2587 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2591 sec
->used_by_bfd
= sdata
;
2594 /* Indicate whether or not this section should use RELA relocations. */
2595 bed
= get_elf_backend_data (abfd
);
2596 sec
->use_rela_p
= bed
->default_use_rela_p
;
2598 /* When we read a file, we don't need to set ELF section type and
2599 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2600 anyway. We will set ELF section type and flags for all linker
2601 created sections. If user specifies BFD section flags, we will
2602 set ELF section type and flags based on BFD section flags in
2603 elf_fake_sections. Special handling for .init_array/.fini_array
2604 output sections since they may contain .ctors/.dtors input
2605 sections. We don't want _bfd_elf_init_private_section_data to
2606 copy ELF section type from .ctors/.dtors input sections. */
2607 if (abfd
->direction
!= read_direction
2608 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2610 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2613 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2614 || ssect
->type
== SHT_INIT_ARRAY
2615 || ssect
->type
== SHT_FINI_ARRAY
))
2617 elf_section_type (sec
) = ssect
->type
;
2618 elf_section_flags (sec
) = ssect
->attr
;
2622 return _bfd_generic_new_section_hook (abfd
, sec
);
2625 /* Create a new bfd section from an ELF program header.
2627 Since program segments have no names, we generate a synthetic name
2628 of the form segment<NUM>, where NUM is generally the index in the
2629 program header table. For segments that are split (see below) we
2630 generate the names segment<NUM>a and segment<NUM>b.
2632 Note that some program segments may have a file size that is different than
2633 (less than) the memory size. All this means is that at execution the
2634 system must allocate the amount of memory specified by the memory size,
2635 but only initialize it with the first "file size" bytes read from the
2636 file. This would occur for example, with program segments consisting
2637 of combined data+bss.
2639 To handle the above situation, this routine generates TWO bfd sections
2640 for the single program segment. The first has the length specified by
2641 the file size of the segment, and the second has the length specified
2642 by the difference between the two sizes. In effect, the segment is split
2643 into its initialized and uninitialized parts.
2648 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2649 Elf_Internal_Phdr
*hdr
,
2651 const char *type_name
)
2659 split
= ((hdr
->p_memsz
> 0)
2660 && (hdr
->p_filesz
> 0)
2661 && (hdr
->p_memsz
> hdr
->p_filesz
));
2663 if (hdr
->p_filesz
> 0)
2665 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2666 len
= strlen (namebuf
) + 1;
2667 name
= (char *) bfd_alloc (abfd
, len
);
2670 memcpy (name
, namebuf
, len
);
2671 newsect
= bfd_make_section (abfd
, name
);
2672 if (newsect
== NULL
)
2674 newsect
->vma
= hdr
->p_vaddr
;
2675 newsect
->lma
= hdr
->p_paddr
;
2676 newsect
->size
= hdr
->p_filesz
;
2677 newsect
->filepos
= hdr
->p_offset
;
2678 newsect
->flags
|= SEC_HAS_CONTENTS
;
2679 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2680 if (hdr
->p_type
== PT_LOAD
)
2682 newsect
->flags
|= SEC_ALLOC
;
2683 newsect
->flags
|= SEC_LOAD
;
2684 if (hdr
->p_flags
& PF_X
)
2686 /* FIXME: all we known is that it has execute PERMISSION,
2688 newsect
->flags
|= SEC_CODE
;
2691 if (!(hdr
->p_flags
& PF_W
))
2693 newsect
->flags
|= SEC_READONLY
;
2697 if (hdr
->p_memsz
> hdr
->p_filesz
)
2701 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2702 len
= strlen (namebuf
) + 1;
2703 name
= (char *) bfd_alloc (abfd
, len
);
2706 memcpy (name
, namebuf
, len
);
2707 newsect
= bfd_make_section (abfd
, name
);
2708 if (newsect
== NULL
)
2710 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2711 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2712 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2713 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2714 align
= newsect
->vma
& -newsect
->vma
;
2715 if (align
== 0 || align
> hdr
->p_align
)
2716 align
= hdr
->p_align
;
2717 newsect
->alignment_power
= bfd_log2 (align
);
2718 if (hdr
->p_type
== PT_LOAD
)
2720 /* Hack for gdb. Segments that have not been modified do
2721 not have their contents written to a core file, on the
2722 assumption that a debugger can find the contents in the
2723 executable. We flag this case by setting the fake
2724 section size to zero. Note that "real" bss sections will
2725 always have their contents dumped to the core file. */
2726 if (bfd_get_format (abfd
) == bfd_core
)
2728 newsect
->flags
|= SEC_ALLOC
;
2729 if (hdr
->p_flags
& PF_X
)
2730 newsect
->flags
|= SEC_CODE
;
2732 if (!(hdr
->p_flags
& PF_W
))
2733 newsect
->flags
|= SEC_READONLY
;
2740 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2742 const struct elf_backend_data
*bed
;
2744 switch (hdr
->p_type
)
2747 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2750 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2753 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2756 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2759 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2761 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2766 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2769 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2771 case PT_GNU_EH_FRAME
:
2772 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2776 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
2779 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
2782 /* Check for any processor-specific program segment types. */
2783 bed
= get_elf_backend_data (abfd
);
2784 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
2788 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2792 _bfd_elf_single_rel_hdr (asection
*sec
)
2794 if (elf_section_data (sec
)->rel
.hdr
)
2796 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
2797 return elf_section_data (sec
)->rel
.hdr
;
2800 return elf_section_data (sec
)->rela
.hdr
;
2804 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
2805 Elf_Internal_Shdr
*rel_hdr
,
2806 const char *sec_name
,
2807 bfd_boolean use_rela_p
)
2809 char *name
= (char *) bfd_alloc (abfd
,
2810 sizeof ".rela" + strlen (sec_name
));
2814 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
2816 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2818 if (rel_hdr
->sh_name
== (unsigned int) -1)
2824 /* Allocate and initialize a section-header for a new reloc section,
2825 containing relocations against ASECT. It is stored in RELDATA. If
2826 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2830 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2831 struct bfd_elf_section_reloc_data
*reldata
,
2832 const char *sec_name
,
2833 bfd_boolean use_rela_p
,
2834 bfd_boolean delay_st_name_p
)
2836 Elf_Internal_Shdr
*rel_hdr
;
2837 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2840 amt
= sizeof (Elf_Internal_Shdr
);
2841 BFD_ASSERT (reldata
->hdr
== NULL
);
2842 rel_hdr
= bfd_zalloc (abfd
, amt
);
2843 reldata
->hdr
= rel_hdr
;
2845 if (delay_st_name_p
)
2846 rel_hdr
->sh_name
= (unsigned int) -1;
2847 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
2850 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2851 rel_hdr
->sh_entsize
= (use_rela_p
2852 ? bed
->s
->sizeof_rela
2853 : bed
->s
->sizeof_rel
);
2854 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2855 rel_hdr
->sh_flags
= 0;
2856 rel_hdr
->sh_addr
= 0;
2857 rel_hdr
->sh_size
= 0;
2858 rel_hdr
->sh_offset
= 0;
2863 /* Return the default section type based on the passed in section flags. */
2866 bfd_elf_get_default_section_type (flagword flags
)
2868 if ((flags
& SEC_ALLOC
) != 0
2869 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2871 return SHT_PROGBITS
;
2874 struct fake_section_arg
2876 struct bfd_link_info
*link_info
;
2880 /* Set up an ELF internal section header for a section. */
2883 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
2885 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
2886 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2887 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
2888 Elf_Internal_Shdr
*this_hdr
;
2889 unsigned int sh_type
;
2890 const char *name
= asect
->name
;
2891 bfd_boolean delay_st_name_p
= FALSE
;
2895 /* We already failed; just get out of the bfd_map_over_sections
2900 this_hdr
= &esd
->this_hdr
;
2904 /* ld: compress DWARF debug sections with names: .debug_*. */
2905 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
2906 && (asect
->flags
& SEC_DEBUGGING
)
2910 /* Set SEC_ELF_COMPRESS to indicate this section should be
2912 asect
->flags
|= SEC_ELF_COMPRESS
;
2914 /* If this section will be compressed, delay adding setion
2915 name to section name section after it is compressed in
2916 _bfd_elf_assign_file_positions_for_non_load. */
2917 delay_st_name_p
= TRUE
;
2920 else if ((asect
->flags
& SEC_ELF_RENAME
))
2922 /* objcopy: rename output DWARF debug section. */
2923 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
2925 /* When we decompress or compress with SHF_COMPRESSED,
2926 convert section name from .zdebug_* to .debug_* if
2930 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
2931 if (new_name
== NULL
)
2939 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
2941 /* PR binutils/18087: Compression does not always make a
2942 section smaller. So only rename the section when
2943 compression has actually taken place. If input section
2944 name is .zdebug_*, we should never compress it again. */
2945 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
2946 if (new_name
== NULL
)
2951 BFD_ASSERT (name
[1] != 'z');
2956 if (delay_st_name_p
)
2957 this_hdr
->sh_name
= (unsigned int) -1;
2961 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2963 if (this_hdr
->sh_name
== (unsigned int) -1)
2970 /* Don't clear sh_flags. Assembler may set additional bits. */
2972 if ((asect
->flags
& SEC_ALLOC
) != 0
2973 || asect
->user_set_vma
)
2974 this_hdr
->sh_addr
= asect
->vma
;
2976 this_hdr
->sh_addr
= 0;
2978 this_hdr
->sh_offset
= 0;
2979 this_hdr
->sh_size
= asect
->size
;
2980 this_hdr
->sh_link
= 0;
2981 /* PR 17512: file: 0eb809fe, 8b0535ee. */
2982 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
2984 (*_bfd_error_handler
)
2985 (_("%B: error: Alignment power %d of section `%A' is too big"),
2986 abfd
, asect
, asect
->alignment_power
);
2990 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2991 /* The sh_entsize and sh_info fields may have been set already by
2992 copy_private_section_data. */
2994 this_hdr
->bfd_section
= asect
;
2995 this_hdr
->contents
= NULL
;
2997 /* If the section type is unspecified, we set it based on
2999 if ((asect
->flags
& SEC_GROUP
) != 0)
3000 sh_type
= SHT_GROUP
;
3002 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3004 if (this_hdr
->sh_type
== SHT_NULL
)
3005 this_hdr
->sh_type
= sh_type
;
3006 else if (this_hdr
->sh_type
== SHT_NOBITS
3007 && sh_type
== SHT_PROGBITS
3008 && (asect
->flags
& SEC_ALLOC
) != 0)
3010 /* Warn if we are changing a NOBITS section to PROGBITS, but
3011 allow the link to proceed. This can happen when users link
3012 non-bss input sections to bss output sections, or emit data
3013 to a bss output section via a linker script. */
3014 (*_bfd_error_handler
)
3015 (_("warning: section `%A' type changed to PROGBITS"), asect
);
3016 this_hdr
->sh_type
= sh_type
;
3019 switch (this_hdr
->sh_type
)
3025 case SHT_INIT_ARRAY
:
3026 case SHT_FINI_ARRAY
:
3027 case SHT_PREINIT_ARRAY
:
3034 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3038 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3042 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3046 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3047 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3051 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3052 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3055 case SHT_GNU_versym
:
3056 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3059 case SHT_GNU_verdef
:
3060 this_hdr
->sh_entsize
= 0;
3061 /* objcopy or strip will copy over sh_info, but may not set
3062 cverdefs. The linker will set cverdefs, but sh_info will be
3064 if (this_hdr
->sh_info
== 0)
3065 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3067 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3068 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3071 case SHT_GNU_verneed
:
3072 this_hdr
->sh_entsize
= 0;
3073 /* objcopy or strip will copy over sh_info, but may not set
3074 cverrefs. The linker will set cverrefs, but sh_info will be
3076 if (this_hdr
->sh_info
== 0)
3077 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3079 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3080 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3084 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3088 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3092 if ((asect
->flags
& SEC_ALLOC
) != 0)
3093 this_hdr
->sh_flags
|= SHF_ALLOC
;
3094 if ((asect
->flags
& SEC_READONLY
) == 0)
3095 this_hdr
->sh_flags
|= SHF_WRITE
;
3096 if ((asect
->flags
& SEC_CODE
) != 0)
3097 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3098 if ((asect
->flags
& SEC_MERGE
) != 0)
3100 this_hdr
->sh_flags
|= SHF_MERGE
;
3101 this_hdr
->sh_entsize
= asect
->entsize
;
3102 if ((asect
->flags
& SEC_STRINGS
) != 0)
3103 this_hdr
->sh_flags
|= SHF_STRINGS
;
3105 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3106 this_hdr
->sh_flags
|= SHF_GROUP
;
3107 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3109 this_hdr
->sh_flags
|= SHF_TLS
;
3110 if (asect
->size
== 0
3111 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3113 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3115 this_hdr
->sh_size
= 0;
3118 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3119 if (this_hdr
->sh_size
!= 0)
3120 this_hdr
->sh_type
= SHT_NOBITS
;
3124 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3125 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3127 /* If the section has relocs, set up a section header for the
3128 SHT_REL[A] section. If two relocation sections are required for
3129 this section, it is up to the processor-specific back-end to
3130 create the other. */
3131 if ((asect
->flags
& SEC_RELOC
) != 0)
3133 /* When doing a relocatable link, create both REL and RELA sections if
3136 /* Do the normal setup if we wouldn't create any sections here. */
3137 && esd
->rel
.count
+ esd
->rela
.count
> 0
3138 && (bfd_link_relocatable (arg
->link_info
)
3139 || arg
->link_info
->emitrelocations
))
3141 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3142 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
, FALSE
,
3148 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3149 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
, TRUE
,
3156 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3158 ? &esd
->rela
: &esd
->rel
),
3165 /* Check for processor-specific section types. */
3166 sh_type
= this_hdr
->sh_type
;
3167 if (bed
->elf_backend_fake_sections
3168 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3171 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3173 /* Don't change the header type from NOBITS if we are being
3174 called for objcopy --only-keep-debug. */
3175 this_hdr
->sh_type
= sh_type
;
3179 /* Fill in the contents of a SHT_GROUP section. Called from
3180 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3181 when ELF targets use the generic linker, ld. Called for ld -r
3182 from bfd_elf_final_link. */
3185 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3187 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3188 asection
*elt
, *first
;
3192 /* Ignore linker created group section. See elfNN_ia64_object_p in
3194 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
3198 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3200 unsigned long symindx
= 0;
3202 /* elf_group_id will have been set up by objcopy and the
3204 if (elf_group_id (sec
) != NULL
)
3205 symindx
= elf_group_id (sec
)->udata
.i
;
3209 /* If called from the assembler, swap_out_syms will have set up
3210 elf_section_syms. */
3211 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3212 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3214 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3216 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3218 /* The ELF backend linker sets sh_info to -2 when the group
3219 signature symbol is global, and thus the index can't be
3220 set until all local symbols are output. */
3221 asection
*igroup
= elf_sec_group (elf_next_in_group (sec
));
3222 struct bfd_elf_section_data
*sec_data
= elf_section_data (igroup
);
3223 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
3224 unsigned long extsymoff
= 0;
3225 struct elf_link_hash_entry
*h
;
3227 if (!elf_bad_symtab (igroup
->owner
))
3229 Elf_Internal_Shdr
*symtab_hdr
;
3231 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3232 extsymoff
= symtab_hdr
->sh_info
;
3234 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3235 while (h
->root
.type
== bfd_link_hash_indirect
3236 || h
->root
.type
== bfd_link_hash_warning
)
3237 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3239 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3242 /* The contents won't be allocated for "ld -r" or objcopy. */
3244 if (sec
->contents
== NULL
)
3247 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3249 /* Arrange for the section to be written out. */
3250 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3251 if (sec
->contents
== NULL
)
3258 loc
= sec
->contents
+ sec
->size
;
3260 /* Get the pointer to the first section in the group that gas
3261 squirreled away here. objcopy arranges for this to be set to the
3262 start of the input section group. */
3263 first
= elt
= elf_next_in_group (sec
);
3265 /* First element is a flag word. Rest of section is elf section
3266 indices for all the sections of the group. Write them backwards
3267 just to keep the group in the same order as given in .section
3268 directives, not that it matters. */
3275 s
= s
->output_section
;
3277 && !bfd_is_abs_section (s
))
3279 unsigned int idx
= elf_section_data (s
)->this_idx
;
3282 H_PUT_32 (abfd
, idx
, loc
);
3284 elt
= elf_next_in_group (elt
);
3289 if ((loc
-= 4) != sec
->contents
)
3292 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3295 /* Return the section which RELOC_SEC applies to. */
3298 _bfd_elf_get_reloc_section (asection
*reloc_sec
)
3304 if (reloc_sec
== NULL
)
3307 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3308 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3311 /* We look up the section the relocs apply to by name. */
3312 name
= reloc_sec
->name
;
3313 if (type
== SHT_REL
)
3318 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3319 section apply to .got.plt section. */
3320 abfd
= reloc_sec
->owner
;
3321 if (get_elf_backend_data (abfd
)->want_got_plt
3322 && strcmp (name
, ".plt") == 0)
3324 /* .got.plt is a linker created input section. It may be mapped
3325 to some other output section. Try two likely sections. */
3327 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3328 if (reloc_sec
!= NULL
)
3333 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
3337 /* Assign all ELF section numbers. The dummy first section is handled here
3338 too. The link/info pointers for the standard section types are filled
3339 in here too, while we're at it. */
3342 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3344 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3346 unsigned int section_number
;
3347 Elf_Internal_Shdr
**i_shdrp
;
3348 struct bfd_elf_section_data
*d
;
3349 bfd_boolean need_symtab
;
3353 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3355 /* SHT_GROUP sections are in relocatable files only. */
3356 if (link_info
== NULL
|| bfd_link_relocatable (link_info
))
3358 bfd_size_type reloc_count
= 0;
3360 /* Put SHT_GROUP sections first. */
3361 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3363 d
= elf_section_data (sec
);
3365 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3367 if (sec
->flags
& SEC_LINKER_CREATED
)
3369 /* Remove the linker created SHT_GROUP sections. */
3370 bfd_section_list_remove (abfd
, sec
);
3371 abfd
->section_count
--;
3374 d
->this_idx
= section_number
++;
3377 /* Count relocations. */
3378 reloc_count
+= sec
->reloc_count
;
3381 /* Clear HAS_RELOC if there are no relocations. */
3382 if (reloc_count
== 0)
3383 abfd
->flags
&= ~HAS_RELOC
;
3386 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3388 d
= elf_section_data (sec
);
3390 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3391 d
->this_idx
= section_number
++;
3392 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3393 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3396 d
->rel
.idx
= section_number
++;
3397 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3398 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3405 d
->rela
.idx
= section_number
++;
3406 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3407 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3413 elf_shstrtab_sec (abfd
) = section_number
++;
3414 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3415 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3417 need_symtab
= (bfd_get_symcount (abfd
) > 0
3418 || (link_info
== NULL
3419 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3423 elf_onesymtab (abfd
) = section_number
++;
3424 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3425 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3427 elf_section_list
* entry
;
3429 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3431 entry
= bfd_zalloc (abfd
, sizeof * entry
);
3432 entry
->ndx
= section_number
++;
3433 elf_symtab_shndx_list (abfd
) = entry
;
3435 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3436 ".symtab_shndx", FALSE
);
3437 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3440 elf_strtab_sec (abfd
) = section_number
++;
3441 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3444 if (section_number
>= SHN_LORESERVE
)
3446 _bfd_error_handler (_("%B: too many sections: %u"),
3447 abfd
, section_number
);
3451 elf_numsections (abfd
) = section_number
;
3452 elf_elfheader (abfd
)->e_shnum
= section_number
;
3454 /* Set up the list of section header pointers, in agreement with the
3456 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3457 sizeof (Elf_Internal_Shdr
*));
3458 if (i_shdrp
== NULL
)
3461 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3462 sizeof (Elf_Internal_Shdr
));
3463 if (i_shdrp
[0] == NULL
)
3465 bfd_release (abfd
, i_shdrp
);
3469 elf_elfsections (abfd
) = i_shdrp
;
3471 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3474 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3475 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3477 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3478 BFD_ASSERT (entry
!= NULL
);
3479 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3480 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3482 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3483 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3486 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3490 d
= elf_section_data (sec
);
3492 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3493 if (d
->rel
.idx
!= 0)
3494 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3495 if (d
->rela
.idx
!= 0)
3496 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3498 /* Fill in the sh_link and sh_info fields while we're at it. */
3500 /* sh_link of a reloc section is the section index of the symbol
3501 table. sh_info is the section index of the section to which
3502 the relocation entries apply. */
3503 if (d
->rel
.idx
!= 0)
3505 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3506 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3507 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3509 if (d
->rela
.idx
!= 0)
3511 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3512 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3513 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3516 /* We need to set up sh_link for SHF_LINK_ORDER. */
3517 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3519 s
= elf_linked_to_section (sec
);
3522 /* elf_linked_to_section points to the input section. */
3523 if (link_info
!= NULL
)
3525 /* Check discarded linkonce section. */
3526 if (discarded_section (s
))
3529 (*_bfd_error_handler
)
3530 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3531 abfd
, d
->this_hdr
.bfd_section
,
3533 /* Point to the kept section if it has the same
3534 size as the discarded one. */
3535 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3538 bfd_set_error (bfd_error_bad_value
);
3544 s
= s
->output_section
;
3545 BFD_ASSERT (s
!= NULL
);
3549 /* Handle objcopy. */
3550 if (s
->output_section
== NULL
)
3552 (*_bfd_error_handler
)
3553 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3554 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3555 bfd_set_error (bfd_error_bad_value
);
3558 s
= s
->output_section
;
3560 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3565 The Intel C compiler generates SHT_IA_64_UNWIND with
3566 SHF_LINK_ORDER. But it doesn't set the sh_link or
3567 sh_info fields. Hence we could get the situation
3569 const struct elf_backend_data
*bed
3570 = get_elf_backend_data (abfd
);
3571 if (bed
->link_order_error_handler
)
3572 bed
->link_order_error_handler
3573 (_("%B: warning: sh_link not set for section `%A'"),
3578 switch (d
->this_hdr
.sh_type
)
3582 /* A reloc section which we are treating as a normal BFD
3583 section. sh_link is the section index of the symbol
3584 table. sh_info is the section index of the section to
3585 which the relocation entries apply. We assume that an
3586 allocated reloc section uses the dynamic symbol table.
3587 FIXME: How can we be sure? */
3588 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3590 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3592 s
= get_elf_backend_data (abfd
)->get_reloc_section (sec
);
3595 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3596 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3601 /* We assume that a section named .stab*str is a stabs
3602 string section. We look for a section with the same name
3603 but without the trailing ``str'', and set its sh_link
3604 field to point to this section. */
3605 if (CONST_STRNEQ (sec
->name
, ".stab")
3606 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3611 len
= strlen (sec
->name
);
3612 alc
= (char *) bfd_malloc (len
- 2);
3615 memcpy (alc
, sec
->name
, len
- 3);
3616 alc
[len
- 3] = '\0';
3617 s
= bfd_get_section_by_name (abfd
, alc
);
3621 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3623 /* This is a .stab section. */
3624 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3625 elf_section_data (s
)->this_hdr
.sh_entsize
3626 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3633 case SHT_GNU_verneed
:
3634 case SHT_GNU_verdef
:
3635 /* sh_link is the section header index of the string table
3636 used for the dynamic entries, or the symbol table, or the
3638 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3640 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3643 case SHT_GNU_LIBLIST
:
3644 /* sh_link is the section header index of the prelink library
3645 list used for the dynamic entries, or the symbol table, or
3646 the version strings. */
3647 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3648 ? ".dynstr" : ".gnu.libstr");
3650 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3655 case SHT_GNU_versym
:
3656 /* sh_link is the section header index of the symbol table
3657 this hash table or version table is for. */
3658 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3660 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3664 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3668 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3669 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3670 debug section name from .debug_* to .zdebug_* if needed. */
3676 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3678 /* If the backend has a special mapping, use it. */
3679 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3680 if (bed
->elf_backend_sym_is_global
)
3681 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3683 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3684 || bfd_is_und_section (bfd_get_section (sym
))
3685 || bfd_is_com_section (bfd_get_section (sym
)));
3688 /* Don't output section symbols for sections that are not going to be
3689 output, that are duplicates or there is no BFD section. */
3692 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3694 elf_symbol_type
*type_ptr
;
3696 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3699 type_ptr
= elf_symbol_from (abfd
, sym
);
3700 return ((type_ptr
!= NULL
3701 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
3702 && bfd_is_abs_section (sym
->section
))
3703 || !(sym
->section
->owner
== abfd
3704 || (sym
->section
->output_section
->owner
== abfd
3705 && sym
->section
->output_offset
== 0)
3706 || bfd_is_abs_section (sym
->section
)));
3709 /* Map symbol from it's internal number to the external number, moving
3710 all local symbols to be at the head of the list. */
3713 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
3715 unsigned int symcount
= bfd_get_symcount (abfd
);
3716 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3717 asymbol
**sect_syms
;
3718 unsigned int num_locals
= 0;
3719 unsigned int num_globals
= 0;
3720 unsigned int num_locals2
= 0;
3721 unsigned int num_globals2
= 0;
3722 unsigned int max_index
= 0;
3728 fprintf (stderr
, "elf_map_symbols\n");
3732 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3734 if (max_index
< asect
->index
)
3735 max_index
= asect
->index
;
3739 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3740 if (sect_syms
== NULL
)
3742 elf_section_syms (abfd
) = sect_syms
;
3743 elf_num_section_syms (abfd
) = max_index
;
3745 /* Init sect_syms entries for any section symbols we have already
3746 decided to output. */
3747 for (idx
= 0; idx
< symcount
; idx
++)
3749 asymbol
*sym
= syms
[idx
];
3751 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3753 && !ignore_section_sym (abfd
, sym
)
3754 && !bfd_is_abs_section (sym
->section
))
3756 asection
*sec
= sym
->section
;
3758 if (sec
->owner
!= abfd
)
3759 sec
= sec
->output_section
;
3761 sect_syms
[sec
->index
] = syms
[idx
];
3765 /* Classify all of the symbols. */
3766 for (idx
= 0; idx
< symcount
; idx
++)
3768 if (sym_is_global (abfd
, syms
[idx
]))
3770 else if (!ignore_section_sym (abfd
, syms
[idx
]))
3774 /* We will be adding a section symbol for each normal BFD section. Most
3775 sections will already have a section symbol in outsymbols, but
3776 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3777 at least in that case. */
3778 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3780 if (sect_syms
[asect
->index
] == NULL
)
3782 if (!sym_is_global (abfd
, asect
->symbol
))
3789 /* Now sort the symbols so the local symbols are first. */
3790 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
3791 sizeof (asymbol
*));
3793 if (new_syms
== NULL
)
3796 for (idx
= 0; idx
< symcount
; idx
++)
3798 asymbol
*sym
= syms
[idx
];
3801 if (sym_is_global (abfd
, sym
))
3802 i
= num_locals
+ num_globals2
++;
3803 else if (!ignore_section_sym (abfd
, sym
))
3808 sym
->udata
.i
= i
+ 1;
3810 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3812 if (sect_syms
[asect
->index
] == NULL
)
3814 asymbol
*sym
= asect
->symbol
;
3817 sect_syms
[asect
->index
] = sym
;
3818 if (!sym_is_global (abfd
, sym
))
3821 i
= num_locals
+ num_globals2
++;
3823 sym
->udata
.i
= i
+ 1;
3827 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3829 *pnum_locals
= num_locals
;
3833 /* Align to the maximum file alignment that could be required for any
3834 ELF data structure. */
3836 static inline file_ptr
3837 align_file_position (file_ptr off
, int align
)
3839 return (off
+ align
- 1) & ~(align
- 1);
3842 /* Assign a file position to a section, optionally aligning to the
3843 required section alignment. */
3846 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3850 if (align
&& i_shdrp
->sh_addralign
> 1)
3851 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3852 i_shdrp
->sh_offset
= offset
;
3853 if (i_shdrp
->bfd_section
!= NULL
)
3854 i_shdrp
->bfd_section
->filepos
= offset
;
3855 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3856 offset
+= i_shdrp
->sh_size
;
3860 /* Compute the file positions we are going to put the sections at, and
3861 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3862 is not NULL, this is being called by the ELF backend linker. */
3865 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3866 struct bfd_link_info
*link_info
)
3868 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3869 struct fake_section_arg fsargs
;
3871 struct elf_strtab_hash
*strtab
= NULL
;
3872 Elf_Internal_Shdr
*shstrtab_hdr
;
3873 bfd_boolean need_symtab
;
3875 if (abfd
->output_has_begun
)
3878 /* Do any elf backend specific processing first. */
3879 if (bed
->elf_backend_begin_write_processing
)
3880 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3882 if (! prep_headers (abfd
))
3885 /* Post process the headers if necessary. */
3886 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3888 fsargs
.failed
= FALSE
;
3889 fsargs
.link_info
= link_info
;
3890 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
3894 if (!assign_section_numbers (abfd
, link_info
))
3897 /* The backend linker builds symbol table information itself. */
3898 need_symtab
= (link_info
== NULL
3899 && (bfd_get_symcount (abfd
) > 0
3900 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3904 /* Non-zero if doing a relocatable link. */
3905 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3907 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3912 if (link_info
== NULL
)
3914 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3919 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3920 /* sh_name was set in prep_headers. */
3921 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3922 shstrtab_hdr
->sh_flags
= 0;
3923 shstrtab_hdr
->sh_addr
= 0;
3924 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
3925 shstrtab_hdr
->sh_entsize
= 0;
3926 shstrtab_hdr
->sh_link
= 0;
3927 shstrtab_hdr
->sh_info
= 0;
3928 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
3929 shstrtab_hdr
->sh_addralign
= 1;
3931 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3937 Elf_Internal_Shdr
*hdr
;
3939 off
= elf_next_file_pos (abfd
);
3941 hdr
= & elf_symtab_hdr (abfd
);
3942 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3944 if (elf_symtab_shndx_list (abfd
) != NULL
)
3946 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
3947 if (hdr
->sh_size
!= 0)
3948 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3949 /* FIXME: What about other symtab_shndx sections in the list ? */
3952 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3953 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3955 elf_next_file_pos (abfd
) = off
;
3957 /* Now that we know where the .strtab section goes, write it
3959 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3960 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
3962 _bfd_elf_strtab_free (strtab
);
3965 abfd
->output_has_begun
= TRUE
;
3970 /* Make an initial estimate of the size of the program header. If we
3971 get the number wrong here, we'll redo section placement. */
3973 static bfd_size_type
3974 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3978 const struct elf_backend_data
*bed
;
3980 /* Assume we will need exactly two PT_LOAD segments: one for text
3981 and one for data. */
3984 s
= bfd_get_section_by_name (abfd
, ".interp");
3985 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3987 /* If we have a loadable interpreter section, we need a
3988 PT_INTERP segment. In this case, assume we also need a
3989 PT_PHDR segment, although that may not be true for all
3994 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3996 /* We need a PT_DYNAMIC segment. */
4000 if (info
!= NULL
&& info
->relro
)
4002 /* We need a PT_GNU_RELRO segment. */
4006 if (elf_eh_frame_hdr (abfd
))
4008 /* We need a PT_GNU_EH_FRAME segment. */
4012 if (elf_stack_flags (abfd
))
4014 /* We need a PT_GNU_STACK segment. */
4018 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4020 if ((s
->flags
& SEC_LOAD
) != 0
4021 && CONST_STRNEQ (s
->name
, ".note"))
4023 /* We need a PT_NOTE segment. */
4025 /* Try to create just one PT_NOTE segment
4026 for all adjacent loadable .note* sections.
4027 gABI requires that within a PT_NOTE segment
4028 (and also inside of each SHT_NOTE section)
4029 each note is padded to a multiple of 4 size,
4030 so we check whether the sections are correctly
4032 if (s
->alignment_power
== 2)
4033 while (s
->next
!= NULL
4034 && s
->next
->alignment_power
== 2
4035 && (s
->next
->flags
& SEC_LOAD
) != 0
4036 && CONST_STRNEQ (s
->next
->name
, ".note"))
4041 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4043 if (s
->flags
& SEC_THREAD_LOCAL
)
4045 /* We need a PT_TLS segment. */
4051 /* Let the backend count up any program headers it might need. */
4052 bed
= get_elf_backend_data (abfd
);
4053 if (bed
->elf_backend_additional_program_headers
)
4057 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4063 return segs
* bed
->s
->sizeof_phdr
;
4066 /* Find the segment that contains the output_section of section. */
4069 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4071 struct elf_segment_map
*m
;
4072 Elf_Internal_Phdr
*p
;
4074 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4080 for (i
= m
->count
- 1; i
>= 0; i
--)
4081 if (m
->sections
[i
] == section
)
4088 /* Create a mapping from a set of sections to a program segment. */
4090 static struct elf_segment_map
*
4091 make_mapping (bfd
*abfd
,
4092 asection
**sections
,
4097 struct elf_segment_map
*m
;
4102 amt
= sizeof (struct elf_segment_map
);
4103 amt
+= (to
- from
- 1) * sizeof (asection
*);
4104 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4108 m
->p_type
= PT_LOAD
;
4109 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4110 m
->sections
[i
- from
] = *hdrpp
;
4111 m
->count
= to
- from
;
4113 if (from
== 0 && phdr
)
4115 /* Include the headers in the first PT_LOAD segment. */
4116 m
->includes_filehdr
= 1;
4117 m
->includes_phdrs
= 1;
4123 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4126 struct elf_segment_map
*
4127 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4129 struct elf_segment_map
*m
;
4131 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4132 sizeof (struct elf_segment_map
));
4136 m
->p_type
= PT_DYNAMIC
;
4138 m
->sections
[0] = dynsec
;
4143 /* Possibly add or remove segments from the segment map. */
4146 elf_modify_segment_map (bfd
*abfd
,
4147 struct bfd_link_info
*info
,
4148 bfd_boolean remove_empty_load
)
4150 struct elf_segment_map
**m
;
4151 const struct elf_backend_data
*bed
;
4153 /* The placement algorithm assumes that non allocated sections are
4154 not in PT_LOAD segments. We ensure this here by removing such
4155 sections from the segment map. We also remove excluded
4156 sections. Finally, any PT_LOAD segment without sections is
4158 m
= &elf_seg_map (abfd
);
4161 unsigned int i
, new_count
;
4163 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4165 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4166 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4167 || (*m
)->p_type
!= PT_LOAD
))
4169 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4173 (*m
)->count
= new_count
;
4175 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
4181 bed
= get_elf_backend_data (abfd
);
4182 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4184 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4191 /* Set up a mapping from BFD sections to program segments. */
4194 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4197 struct elf_segment_map
*m
;
4198 asection
**sections
= NULL
;
4199 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4200 bfd_boolean no_user_phdrs
;
4202 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4205 info
->user_phdrs
= !no_user_phdrs
;
4207 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4211 struct elf_segment_map
*mfirst
;
4212 struct elf_segment_map
**pm
;
4215 unsigned int phdr_index
;
4216 bfd_vma maxpagesize
;
4218 bfd_boolean phdr_in_segment
= TRUE
;
4219 bfd_boolean writable
;
4221 asection
*first_tls
= NULL
;
4222 asection
*dynsec
, *eh_frame_hdr
;
4224 bfd_vma addr_mask
, wrap_to
= 0;
4226 /* Select the allocated sections, and sort them. */
4228 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4229 sizeof (asection
*));
4230 if (sections
== NULL
)
4233 /* Calculate top address, avoiding undefined behaviour of shift
4234 left operator when shift count is equal to size of type
4236 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4237 addr_mask
= (addr_mask
<< 1) + 1;
4240 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4242 if ((s
->flags
& SEC_ALLOC
) != 0)
4246 /* A wrapping section potentially clashes with header. */
4247 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4248 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4251 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4254 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4256 /* Build the mapping. */
4261 /* If we have a .interp section, then create a PT_PHDR segment for
4262 the program headers and a PT_INTERP segment for the .interp
4264 s
= bfd_get_section_by_name (abfd
, ".interp");
4265 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4267 amt
= sizeof (struct elf_segment_map
);
4268 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4272 m
->p_type
= PT_PHDR
;
4273 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
4274 m
->p_flags
= PF_R
| PF_X
;
4275 m
->p_flags_valid
= 1;
4276 m
->includes_phdrs
= 1;
4281 amt
= sizeof (struct elf_segment_map
);
4282 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4286 m
->p_type
= PT_INTERP
;
4294 /* Look through the sections. We put sections in the same program
4295 segment when the start of the second section can be placed within
4296 a few bytes of the end of the first section. */
4300 maxpagesize
= bed
->maxpagesize
;
4301 /* PR 17512: file: c8455299.
4302 Avoid divide-by-zero errors later on.
4303 FIXME: Should we abort if the maxpagesize is zero ? */
4304 if (maxpagesize
== 0)
4307 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4309 && (dynsec
->flags
& SEC_LOAD
) == 0)
4312 /* Deal with -Ttext or something similar such that the first section
4313 is not adjacent to the program headers. This is an
4314 approximation, since at this point we don't know exactly how many
4315 program headers we will need. */
4318 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
4320 if (phdr_size
== (bfd_size_type
) -1)
4321 phdr_size
= get_program_header_size (abfd
, info
);
4322 phdr_size
+= bed
->s
->sizeof_ehdr
;
4323 if ((abfd
->flags
& D_PAGED
) == 0
4324 || (sections
[0]->lma
& addr_mask
) < phdr_size
4325 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
4326 < phdr_size
% maxpagesize
)
4327 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
4328 phdr_in_segment
= FALSE
;
4331 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4334 bfd_boolean new_segment
;
4338 /* See if this section and the last one will fit in the same
4341 if (last_hdr
== NULL
)
4343 /* If we don't have a segment yet, then we don't need a new
4344 one (we build the last one after this loop). */
4345 new_segment
= FALSE
;
4347 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4349 /* If this section has a different relation between the
4350 virtual address and the load address, then we need a new
4354 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4355 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4357 /* If this section has a load address that makes it overlap
4358 the previous section, then we need a new segment. */
4361 /* In the next test we have to be careful when last_hdr->lma is close
4362 to the end of the address space. If the aligned address wraps
4363 around to the start of the address space, then there are no more
4364 pages left in memory and it is OK to assume that the current
4365 section can be included in the current segment. */
4366 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4368 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
4371 /* If putting this section in this segment would force us to
4372 skip a page in the segment, then we need a new segment. */
4375 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4376 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0
4377 && ((abfd
->flags
& D_PAGED
) == 0
4378 || (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4379 != (hdr
->lma
& -maxpagesize
))))
4381 /* We don't want to put a loaded section after a
4382 nonloaded (ie. bss style) section in the same segment
4383 as that will force the non-loaded section to be loaded.
4384 Consider .tbss sections as loaded for this purpose.
4385 However, like the writable/non-writable case below,
4386 if they are on the same page then they must be put
4387 in the same segment. */
4390 else if ((abfd
->flags
& D_PAGED
) == 0)
4392 /* If the file is not demand paged, which means that we
4393 don't require the sections to be correctly aligned in the
4394 file, then there is no other reason for a new segment. */
4395 new_segment
= FALSE
;
4398 && (hdr
->flags
& SEC_READONLY
) == 0
4399 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4400 != (hdr
->lma
& -maxpagesize
)))
4402 /* We don't want to put a writable section in a read only
4403 segment, unless they are on the same page in memory
4404 anyhow. We already know that the last section does not
4405 bring us past the current section on the page, so the
4406 only case in which the new section is not on the same
4407 page as the previous section is when the previous section
4408 ends precisely on a page boundary. */
4413 /* Otherwise, we can use the same segment. */
4414 new_segment
= FALSE
;
4417 /* Allow interested parties a chance to override our decision. */
4418 if (last_hdr
!= NULL
4420 && info
->callbacks
->override_segment_assignment
!= NULL
)
4422 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4428 if ((hdr
->flags
& SEC_READONLY
) == 0)
4431 /* .tbss sections effectively have zero size. */
4432 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4433 != SEC_THREAD_LOCAL
)
4434 last_size
= hdr
->size
;
4440 /* We need a new program segment. We must create a new program
4441 header holding all the sections from phdr_index until hdr. */
4443 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4450 if ((hdr
->flags
& SEC_READONLY
) == 0)
4456 /* .tbss sections effectively have zero size. */
4457 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4458 last_size
= hdr
->size
;
4462 phdr_in_segment
= FALSE
;
4465 /* Create a final PT_LOAD program segment, but not if it's just
4467 if (last_hdr
!= NULL
4468 && (i
- phdr_index
!= 1
4469 || ((last_hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4470 != SEC_THREAD_LOCAL
)))
4472 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4480 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4483 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4490 /* For each batch of consecutive loadable .note sections,
4491 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4492 because if we link together nonloadable .note sections and
4493 loadable .note sections, we will generate two .note sections
4494 in the output file. FIXME: Using names for section types is
4496 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4498 if ((s
->flags
& SEC_LOAD
) != 0
4499 && CONST_STRNEQ (s
->name
, ".note"))
4504 amt
= sizeof (struct elf_segment_map
);
4505 if (s
->alignment_power
== 2)
4506 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4508 if (s2
->next
->alignment_power
== 2
4509 && (s2
->next
->flags
& SEC_LOAD
) != 0
4510 && CONST_STRNEQ (s2
->next
->name
, ".note")
4511 && align_power (s2
->lma
+ s2
->size
, 2)
4517 amt
+= (count
- 1) * sizeof (asection
*);
4518 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4522 m
->p_type
= PT_NOTE
;
4526 m
->sections
[m
->count
- count
--] = s
;
4527 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4530 m
->sections
[m
->count
- 1] = s
;
4531 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4535 if (s
->flags
& SEC_THREAD_LOCAL
)
4543 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4546 amt
= sizeof (struct elf_segment_map
);
4547 amt
+= (tls_count
- 1) * sizeof (asection
*);
4548 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4553 m
->count
= tls_count
;
4554 /* Mandated PF_R. */
4556 m
->p_flags_valid
= 1;
4558 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4560 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
4563 (_("%B: TLS sections are not adjacent:"), abfd
);
4566 while (i
< (unsigned int) tls_count
)
4568 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
4570 _bfd_error_handler (_(" TLS: %A"), s
);
4574 _bfd_error_handler (_(" non-TLS: %A"), s
);
4577 bfd_set_error (bfd_error_bad_value
);
4588 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4590 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
4591 if (eh_frame_hdr
!= NULL
4592 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4594 amt
= sizeof (struct elf_segment_map
);
4595 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4599 m
->p_type
= PT_GNU_EH_FRAME
;
4601 m
->sections
[0] = eh_frame_hdr
->output_section
;
4607 if (elf_stack_flags (abfd
))
4609 amt
= sizeof (struct elf_segment_map
);
4610 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4614 m
->p_type
= PT_GNU_STACK
;
4615 m
->p_flags
= elf_stack_flags (abfd
);
4616 m
->p_align
= bed
->stack_align
;
4617 m
->p_flags_valid
= 1;
4618 m
->p_align_valid
= m
->p_align
!= 0;
4619 if (info
->stacksize
> 0)
4621 m
->p_size
= info
->stacksize
;
4622 m
->p_size_valid
= 1;
4629 if (info
!= NULL
&& info
->relro
)
4631 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
4633 if (m
->p_type
== PT_LOAD
4635 && m
->sections
[0]->vma
>= info
->relro_start
4636 && m
->sections
[0]->vma
< info
->relro_end
)
4639 while (--i
!= (unsigned) -1)
4640 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
4641 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
4644 if (i
!= (unsigned) -1)
4649 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4652 amt
= sizeof (struct elf_segment_map
);
4653 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4657 m
->p_type
= PT_GNU_RELRO
;
4664 elf_seg_map (abfd
) = mfirst
;
4667 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4670 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4672 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
4677 if (sections
!= NULL
)
4682 /* Sort sections by address. */
4685 elf_sort_sections (const void *arg1
, const void *arg2
)
4687 const asection
*sec1
= *(const asection
**) arg1
;
4688 const asection
*sec2
= *(const asection
**) arg2
;
4689 bfd_size_type size1
, size2
;
4691 /* Sort by LMA first, since this is the address used to
4692 place the section into a segment. */
4693 if (sec1
->lma
< sec2
->lma
)
4695 else if (sec1
->lma
> sec2
->lma
)
4698 /* Then sort by VMA. Normally the LMA and the VMA will be
4699 the same, and this will do nothing. */
4700 if (sec1
->vma
< sec2
->vma
)
4702 else if (sec1
->vma
> sec2
->vma
)
4705 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4707 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4713 /* If the indicies are the same, do not return 0
4714 here, but continue to try the next comparison. */
4715 if (sec1
->target_index
- sec2
->target_index
!= 0)
4716 return sec1
->target_index
- sec2
->target_index
;
4721 else if (TOEND (sec2
))
4726 /* Sort by size, to put zero sized sections
4727 before others at the same address. */
4729 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4730 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4737 return sec1
->target_index
- sec2
->target_index
;
4740 /* Ian Lance Taylor writes:
4742 We shouldn't be using % with a negative signed number. That's just
4743 not good. We have to make sure either that the number is not
4744 negative, or that the number has an unsigned type. When the types
4745 are all the same size they wind up as unsigned. When file_ptr is a
4746 larger signed type, the arithmetic winds up as signed long long,
4749 What we're trying to say here is something like ``increase OFF by
4750 the least amount that will cause it to be equal to the VMA modulo
4752 /* In other words, something like:
4754 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4755 off_offset = off % bed->maxpagesize;
4756 if (vma_offset < off_offset)
4757 adjustment = vma_offset + bed->maxpagesize - off_offset;
4759 adjustment = vma_offset - off_offset;
4761 which can can be collapsed into the expression below. */
4764 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4766 /* PR binutils/16199: Handle an alignment of zero. */
4767 if (maxpagesize
== 0)
4769 return ((vma
- off
) % maxpagesize
);
4773 print_segment_map (const struct elf_segment_map
*m
)
4776 const char *pt
= get_segment_type (m
->p_type
);
4781 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4782 sprintf (buf
, "LOPROC+%7.7x",
4783 (unsigned int) (m
->p_type
- PT_LOPROC
));
4784 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4785 sprintf (buf
, "LOOS+%7.7x",
4786 (unsigned int) (m
->p_type
- PT_LOOS
));
4788 snprintf (buf
, sizeof (buf
), "%8.8x",
4789 (unsigned int) m
->p_type
);
4793 fprintf (stderr
, "%s:", pt
);
4794 for (j
= 0; j
< m
->count
; j
++)
4795 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4801 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
4806 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4808 buf
= bfd_zmalloc (len
);
4811 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
4816 /* Assign file positions to the sections based on the mapping from
4817 sections to segments. This function also sets up some fields in
4821 assign_file_positions_for_load_sections (bfd
*abfd
,
4822 struct bfd_link_info
*link_info
)
4824 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4825 struct elf_segment_map
*m
;
4826 Elf_Internal_Phdr
*phdrs
;
4827 Elf_Internal_Phdr
*p
;
4829 bfd_size_type maxpagesize
;
4832 bfd_vma header_pad
= 0;
4834 if (link_info
== NULL
4835 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
4839 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
4843 header_pad
= m
->header_size
;
4848 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4849 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4853 /* PR binutils/12467. */
4854 elf_elfheader (abfd
)->e_phoff
= 0;
4855 elf_elfheader (abfd
)->e_phentsize
= 0;
4858 elf_elfheader (abfd
)->e_phnum
= alloc
;
4860 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
4861 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
4863 BFD_ASSERT (elf_program_header_size (abfd
)
4864 >= alloc
* bed
->s
->sizeof_phdr
);
4868 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
4872 /* We're writing the size in elf_program_header_size (abfd),
4873 see assign_file_positions_except_relocs, so make sure we have
4874 that amount allocated, with trailing space cleared.
4875 The variable alloc contains the computed need, while
4876 elf_program_header_size (abfd) contains the size used for the
4878 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4879 where the layout is forced to according to a larger size in the
4880 last iterations for the testcase ld-elf/header. */
4881 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
4883 phdrs
= (Elf_Internal_Phdr
*)
4885 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
4886 sizeof (Elf_Internal_Phdr
));
4887 elf_tdata (abfd
)->phdr
= phdrs
;
4892 if ((abfd
->flags
& D_PAGED
) != 0)
4893 maxpagesize
= bed
->maxpagesize
;
4895 off
= bed
->s
->sizeof_ehdr
;
4896 off
+= alloc
* bed
->s
->sizeof_phdr
;
4897 if (header_pad
< (bfd_vma
) off
)
4903 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
4905 m
= m
->next
, p
++, j
++)
4909 bfd_boolean no_contents
;
4911 /* If elf_segment_map is not from map_sections_to_segments, the
4912 sections may not be correctly ordered. NOTE: sorting should
4913 not be done to the PT_NOTE section of a corefile, which may
4914 contain several pseudo-sections artificially created by bfd.
4915 Sorting these pseudo-sections breaks things badly. */
4917 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4918 && m
->p_type
== PT_NOTE
))
4919 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4922 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4923 number of sections with contents contributing to both p_filesz
4924 and p_memsz, followed by a number of sections with no contents
4925 that just contribute to p_memsz. In this loop, OFF tracks next
4926 available file offset for PT_LOAD and PT_NOTE segments. */
4927 p
->p_type
= m
->p_type
;
4928 p
->p_flags
= m
->p_flags
;
4933 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4935 if (m
->p_paddr_valid
)
4936 p
->p_paddr
= m
->p_paddr
;
4937 else if (m
->count
== 0)
4940 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4942 if (p
->p_type
== PT_LOAD
4943 && (abfd
->flags
& D_PAGED
) != 0)
4945 /* p_align in demand paged PT_LOAD segments effectively stores
4946 the maximum page size. When copying an executable with
4947 objcopy, we set m->p_align from the input file. Use this
4948 value for maxpagesize rather than bed->maxpagesize, which
4949 may be different. Note that we use maxpagesize for PT_TLS
4950 segment alignment later in this function, so we are relying
4951 on at least one PT_LOAD segment appearing before a PT_TLS
4953 if (m
->p_align_valid
)
4954 maxpagesize
= m
->p_align
;
4956 p
->p_align
= maxpagesize
;
4958 else if (m
->p_align_valid
)
4959 p
->p_align
= m
->p_align
;
4960 else if (m
->count
== 0)
4961 p
->p_align
= 1 << bed
->s
->log_file_align
;
4965 no_contents
= FALSE
;
4967 if (p
->p_type
== PT_LOAD
4970 bfd_size_type align
;
4971 unsigned int align_power
= 0;
4973 if (m
->p_align_valid
)
4977 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4979 unsigned int secalign
;
4981 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4982 if (secalign
> align_power
)
4983 align_power
= secalign
;
4985 align
= (bfd_size_type
) 1 << align_power
;
4986 if (align
< maxpagesize
)
4987 align
= maxpagesize
;
4990 for (i
= 0; i
< m
->count
; i
++)
4991 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4992 /* If we aren't making room for this section, then
4993 it must be SHT_NOBITS regardless of what we've
4994 set via struct bfd_elf_special_section. */
4995 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4997 /* Find out whether this segment contains any loadable
5000 for (i
= 0; i
< m
->count
; i
++)
5001 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5003 no_contents
= FALSE
;
5007 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5011 /* We shouldn't need to align the segment on disk since
5012 the segment doesn't need file space, but the gABI
5013 arguably requires the alignment and glibc ld.so
5014 checks it. So to comply with the alignment
5015 requirement but not waste file space, we adjust
5016 p_offset for just this segment. (OFF_ADJUST is
5017 subtracted from OFF later.) This may put p_offset
5018 past the end of file, but that shouldn't matter. */
5023 /* Make sure the .dynamic section is the first section in the
5024 PT_DYNAMIC segment. */
5025 else if (p
->p_type
== PT_DYNAMIC
5027 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5030 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
5032 bfd_set_error (bfd_error_bad_value
);
5035 /* Set the note section type to SHT_NOTE. */
5036 else if (p
->p_type
== PT_NOTE
)
5037 for (i
= 0; i
< m
->count
; i
++)
5038 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5044 if (m
->includes_filehdr
)
5046 if (!m
->p_flags_valid
)
5048 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5049 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5052 if (p
->p_vaddr
< (bfd_vma
) off
)
5054 (*_bfd_error_handler
)
5055 (_("%B: Not enough room for program headers, try linking with -N"),
5057 bfd_set_error (bfd_error_bad_value
);
5062 if (!m
->p_paddr_valid
)
5067 if (m
->includes_phdrs
)
5069 if (!m
->p_flags_valid
)
5072 if (!m
->includes_filehdr
)
5074 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5078 p
->p_vaddr
-= off
- p
->p_offset
;
5079 if (!m
->p_paddr_valid
)
5080 p
->p_paddr
-= off
- p
->p_offset
;
5084 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
5085 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
5088 p
->p_filesz
+= header_pad
;
5089 p
->p_memsz
+= header_pad
;
5093 if (p
->p_type
== PT_LOAD
5094 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5096 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5102 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5104 p
->p_filesz
+= adjust
;
5105 p
->p_memsz
+= adjust
;
5109 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5110 maps. Set filepos for sections in PT_LOAD segments, and in
5111 core files, for sections in PT_NOTE segments.
5112 assign_file_positions_for_non_load_sections will set filepos
5113 for other sections and update p_filesz for other segments. */
5114 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5117 bfd_size_type align
;
5118 Elf_Internal_Shdr
*this_hdr
;
5121 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5122 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
5124 if ((p
->p_type
== PT_LOAD
5125 || p
->p_type
== PT_TLS
)
5126 && (this_hdr
->sh_type
!= SHT_NOBITS
5127 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5128 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5129 || p
->p_type
== PT_TLS
))))
5131 bfd_vma p_start
= p
->p_paddr
;
5132 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5133 bfd_vma s_start
= sec
->lma
;
5134 bfd_vma adjust
= s_start
- p_end
;
5138 || p_end
< p_start
))
5140 (*_bfd_error_handler
)
5141 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
5142 (unsigned long) s_start
, (unsigned long) p_end
);
5146 p
->p_memsz
+= adjust
;
5148 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5150 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5152 /* We have a PROGBITS section following NOBITS ones.
5153 Allocate file space for the NOBITS section(s) and
5155 adjust
= p
->p_memsz
- p
->p_filesz
;
5156 if (!write_zeros (abfd
, off
, adjust
))
5160 p
->p_filesz
+= adjust
;
5164 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5166 /* The section at i == 0 is the one that actually contains
5170 this_hdr
->sh_offset
= sec
->filepos
= off
;
5171 off
+= this_hdr
->sh_size
;
5172 p
->p_filesz
= this_hdr
->sh_size
;
5178 /* The rest are fake sections that shouldn't be written. */
5187 if (p
->p_type
== PT_LOAD
)
5189 this_hdr
->sh_offset
= sec
->filepos
= off
;
5190 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5191 off
+= this_hdr
->sh_size
;
5193 else if (this_hdr
->sh_type
== SHT_NOBITS
5194 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5195 && this_hdr
->sh_offset
== 0)
5197 /* This is a .tbss section that didn't get a PT_LOAD.
5198 (See _bfd_elf_map_sections_to_segments "Create a
5199 final PT_LOAD".) Set sh_offset to the value it
5200 would have if we had created a zero p_filesz and
5201 p_memsz PT_LOAD header for the section. This
5202 also makes the PT_TLS header have the same
5204 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5206 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5209 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5211 p
->p_filesz
+= this_hdr
->sh_size
;
5212 /* A load section without SHF_ALLOC is something like
5213 a note section in a PT_NOTE segment. These take
5214 file space but are not loaded into memory. */
5215 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5216 p
->p_memsz
+= this_hdr
->sh_size
;
5218 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5220 if (p
->p_type
== PT_TLS
)
5221 p
->p_memsz
+= this_hdr
->sh_size
;
5223 /* .tbss is special. It doesn't contribute to p_memsz of
5225 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5226 p
->p_memsz
+= this_hdr
->sh_size
;
5229 if (align
> p
->p_align
5230 && !m
->p_align_valid
5231 && (p
->p_type
!= PT_LOAD
5232 || (abfd
->flags
& D_PAGED
) == 0))
5236 if (!m
->p_flags_valid
)
5239 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5241 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5248 /* Check that all sections are in a PT_LOAD segment.
5249 Don't check funky gdb generated core files. */
5250 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5252 bfd_boolean check_vma
= TRUE
;
5254 for (i
= 1; i
< m
->count
; i
++)
5255 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5256 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5257 ->this_hdr
), p
) != 0
5258 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5259 ->this_hdr
), p
) != 0)
5261 /* Looks like we have overlays packed into the segment. */
5266 for (i
= 0; i
< m
->count
; i
++)
5268 Elf_Internal_Shdr
*this_hdr
;
5271 sec
= m
->sections
[i
];
5272 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5273 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5274 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5276 (*_bfd_error_handler
)
5277 (_("%B: section `%A' can't be allocated in segment %d"),
5279 print_segment_map (m
);
5285 elf_next_file_pos (abfd
) = off
;
5289 /* Assign file positions for the other sections. */
5292 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5293 struct bfd_link_info
*link_info
)
5295 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5296 Elf_Internal_Shdr
**i_shdrpp
;
5297 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
5298 Elf_Internal_Phdr
*phdrs
;
5299 Elf_Internal_Phdr
*p
;
5300 struct elf_segment_map
*m
;
5301 struct elf_segment_map
*hdrs_segment
;
5302 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5303 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5307 i_shdrpp
= elf_elfsections (abfd
);
5308 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
5309 off
= elf_next_file_pos (abfd
);
5310 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
5312 Elf_Internal_Shdr
*hdr
;
5315 if (hdr
->bfd_section
!= NULL
5316 && (hdr
->bfd_section
->filepos
!= 0
5317 || (hdr
->sh_type
== SHT_NOBITS
5318 && hdr
->contents
== NULL
)))
5319 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5320 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5322 if (hdr
->sh_size
!= 0)
5323 (*_bfd_error_handler
)
5324 (_("%B: warning: allocated section `%s' not in segment"),
5326 (hdr
->bfd_section
== NULL
5328 : hdr
->bfd_section
->name
));
5329 /* We don't need to page align empty sections. */
5330 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5331 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5334 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5336 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5339 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5340 && hdr
->bfd_section
== NULL
)
5341 || (hdr
->bfd_section
!= NULL
5342 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5343 /* Compress DWARF debug sections. */
5344 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5345 || (elf_symtab_shndx_list (abfd
) != NULL
5346 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5347 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
5348 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
5349 hdr
->sh_offset
= -1;
5351 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5354 /* Now that we have set the section file positions, we can set up
5355 the file positions for the non PT_LOAD segments. */
5359 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5361 hdrs_segment
= NULL
;
5362 phdrs
= elf_tdata (abfd
)->phdr
;
5363 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5366 if (p
->p_type
!= PT_LOAD
)
5369 if (m
->includes_filehdr
)
5371 filehdr_vaddr
= p
->p_vaddr
;
5372 filehdr_paddr
= p
->p_paddr
;
5374 if (m
->includes_phdrs
)
5376 phdrs_vaddr
= p
->p_vaddr
;
5377 phdrs_paddr
= p
->p_paddr
;
5378 if (m
->includes_filehdr
)
5381 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5382 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5387 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5389 /* There is a segment that contains both the file headers and the
5390 program headers, so provide a symbol __ehdr_start pointing there.
5391 A program can use this to examine itself robustly. */
5393 struct elf_link_hash_entry
*hash
5394 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5395 FALSE
, FALSE
, TRUE
);
5396 /* If the symbol was referenced and not defined, define it. */
5398 && (hash
->root
.type
== bfd_link_hash_new
5399 || hash
->root
.type
== bfd_link_hash_undefined
5400 || hash
->root
.type
== bfd_link_hash_undefweak
5401 || hash
->root
.type
== bfd_link_hash_common
))
5404 if (hdrs_segment
->count
!= 0)
5405 /* The segment contains sections, so use the first one. */
5406 s
= hdrs_segment
->sections
[0];
5408 /* Use the first (i.e. lowest-addressed) section in any segment. */
5409 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5418 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5419 hash
->root
.u
.def
.section
= s
;
5423 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5424 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5427 hash
->root
.type
= bfd_link_hash_defined
;
5428 hash
->def_regular
= 1;
5433 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5435 if (p
->p_type
== PT_GNU_RELRO
)
5437 const Elf_Internal_Phdr
*lp
;
5438 struct elf_segment_map
*lm
;
5440 if (link_info
!= NULL
)
5442 /* During linking the range of the RELRO segment is passed
5444 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5446 lm
= lm
->next
, lp
++)
5448 if (lp
->p_type
== PT_LOAD
5449 && lp
->p_vaddr
< link_info
->relro_end
5451 && lm
->sections
[0]->vma
>= link_info
->relro_start
)
5455 BFD_ASSERT (lm
!= NULL
);
5459 /* Otherwise we are copying an executable or shared
5460 library, but we need to use the same linker logic. */
5461 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
5463 if (lp
->p_type
== PT_LOAD
5464 && lp
->p_paddr
== p
->p_paddr
)
5469 if (lp
< phdrs
+ count
)
5471 p
->p_vaddr
= lp
->p_vaddr
;
5472 p
->p_paddr
= lp
->p_paddr
;
5473 p
->p_offset
= lp
->p_offset
;
5474 if (link_info
!= NULL
)
5475 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
5476 else if (m
->p_size_valid
)
5477 p
->p_filesz
= m
->p_size
;
5480 p
->p_memsz
= p
->p_filesz
;
5481 /* Preserve the alignment and flags if they are valid. The
5482 gold linker generates RW/4 for the PT_GNU_RELRO section.
5483 It is better for objcopy/strip to honor these attributes
5484 otherwise gdb will choke when using separate debug files.
5486 if (!m
->p_align_valid
)
5488 if (!m
->p_flags_valid
)
5493 memset (p
, 0, sizeof *p
);
5494 p
->p_type
= PT_NULL
;
5497 else if (p
->p_type
== PT_GNU_STACK
)
5499 if (m
->p_size_valid
)
5500 p
->p_memsz
= m
->p_size
;
5502 else if (m
->count
!= 0)
5505 if (p
->p_type
!= PT_LOAD
5506 && (p
->p_type
!= PT_NOTE
5507 || bfd_get_format (abfd
) != bfd_core
))
5509 if (m
->includes_filehdr
|| m
->includes_phdrs
)
5511 /* PR 17512: file: 2195325e. */
5512 (*_bfd_error_handler
)
5513 (_("%B: warning: non-load segment includes file header and/or program header"),
5519 p
->p_offset
= m
->sections
[0]->filepos
;
5520 for (i
= m
->count
; i
-- != 0;)
5522 asection
*sect
= m
->sections
[i
];
5523 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
5524 if (hdr
->sh_type
!= SHT_NOBITS
)
5526 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
5533 else if (m
->includes_filehdr
)
5535 p
->p_vaddr
= filehdr_vaddr
;
5536 if (! m
->p_paddr_valid
)
5537 p
->p_paddr
= filehdr_paddr
;
5539 else if (m
->includes_phdrs
)
5541 p
->p_vaddr
= phdrs_vaddr
;
5542 if (! m
->p_paddr_valid
)
5543 p
->p_paddr
= phdrs_paddr
;
5547 elf_next_file_pos (abfd
) = off
;
5552 static elf_section_list
*
5553 find_section_in_list (unsigned int i
, elf_section_list
* list
)
5555 for (;list
!= NULL
; list
= list
->next
)
5561 /* Work out the file positions of all the sections. This is called by
5562 _bfd_elf_compute_section_file_positions. All the section sizes and
5563 VMAs must be known before this is called.
5565 Reloc sections come in two flavours: Those processed specially as
5566 "side-channel" data attached to a section to which they apply, and
5567 those that bfd doesn't process as relocations. The latter sort are
5568 stored in a normal bfd section by bfd_section_from_shdr. We don't
5569 consider the former sort here, unless they form part of the loadable
5570 image. Reloc sections not assigned here will be handled later by
5571 assign_file_positions_for_relocs.
5573 We also don't set the positions of the .symtab and .strtab here. */
5576 assign_file_positions_except_relocs (bfd
*abfd
,
5577 struct bfd_link_info
*link_info
)
5579 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
5580 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5581 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5583 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
5584 && bfd_get_format (abfd
) != bfd_core
)
5586 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
5587 unsigned int num_sec
= elf_numsections (abfd
);
5588 Elf_Internal_Shdr
**hdrpp
;
5592 /* Start after the ELF header. */
5593 off
= i_ehdrp
->e_ehsize
;
5595 /* We are not creating an executable, which means that we are
5596 not creating a program header, and that the actual order of
5597 the sections in the file is unimportant. */
5598 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
5600 Elf_Internal_Shdr
*hdr
;
5603 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5604 && hdr
->bfd_section
== NULL
)
5605 || (hdr
->bfd_section
!= NULL
5606 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5607 /* Compress DWARF debug sections. */
5608 || i
== elf_onesymtab (abfd
)
5609 || (elf_symtab_shndx_list (abfd
) != NULL
5610 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5611 || i
== elf_strtab_sec (abfd
)
5612 || i
== elf_shstrtab_sec (abfd
))
5614 hdr
->sh_offset
= -1;
5617 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5620 elf_next_file_pos (abfd
) = off
;
5626 /* Assign file positions for the loaded sections based on the
5627 assignment of sections to segments. */
5628 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
5631 /* And for non-load sections. */
5632 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
5635 if (bed
->elf_backend_modify_program_headers
!= NULL
)
5637 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
5641 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
5642 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
5644 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
5645 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
5646 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
5648 /* Find the lowest p_vaddr in PT_LOAD segments. */
5649 bfd_vma p_vaddr
= (bfd_vma
) -1;
5650 for (; segment
< end_segment
; segment
++)
5651 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
5652 p_vaddr
= segment
->p_vaddr
;
5654 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5655 segments is non-zero. */
5657 i_ehdrp
->e_type
= ET_EXEC
;
5660 /* Write out the program headers. */
5661 alloc
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5662 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
5663 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
5671 prep_headers (bfd
*abfd
)
5673 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
5674 struct elf_strtab_hash
*shstrtab
;
5675 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5677 i_ehdrp
= elf_elfheader (abfd
);
5679 shstrtab
= _bfd_elf_strtab_init ();
5680 if (shstrtab
== NULL
)
5683 elf_shstrtab (abfd
) = shstrtab
;
5685 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
5686 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
5687 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
5688 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
5690 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
5691 i_ehdrp
->e_ident
[EI_DATA
] =
5692 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
5693 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
5695 if ((abfd
->flags
& DYNAMIC
) != 0)
5696 i_ehdrp
->e_type
= ET_DYN
;
5697 else if ((abfd
->flags
& EXEC_P
) != 0)
5698 i_ehdrp
->e_type
= ET_EXEC
;
5699 else if (bfd_get_format (abfd
) == bfd_core
)
5700 i_ehdrp
->e_type
= ET_CORE
;
5702 i_ehdrp
->e_type
= ET_REL
;
5704 switch (bfd_get_arch (abfd
))
5706 case bfd_arch_unknown
:
5707 i_ehdrp
->e_machine
= EM_NONE
;
5710 /* There used to be a long list of cases here, each one setting
5711 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5712 in the corresponding bfd definition. To avoid duplication,
5713 the switch was removed. Machines that need special handling
5714 can generally do it in elf_backend_final_write_processing(),
5715 unless they need the information earlier than the final write.
5716 Such need can generally be supplied by replacing the tests for
5717 e_machine with the conditions used to determine it. */
5719 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
5722 i_ehdrp
->e_version
= bed
->s
->ev_current
;
5723 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
5725 /* No program header, for now. */
5726 i_ehdrp
->e_phoff
= 0;
5727 i_ehdrp
->e_phentsize
= 0;
5728 i_ehdrp
->e_phnum
= 0;
5730 /* Each bfd section is section header entry. */
5731 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
5732 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
5734 /* If we're building an executable, we'll need a program header table. */
5735 if (abfd
->flags
& EXEC_P
)
5736 /* It all happens later. */
5740 i_ehdrp
->e_phentsize
= 0;
5741 i_ehdrp
->e_phoff
= 0;
5744 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
5745 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
5746 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
5747 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
5748 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
5749 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
5750 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5751 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
5752 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
5758 /* Assign file positions for all the reloc sections which are not part
5759 of the loadable file image, and the file position of section headers. */
5762 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
5765 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
5766 Elf_Internal_Shdr
*shdrp
;
5767 Elf_Internal_Ehdr
*i_ehdrp
;
5768 const struct elf_backend_data
*bed
;
5770 off
= elf_next_file_pos (abfd
);
5772 shdrpp
= elf_elfsections (abfd
);
5773 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
5774 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
5777 if (shdrp
->sh_offset
== -1)
5779 asection
*sec
= shdrp
->bfd_section
;
5780 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
5781 || shdrp
->sh_type
== SHT_RELA
);
5783 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
5787 const char *name
= sec
->name
;
5788 struct bfd_elf_section_data
*d
;
5790 /* Compress DWARF debug sections. */
5791 if (!bfd_compress_section (abfd
, sec
,
5795 if (sec
->compress_status
== COMPRESS_SECTION_DONE
5796 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
5798 /* If section is compressed with zlib-gnu, convert
5799 section name from .debug_* to .zdebug_*. */
5801 = convert_debug_to_zdebug (abfd
, name
);
5802 if (new_name
== NULL
)
5806 /* Add setion name to section name section. */
5807 if (shdrp
->sh_name
!= (unsigned int) -1)
5810 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
5812 d
= elf_section_data (sec
);
5814 /* Add reloc setion name to section name section. */
5816 && !_bfd_elf_set_reloc_sh_name (abfd
,
5821 && !_bfd_elf_set_reloc_sh_name (abfd
,
5826 /* Update section size and contents. */
5827 shdrp
->sh_size
= sec
->size
;
5828 shdrp
->contents
= sec
->contents
;
5829 shdrp
->bfd_section
->contents
= NULL
;
5831 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
5838 /* Place section name section after DWARF debug sections have been
5840 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
5841 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
5842 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
5843 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5845 /* Place the section headers. */
5846 i_ehdrp
= elf_elfheader (abfd
);
5847 bed
= get_elf_backend_data (abfd
);
5848 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
5849 i_ehdrp
->e_shoff
= off
;
5850 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
5851 elf_next_file_pos (abfd
) = off
;
5857 _bfd_elf_write_object_contents (bfd
*abfd
)
5859 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5860 Elf_Internal_Shdr
**i_shdrp
;
5862 unsigned int count
, num_sec
;
5863 struct elf_obj_tdata
*t
;
5865 if (! abfd
->output_has_begun
5866 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5869 i_shdrp
= elf_elfsections (abfd
);
5872 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5876 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
5879 /* After writing the headers, we need to write the sections too... */
5880 num_sec
= elf_numsections (abfd
);
5881 for (count
= 1; count
< num_sec
; count
++)
5883 i_shdrp
[count
]->sh_name
5884 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
5885 i_shdrp
[count
]->sh_name
);
5886 if (bed
->elf_backend_section_processing
)
5887 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5888 if (i_shdrp
[count
]->contents
)
5890 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5892 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5893 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5898 /* Write out the section header names. */
5899 t
= elf_tdata (abfd
);
5900 if (elf_shstrtab (abfd
) != NULL
5901 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5902 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5905 if (bed
->elf_backend_final_write_processing
)
5906 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
5908 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5911 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5912 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
5913 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
5919 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5921 /* Hopefully this can be done just like an object file. */
5922 return _bfd_elf_write_object_contents (abfd
);
5925 /* Given a section, search the header to find them. */
5928 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5930 const struct elf_backend_data
*bed
;
5931 unsigned int sec_index
;
5933 if (elf_section_data (asect
) != NULL
5934 && elf_section_data (asect
)->this_idx
!= 0)
5935 return elf_section_data (asect
)->this_idx
;
5937 if (bfd_is_abs_section (asect
))
5938 sec_index
= SHN_ABS
;
5939 else if (bfd_is_com_section (asect
))
5940 sec_index
= SHN_COMMON
;
5941 else if (bfd_is_und_section (asect
))
5942 sec_index
= SHN_UNDEF
;
5944 sec_index
= SHN_BAD
;
5946 bed
= get_elf_backend_data (abfd
);
5947 if (bed
->elf_backend_section_from_bfd_section
)
5949 int retval
= sec_index
;
5951 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5955 if (sec_index
== SHN_BAD
)
5956 bfd_set_error (bfd_error_nonrepresentable_section
);
5961 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5965 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5967 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5969 flagword flags
= asym_ptr
->flags
;
5971 /* When gas creates relocations against local labels, it creates its
5972 own symbol for the section, but does put the symbol into the
5973 symbol chain, so udata is 0. When the linker is generating
5974 relocatable output, this section symbol may be for one of the
5975 input sections rather than the output section. */
5976 if (asym_ptr
->udata
.i
== 0
5977 && (flags
& BSF_SECTION_SYM
)
5978 && asym_ptr
->section
)
5983 sec
= asym_ptr
->section
;
5984 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5985 sec
= sec
->output_section
;
5986 if (sec
->owner
== abfd
5987 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5988 && elf_section_syms (abfd
)[indx
] != NULL
)
5989 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5992 idx
= asym_ptr
->udata
.i
;
5996 /* This case can occur when using --strip-symbol on a symbol
5997 which is used in a relocation entry. */
5998 (*_bfd_error_handler
)
5999 (_("%B: symbol `%s' required but not present"),
6000 abfd
, bfd_asymbol_name (asym_ptr
));
6001 bfd_set_error (bfd_error_no_symbols
);
6008 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
6009 (long) asym_ptr
, asym_ptr
->name
, idx
, (long) flags
);
6017 /* Rewrite program header information. */
6020 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6022 Elf_Internal_Ehdr
*iehdr
;
6023 struct elf_segment_map
*map
;
6024 struct elf_segment_map
*map_first
;
6025 struct elf_segment_map
**pointer_to_map
;
6026 Elf_Internal_Phdr
*segment
;
6029 unsigned int num_segments
;
6030 bfd_boolean phdr_included
= FALSE
;
6031 bfd_boolean p_paddr_valid
;
6032 bfd_vma maxpagesize
;
6033 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6034 unsigned int phdr_adjust_num
= 0;
6035 const struct elf_backend_data
*bed
;
6037 bed
= get_elf_backend_data (ibfd
);
6038 iehdr
= elf_elfheader (ibfd
);
6041 pointer_to_map
= &map_first
;
6043 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6044 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6046 /* Returns the end address of the segment + 1. */
6047 #define SEGMENT_END(segment, start) \
6048 (start + (segment->p_memsz > segment->p_filesz \
6049 ? segment->p_memsz : segment->p_filesz))
6051 #define SECTION_SIZE(section, segment) \
6052 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6053 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6054 ? section->size : 0)
6056 /* Returns TRUE if the given section is contained within
6057 the given segment. VMA addresses are compared. */
6058 #define IS_CONTAINED_BY_VMA(section, segment) \
6059 (section->vma >= segment->p_vaddr \
6060 && (section->vma + SECTION_SIZE (section, segment) \
6061 <= (SEGMENT_END (segment, segment->p_vaddr))))
6063 /* Returns TRUE if the given section is contained within
6064 the given segment. LMA addresses are compared. */
6065 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6066 (section->lma >= base \
6067 && (section->lma + SECTION_SIZE (section, segment) \
6068 <= SEGMENT_END (segment, base)))
6070 /* Handle PT_NOTE segment. */
6071 #define IS_NOTE(p, s) \
6072 (p->p_type == PT_NOTE \
6073 && elf_section_type (s) == SHT_NOTE \
6074 && (bfd_vma) s->filepos >= p->p_offset \
6075 && ((bfd_vma) s->filepos + s->size \
6076 <= p->p_offset + p->p_filesz))
6078 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6080 #define IS_COREFILE_NOTE(p, s) \
6082 && bfd_get_format (ibfd) == bfd_core \
6086 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6087 linker, which generates a PT_INTERP section with p_vaddr and
6088 p_memsz set to 0. */
6089 #define IS_SOLARIS_PT_INTERP(p, s) \
6091 && p->p_paddr == 0 \
6092 && p->p_memsz == 0 \
6093 && p->p_filesz > 0 \
6094 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6096 && (bfd_vma) s->filepos >= p->p_offset \
6097 && ((bfd_vma) s->filepos + s->size \
6098 <= p->p_offset + p->p_filesz))
6100 /* Decide if the given section should be included in the given segment.
6101 A section will be included if:
6102 1. It is within the address space of the segment -- we use the LMA
6103 if that is set for the segment and the VMA otherwise,
6104 2. It is an allocated section or a NOTE section in a PT_NOTE
6106 3. There is an output section associated with it,
6107 4. The section has not already been allocated to a previous segment.
6108 5. PT_GNU_STACK segments do not include any sections.
6109 6. PT_TLS segment includes only SHF_TLS sections.
6110 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6111 8. PT_DYNAMIC should not contain empty sections at the beginning
6112 (with the possible exception of .dynamic). */
6113 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6114 ((((segment->p_paddr \
6115 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6116 : IS_CONTAINED_BY_VMA (section, segment)) \
6117 && (section->flags & SEC_ALLOC) != 0) \
6118 || IS_NOTE (segment, section)) \
6119 && segment->p_type != PT_GNU_STACK \
6120 && (segment->p_type != PT_TLS \
6121 || (section->flags & SEC_THREAD_LOCAL)) \
6122 && (segment->p_type == PT_LOAD \
6123 || segment->p_type == PT_TLS \
6124 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6125 && (segment->p_type != PT_DYNAMIC \
6126 || SECTION_SIZE (section, segment) > 0 \
6127 || (segment->p_paddr \
6128 ? segment->p_paddr != section->lma \
6129 : segment->p_vaddr != section->vma) \
6130 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6132 && !section->segment_mark)
6134 /* If the output section of a section in the input segment is NULL,
6135 it is removed from the corresponding output segment. */
6136 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6137 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6138 && section->output_section != NULL)
6140 /* Returns TRUE iff seg1 starts after the end of seg2. */
6141 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6142 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6144 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6145 their VMA address ranges and their LMA address ranges overlap.
6146 It is possible to have overlapping VMA ranges without overlapping LMA
6147 ranges. RedBoot images for example can have both .data and .bss mapped
6148 to the same VMA range, but with the .data section mapped to a different
6150 #define SEGMENT_OVERLAPS(seg1, seg2) \
6151 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6152 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6153 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6154 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6156 /* Initialise the segment mark field. */
6157 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6158 section
->segment_mark
= FALSE
;
6160 /* The Solaris linker creates program headers in which all the
6161 p_paddr fields are zero. When we try to objcopy or strip such a
6162 file, we get confused. Check for this case, and if we find it
6163 don't set the p_paddr_valid fields. */
6164 p_paddr_valid
= FALSE
;
6165 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6168 if (segment
->p_paddr
!= 0)
6170 p_paddr_valid
= TRUE
;
6174 /* Scan through the segments specified in the program header
6175 of the input BFD. For this first scan we look for overlaps
6176 in the loadable segments. These can be created by weird
6177 parameters to objcopy. Also, fix some solaris weirdness. */
6178 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6183 Elf_Internal_Phdr
*segment2
;
6185 if (segment
->p_type
== PT_INTERP
)
6186 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6187 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6189 /* Mininal change so that the normal section to segment
6190 assignment code will work. */
6191 segment
->p_vaddr
= section
->vma
;
6195 if (segment
->p_type
!= PT_LOAD
)
6197 /* Remove PT_GNU_RELRO segment. */
6198 if (segment
->p_type
== PT_GNU_RELRO
)
6199 segment
->p_type
= PT_NULL
;
6203 /* Determine if this segment overlaps any previous segments. */
6204 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6206 bfd_signed_vma extra_length
;
6208 if (segment2
->p_type
!= PT_LOAD
6209 || !SEGMENT_OVERLAPS (segment
, segment2
))
6212 /* Merge the two segments together. */
6213 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6215 /* Extend SEGMENT2 to include SEGMENT and then delete
6217 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6218 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6220 if (extra_length
> 0)
6222 segment2
->p_memsz
+= extra_length
;
6223 segment2
->p_filesz
+= extra_length
;
6226 segment
->p_type
= PT_NULL
;
6228 /* Since we have deleted P we must restart the outer loop. */
6230 segment
= elf_tdata (ibfd
)->phdr
;
6235 /* Extend SEGMENT to include SEGMENT2 and then delete
6237 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
6238 - SEGMENT_END (segment
, segment
->p_vaddr
));
6240 if (extra_length
> 0)
6242 segment
->p_memsz
+= extra_length
;
6243 segment
->p_filesz
+= extra_length
;
6246 segment2
->p_type
= PT_NULL
;
6251 /* The second scan attempts to assign sections to segments. */
6252 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6256 unsigned int section_count
;
6257 asection
**sections
;
6258 asection
*output_section
;
6260 bfd_vma matching_lma
;
6261 bfd_vma suggested_lma
;
6264 asection
*first_section
;
6265 bfd_boolean first_matching_lma
;
6266 bfd_boolean first_suggested_lma
;
6268 if (segment
->p_type
== PT_NULL
)
6271 first_section
= NULL
;
6272 /* Compute how many sections might be placed into this segment. */
6273 for (section
= ibfd
->sections
, section_count
= 0;
6275 section
= section
->next
)
6277 /* Find the first section in the input segment, which may be
6278 removed from the corresponding output segment. */
6279 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
6281 if (first_section
== NULL
)
6282 first_section
= section
;
6283 if (section
->output_section
!= NULL
)
6288 /* Allocate a segment map big enough to contain
6289 all of the sections we have selected. */
6290 amt
= sizeof (struct elf_segment_map
);
6291 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6292 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6296 /* Initialise the fields of the segment map. Default to
6297 using the physical address of the segment in the input BFD. */
6299 map
->p_type
= segment
->p_type
;
6300 map
->p_flags
= segment
->p_flags
;
6301 map
->p_flags_valid
= 1;
6303 /* If the first section in the input segment is removed, there is
6304 no need to preserve segment physical address in the corresponding
6306 if (!first_section
|| first_section
->output_section
!= NULL
)
6308 map
->p_paddr
= segment
->p_paddr
;
6309 map
->p_paddr_valid
= p_paddr_valid
;
6312 /* Determine if this segment contains the ELF file header
6313 and if it contains the program headers themselves. */
6314 map
->includes_filehdr
= (segment
->p_offset
== 0
6315 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6316 map
->includes_phdrs
= 0;
6318 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
6320 map
->includes_phdrs
=
6321 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6322 && (segment
->p_offset
+ segment
->p_filesz
6323 >= ((bfd_vma
) iehdr
->e_phoff
6324 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6326 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6327 phdr_included
= TRUE
;
6330 if (section_count
== 0)
6332 /* Special segments, such as the PT_PHDR segment, may contain
6333 no sections, but ordinary, loadable segments should contain
6334 something. They are allowed by the ELF spec however, so only
6335 a warning is produced. */
6336 if (segment
->p_type
== PT_LOAD
)
6337 (*_bfd_error_handler
) (_("\
6338 %B: warning: Empty loadable segment detected, is this intentional ?"),
6342 *pointer_to_map
= map
;
6343 pointer_to_map
= &map
->next
;
6348 /* Now scan the sections in the input BFD again and attempt
6349 to add their corresponding output sections to the segment map.
6350 The problem here is how to handle an output section which has
6351 been moved (ie had its LMA changed). There are four possibilities:
6353 1. None of the sections have been moved.
6354 In this case we can continue to use the segment LMA from the
6357 2. All of the sections have been moved by the same amount.
6358 In this case we can change the segment's LMA to match the LMA
6359 of the first section.
6361 3. Some of the sections have been moved, others have not.
6362 In this case those sections which have not been moved can be
6363 placed in the current segment which will have to have its size,
6364 and possibly its LMA changed, and a new segment or segments will
6365 have to be created to contain the other sections.
6367 4. The sections have been moved, but not by the same amount.
6368 In this case we can change the segment's LMA to match the LMA
6369 of the first section and we will have to create a new segment
6370 or segments to contain the other sections.
6372 In order to save time, we allocate an array to hold the section
6373 pointers that we are interested in. As these sections get assigned
6374 to a segment, they are removed from this array. */
6376 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
6377 if (sections
== NULL
)
6380 /* Step One: Scan for segment vs section LMA conflicts.
6381 Also add the sections to the section array allocated above.
6382 Also add the sections to the current segment. In the common
6383 case, where the sections have not been moved, this means that
6384 we have completely filled the segment, and there is nothing
6389 first_matching_lma
= TRUE
;
6390 first_suggested_lma
= TRUE
;
6392 for (section
= first_section
, j
= 0;
6394 section
= section
->next
)
6396 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
6398 output_section
= section
->output_section
;
6400 sections
[j
++] = section
;
6402 /* The Solaris native linker always sets p_paddr to 0.
6403 We try to catch that case here, and set it to the
6404 correct value. Note - some backends require that
6405 p_paddr be left as zero. */
6407 && segment
->p_vaddr
!= 0
6408 && !bed
->want_p_paddr_set_to_zero
6410 && output_section
->lma
!= 0
6411 && output_section
->vma
== (segment
->p_vaddr
6412 + (map
->includes_filehdr
6415 + (map
->includes_phdrs
6417 * iehdr
->e_phentsize
)
6419 map
->p_paddr
= segment
->p_vaddr
;
6421 /* Match up the physical address of the segment with the
6422 LMA address of the output section. */
6423 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6424 || IS_COREFILE_NOTE (segment
, section
)
6425 || (bed
->want_p_paddr_set_to_zero
6426 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
6428 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
6430 matching_lma
= output_section
->lma
;
6431 first_matching_lma
= FALSE
;
6434 /* We assume that if the section fits within the segment
6435 then it does not overlap any other section within that
6437 map
->sections
[isec
++] = output_section
;
6439 else if (first_suggested_lma
)
6441 suggested_lma
= output_section
->lma
;
6442 first_suggested_lma
= FALSE
;
6445 if (j
== section_count
)
6450 BFD_ASSERT (j
== section_count
);
6452 /* Step Two: Adjust the physical address of the current segment,
6454 if (isec
== section_count
)
6456 /* All of the sections fitted within the segment as currently
6457 specified. This is the default case. Add the segment to
6458 the list of built segments and carry on to process the next
6459 program header in the input BFD. */
6460 map
->count
= section_count
;
6461 *pointer_to_map
= map
;
6462 pointer_to_map
= &map
->next
;
6465 && !bed
->want_p_paddr_set_to_zero
6466 && matching_lma
!= map
->p_paddr
6467 && !map
->includes_filehdr
6468 && !map
->includes_phdrs
)
6469 /* There is some padding before the first section in the
6470 segment. So, we must account for that in the output
6472 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
6479 if (!first_matching_lma
)
6481 /* At least one section fits inside the current segment.
6482 Keep it, but modify its physical address to match the
6483 LMA of the first section that fitted. */
6484 map
->p_paddr
= matching_lma
;
6488 /* None of the sections fitted inside the current segment.
6489 Change the current segment's physical address to match
6490 the LMA of the first section. */
6491 map
->p_paddr
= suggested_lma
;
6494 /* Offset the segment physical address from the lma
6495 to allow for space taken up by elf headers. */
6496 if (map
->includes_filehdr
)
6498 if (map
->p_paddr
>= iehdr
->e_ehsize
)
6499 map
->p_paddr
-= iehdr
->e_ehsize
;
6502 map
->includes_filehdr
= FALSE
;
6503 map
->includes_phdrs
= FALSE
;
6507 if (map
->includes_phdrs
)
6509 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
6511 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
6513 /* iehdr->e_phnum is just an estimate of the number
6514 of program headers that we will need. Make a note
6515 here of the number we used and the segment we chose
6516 to hold these headers, so that we can adjust the
6517 offset when we know the correct value. */
6518 phdr_adjust_num
= iehdr
->e_phnum
;
6519 phdr_adjust_seg
= map
;
6522 map
->includes_phdrs
= FALSE
;
6526 /* Step Three: Loop over the sections again, this time assigning
6527 those that fit to the current segment and removing them from the
6528 sections array; but making sure not to leave large gaps. Once all
6529 possible sections have been assigned to the current segment it is
6530 added to the list of built segments and if sections still remain
6531 to be assigned, a new segment is constructed before repeating
6538 first_suggested_lma
= TRUE
;
6540 /* Fill the current segment with sections that fit. */
6541 for (j
= 0; j
< section_count
; j
++)
6543 section
= sections
[j
];
6545 if (section
== NULL
)
6548 output_section
= section
->output_section
;
6550 BFD_ASSERT (output_section
!= NULL
);
6552 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6553 || IS_COREFILE_NOTE (segment
, section
))
6555 if (map
->count
== 0)
6557 /* If the first section in a segment does not start at
6558 the beginning of the segment, then something is
6560 if (output_section
->lma
6562 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
6563 + (map
->includes_phdrs
6564 ? iehdr
->e_phnum
* iehdr
->e_phentsize
6572 prev_sec
= map
->sections
[map
->count
- 1];
6574 /* If the gap between the end of the previous section
6575 and the start of this section is more than
6576 maxpagesize then we need to start a new segment. */
6577 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
6579 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
6580 || (prev_sec
->lma
+ prev_sec
->size
6581 > output_section
->lma
))
6583 if (first_suggested_lma
)
6585 suggested_lma
= output_section
->lma
;
6586 first_suggested_lma
= FALSE
;
6593 map
->sections
[map
->count
++] = output_section
;
6596 section
->segment_mark
= TRUE
;
6598 else if (first_suggested_lma
)
6600 suggested_lma
= output_section
->lma
;
6601 first_suggested_lma
= FALSE
;
6605 BFD_ASSERT (map
->count
> 0);
6607 /* Add the current segment to the list of built segments. */
6608 *pointer_to_map
= map
;
6609 pointer_to_map
= &map
->next
;
6611 if (isec
< section_count
)
6613 /* We still have not allocated all of the sections to
6614 segments. Create a new segment here, initialise it
6615 and carry on looping. */
6616 amt
= sizeof (struct elf_segment_map
);
6617 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6618 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6625 /* Initialise the fields of the segment map. Set the physical
6626 physical address to the LMA of the first section that has
6627 not yet been assigned. */
6629 map
->p_type
= segment
->p_type
;
6630 map
->p_flags
= segment
->p_flags
;
6631 map
->p_flags_valid
= 1;
6632 map
->p_paddr
= suggested_lma
;
6633 map
->p_paddr_valid
= p_paddr_valid
;
6634 map
->includes_filehdr
= 0;
6635 map
->includes_phdrs
= 0;
6638 while (isec
< section_count
);
6643 elf_seg_map (obfd
) = map_first
;
6645 /* If we had to estimate the number of program headers that were
6646 going to be needed, then check our estimate now and adjust
6647 the offset if necessary. */
6648 if (phdr_adjust_seg
!= NULL
)
6652 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
6655 if (count
> phdr_adjust_num
)
6656 phdr_adjust_seg
->p_paddr
6657 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
6662 #undef IS_CONTAINED_BY_VMA
6663 #undef IS_CONTAINED_BY_LMA
6665 #undef IS_COREFILE_NOTE
6666 #undef IS_SOLARIS_PT_INTERP
6667 #undef IS_SECTION_IN_INPUT_SEGMENT
6668 #undef INCLUDE_SECTION_IN_SEGMENT
6669 #undef SEGMENT_AFTER_SEGMENT
6670 #undef SEGMENT_OVERLAPS
6674 /* Copy ELF program header information. */
6677 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6679 Elf_Internal_Ehdr
*iehdr
;
6680 struct elf_segment_map
*map
;
6681 struct elf_segment_map
*map_first
;
6682 struct elf_segment_map
**pointer_to_map
;
6683 Elf_Internal_Phdr
*segment
;
6685 unsigned int num_segments
;
6686 bfd_boolean phdr_included
= FALSE
;
6687 bfd_boolean p_paddr_valid
;
6689 iehdr
= elf_elfheader (ibfd
);
6692 pointer_to_map
= &map_first
;
6694 /* If all the segment p_paddr fields are zero, don't set
6695 map->p_paddr_valid. */
6696 p_paddr_valid
= FALSE
;
6697 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6698 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6701 if (segment
->p_paddr
!= 0)
6703 p_paddr_valid
= TRUE
;
6707 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6712 unsigned int section_count
;
6714 Elf_Internal_Shdr
*this_hdr
;
6715 asection
*first_section
= NULL
;
6716 asection
*lowest_section
;
6718 /* Compute how many sections are in this segment. */
6719 for (section
= ibfd
->sections
, section_count
= 0;
6721 section
= section
->next
)
6723 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6724 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6726 if (first_section
== NULL
)
6727 first_section
= section
;
6732 /* Allocate a segment map big enough to contain
6733 all of the sections we have selected. */
6734 amt
= sizeof (struct elf_segment_map
);
6735 if (section_count
!= 0)
6736 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6737 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6741 /* Initialize the fields of the output segment map with the
6744 map
->p_type
= segment
->p_type
;
6745 map
->p_flags
= segment
->p_flags
;
6746 map
->p_flags_valid
= 1;
6747 map
->p_paddr
= segment
->p_paddr
;
6748 map
->p_paddr_valid
= p_paddr_valid
;
6749 map
->p_align
= segment
->p_align
;
6750 map
->p_align_valid
= 1;
6751 map
->p_vaddr_offset
= 0;
6753 if (map
->p_type
== PT_GNU_RELRO
6754 || map
->p_type
== PT_GNU_STACK
)
6756 /* The PT_GNU_RELRO segment may contain the first a few
6757 bytes in the .got.plt section even if the whole .got.plt
6758 section isn't in the PT_GNU_RELRO segment. We won't
6759 change the size of the PT_GNU_RELRO segment.
6760 Similarly, PT_GNU_STACK size is significant on uclinux
6762 map
->p_size
= segment
->p_memsz
;
6763 map
->p_size_valid
= 1;
6766 /* Determine if this segment contains the ELF file header
6767 and if it contains the program headers themselves. */
6768 map
->includes_filehdr
= (segment
->p_offset
== 0
6769 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6771 map
->includes_phdrs
= 0;
6772 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
6774 map
->includes_phdrs
=
6775 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6776 && (segment
->p_offset
+ segment
->p_filesz
6777 >= ((bfd_vma
) iehdr
->e_phoff
6778 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6780 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6781 phdr_included
= TRUE
;
6784 lowest_section
= NULL
;
6785 if (section_count
!= 0)
6787 unsigned int isec
= 0;
6789 for (section
= first_section
;
6791 section
= section
->next
)
6793 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6794 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6796 map
->sections
[isec
++] = section
->output_section
;
6797 if ((section
->flags
& SEC_ALLOC
) != 0)
6801 if (lowest_section
== NULL
6802 || section
->lma
< lowest_section
->lma
)
6803 lowest_section
= section
;
6805 /* Section lmas are set up from PT_LOAD header
6806 p_paddr in _bfd_elf_make_section_from_shdr.
6807 If this header has a p_paddr that disagrees
6808 with the section lma, flag the p_paddr as
6810 if ((section
->flags
& SEC_LOAD
) != 0)
6811 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
6813 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
6814 if (section
->lma
- segment
->p_paddr
!= seg_off
)
6815 map
->p_paddr_valid
= FALSE
;
6817 if (isec
== section_count
)
6823 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
6824 /* We need to keep the space used by the headers fixed. */
6825 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
6827 if (!map
->includes_phdrs
6828 && !map
->includes_filehdr
6829 && map
->p_paddr_valid
)
6830 /* There is some other padding before the first section. */
6831 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
6832 - segment
->p_paddr
);
6834 map
->count
= section_count
;
6835 *pointer_to_map
= map
;
6836 pointer_to_map
= &map
->next
;
6839 elf_seg_map (obfd
) = map_first
;
6843 /* Copy private BFD data. This copies or rewrites ELF program header
6847 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
6849 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6850 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6853 if (elf_tdata (ibfd
)->phdr
== NULL
)
6856 if (ibfd
->xvec
== obfd
->xvec
)
6858 /* Check to see if any sections in the input BFD
6859 covered by ELF program header have changed. */
6860 Elf_Internal_Phdr
*segment
;
6861 asection
*section
, *osec
;
6862 unsigned int i
, num_segments
;
6863 Elf_Internal_Shdr
*this_hdr
;
6864 const struct elf_backend_data
*bed
;
6866 bed
= get_elf_backend_data (ibfd
);
6868 /* Regenerate the segment map if p_paddr is set to 0. */
6869 if (bed
->want_p_paddr_set_to_zero
)
6872 /* Initialize the segment mark field. */
6873 for (section
= obfd
->sections
; section
!= NULL
;
6874 section
= section
->next
)
6875 section
->segment_mark
= FALSE
;
6877 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6878 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6882 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6883 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6884 which severly confuses things, so always regenerate the segment
6885 map in this case. */
6886 if (segment
->p_paddr
== 0
6887 && segment
->p_memsz
== 0
6888 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6891 for (section
= ibfd
->sections
;
6892 section
!= NULL
; section
= section
->next
)
6894 /* We mark the output section so that we know it comes
6895 from the input BFD. */
6896 osec
= section
->output_section
;
6898 osec
->segment_mark
= TRUE
;
6900 /* Check if this section is covered by the segment. */
6901 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6902 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6904 /* FIXME: Check if its output section is changed or
6905 removed. What else do we need to check? */
6907 || section
->flags
!= osec
->flags
6908 || section
->lma
!= osec
->lma
6909 || section
->vma
!= osec
->vma
6910 || section
->size
!= osec
->size
6911 || section
->rawsize
!= osec
->rawsize
6912 || section
->alignment_power
!= osec
->alignment_power
)
6918 /* Check to see if any output section do not come from the
6920 for (section
= obfd
->sections
; section
!= NULL
;
6921 section
= section
->next
)
6923 if (section
->segment_mark
== FALSE
)
6926 section
->segment_mark
= FALSE
;
6929 return copy_elf_program_header (ibfd
, obfd
);
6933 if (ibfd
->xvec
== obfd
->xvec
)
6935 /* When rewriting program header, set the output maxpagesize to
6936 the maximum alignment of input PT_LOAD segments. */
6937 Elf_Internal_Phdr
*segment
;
6939 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6940 bfd_vma maxpagesize
= 0;
6942 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6945 if (segment
->p_type
== PT_LOAD
6946 && maxpagesize
< segment
->p_align
)
6948 /* PR 17512: file: f17299af. */
6949 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
6950 (*_bfd_error_handler
) (_("\
6951 %B: warning: segment alignment of 0x%llx is too large"),
6952 ibfd
, (long long) segment
->p_align
);
6954 maxpagesize
= segment
->p_align
;
6957 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
6958 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
6961 return rewrite_elf_program_header (ibfd
, obfd
);
6964 /* Initialize private output section information from input section. */
6967 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6971 struct bfd_link_info
*link_info
)
6974 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6975 bfd_boolean final_link
= (link_info
!= NULL
6976 && !bfd_link_relocatable (link_info
));
6978 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6979 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6982 BFD_ASSERT (elf_section_data (osec
) != NULL
);
6984 /* For objcopy and relocatable link, don't copy the output ELF
6985 section type from input if the output BFD section flags have been
6986 set to something different. For a final link allow some flags
6987 that the linker clears to differ. */
6988 if (elf_section_type (osec
) == SHT_NULL
6989 && (osec
->flags
== isec
->flags
6991 && ((osec
->flags
^ isec
->flags
)
6992 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
6993 elf_section_type (osec
) = elf_section_type (isec
);
6995 /* FIXME: Is this correct for all OS/PROC specific flags? */
6996 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6997 & (SHF_MASKOS
| SHF_MASKPROC
));
6999 /* Set things up for objcopy and relocatable link. The output
7000 SHT_GROUP section will have its elf_next_in_group pointing back
7001 to the input group members. Ignore linker created group section.
7002 See elfNN_ia64_object_p in elfxx-ia64.c. */
7005 if (elf_sec_group (isec
) == NULL
7006 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
7008 if (elf_section_flags (isec
) & SHF_GROUP
)
7009 elf_section_flags (osec
) |= SHF_GROUP
;
7010 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7011 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7014 /* If not decompress, preserve SHF_COMPRESSED. */
7015 if ((ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7016 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7020 ihdr
= &elf_section_data (isec
)->this_hdr
;
7022 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7023 don't use the output section of the linked-to section since it
7024 may be NULL at this point. */
7025 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7027 ohdr
= &elf_section_data (osec
)->this_hdr
;
7028 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7029 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7032 osec
->use_rela_p
= isec
->use_rela_p
;
7037 /* Copy private section information. This copies over the entsize
7038 field, and sometimes the info field. */
7041 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7046 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7048 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7049 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7052 ihdr
= &elf_section_data (isec
)->this_hdr
;
7053 ohdr
= &elf_section_data (osec
)->this_hdr
;
7055 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7057 if (ihdr
->sh_type
== SHT_SYMTAB
7058 || ihdr
->sh_type
== SHT_DYNSYM
7059 || ihdr
->sh_type
== SHT_GNU_verneed
7060 || ihdr
->sh_type
== SHT_GNU_verdef
)
7061 ohdr
->sh_info
= ihdr
->sh_info
;
7063 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7067 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7068 necessary if we are removing either the SHT_GROUP section or any of
7069 the group member sections. DISCARDED is the value that a section's
7070 output_section has if the section will be discarded, NULL when this
7071 function is called from objcopy, bfd_abs_section_ptr when called
7075 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7079 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7080 if (elf_section_type (isec
) == SHT_GROUP
)
7082 asection
*first
= elf_next_in_group (isec
);
7083 asection
*s
= first
;
7084 bfd_size_type removed
= 0;
7088 /* If this member section is being output but the
7089 SHT_GROUP section is not, then clear the group info
7090 set up by _bfd_elf_copy_private_section_data. */
7091 if (s
->output_section
!= discarded
7092 && isec
->output_section
== discarded
)
7094 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7095 elf_group_name (s
->output_section
) = NULL
;
7097 /* Conversely, if the member section is not being output
7098 but the SHT_GROUP section is, then adjust its size. */
7099 else if (s
->output_section
== discarded
7100 && isec
->output_section
!= discarded
)
7102 s
= elf_next_in_group (s
);
7108 if (discarded
!= NULL
)
7110 /* If we've been called for ld -r, then we need to
7111 adjust the input section size. This function may
7112 be called multiple times, so save the original
7114 if (isec
->rawsize
== 0)
7115 isec
->rawsize
= isec
->size
;
7116 isec
->size
= isec
->rawsize
- removed
;
7120 /* Adjust the output section size when called from
7122 isec
->output_section
->size
-= removed
;
7130 /* Copy private header information. */
7133 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7135 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7136 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7139 /* Copy over private BFD data if it has not already been copied.
7140 This must be done here, rather than in the copy_private_bfd_data
7141 entry point, because the latter is called after the section
7142 contents have been set, which means that the program headers have
7143 already been worked out. */
7144 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7146 if (! copy_private_bfd_data (ibfd
, obfd
))
7150 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7153 /* Copy private symbol information. If this symbol is in a section
7154 which we did not map into a BFD section, try to map the section
7155 index correctly. We use special macro definitions for the mapped
7156 section indices; these definitions are interpreted by the
7157 swap_out_syms function. */
7159 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7160 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7161 #define MAP_STRTAB (SHN_HIOS + 3)
7162 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7163 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7166 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7171 elf_symbol_type
*isym
, *osym
;
7173 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7174 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7177 isym
= elf_symbol_from (ibfd
, isymarg
);
7178 osym
= elf_symbol_from (obfd
, osymarg
);
7181 && isym
->internal_elf_sym
.st_shndx
!= 0
7183 && bfd_is_abs_section (isym
->symbol
.section
))
7187 shndx
= isym
->internal_elf_sym
.st_shndx
;
7188 if (shndx
== elf_onesymtab (ibfd
))
7189 shndx
= MAP_ONESYMTAB
;
7190 else if (shndx
== elf_dynsymtab (ibfd
))
7191 shndx
= MAP_DYNSYMTAB
;
7192 else if (shndx
== elf_strtab_sec (ibfd
))
7194 else if (shndx
== elf_shstrtab_sec (ibfd
))
7195 shndx
= MAP_SHSTRTAB
;
7196 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7197 shndx
= MAP_SYM_SHNDX
;
7198 osym
->internal_elf_sym
.st_shndx
= shndx
;
7204 /* Swap out the symbols. */
7207 swap_out_syms (bfd
*abfd
,
7208 struct elf_strtab_hash
**sttp
,
7211 const struct elf_backend_data
*bed
;
7214 struct elf_strtab_hash
*stt
;
7215 Elf_Internal_Shdr
*symtab_hdr
;
7216 Elf_Internal_Shdr
*symtab_shndx_hdr
;
7217 Elf_Internal_Shdr
*symstrtab_hdr
;
7218 struct elf_sym_strtab
*symstrtab
;
7219 bfd_byte
*outbound_syms
;
7220 bfd_byte
*outbound_shndx
;
7221 unsigned long outbound_syms_index
;
7222 unsigned long outbound_shndx_index
;
7224 unsigned int num_locals
;
7226 bfd_boolean name_local_sections
;
7228 if (!elf_map_symbols (abfd
, &num_locals
))
7231 /* Dump out the symtabs. */
7232 stt
= _bfd_elf_strtab_init ();
7236 bed
= get_elf_backend_data (abfd
);
7237 symcount
= bfd_get_symcount (abfd
);
7238 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7239 symtab_hdr
->sh_type
= SHT_SYMTAB
;
7240 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
7241 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
7242 symtab_hdr
->sh_info
= num_locals
+ 1;
7243 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
7245 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
7246 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7248 /* Allocate buffer to swap out the .strtab section. */
7249 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc ((symcount
+ 1)
7250 * sizeof (*symstrtab
));
7251 if (symstrtab
== NULL
)
7253 _bfd_elf_strtab_free (stt
);
7257 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
7258 bed
->s
->sizeof_sym
);
7259 if (outbound_syms
== NULL
)
7262 _bfd_elf_strtab_free (stt
);
7266 symtab_hdr
->contents
= outbound_syms
;
7267 outbound_syms_index
= 0;
7269 outbound_shndx
= NULL
;
7270 outbound_shndx_index
= 0;
7272 if (elf_symtab_shndx_list (abfd
))
7274 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
7275 if (symtab_shndx_hdr
->sh_name
!= 0)
7277 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
7278 outbound_shndx
= (bfd_byte
*)
7279 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
7280 if (outbound_shndx
== NULL
)
7283 symtab_shndx_hdr
->contents
= outbound_shndx
;
7284 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
7285 symtab_shndx_hdr
->sh_size
= amt
;
7286 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
7287 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
7289 /* FIXME: What about any other headers in the list ? */
7292 /* Now generate the data (for "contents"). */
7294 /* Fill in zeroth symbol and swap it out. */
7295 Elf_Internal_Sym sym
;
7301 sym
.st_shndx
= SHN_UNDEF
;
7302 sym
.st_target_internal
= 0;
7303 symstrtab
[0].sym
= sym
;
7304 symstrtab
[0].dest_index
= outbound_syms_index
;
7305 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
7306 outbound_syms_index
++;
7307 if (outbound_shndx
!= NULL
)
7308 outbound_shndx_index
++;
7312 = (bed
->elf_backend_name_local_section_symbols
7313 && bed
->elf_backend_name_local_section_symbols (abfd
));
7315 syms
= bfd_get_outsymbols (abfd
);
7316 for (idx
= 0; idx
< symcount
;)
7318 Elf_Internal_Sym sym
;
7319 bfd_vma value
= syms
[idx
]->value
;
7320 elf_symbol_type
*type_ptr
;
7321 flagword flags
= syms
[idx
]->flags
;
7324 if (!name_local_sections
7325 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
7327 /* Local section symbols have no name. */
7328 sym
.st_name
= (unsigned long) -1;
7332 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7333 to get the final offset for st_name. */
7335 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
7337 if (sym
.st_name
== (unsigned long) -1)
7341 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
7343 if ((flags
& BSF_SECTION_SYM
) == 0
7344 && bfd_is_com_section (syms
[idx
]->section
))
7346 /* ELF common symbols put the alignment into the `value' field,
7347 and the size into the `size' field. This is backwards from
7348 how BFD handles it, so reverse it here. */
7349 sym
.st_size
= value
;
7350 if (type_ptr
== NULL
7351 || type_ptr
->internal_elf_sym
.st_value
== 0)
7352 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
7354 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
7355 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
7356 (abfd
, syms
[idx
]->section
);
7360 asection
*sec
= syms
[idx
]->section
;
7363 if (sec
->output_section
)
7365 value
+= sec
->output_offset
;
7366 sec
= sec
->output_section
;
7369 /* Don't add in the section vma for relocatable output. */
7370 if (! relocatable_p
)
7372 sym
.st_value
= value
;
7373 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
7375 if (bfd_is_abs_section (sec
)
7377 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
7379 /* This symbol is in a real ELF section which we did
7380 not create as a BFD section. Undo the mapping done
7381 by copy_private_symbol_data. */
7382 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
7386 shndx
= elf_onesymtab (abfd
);
7389 shndx
= elf_dynsymtab (abfd
);
7392 shndx
= elf_strtab_sec (abfd
);
7395 shndx
= elf_shstrtab_sec (abfd
);
7398 if (elf_symtab_shndx_list (abfd
))
7399 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
7408 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
7410 if (shndx
== SHN_BAD
)
7414 /* Writing this would be a hell of a lot easier if
7415 we had some decent documentation on bfd, and
7416 knew what to expect of the library, and what to
7417 demand of applications. For example, it
7418 appears that `objcopy' might not set the
7419 section of a symbol to be a section that is
7420 actually in the output file. */
7421 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
7424 _bfd_error_handler (_("\
7425 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7426 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
7428 bfd_set_error (bfd_error_invalid_operation
);
7432 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
7433 BFD_ASSERT (shndx
!= SHN_BAD
);
7437 sym
.st_shndx
= shndx
;
7440 if ((flags
& BSF_THREAD_LOCAL
) != 0)
7442 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
7443 type
= STT_GNU_IFUNC
;
7444 else if ((flags
& BSF_FUNCTION
) != 0)
7446 else if ((flags
& BSF_OBJECT
) != 0)
7448 else if ((flags
& BSF_RELC
) != 0)
7450 else if ((flags
& BSF_SRELC
) != 0)
7455 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
7458 /* Processor-specific types. */
7459 if (type_ptr
!= NULL
7460 && bed
->elf_backend_get_symbol_type
)
7461 type
= ((*bed
->elf_backend_get_symbol_type
)
7462 (&type_ptr
->internal_elf_sym
, type
));
7464 if (flags
& BSF_SECTION_SYM
)
7466 if (flags
& BSF_GLOBAL
)
7467 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7469 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
7471 else if (bfd_is_com_section (syms
[idx
]->section
))
7473 if (type
!= STT_TLS
)
7475 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
7476 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
7477 ? STT_COMMON
: STT_OBJECT
);
7479 type
= ((flags
& BSF_ELF_COMMON
) != 0
7480 ? STT_COMMON
: STT_OBJECT
);
7482 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
7484 else if (bfd_is_und_section (syms
[idx
]->section
))
7485 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
7489 else if (flags
& BSF_FILE
)
7490 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
7493 int bind
= STB_LOCAL
;
7495 if (flags
& BSF_LOCAL
)
7497 else if (flags
& BSF_GNU_UNIQUE
)
7498 bind
= STB_GNU_UNIQUE
;
7499 else if (flags
& BSF_WEAK
)
7501 else if (flags
& BSF_GLOBAL
)
7504 sym
.st_info
= ELF_ST_INFO (bind
, type
);
7507 if (type_ptr
!= NULL
)
7509 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
7510 sym
.st_target_internal
7511 = type_ptr
->internal_elf_sym
.st_target_internal
;
7516 sym
.st_target_internal
= 0;
7520 symstrtab
[idx
].sym
= sym
;
7521 symstrtab
[idx
].dest_index
= outbound_syms_index
;
7522 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
7524 outbound_syms_index
++;
7525 if (outbound_shndx
!= NULL
)
7526 outbound_shndx_index
++;
7529 /* Finalize the .strtab section. */
7530 _bfd_elf_strtab_finalize (stt
);
7532 /* Swap out the .strtab section. */
7533 for (idx
= 0; idx
<= symcount
; idx
++)
7535 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
7536 if (elfsym
->sym
.st_name
== (unsigned long) -1)
7537 elfsym
->sym
.st_name
= 0;
7539 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
7540 elfsym
->sym
.st_name
);
7541 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
7543 + (elfsym
->dest_index
7544 * bed
->s
->sizeof_sym
)),
7546 + (elfsym
->destshndx_index
7547 * sizeof (Elf_External_Sym_Shndx
))));
7552 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
7553 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7555 symstrtab_hdr
->sh_flags
= 0;
7556 symstrtab_hdr
->sh_addr
= 0;
7557 symstrtab_hdr
->sh_entsize
= 0;
7558 symstrtab_hdr
->sh_link
= 0;
7559 symstrtab_hdr
->sh_info
= 0;
7560 symstrtab_hdr
->sh_addralign
= 1;
7565 /* Return the number of bytes required to hold the symtab vector.
7567 Note that we base it on the count plus 1, since we will null terminate
7568 the vector allocated based on this size. However, the ELF symbol table
7569 always has a dummy entry as symbol #0, so it ends up even. */
7572 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
7576 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7578 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7579 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7581 symtab_size
-= sizeof (asymbol
*);
7587 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
7591 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
7593 if (elf_dynsymtab (abfd
) == 0)
7595 bfd_set_error (bfd_error_invalid_operation
);
7599 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
7600 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
7602 symtab_size
-= sizeof (asymbol
*);
7608 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
7611 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
7614 /* Canonicalize the relocs. */
7617 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
7624 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7626 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
7629 tblptr
= section
->relocation
;
7630 for (i
= 0; i
< section
->reloc_count
; i
++)
7631 *relptr
++ = tblptr
++;
7635 return section
->reloc_count
;
7639 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
7641 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7642 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
7645 bfd_get_symcount (abfd
) = symcount
;
7650 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
7651 asymbol
**allocation
)
7653 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7654 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
7657 bfd_get_dynamic_symcount (abfd
) = symcount
;
7661 /* Return the size required for the dynamic reloc entries. Any loadable
7662 section that was actually installed in the BFD, and has type SHT_REL
7663 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7664 dynamic reloc section. */
7667 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
7672 if (elf_dynsymtab (abfd
) == 0)
7674 bfd_set_error (bfd_error_invalid_operation
);
7678 ret
= sizeof (arelent
*);
7679 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7680 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7681 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7682 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7683 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
7684 * sizeof (arelent
*));
7689 /* Canonicalize the dynamic relocation entries. Note that we return the
7690 dynamic relocations as a single block, although they are actually
7691 associated with particular sections; the interface, which was
7692 designed for SunOS style shared libraries, expects that there is only
7693 one set of dynamic relocs. Any loadable section that was actually
7694 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7695 dynamic symbol table, is considered to be a dynamic reloc section. */
7698 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
7702 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
7706 if (elf_dynsymtab (abfd
) == 0)
7708 bfd_set_error (bfd_error_invalid_operation
);
7712 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
7714 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7716 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
7717 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
7718 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
7723 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
7725 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
7727 for (i
= 0; i
< count
; i
++)
7738 /* Read in the version information. */
7741 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
7743 bfd_byte
*contents
= NULL
;
7744 unsigned int freeidx
= 0;
7746 if (elf_dynverref (abfd
) != 0)
7748 Elf_Internal_Shdr
*hdr
;
7749 Elf_External_Verneed
*everneed
;
7750 Elf_Internal_Verneed
*iverneed
;
7752 bfd_byte
*contents_end
;
7754 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
7756 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verneed
))
7758 error_return_bad_verref
:
7759 (*_bfd_error_handler
)
7760 (_("%B: .gnu.version_r invalid entry"), abfd
);
7761 bfd_set_error (bfd_error_bad_value
);
7762 error_return_verref
:
7763 elf_tdata (abfd
)->verref
= NULL
;
7764 elf_tdata (abfd
)->cverrefs
= 0;
7768 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7769 if (contents
== NULL
)
7770 goto error_return_verref
;
7772 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7773 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7774 goto error_return_verref
;
7776 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
7777 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
7779 if (elf_tdata (abfd
)->verref
== NULL
)
7780 goto error_return_verref
;
7782 BFD_ASSERT (sizeof (Elf_External_Verneed
)
7783 == sizeof (Elf_External_Vernaux
));
7784 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
7785 everneed
= (Elf_External_Verneed
*) contents
;
7786 iverneed
= elf_tdata (abfd
)->verref
;
7787 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
7789 Elf_External_Vernaux
*evernaux
;
7790 Elf_Internal_Vernaux
*ivernaux
;
7793 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
7795 iverneed
->vn_bfd
= abfd
;
7797 iverneed
->vn_filename
=
7798 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7800 if (iverneed
->vn_filename
== NULL
)
7801 goto error_return_bad_verref
;
7803 if (iverneed
->vn_cnt
== 0)
7804 iverneed
->vn_auxptr
= NULL
;
7807 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
7808 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
7809 sizeof (Elf_Internal_Vernaux
));
7810 if (iverneed
->vn_auxptr
== NULL
)
7811 goto error_return_verref
;
7814 if (iverneed
->vn_aux
7815 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7816 goto error_return_bad_verref
;
7818 evernaux
= ((Elf_External_Vernaux
*)
7819 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
7820 ivernaux
= iverneed
->vn_auxptr
;
7821 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
7823 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
7825 ivernaux
->vna_nodename
=
7826 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7827 ivernaux
->vna_name
);
7828 if (ivernaux
->vna_nodename
== NULL
)
7829 goto error_return_bad_verref
;
7831 if (ivernaux
->vna_other
> freeidx
)
7832 freeidx
= ivernaux
->vna_other
;
7834 ivernaux
->vna_nextptr
= NULL
;
7835 if (ivernaux
->vna_next
== 0)
7837 iverneed
->vn_cnt
= j
+ 1;
7840 if (j
+ 1 < iverneed
->vn_cnt
)
7841 ivernaux
->vna_nextptr
= ivernaux
+ 1;
7843 if (ivernaux
->vna_next
7844 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
7845 goto error_return_bad_verref
;
7847 evernaux
= ((Elf_External_Vernaux
*)
7848 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
7851 iverneed
->vn_nextref
= NULL
;
7852 if (iverneed
->vn_next
== 0)
7854 if (i
+ 1 < hdr
->sh_info
)
7855 iverneed
->vn_nextref
= iverneed
+ 1;
7857 if (iverneed
->vn_next
7858 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
7859 goto error_return_bad_verref
;
7861 everneed
= ((Elf_External_Verneed
*)
7862 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
7864 elf_tdata (abfd
)->cverrefs
= i
;
7870 if (elf_dynverdef (abfd
) != 0)
7872 Elf_Internal_Shdr
*hdr
;
7873 Elf_External_Verdef
*everdef
;
7874 Elf_Internal_Verdef
*iverdef
;
7875 Elf_Internal_Verdef
*iverdefarr
;
7876 Elf_Internal_Verdef iverdefmem
;
7878 unsigned int maxidx
;
7879 bfd_byte
*contents_end_def
, *contents_end_aux
;
7881 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
7883 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
7885 error_return_bad_verdef
:
7886 (*_bfd_error_handler
)
7887 (_("%B: .gnu.version_d invalid entry"), abfd
);
7888 bfd_set_error (bfd_error_bad_value
);
7889 error_return_verdef
:
7890 elf_tdata (abfd
)->verdef
= NULL
;
7891 elf_tdata (abfd
)->cverdefs
= 0;
7895 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
7896 if (contents
== NULL
)
7897 goto error_return_verdef
;
7898 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
7899 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
7900 goto error_return_verdef
;
7902 BFD_ASSERT (sizeof (Elf_External_Verdef
)
7903 >= sizeof (Elf_External_Verdaux
));
7904 contents_end_def
= contents
+ hdr
->sh_size
7905 - sizeof (Elf_External_Verdef
);
7906 contents_end_aux
= contents
+ hdr
->sh_size
7907 - sizeof (Elf_External_Verdaux
);
7909 /* We know the number of entries in the section but not the maximum
7910 index. Therefore we have to run through all entries and find
7912 everdef
= (Elf_External_Verdef
*) contents
;
7914 for (i
= 0; i
< hdr
->sh_info
; ++i
)
7916 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7918 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
7919 goto error_return_bad_verdef
;
7920 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
7921 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
7923 if (iverdefmem
.vd_next
== 0)
7926 if (iverdefmem
.vd_next
7927 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
7928 goto error_return_bad_verdef
;
7930 everdef
= ((Elf_External_Verdef
*)
7931 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
7934 if (default_imported_symver
)
7936 if (freeidx
> maxidx
)
7942 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7943 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
7944 if (elf_tdata (abfd
)->verdef
== NULL
)
7945 goto error_return_verdef
;
7947 elf_tdata (abfd
)->cverdefs
= maxidx
;
7949 everdef
= (Elf_External_Verdef
*) contents
;
7950 iverdefarr
= elf_tdata (abfd
)->verdef
;
7951 for (i
= 0; i
< hdr
->sh_info
; i
++)
7953 Elf_External_Verdaux
*everdaux
;
7954 Elf_Internal_Verdaux
*iverdaux
;
7957 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7959 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
7960 goto error_return_bad_verdef
;
7962 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
7963 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
7965 iverdef
->vd_bfd
= abfd
;
7967 if (iverdef
->vd_cnt
== 0)
7968 iverdef
->vd_auxptr
= NULL
;
7971 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7972 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
7973 sizeof (Elf_Internal_Verdaux
));
7974 if (iverdef
->vd_auxptr
== NULL
)
7975 goto error_return_verdef
;
7979 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
7980 goto error_return_bad_verdef
;
7982 everdaux
= ((Elf_External_Verdaux
*)
7983 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
7984 iverdaux
= iverdef
->vd_auxptr
;
7985 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
7987 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
7989 iverdaux
->vda_nodename
=
7990 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7991 iverdaux
->vda_name
);
7992 if (iverdaux
->vda_nodename
== NULL
)
7993 goto error_return_bad_verdef
;
7995 iverdaux
->vda_nextptr
= NULL
;
7996 if (iverdaux
->vda_next
== 0)
7998 iverdef
->vd_cnt
= j
+ 1;
8001 if (j
+ 1 < iverdef
->vd_cnt
)
8002 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8004 if (iverdaux
->vda_next
8005 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8006 goto error_return_bad_verdef
;
8008 everdaux
= ((Elf_External_Verdaux
*)
8009 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8012 iverdef
->vd_nodename
= NULL
;
8013 if (iverdef
->vd_cnt
)
8014 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8016 iverdef
->vd_nextdef
= NULL
;
8017 if (iverdef
->vd_next
== 0)
8019 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8020 iverdef
->vd_nextdef
= iverdef
+ 1;
8022 everdef
= ((Elf_External_Verdef
*)
8023 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8029 else if (default_imported_symver
)
8036 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8037 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8038 if (elf_tdata (abfd
)->verdef
== NULL
)
8041 elf_tdata (abfd
)->cverdefs
= freeidx
;
8044 /* Create a default version based on the soname. */
8045 if (default_imported_symver
)
8047 Elf_Internal_Verdef
*iverdef
;
8048 Elf_Internal_Verdaux
*iverdaux
;
8050 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8052 iverdef
->vd_version
= VER_DEF_CURRENT
;
8053 iverdef
->vd_flags
= 0;
8054 iverdef
->vd_ndx
= freeidx
;
8055 iverdef
->vd_cnt
= 1;
8057 iverdef
->vd_bfd
= abfd
;
8059 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8060 if (iverdef
->vd_nodename
== NULL
)
8061 goto error_return_verdef
;
8062 iverdef
->vd_nextdef
= NULL
;
8063 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8064 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8065 if (iverdef
->vd_auxptr
== NULL
)
8066 goto error_return_verdef
;
8068 iverdaux
= iverdef
->vd_auxptr
;
8069 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8075 if (contents
!= NULL
)
8081 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8083 elf_symbol_type
*newsym
;
8085 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
8088 newsym
->symbol
.the_bfd
= abfd
;
8089 return &newsym
->symbol
;
8093 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8097 bfd_symbol_info (symbol
, ret
);
8100 /* Return whether a symbol name implies a local symbol. Most targets
8101 use this function for the is_local_label_name entry point, but some
8105 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8108 /* Normal local symbols start with ``.L''. */
8109 if (name
[0] == '.' && name
[1] == 'L')
8112 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8113 DWARF debugging symbols starting with ``..''. */
8114 if (name
[0] == '.' && name
[1] == '.')
8117 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8118 emitting DWARF debugging output. I suspect this is actually a
8119 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8120 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8121 underscore to be emitted on some ELF targets). For ease of use,
8122 we treat such symbols as local. */
8123 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8126 /* Treat assembler generated fake symbols, dollar local labels and
8127 forward-backward labels (aka local labels) as locals.
8128 These labels have the form:
8130 L0^A.* (fake symbols)
8132 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8134 Versions which start with .L will have already been matched above,
8135 so we only need to match the rest. */
8136 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8138 bfd_boolean ret
= FALSE
;
8142 for (p
= name
+ 2; (c
= *p
); p
++)
8144 if (c
== 1 || c
== 2)
8146 if (c
== 1 && p
== name
+ 2)
8147 /* A fake symbol. */
8150 /* FIXME: We are being paranoid here and treating symbols like
8151 L0^Bfoo as if there were non-local, on the grounds that the
8152 assembler will never generate them. But can any symbol
8153 containing an ASCII value in the range 1-31 ever be anything
8154 other than some kind of local ? */
8171 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
8172 asymbol
*symbol ATTRIBUTE_UNUSED
)
8179 _bfd_elf_set_arch_mach (bfd
*abfd
,
8180 enum bfd_architecture arch
,
8181 unsigned long machine
)
8183 /* If this isn't the right architecture for this backend, and this
8184 isn't the generic backend, fail. */
8185 if (arch
!= get_elf_backend_data (abfd
)->arch
8186 && arch
!= bfd_arch_unknown
8187 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
8190 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
8193 /* Find the nearest line to a particular section and offset,
8194 for error reporting. */
8197 _bfd_elf_find_nearest_line (bfd
*abfd
,
8201 const char **filename_ptr
,
8202 const char **functionname_ptr
,
8203 unsigned int *line_ptr
,
8204 unsigned int *discriminator_ptr
)
8208 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
8209 filename_ptr
, functionname_ptr
,
8210 line_ptr
, discriminator_ptr
,
8211 dwarf_debug_sections
, 0,
8212 &elf_tdata (abfd
)->dwarf2_find_line_info
)
8213 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
8214 filename_ptr
, functionname_ptr
,
8217 if (!*functionname_ptr
)
8218 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8219 *filename_ptr
? NULL
: filename_ptr
,
8224 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
8225 &found
, filename_ptr
,
8226 functionname_ptr
, line_ptr
,
8227 &elf_tdata (abfd
)->line_info
))
8229 if (found
&& (*functionname_ptr
|| *line_ptr
))
8232 if (symbols
== NULL
)
8235 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8236 filename_ptr
, functionname_ptr
))
8243 /* Find the line for a symbol. */
8246 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
8247 const char **filename_ptr
, unsigned int *line_ptr
)
8249 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
8250 filename_ptr
, NULL
, line_ptr
, NULL
,
8251 dwarf_debug_sections
, 0,
8252 &elf_tdata (abfd
)->dwarf2_find_line_info
);
8255 /* After a call to bfd_find_nearest_line, successive calls to
8256 bfd_find_inliner_info can be used to get source information about
8257 each level of function inlining that terminated at the address
8258 passed to bfd_find_nearest_line. Currently this is only supported
8259 for DWARF2 with appropriate DWARF3 extensions. */
8262 _bfd_elf_find_inliner_info (bfd
*abfd
,
8263 const char **filename_ptr
,
8264 const char **functionname_ptr
,
8265 unsigned int *line_ptr
)
8268 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
8269 functionname_ptr
, line_ptr
,
8270 & elf_tdata (abfd
)->dwarf2_find_line_info
);
8275 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
8277 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8278 int ret
= bed
->s
->sizeof_ehdr
;
8280 if (!bfd_link_relocatable (info
))
8282 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
8284 if (phdr_size
== (bfd_size_type
) -1)
8286 struct elf_segment_map
*m
;
8289 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
8290 phdr_size
+= bed
->s
->sizeof_phdr
;
8293 phdr_size
= get_program_header_size (abfd
, info
);
8296 elf_program_header_size (abfd
) = phdr_size
;
8304 _bfd_elf_set_section_contents (bfd
*abfd
,
8306 const void *location
,
8308 bfd_size_type count
)
8310 Elf_Internal_Shdr
*hdr
;
8313 if (! abfd
->output_has_begun
8314 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
8320 hdr
= &elf_section_data (section
)->this_hdr
;
8321 if (hdr
->sh_offset
== (file_ptr
) -1)
8323 /* We must compress this section. Write output to the buffer. */
8324 unsigned char *contents
= hdr
->contents
;
8325 if ((offset
+ count
) > hdr
->sh_size
8326 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
8327 || contents
== NULL
)
8329 memcpy (contents
+ offset
, location
, count
);
8332 pos
= hdr
->sh_offset
+ offset
;
8333 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
8334 || bfd_bwrite (location
, count
, abfd
) != count
)
8341 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
8342 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
8343 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
8348 /* Try to convert a non-ELF reloc into an ELF one. */
8351 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
8353 /* Check whether we really have an ELF howto. */
8355 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
8357 bfd_reloc_code_real_type code
;
8358 reloc_howto_type
*howto
;
8360 /* Alien reloc: Try to determine its type to replace it with an
8361 equivalent ELF reloc. */
8363 if (areloc
->howto
->pc_relative
)
8365 switch (areloc
->howto
->bitsize
)
8368 code
= BFD_RELOC_8_PCREL
;
8371 code
= BFD_RELOC_12_PCREL
;
8374 code
= BFD_RELOC_16_PCREL
;
8377 code
= BFD_RELOC_24_PCREL
;
8380 code
= BFD_RELOC_32_PCREL
;
8383 code
= BFD_RELOC_64_PCREL
;
8389 howto
= bfd_reloc_type_lookup (abfd
, code
);
8391 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
8393 if (howto
->pcrel_offset
)
8394 areloc
->addend
+= areloc
->address
;
8396 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
8401 switch (areloc
->howto
->bitsize
)
8407 code
= BFD_RELOC_14
;
8410 code
= BFD_RELOC_16
;
8413 code
= BFD_RELOC_26
;
8416 code
= BFD_RELOC_32
;
8419 code
= BFD_RELOC_64
;
8425 howto
= bfd_reloc_type_lookup (abfd
, code
);
8429 areloc
->howto
= howto
;
8437 (*_bfd_error_handler
)
8438 (_("%B: unsupported relocation type %s"),
8439 abfd
, areloc
->howto
->name
);
8440 bfd_set_error (bfd_error_bad_value
);
8445 _bfd_elf_close_and_cleanup (bfd
*abfd
)
8447 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
8448 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
8450 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
8451 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
8452 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
8455 return _bfd_generic_close_and_cleanup (abfd
);
8458 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8459 in the relocation's offset. Thus we cannot allow any sort of sanity
8460 range-checking to interfere. There is nothing else to do in processing
8463 bfd_reloc_status_type
8464 _bfd_elf_rel_vtable_reloc_fn
8465 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
8466 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
8467 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
8468 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
8470 return bfd_reloc_ok
;
8473 /* Elf core file support. Much of this only works on native
8474 toolchains, since we rely on knowing the
8475 machine-dependent procfs structure in order to pick
8476 out details about the corefile. */
8478 #ifdef HAVE_SYS_PROCFS_H
8479 /* Needed for new procfs interface on sparc-solaris. */
8480 # define _STRUCTURED_PROC 1
8481 # include <sys/procfs.h>
8484 /* Return a PID that identifies a "thread" for threaded cores, or the
8485 PID of the main process for non-threaded cores. */
8488 elfcore_make_pid (bfd
*abfd
)
8492 pid
= elf_tdata (abfd
)->core
->lwpid
;
8494 pid
= elf_tdata (abfd
)->core
->pid
;
8499 /* If there isn't a section called NAME, make one, using
8500 data from SECT. Note, this function will generate a
8501 reference to NAME, so you shouldn't deallocate or
8505 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
8509 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
8512 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
8516 sect2
->size
= sect
->size
;
8517 sect2
->filepos
= sect
->filepos
;
8518 sect2
->alignment_power
= sect
->alignment_power
;
8522 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
8523 actually creates up to two pseudosections:
8524 - For the single-threaded case, a section named NAME, unless
8525 such a section already exists.
8526 - For the multi-threaded case, a section named "NAME/PID", where
8527 PID is elfcore_make_pid (abfd).
8528 Both pseudosections have identical contents. */
8530 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
8536 char *threaded_name
;
8540 /* Build the section name. */
8542 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
8543 len
= strlen (buf
) + 1;
8544 threaded_name
= (char *) bfd_alloc (abfd
, len
);
8545 if (threaded_name
== NULL
)
8547 memcpy (threaded_name
, buf
, len
);
8549 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
8554 sect
->filepos
= filepos
;
8555 sect
->alignment_power
= 2;
8557 return elfcore_maybe_make_sect (abfd
, name
, sect
);
8560 /* prstatus_t exists on:
8562 linux 2.[01] + glibc
8566 #if defined (HAVE_PRSTATUS_T)
8569 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8574 if (note
->descsz
== sizeof (prstatus_t
))
8578 size
= sizeof (prstat
.pr_reg
);
8579 offset
= offsetof (prstatus_t
, pr_reg
);
8580 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8582 /* Do not overwrite the core signal if it
8583 has already been set by another thread. */
8584 if (elf_tdata (abfd
)->core
->signal
== 0)
8585 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8586 if (elf_tdata (abfd
)->core
->pid
== 0)
8587 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8589 /* pr_who exists on:
8592 pr_who doesn't exist on:
8595 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8596 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8598 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8601 #if defined (HAVE_PRSTATUS32_T)
8602 else if (note
->descsz
== sizeof (prstatus32_t
))
8604 /* 64-bit host, 32-bit corefile */
8605 prstatus32_t prstat
;
8607 size
= sizeof (prstat
.pr_reg
);
8608 offset
= offsetof (prstatus32_t
, pr_reg
);
8609 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
8611 /* Do not overwrite the core signal if it
8612 has already been set by another thread. */
8613 if (elf_tdata (abfd
)->core
->signal
== 0)
8614 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
8615 if (elf_tdata (abfd
)->core
->pid
== 0)
8616 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
8618 /* pr_who exists on:
8621 pr_who doesn't exist on:
8624 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8625 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
8627 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
8630 #endif /* HAVE_PRSTATUS32_T */
8633 /* Fail - we don't know how to handle any other
8634 note size (ie. data object type). */
8638 /* Make a ".reg/999" section and a ".reg" section. */
8639 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
8640 size
, note
->descpos
+ offset
);
8642 #endif /* defined (HAVE_PRSTATUS_T) */
8644 /* Create a pseudosection containing the exact contents of NOTE. */
8646 elfcore_make_note_pseudosection (bfd
*abfd
,
8648 Elf_Internal_Note
*note
)
8650 return _bfd_elfcore_make_pseudosection (abfd
, name
,
8651 note
->descsz
, note
->descpos
);
8654 /* There isn't a consistent prfpregset_t across platforms,
8655 but it doesn't matter, because we don't have to pick this
8656 data structure apart. */
8659 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8661 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8664 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8665 type of NT_PRXFPREG. Just include the whole note's contents
8669 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8671 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
8674 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8675 with a note type of NT_X86_XSTATE. Just include the whole note's
8676 contents literally. */
8679 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
8681 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
8685 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
8687 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
8691 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
8693 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
8697 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
8699 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
8703 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
8705 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
8709 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
8711 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
8715 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
8717 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
8721 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
8723 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
8727 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
8729 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
8733 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8735 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
8739 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
8741 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
8745 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
8747 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
8751 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
8753 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
8757 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
8759 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
8763 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
8765 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
8769 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
8771 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
8775 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
8777 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
8781 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
8783 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
8786 #if defined (HAVE_PRPSINFO_T)
8787 typedef prpsinfo_t elfcore_psinfo_t
;
8788 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
8789 typedef prpsinfo32_t elfcore_psinfo32_t
;
8793 #if defined (HAVE_PSINFO_T)
8794 typedef psinfo_t elfcore_psinfo_t
;
8795 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
8796 typedef psinfo32_t elfcore_psinfo32_t
;
8800 /* return a malloc'ed copy of a string at START which is at
8801 most MAX bytes long, possibly without a terminating '\0'.
8802 the copy will always have a terminating '\0'. */
8805 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
8808 char *end
= (char *) memchr (start
, '\0', max
);
8816 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
8820 memcpy (dups
, start
, len
);
8826 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8828 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8830 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
8832 elfcore_psinfo_t psinfo
;
8834 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8836 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8837 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8839 elf_tdata (abfd
)->core
->program
8840 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8841 sizeof (psinfo
.pr_fname
));
8843 elf_tdata (abfd
)->core
->command
8844 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8845 sizeof (psinfo
.pr_psargs
));
8847 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8848 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
8850 /* 64-bit host, 32-bit corefile */
8851 elfcore_psinfo32_t psinfo
;
8853 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
8855 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8856 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
8858 elf_tdata (abfd
)->core
->program
8859 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
8860 sizeof (psinfo
.pr_fname
));
8862 elf_tdata (abfd
)->core
->command
8863 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
8864 sizeof (psinfo
.pr_psargs
));
8870 /* Fail - we don't know how to handle any other
8871 note size (ie. data object type). */
8875 /* Note that for some reason, a spurious space is tacked
8876 onto the end of the args in some (at least one anyway)
8877 implementations, so strip it off if it exists. */
8880 char *command
= elf_tdata (abfd
)->core
->command
;
8881 int n
= strlen (command
);
8883 if (0 < n
&& command
[n
- 1] == ' ')
8884 command
[n
- 1] = '\0';
8889 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8891 #if defined (HAVE_PSTATUS_T)
8893 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8895 if (note
->descsz
== sizeof (pstatus_t
)
8896 #if defined (HAVE_PXSTATUS_T)
8897 || note
->descsz
== sizeof (pxstatus_t
)
8903 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8905 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8907 #if defined (HAVE_PSTATUS32_T)
8908 else if (note
->descsz
== sizeof (pstatus32_t
))
8910 /* 64-bit host, 32-bit corefile */
8913 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
8915 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
8918 /* Could grab some more details from the "representative"
8919 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8920 NT_LWPSTATUS note, presumably. */
8924 #endif /* defined (HAVE_PSTATUS_T) */
8926 #if defined (HAVE_LWPSTATUS_T)
8928 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8930 lwpstatus_t lwpstat
;
8936 if (note
->descsz
!= sizeof (lwpstat
)
8937 #if defined (HAVE_LWPXSTATUS_T)
8938 && note
->descsz
!= sizeof (lwpxstatus_t
)
8943 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
8945 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
8946 /* Do not overwrite the core signal if it has already been set by
8948 if (elf_tdata (abfd
)->core
->signal
== 0)
8949 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
8951 /* Make a ".reg/999" section. */
8953 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
8954 len
= strlen (buf
) + 1;
8955 name
= bfd_alloc (abfd
, len
);
8958 memcpy (name
, buf
, len
);
8960 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8964 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8965 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
8966 sect
->filepos
= note
->descpos
8967 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
8970 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8971 sect
->size
= sizeof (lwpstat
.pr_reg
);
8972 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
8975 sect
->alignment_power
= 2;
8977 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8980 /* Make a ".reg2/999" section */
8982 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
8983 len
= strlen (buf
) + 1;
8984 name
= bfd_alloc (abfd
, len
);
8987 memcpy (name
, buf
, len
);
8989 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8993 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8994 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
8995 sect
->filepos
= note
->descpos
8996 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
8999 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9000 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9001 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9004 sect
->alignment_power
= 2;
9006 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9008 #endif /* defined (HAVE_LWPSTATUS_T) */
9011 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9018 int is_active_thread
;
9021 if (note
->descsz
< 728)
9024 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9027 type
= bfd_get_32 (abfd
, note
->descdata
);
9031 case 1 /* NOTE_INFO_PROCESS */:
9032 /* FIXME: need to add ->core->command. */
9033 /* process_info.pid */
9034 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9035 /* process_info.signal */
9036 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
9039 case 2 /* NOTE_INFO_THREAD */:
9040 /* Make a ".reg/999" section. */
9041 /* thread_info.tid */
9042 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
9044 len
= strlen (buf
) + 1;
9045 name
= (char *) bfd_alloc (abfd
, len
);
9049 memcpy (name
, buf
, len
);
9051 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9055 /* sizeof (thread_info.thread_context) */
9057 /* offsetof (thread_info.thread_context) */
9058 sect
->filepos
= note
->descpos
+ 12;
9059 sect
->alignment_power
= 2;
9061 /* thread_info.is_active_thread */
9062 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9064 if (is_active_thread
)
9065 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9069 case 3 /* NOTE_INFO_MODULE */:
9070 /* Make a ".module/xxxxxxxx" section. */
9071 /* module_info.base_address */
9072 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
9073 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
9075 len
= strlen (buf
) + 1;
9076 name
= (char *) bfd_alloc (abfd
, len
);
9080 memcpy (name
, buf
, len
);
9082 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9087 sect
->size
= note
->descsz
;
9088 sect
->filepos
= note
->descpos
;
9089 sect
->alignment_power
= 2;
9100 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9102 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9110 if (bed
->elf_backend_grok_prstatus
)
9111 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
9113 #if defined (HAVE_PRSTATUS_T)
9114 return elfcore_grok_prstatus (abfd
, note
);
9119 #if defined (HAVE_PSTATUS_T)
9121 return elfcore_grok_pstatus (abfd
, note
);
9124 #if defined (HAVE_LWPSTATUS_T)
9126 return elfcore_grok_lwpstatus (abfd
, note
);
9129 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
9130 return elfcore_grok_prfpreg (abfd
, note
);
9132 case NT_WIN32PSTATUS
:
9133 return elfcore_grok_win32pstatus (abfd
, note
);
9135 case NT_PRXFPREG
: /* Linux SSE extension */
9136 if (note
->namesz
== 6
9137 && strcmp (note
->namedata
, "LINUX") == 0)
9138 return elfcore_grok_prxfpreg (abfd
, note
);
9142 case NT_X86_XSTATE
: /* Linux XSAVE extension */
9143 if (note
->namesz
== 6
9144 && strcmp (note
->namedata
, "LINUX") == 0)
9145 return elfcore_grok_xstatereg (abfd
, note
);
9146 else if (note
->namesz
== 8
9147 && strcmp (note
->namedata
, "FreeBSD") == 0)
9148 return elfcore_grok_xstatereg (abfd
, note
);
9153 if (note
->namesz
== 6
9154 && strcmp (note
->namedata
, "LINUX") == 0)
9155 return elfcore_grok_ppc_vmx (abfd
, note
);
9160 if (note
->namesz
== 6
9161 && strcmp (note
->namedata
, "LINUX") == 0)
9162 return elfcore_grok_ppc_vsx (abfd
, note
);
9166 case NT_S390_HIGH_GPRS
:
9167 if (note
->namesz
== 6
9168 && strcmp (note
->namedata
, "LINUX") == 0)
9169 return elfcore_grok_s390_high_gprs (abfd
, note
);
9174 if (note
->namesz
== 6
9175 && strcmp (note
->namedata
, "LINUX") == 0)
9176 return elfcore_grok_s390_timer (abfd
, note
);
9180 case NT_S390_TODCMP
:
9181 if (note
->namesz
== 6
9182 && strcmp (note
->namedata
, "LINUX") == 0)
9183 return elfcore_grok_s390_todcmp (abfd
, note
);
9187 case NT_S390_TODPREG
:
9188 if (note
->namesz
== 6
9189 && strcmp (note
->namedata
, "LINUX") == 0)
9190 return elfcore_grok_s390_todpreg (abfd
, note
);
9195 if (note
->namesz
== 6
9196 && strcmp (note
->namedata
, "LINUX") == 0)
9197 return elfcore_grok_s390_ctrs (abfd
, note
);
9201 case NT_S390_PREFIX
:
9202 if (note
->namesz
== 6
9203 && strcmp (note
->namedata
, "LINUX") == 0)
9204 return elfcore_grok_s390_prefix (abfd
, note
);
9208 case NT_S390_LAST_BREAK
:
9209 if (note
->namesz
== 6
9210 && strcmp (note
->namedata
, "LINUX") == 0)
9211 return elfcore_grok_s390_last_break (abfd
, note
);
9215 case NT_S390_SYSTEM_CALL
:
9216 if (note
->namesz
== 6
9217 && strcmp (note
->namedata
, "LINUX") == 0)
9218 return elfcore_grok_s390_system_call (abfd
, note
);
9223 if (note
->namesz
== 6
9224 && strcmp (note
->namedata
, "LINUX") == 0)
9225 return elfcore_grok_s390_tdb (abfd
, note
);
9229 case NT_S390_VXRS_LOW
:
9230 if (note
->namesz
== 6
9231 && strcmp (note
->namedata
, "LINUX") == 0)
9232 return elfcore_grok_s390_vxrs_low (abfd
, note
);
9236 case NT_S390_VXRS_HIGH
:
9237 if (note
->namesz
== 6
9238 && strcmp (note
->namedata
, "LINUX") == 0)
9239 return elfcore_grok_s390_vxrs_high (abfd
, note
);
9244 if (note
->namesz
== 6
9245 && strcmp (note
->namedata
, "LINUX") == 0)
9246 return elfcore_grok_arm_vfp (abfd
, note
);
9251 if (note
->namesz
== 6
9252 && strcmp (note
->namedata
, "LINUX") == 0)
9253 return elfcore_grok_aarch_tls (abfd
, note
);
9257 case NT_ARM_HW_BREAK
:
9258 if (note
->namesz
== 6
9259 && strcmp (note
->namedata
, "LINUX") == 0)
9260 return elfcore_grok_aarch_hw_break (abfd
, note
);
9264 case NT_ARM_HW_WATCH
:
9265 if (note
->namesz
== 6
9266 && strcmp (note
->namedata
, "LINUX") == 0)
9267 return elfcore_grok_aarch_hw_watch (abfd
, note
);
9273 if (bed
->elf_backend_grok_psinfo
)
9274 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
9276 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9277 return elfcore_grok_psinfo (abfd
, note
);
9284 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9289 sect
->size
= note
->descsz
;
9290 sect
->filepos
= note
->descpos
;
9291 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9297 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
9301 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
9304 case NT_FREEBSD_THRMISC
:
9305 if (note
->namesz
== 8
9306 && strcmp (note
->namedata
, "FreeBSD") == 0)
9307 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
9314 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
9316 struct bfd_build_id
* build_id
;
9318 if (note
->descsz
== 0)
9321 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
9322 if (build_id
== NULL
)
9325 build_id
->size
= note
->descsz
;
9326 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
9327 abfd
->build_id
= build_id
;
9333 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9340 case NT_GNU_BUILD_ID
:
9341 return elfobj_grok_gnu_build_id (abfd
, note
);
9346 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
9348 struct sdt_note
*cur
=
9349 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
9352 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
9353 cur
->size
= (bfd_size_type
) note
->descsz
;
9354 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
9356 elf_tdata (abfd
)->sdt_note_head
= cur
;
9362 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9367 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
9375 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
9379 cp
= strchr (note
->namedata
, '@');
9382 *lwpidp
= atoi(cp
+ 1);
9389 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9391 /* Signal number at offset 0x08. */
9392 elf_tdata (abfd
)->core
->signal
9393 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
9395 /* Process ID at offset 0x50. */
9396 elf_tdata (abfd
)->core
->pid
9397 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
9399 /* Command name at 0x7c (max 32 bytes, including nul). */
9400 elf_tdata (abfd
)->core
->command
9401 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
9403 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
9408 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9412 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
9413 elf_tdata (abfd
)->core
->lwpid
= lwp
;
9415 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
9417 /* NetBSD-specific core "procinfo". Note that we expect to
9418 find this note before any of the others, which is fine,
9419 since the kernel writes this note out first when it
9420 creates a core file. */
9422 return elfcore_grok_netbsd_procinfo (abfd
, note
);
9425 /* As of Jan 2002 there are no other machine-independent notes
9426 defined for NetBSD core files. If the note type is less
9427 than the start of the machine-dependent note types, we don't
9430 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
9434 switch (bfd_get_arch (abfd
))
9436 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
9437 PT_GETFPREGS == mach+2. */
9439 case bfd_arch_alpha
:
9440 case bfd_arch_sparc
:
9443 case NT_NETBSDCORE_FIRSTMACH
+0:
9444 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9446 case NT_NETBSDCORE_FIRSTMACH
+2:
9447 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9453 /* On all other arch's, PT_GETREGS == mach+1 and
9454 PT_GETFPREGS == mach+3. */
9459 case NT_NETBSDCORE_FIRSTMACH
+1:
9460 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9462 case NT_NETBSDCORE_FIRSTMACH
+3:
9463 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9473 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9475 /* Signal number at offset 0x08. */
9476 elf_tdata (abfd
)->core
->signal
9477 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
9479 /* Process ID at offset 0x20. */
9480 elf_tdata (abfd
)->core
->pid
9481 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
9483 /* Command name at 0x48 (max 32 bytes, including nul). */
9484 elf_tdata (abfd
)->core
->command
9485 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
9491 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9493 if (note
->type
== NT_OPENBSD_PROCINFO
)
9494 return elfcore_grok_openbsd_procinfo (abfd
, note
);
9496 if (note
->type
== NT_OPENBSD_REGS
)
9497 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
9499 if (note
->type
== NT_OPENBSD_FPREGS
)
9500 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9502 if (note
->type
== NT_OPENBSD_XFPREGS
)
9503 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9505 if (note
->type
== NT_OPENBSD_AUXV
)
9507 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9512 sect
->size
= note
->descsz
;
9513 sect
->filepos
= note
->descpos
;
9514 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9519 if (note
->type
== NT_OPENBSD_WCOOKIE
)
9521 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
9526 sect
->size
= note
->descsz
;
9527 sect
->filepos
= note
->descpos
;
9528 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9537 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
9539 void *ddata
= note
->descdata
;
9546 /* nto_procfs_status 'pid' field is at offset 0. */
9547 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
9549 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
9550 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
9552 /* nto_procfs_status 'flags' field is at offset 8. */
9553 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
9555 /* nto_procfs_status 'what' field is at offset 14. */
9556 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
9558 elf_tdata (abfd
)->core
->signal
= sig
;
9559 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9562 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
9563 do not come from signals so we make sure we set the current
9564 thread just in case. */
9565 if (flags
& 0x00000080)
9566 elf_tdata (abfd
)->core
->lwpid
= *tid
;
9568 /* Make a ".qnx_core_status/%d" section. */
9569 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
9571 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9576 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9580 sect
->size
= note
->descsz
;
9581 sect
->filepos
= note
->descpos
;
9582 sect
->alignment_power
= 2;
9584 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
9588 elfcore_grok_nto_regs (bfd
*abfd
,
9589 Elf_Internal_Note
*note
,
9597 /* Make a "(base)/%d" section. */
9598 sprintf (buf
, "%s/%ld", base
, tid
);
9600 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
9605 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9609 sect
->size
= note
->descsz
;
9610 sect
->filepos
= note
->descpos
;
9611 sect
->alignment_power
= 2;
9613 /* This is the current thread. */
9614 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
9615 return elfcore_maybe_make_sect (abfd
, base
, sect
);
9620 #define BFD_QNT_CORE_INFO 7
9621 #define BFD_QNT_CORE_STATUS 8
9622 #define BFD_QNT_CORE_GREG 9
9623 #define BFD_QNT_CORE_FPREG 10
9626 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9628 /* Every GREG section has a STATUS section before it. Store the
9629 tid from the previous call to pass down to the next gregs
9631 static long tid
= 1;
9635 case BFD_QNT_CORE_INFO
:
9636 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
9637 case BFD_QNT_CORE_STATUS
:
9638 return elfcore_grok_nto_status (abfd
, note
, &tid
);
9639 case BFD_QNT_CORE_GREG
:
9640 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
9641 case BFD_QNT_CORE_FPREG
:
9642 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
9649 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9655 /* Use note name as section name. */
9657 name
= (char *) bfd_alloc (abfd
, len
);
9660 memcpy (name
, note
->namedata
, len
);
9661 name
[len
- 1] = '\0';
9663 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9667 sect
->size
= note
->descsz
;
9668 sect
->filepos
= note
->descpos
;
9669 sect
->alignment_power
= 1;
9674 /* Function: elfcore_write_note
9677 buffer to hold note, and current size of buffer
9681 size of data for note
9683 Writes note to end of buffer. ELF64 notes are written exactly as
9684 for ELF32, despite the current (as of 2006) ELF gabi specifying
9685 that they ought to have 8-byte namesz and descsz field, and have
9686 8-byte alignment. Other writers, eg. Linux kernel, do the same.
9689 Pointer to realloc'd buffer, *BUFSIZ updated. */
9692 elfcore_write_note (bfd
*abfd
,
9700 Elf_External_Note
*xnp
;
9707 namesz
= strlen (name
) + 1;
9709 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
9711 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
9714 dest
= buf
+ *bufsiz
;
9715 *bufsiz
+= newspace
;
9716 xnp
= (Elf_External_Note
*) dest
;
9717 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
9718 H_PUT_32 (abfd
, size
, xnp
->descsz
);
9719 H_PUT_32 (abfd
, type
, xnp
->type
);
9723 memcpy (dest
, name
, namesz
);
9731 memcpy (dest
, input
, size
);
9742 elfcore_write_prpsinfo (bfd
*abfd
,
9748 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9750 if (bed
->elf_backend_write_core_note
!= NULL
)
9753 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9754 NT_PRPSINFO
, fname
, psargs
);
9759 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9760 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9761 if (bed
->s
->elfclass
== ELFCLASS32
)
9763 #if defined (HAVE_PSINFO32_T)
9765 int note_type
= NT_PSINFO
;
9768 int note_type
= NT_PRPSINFO
;
9771 memset (&data
, 0, sizeof (data
));
9772 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9773 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9774 return elfcore_write_note (abfd
, buf
, bufsiz
,
9775 "CORE", note_type
, &data
, sizeof (data
));
9780 #if defined (HAVE_PSINFO_T)
9782 int note_type
= NT_PSINFO
;
9785 int note_type
= NT_PRPSINFO
;
9788 memset (&data
, 0, sizeof (data
));
9789 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
9790 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
9791 return elfcore_write_note (abfd
, buf
, bufsiz
,
9792 "CORE", note_type
, &data
, sizeof (data
));
9794 #endif /* PSINFO_T or PRPSINFO_T */
9801 elfcore_write_linux_prpsinfo32
9802 (bfd
*abfd
, char *buf
, int *bufsiz
,
9803 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9805 struct elf_external_linux_prpsinfo32 data
;
9807 swap_linux_prpsinfo32_out (abfd
, prpsinfo
, &data
);
9808 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
9809 &data
, sizeof (data
));
9813 elfcore_write_linux_prpsinfo64
9814 (bfd
*abfd
, char *buf
, int *bufsiz
,
9815 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
9817 struct elf_external_linux_prpsinfo64 data
;
9819 swap_linux_prpsinfo64_out (abfd
, prpsinfo
, &data
);
9820 return elfcore_write_note (abfd
, buf
, bufsiz
,
9821 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
9825 elfcore_write_prstatus (bfd
*abfd
,
9832 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9834 if (bed
->elf_backend_write_core_note
!= NULL
)
9837 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
9839 pid
, cursig
, gregs
);
9844 #if defined (HAVE_PRSTATUS_T)
9845 #if defined (HAVE_PRSTATUS32_T)
9846 if (bed
->s
->elfclass
== ELFCLASS32
)
9848 prstatus32_t prstat
;
9850 memset (&prstat
, 0, sizeof (prstat
));
9851 prstat
.pr_pid
= pid
;
9852 prstat
.pr_cursig
= cursig
;
9853 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9854 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9855 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9862 memset (&prstat
, 0, sizeof (prstat
));
9863 prstat
.pr_pid
= pid
;
9864 prstat
.pr_cursig
= cursig
;
9865 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
9866 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
9867 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
9869 #endif /* HAVE_PRSTATUS_T */
9875 #if defined (HAVE_LWPSTATUS_T)
9877 elfcore_write_lwpstatus (bfd
*abfd
,
9884 lwpstatus_t lwpstat
;
9885 const char *note_name
= "CORE";
9887 memset (&lwpstat
, 0, sizeof (lwpstat
));
9888 lwpstat
.pr_lwpid
= pid
>> 16;
9889 lwpstat
.pr_cursig
= cursig
;
9890 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9891 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
9892 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9894 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
9895 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
9897 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
9898 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
9901 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9902 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
9904 #endif /* HAVE_LWPSTATUS_T */
9906 #if defined (HAVE_PSTATUS_T)
9908 elfcore_write_pstatus (bfd
*abfd
,
9912 int cursig ATTRIBUTE_UNUSED
,
9913 const void *gregs ATTRIBUTE_UNUSED
)
9915 const char *note_name
= "CORE";
9916 #if defined (HAVE_PSTATUS32_T)
9917 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9919 if (bed
->s
->elfclass
== ELFCLASS32
)
9923 memset (&pstat
, 0, sizeof (pstat
));
9924 pstat
.pr_pid
= pid
& 0xffff;
9925 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9926 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9934 memset (&pstat
, 0, sizeof (pstat
));
9935 pstat
.pr_pid
= pid
& 0xffff;
9936 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
9937 NT_PSTATUS
, &pstat
, sizeof (pstat
));
9941 #endif /* HAVE_PSTATUS_T */
9944 elfcore_write_prfpreg (bfd
*abfd
,
9950 const char *note_name
= "CORE";
9951 return elfcore_write_note (abfd
, buf
, bufsiz
,
9952 note_name
, NT_FPREGSET
, fpregs
, size
);
9956 elfcore_write_prxfpreg (bfd
*abfd
,
9959 const void *xfpregs
,
9962 char *note_name
= "LINUX";
9963 return elfcore_write_note (abfd
, buf
, bufsiz
,
9964 note_name
, NT_PRXFPREG
, xfpregs
, size
);
9968 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
9969 const void *xfpregs
, int size
)
9972 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
9973 note_name
= "FreeBSD";
9975 note_name
= "LINUX";
9976 return elfcore_write_note (abfd
, buf
, bufsiz
,
9977 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
9981 elfcore_write_ppc_vmx (bfd
*abfd
,
9984 const void *ppc_vmx
,
9987 char *note_name
= "LINUX";
9988 return elfcore_write_note (abfd
, buf
, bufsiz
,
9989 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
9993 elfcore_write_ppc_vsx (bfd
*abfd
,
9996 const void *ppc_vsx
,
9999 char *note_name
= "LINUX";
10000 return elfcore_write_note (abfd
, buf
, bufsiz
,
10001 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
10005 elfcore_write_s390_high_gprs (bfd
*abfd
,
10008 const void *s390_high_gprs
,
10011 char *note_name
= "LINUX";
10012 return elfcore_write_note (abfd
, buf
, bufsiz
,
10013 note_name
, NT_S390_HIGH_GPRS
,
10014 s390_high_gprs
, size
);
10018 elfcore_write_s390_timer (bfd
*abfd
,
10021 const void *s390_timer
,
10024 char *note_name
= "LINUX";
10025 return elfcore_write_note (abfd
, buf
, bufsiz
,
10026 note_name
, NT_S390_TIMER
, s390_timer
, size
);
10030 elfcore_write_s390_todcmp (bfd
*abfd
,
10033 const void *s390_todcmp
,
10036 char *note_name
= "LINUX";
10037 return elfcore_write_note (abfd
, buf
, bufsiz
,
10038 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
10042 elfcore_write_s390_todpreg (bfd
*abfd
,
10045 const void *s390_todpreg
,
10048 char *note_name
= "LINUX";
10049 return elfcore_write_note (abfd
, buf
, bufsiz
,
10050 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
10054 elfcore_write_s390_ctrs (bfd
*abfd
,
10057 const void *s390_ctrs
,
10060 char *note_name
= "LINUX";
10061 return elfcore_write_note (abfd
, buf
, bufsiz
,
10062 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
10066 elfcore_write_s390_prefix (bfd
*abfd
,
10069 const void *s390_prefix
,
10072 char *note_name
= "LINUX";
10073 return elfcore_write_note (abfd
, buf
, bufsiz
,
10074 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
10078 elfcore_write_s390_last_break (bfd
*abfd
,
10081 const void *s390_last_break
,
10084 char *note_name
= "LINUX";
10085 return elfcore_write_note (abfd
, buf
, bufsiz
,
10086 note_name
, NT_S390_LAST_BREAK
,
10087 s390_last_break
, size
);
10091 elfcore_write_s390_system_call (bfd
*abfd
,
10094 const void *s390_system_call
,
10097 char *note_name
= "LINUX";
10098 return elfcore_write_note (abfd
, buf
, bufsiz
,
10099 note_name
, NT_S390_SYSTEM_CALL
,
10100 s390_system_call
, size
);
10104 elfcore_write_s390_tdb (bfd
*abfd
,
10107 const void *s390_tdb
,
10110 char *note_name
= "LINUX";
10111 return elfcore_write_note (abfd
, buf
, bufsiz
,
10112 note_name
, NT_S390_TDB
, s390_tdb
, size
);
10116 elfcore_write_s390_vxrs_low (bfd
*abfd
,
10119 const void *s390_vxrs_low
,
10122 char *note_name
= "LINUX";
10123 return elfcore_write_note (abfd
, buf
, bufsiz
,
10124 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
10128 elfcore_write_s390_vxrs_high (bfd
*abfd
,
10131 const void *s390_vxrs_high
,
10134 char *note_name
= "LINUX";
10135 return elfcore_write_note (abfd
, buf
, bufsiz
,
10136 note_name
, NT_S390_VXRS_HIGH
,
10137 s390_vxrs_high
, size
);
10141 elfcore_write_arm_vfp (bfd
*abfd
,
10144 const void *arm_vfp
,
10147 char *note_name
= "LINUX";
10148 return elfcore_write_note (abfd
, buf
, bufsiz
,
10149 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
10153 elfcore_write_aarch_tls (bfd
*abfd
,
10156 const void *aarch_tls
,
10159 char *note_name
= "LINUX";
10160 return elfcore_write_note (abfd
, buf
, bufsiz
,
10161 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
10165 elfcore_write_aarch_hw_break (bfd
*abfd
,
10168 const void *aarch_hw_break
,
10171 char *note_name
= "LINUX";
10172 return elfcore_write_note (abfd
, buf
, bufsiz
,
10173 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
10177 elfcore_write_aarch_hw_watch (bfd
*abfd
,
10180 const void *aarch_hw_watch
,
10183 char *note_name
= "LINUX";
10184 return elfcore_write_note (abfd
, buf
, bufsiz
,
10185 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
10189 elfcore_write_register_note (bfd
*abfd
,
10192 const char *section
,
10196 if (strcmp (section
, ".reg2") == 0)
10197 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
10198 if (strcmp (section
, ".reg-xfp") == 0)
10199 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
10200 if (strcmp (section
, ".reg-xstate") == 0)
10201 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
10202 if (strcmp (section
, ".reg-ppc-vmx") == 0)
10203 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
10204 if (strcmp (section
, ".reg-ppc-vsx") == 0)
10205 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
10206 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
10207 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
10208 if (strcmp (section
, ".reg-s390-timer") == 0)
10209 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
10210 if (strcmp (section
, ".reg-s390-todcmp") == 0)
10211 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
10212 if (strcmp (section
, ".reg-s390-todpreg") == 0)
10213 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
10214 if (strcmp (section
, ".reg-s390-ctrs") == 0)
10215 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
10216 if (strcmp (section
, ".reg-s390-prefix") == 0)
10217 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
10218 if (strcmp (section
, ".reg-s390-last-break") == 0)
10219 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
10220 if (strcmp (section
, ".reg-s390-system-call") == 0)
10221 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
10222 if (strcmp (section
, ".reg-s390-tdb") == 0)
10223 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
10224 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
10225 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
10226 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
10227 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
10228 if (strcmp (section
, ".reg-arm-vfp") == 0)
10229 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
10230 if (strcmp (section
, ".reg-aarch-tls") == 0)
10231 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
10232 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
10233 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
10234 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
10235 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
10240 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
10245 while (p
< buf
+ size
)
10247 /* FIXME: bad alignment assumption. */
10248 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
10249 Elf_Internal_Note in
;
10251 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
10254 in
.type
= H_GET_32 (abfd
, xnp
->type
);
10256 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
10257 in
.namedata
= xnp
->name
;
10258 if (in
.namesz
> buf
- in
.namedata
+ size
)
10261 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
10262 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
10263 in
.descpos
= offset
+ (in
.descdata
- buf
);
10265 && (in
.descdata
>= buf
+ size
10266 || in
.descsz
> buf
- in
.descdata
+ size
))
10269 switch (bfd_get_format (abfd
))
10276 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
10279 const char * string
;
10281 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
10285 GROKER_ELEMENT ("", elfcore_grok_note
),
10286 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
10287 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
10288 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
10289 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
10291 #undef GROKER_ELEMENT
10294 for (i
= ARRAY_SIZE (grokers
); i
--;)
10296 if (in
.namesz
>= grokers
[i
].len
10297 && strncmp (in
.namedata
, grokers
[i
].string
,
10298 grokers
[i
].len
) == 0)
10300 if (! grokers
[i
].func (abfd
, & in
))
10309 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
10311 if (! elfobj_grok_gnu_note (abfd
, &in
))
10314 else if (in
.namesz
== sizeof "stapsdt"
10315 && strcmp (in
.namedata
, "stapsdt") == 0)
10317 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
10323 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
10330 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
10337 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
10340 buf
= (char *) bfd_malloc (size
+ 1);
10344 /* PR 17512: file: ec08f814
10345 0-termintate the buffer so that string searches will not overflow. */
10348 if (bfd_bread (buf
, size
, abfd
) != size
10349 || !elf_parse_notes (abfd
, buf
, size
, offset
))
10359 /* Providing external access to the ELF program header table. */
10361 /* Return an upper bound on the number of bytes required to store a
10362 copy of ABFD's program header table entries. Return -1 if an error
10363 occurs; bfd_get_error will return an appropriate code. */
10366 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
10368 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
10370 bfd_set_error (bfd_error_wrong_format
);
10374 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
10377 /* Copy ABFD's program header table entries to *PHDRS. The entries
10378 will be stored as an array of Elf_Internal_Phdr structures, as
10379 defined in include/elf/internal.h. To find out how large the
10380 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
10382 Return the number of program header table entries read, or -1 if an
10383 error occurs; bfd_get_error will return an appropriate code. */
10386 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
10390 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
10392 bfd_set_error (bfd_error_wrong_format
);
10396 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
10397 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
10398 num_phdrs
* sizeof (Elf_Internal_Phdr
));
10403 enum elf_reloc_type_class
10404 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
10405 const asection
*rel_sec ATTRIBUTE_UNUSED
,
10406 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
10408 return reloc_class_normal
;
10411 /* For RELA architectures, return the relocation value for a
10412 relocation against a local symbol. */
10415 _bfd_elf_rela_local_sym (bfd
*abfd
,
10416 Elf_Internal_Sym
*sym
,
10418 Elf_Internal_Rela
*rel
)
10420 asection
*sec
= *psec
;
10421 bfd_vma relocation
;
10423 relocation
= (sec
->output_section
->vma
10424 + sec
->output_offset
10426 if ((sec
->flags
& SEC_MERGE
)
10427 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
10428 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
10431 _bfd_merged_section_offset (abfd
, psec
,
10432 elf_section_data (sec
)->sec_info
,
10433 sym
->st_value
+ rel
->r_addend
);
10436 /* If we have changed the section, and our original section is
10437 marked with SEC_EXCLUDE, it means that the original
10438 SEC_MERGE section has been completely subsumed in some
10439 other SEC_MERGE section. In this case, we need to leave
10440 some info around for --emit-relocs. */
10441 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
10442 sec
->kept_section
= *psec
;
10445 rel
->r_addend
-= relocation
;
10446 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
10452 _bfd_elf_rel_local_sym (bfd
*abfd
,
10453 Elf_Internal_Sym
*sym
,
10457 asection
*sec
= *psec
;
10459 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
10460 return sym
->st_value
+ addend
;
10462 return _bfd_merged_section_offset (abfd
, psec
,
10463 elf_section_data (sec
)->sec_info
,
10464 sym
->st_value
+ addend
);
10467 /* Adjust an address within a section. Given OFFSET within SEC, return
10468 the new offset within the section, based upon changes made to the
10469 section. Returns -1 if the offset is now invalid.
10470 The offset (in abnd out) is in target sized bytes, however big a
10474 _bfd_elf_section_offset (bfd
*abfd
,
10475 struct bfd_link_info
*info
,
10479 switch (sec
->sec_info_type
)
10481 case SEC_INFO_TYPE_STABS
:
10482 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
10484 case SEC_INFO_TYPE_EH_FRAME
:
10485 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
10488 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
10490 /* Reverse the offset. */
10491 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10492 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
10494 /* address_size and sec->size are in octets. Convert
10495 to bytes before subtracting the original offset. */
10496 offset
= (sec
->size
- address_size
) / bfd_octets_per_byte (abfd
) - offset
;
10502 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
10503 reconstruct an ELF file by reading the segments out of remote memory
10504 based on the ELF file header at EHDR_VMA and the ELF program headers it
10505 points to. If not null, *LOADBASEP is filled in with the difference
10506 between the VMAs from which the segments were read, and the VMAs the
10507 file headers (and hence BFD's idea of each section's VMA) put them at.
10509 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
10510 remote memory at target address VMA into the local buffer at MYADDR; it
10511 should return zero on success or an `errno' code on failure. TEMPL must
10512 be a BFD for an ELF target with the word size and byte order found in
10513 the remote memory. */
10516 bfd_elf_bfd_from_remote_memory
10519 bfd_size_type size
,
10520 bfd_vma
*loadbasep
,
10521 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
10523 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
10524 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
10528 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
10529 long symcount ATTRIBUTE_UNUSED
,
10530 asymbol
**syms ATTRIBUTE_UNUSED
,
10535 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10538 const char *relplt_name
;
10539 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
10543 Elf_Internal_Shdr
*hdr
;
10549 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
10552 if (dynsymcount
<= 0)
10555 if (!bed
->plt_sym_val
)
10558 relplt_name
= bed
->relplt_name
;
10559 if (relplt_name
== NULL
)
10560 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
10561 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
10562 if (relplt
== NULL
)
10565 hdr
= &elf_section_data (relplt
)->this_hdr
;
10566 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
10567 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
10570 plt
= bfd_get_section_by_name (abfd
, ".plt");
10574 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
10575 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
10578 count
= relplt
->size
/ hdr
->sh_entsize
;
10579 size
= count
* sizeof (asymbol
);
10580 p
= relplt
->relocation
;
10581 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10583 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
10584 if (p
->addend
!= 0)
10587 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
10589 size
+= sizeof ("+0x") - 1 + 8;
10594 s
= *ret
= (asymbol
*) bfd_malloc (size
);
10598 names
= (char *) (s
+ count
);
10599 p
= relplt
->relocation
;
10601 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
10606 addr
= bed
->plt_sym_val (i
, plt
, p
);
10607 if (addr
== (bfd_vma
) -1)
10610 *s
= **p
->sym_ptr_ptr
;
10611 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
10612 we are defining a symbol, ensure one of them is set. */
10613 if ((s
->flags
& BSF_LOCAL
) == 0)
10614 s
->flags
|= BSF_GLOBAL
;
10615 s
->flags
|= BSF_SYNTHETIC
;
10617 s
->value
= addr
- plt
->vma
;
10620 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
10621 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
10623 if (p
->addend
!= 0)
10627 memcpy (names
, "+0x", sizeof ("+0x") - 1);
10628 names
+= sizeof ("+0x") - 1;
10629 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
10630 for (a
= buf
; *a
== '0'; ++a
)
10633 memcpy (names
, a
, len
);
10636 memcpy (names
, "@plt", sizeof ("@plt"));
10637 names
+= sizeof ("@plt");
10644 /* It is only used by x86-64 so far. */
10645 asection _bfd_elf_large_com_section
10646 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
10647 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
10650 _bfd_elf_post_process_headers (bfd
* abfd
,
10651 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
10653 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
10655 i_ehdrp
= elf_elfheader (abfd
);
10657 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
10659 /* To make things simpler for the loader on Linux systems we set the
10660 osabi field to ELFOSABI_GNU if the binary contains symbols of
10661 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
10662 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
10663 && elf_tdata (abfd
)->has_gnu_symbols
)
10664 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
10668 /* Return TRUE for ELF symbol types that represent functions.
10669 This is the default version of this function, which is sufficient for
10670 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
10673 _bfd_elf_is_function_type (unsigned int type
)
10675 return (type
== STT_FUNC
10676 || type
== STT_GNU_IFUNC
);
10679 /* If the ELF symbol SYM might be a function in SEC, return the
10680 function size and set *CODE_OFF to the function's entry point,
10681 otherwise return zero. */
10684 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
10687 bfd_size_type size
;
10689 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
10690 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
10691 || sym
->section
!= sec
)
10694 *code_off
= sym
->value
;
10696 if (!(sym
->flags
& BSF_SYNTHETIC
))
10697 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;