1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 BFD support for ELF formats is being worked on.
29 Currently, the best supported back ends are for sparc and i386
30 (running svr4 or Solaris 2).
32 Documentation of the internals of the support code still needs
33 to be written. The code is changing quickly enough that we
34 haven't bothered yet. */
36 /* For sparc64-cross-sparc32. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
47 static int elf_sort_sections (const void *, const void *);
48 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
49 static bfd_boolean
prep_headers (bfd
*);
50 static bfd_boolean
swap_out_syms (bfd
*, struct bfd_strtab_hash
**, int) ;
51 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
52 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
55 /* Swap version information in and out. The version information is
56 currently size independent. If that ever changes, this code will
57 need to move into elfcode.h. */
59 /* Swap in a Verdef structure. */
62 _bfd_elf_swap_verdef_in (bfd
*abfd
,
63 const Elf_External_Verdef
*src
,
64 Elf_Internal_Verdef
*dst
)
66 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
67 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
68 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
69 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
70 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
71 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
72 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
75 /* Swap out a Verdef structure. */
78 _bfd_elf_swap_verdef_out (bfd
*abfd
,
79 const Elf_Internal_Verdef
*src
,
80 Elf_External_Verdef
*dst
)
82 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
83 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
84 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
85 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
86 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
87 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
88 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
91 /* Swap in a Verdaux structure. */
94 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
95 const Elf_External_Verdaux
*src
,
96 Elf_Internal_Verdaux
*dst
)
98 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
99 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
102 /* Swap out a Verdaux structure. */
105 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
106 const Elf_Internal_Verdaux
*src
,
107 Elf_External_Verdaux
*dst
)
109 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
110 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
113 /* Swap in a Verneed structure. */
116 _bfd_elf_swap_verneed_in (bfd
*abfd
,
117 const Elf_External_Verneed
*src
,
118 Elf_Internal_Verneed
*dst
)
120 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
121 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
122 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
123 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
124 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
127 /* Swap out a Verneed structure. */
130 _bfd_elf_swap_verneed_out (bfd
*abfd
,
131 const Elf_Internal_Verneed
*src
,
132 Elf_External_Verneed
*dst
)
134 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
135 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
136 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
137 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
138 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
141 /* Swap in a Vernaux structure. */
144 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
145 const Elf_External_Vernaux
*src
,
146 Elf_Internal_Vernaux
*dst
)
148 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
149 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
150 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
151 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
152 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
155 /* Swap out a Vernaux structure. */
158 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
159 const Elf_Internal_Vernaux
*src
,
160 Elf_External_Vernaux
*dst
)
162 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
163 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
164 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
165 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
166 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
169 /* Swap in a Versym structure. */
172 _bfd_elf_swap_versym_in (bfd
*abfd
,
173 const Elf_External_Versym
*src
,
174 Elf_Internal_Versym
*dst
)
176 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
179 /* Swap out a Versym structure. */
182 _bfd_elf_swap_versym_out (bfd
*abfd
,
183 const Elf_Internal_Versym
*src
,
184 Elf_External_Versym
*dst
)
186 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
189 /* Standard ELF hash function. Do not change this function; you will
190 cause invalid hash tables to be generated. */
193 bfd_elf_hash (const char *namearg
)
195 const unsigned char *name
= (const unsigned char *) namearg
;
200 while ((ch
= *name
++) != '\0')
203 if ((g
= (h
& 0xf0000000)) != 0)
206 /* The ELF ABI says `h &= ~g', but this is equivalent in
207 this case and on some machines one insn instead of two. */
211 return h
& 0xffffffff;
214 /* DT_GNU_HASH hash function. Do not change this function; you will
215 cause invalid hash tables to be generated. */
218 bfd_elf_gnu_hash (const char *namearg
)
220 const unsigned char *name
= (const unsigned char *) namearg
;
221 unsigned long h
= 5381;
224 while ((ch
= *name
++) != '\0')
225 h
= (h
<< 5) + h
+ ch
;
226 return h
& 0xffffffff;
230 bfd_elf_mkobject (bfd
*abfd
)
232 if (abfd
->tdata
.any
== NULL
)
234 abfd
->tdata
.any
= bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
235 if (abfd
->tdata
.any
== NULL
)
239 elf_tdata (abfd
)->program_header_size
= (bfd_size_type
) -1;
245 bfd_elf_mkcorefile (bfd
*abfd
)
247 /* I think this can be done just like an object file. */
248 return bfd_elf_mkobject (abfd
);
252 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
254 Elf_Internal_Shdr
**i_shdrp
;
255 bfd_byte
*shstrtab
= NULL
;
257 bfd_size_type shstrtabsize
;
259 i_shdrp
= elf_elfsections (abfd
);
261 || shindex
>= elf_numsections (abfd
)
262 || i_shdrp
[shindex
] == 0)
265 shstrtab
= i_shdrp
[shindex
]->contents
;
266 if (shstrtab
== NULL
)
268 /* No cached one, attempt to read, and cache what we read. */
269 offset
= i_shdrp
[shindex
]->sh_offset
;
270 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
272 /* Allocate and clear an extra byte at the end, to prevent crashes
273 in case the string table is not terminated. */
274 if (shstrtabsize
+ 1 == 0
275 || (shstrtab
= bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
276 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
278 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
280 if (bfd_get_error () != bfd_error_system_call
)
281 bfd_set_error (bfd_error_file_truncated
);
285 shstrtab
[shstrtabsize
] = '\0';
286 i_shdrp
[shindex
]->contents
= shstrtab
;
288 return (char *) shstrtab
;
292 bfd_elf_string_from_elf_section (bfd
*abfd
,
293 unsigned int shindex
,
294 unsigned int strindex
)
296 Elf_Internal_Shdr
*hdr
;
301 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
304 hdr
= elf_elfsections (abfd
)[shindex
];
306 if (hdr
->contents
== NULL
307 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
310 if (strindex
>= hdr
->sh_size
)
312 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
313 (*_bfd_error_handler
)
314 (_("%B: invalid string offset %u >= %lu for section `%s'"),
315 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
316 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
318 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
322 return ((char *) hdr
->contents
) + strindex
;
325 /* Read and convert symbols to internal format.
326 SYMCOUNT specifies the number of symbols to read, starting from
327 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
328 are non-NULL, they are used to store the internal symbols, external
329 symbols, and symbol section index extensions, respectively. */
332 bfd_elf_get_elf_syms (bfd
*ibfd
,
333 Elf_Internal_Shdr
*symtab_hdr
,
336 Elf_Internal_Sym
*intsym_buf
,
338 Elf_External_Sym_Shndx
*extshndx_buf
)
340 Elf_Internal_Shdr
*shndx_hdr
;
342 const bfd_byte
*esym
;
343 Elf_External_Sym_Shndx
*alloc_extshndx
;
344 Elf_External_Sym_Shndx
*shndx
;
345 Elf_Internal_Sym
*isym
;
346 Elf_Internal_Sym
*isymend
;
347 const struct elf_backend_data
*bed
;
355 /* Normal syms might have section extension entries. */
357 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
358 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
360 /* Read the symbols. */
362 alloc_extshndx
= NULL
;
363 bed
= get_elf_backend_data (ibfd
);
364 extsym_size
= bed
->s
->sizeof_sym
;
365 amt
= symcount
* extsym_size
;
366 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
367 if (extsym_buf
== NULL
)
369 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
370 extsym_buf
= alloc_ext
;
372 if (extsym_buf
== NULL
373 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
374 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
380 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
384 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
385 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
386 if (extshndx_buf
== NULL
)
388 alloc_extshndx
= bfd_malloc2 (symcount
,
389 sizeof (Elf_External_Sym_Shndx
));
390 extshndx_buf
= alloc_extshndx
;
392 if (extshndx_buf
== NULL
393 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
394 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
401 if (intsym_buf
== NULL
)
403 intsym_buf
= bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
404 if (intsym_buf
== NULL
)
408 /* Convert the symbols to internal form. */
409 isymend
= intsym_buf
+ symcount
;
410 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
412 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
413 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
415 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
416 (*_bfd_error_handler
) (_("%B symbol number %lu references "
417 "nonexistent SHT_SYMTAB_SHNDX section"),
418 ibfd
, (unsigned long) symoffset
);
424 if (alloc_ext
!= NULL
)
426 if (alloc_extshndx
!= NULL
)
427 free (alloc_extshndx
);
432 /* Look up a symbol name. */
434 bfd_elf_sym_name (bfd
*abfd
,
435 Elf_Internal_Shdr
*symtab_hdr
,
436 Elf_Internal_Sym
*isym
,
440 unsigned int iname
= isym
->st_name
;
441 unsigned int shindex
= symtab_hdr
->sh_link
;
443 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
444 /* Check for a bogus st_shndx to avoid crashing. */
445 && isym
->st_shndx
< elf_numsections (abfd
)
446 && !(isym
->st_shndx
>= SHN_LORESERVE
&& isym
->st_shndx
<= SHN_HIRESERVE
))
448 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
449 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
452 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
455 else if (sym_sec
&& *name
== '\0')
456 name
= bfd_section_name (abfd
, sym_sec
);
461 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
462 sections. The first element is the flags, the rest are section
465 typedef union elf_internal_group
{
466 Elf_Internal_Shdr
*shdr
;
468 } Elf_Internal_Group
;
470 /* Return the name of the group signature symbol. Why isn't the
471 signature just a string? */
474 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
476 Elf_Internal_Shdr
*hdr
;
477 unsigned char esym
[sizeof (Elf64_External_Sym
)];
478 Elf_External_Sym_Shndx eshndx
;
479 Elf_Internal_Sym isym
;
481 /* First we need to ensure the symbol table is available. Make sure
482 that it is a symbol table section. */
483 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
484 if (hdr
->sh_type
!= SHT_SYMTAB
485 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
488 /* Go read the symbol. */
489 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
490 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
491 &isym
, esym
, &eshndx
) == NULL
)
494 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
497 /* Set next_in_group list pointer, and group name for NEWSECT. */
500 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
502 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
504 /* If num_group is zero, read in all SHT_GROUP sections. The count
505 is set to -1 if there are no SHT_GROUP sections. */
508 unsigned int i
, shnum
;
510 /* First count the number of groups. If we have a SHT_GROUP
511 section with just a flag word (ie. sh_size is 4), ignore it. */
512 shnum
= elf_numsections (abfd
);
515 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
516 ( (shdr)->sh_type == SHT_GROUP \
517 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
518 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
519 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
521 for (i
= 0; i
< shnum
; i
++)
523 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
525 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
531 num_group
= (unsigned) -1;
532 elf_tdata (abfd
)->num_group
= num_group
;
536 /* We keep a list of elf section headers for group sections,
537 so we can find them quickly. */
540 elf_tdata (abfd
)->num_group
= num_group
;
541 elf_tdata (abfd
)->group_sect_ptr
542 = bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
543 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
547 for (i
= 0; i
< shnum
; i
++)
549 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
551 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
554 Elf_Internal_Group
*dest
;
556 /* Add to list of sections. */
557 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
560 /* Read the raw contents. */
561 BFD_ASSERT (sizeof (*dest
) >= 4);
562 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
563 shdr
->contents
= bfd_alloc2 (abfd
, shdr
->sh_size
,
565 /* PR binutils/4110: Handle corrupt group headers. */
566 if (shdr
->contents
== NULL
)
569 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
570 bfd_set_error (bfd_error_bad_value
);
574 memset (shdr
->contents
, 0, amt
);
576 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
577 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
581 /* Translate raw contents, a flag word followed by an
582 array of elf section indices all in target byte order,
583 to the flag word followed by an array of elf section
585 src
= shdr
->contents
+ shdr
->sh_size
;
586 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
593 idx
= H_GET_32 (abfd
, src
);
594 if (src
== shdr
->contents
)
597 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
598 shdr
->bfd_section
->flags
599 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
604 ((*_bfd_error_handler
)
605 (_("%B: invalid SHT_GROUP entry"), abfd
));
608 dest
->shdr
= elf_elfsections (abfd
)[idx
];
615 if (num_group
!= (unsigned) -1)
619 for (i
= 0; i
< num_group
; i
++)
621 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
622 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
623 unsigned int n_elt
= shdr
->sh_size
/ 4;
625 /* Look through this group's sections to see if current
626 section is a member. */
628 if ((++idx
)->shdr
== hdr
)
632 /* We are a member of this group. Go looking through
633 other members to see if any others are linked via
635 idx
= (Elf_Internal_Group
*) shdr
->contents
;
636 n_elt
= shdr
->sh_size
/ 4;
638 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
639 && elf_next_in_group (s
) != NULL
)
643 /* Snarf the group name from other member, and
644 insert current section in circular list. */
645 elf_group_name (newsect
) = elf_group_name (s
);
646 elf_next_in_group (newsect
) = elf_next_in_group (s
);
647 elf_next_in_group (s
) = newsect
;
653 gname
= group_signature (abfd
, shdr
);
656 elf_group_name (newsect
) = gname
;
658 /* Start a circular list with one element. */
659 elf_next_in_group (newsect
) = newsect
;
662 /* If the group section has been created, point to the
664 if (shdr
->bfd_section
!= NULL
)
665 elf_next_in_group (shdr
->bfd_section
) = newsect
;
673 if (elf_group_name (newsect
) == NULL
)
675 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
682 _bfd_elf_setup_sections (bfd
*abfd
)
685 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
686 bfd_boolean result
= TRUE
;
689 /* Process SHF_LINK_ORDER. */
690 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
692 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
693 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
695 unsigned int elfsec
= this_hdr
->sh_link
;
696 /* FIXME: The old Intel compiler and old strip/objcopy may
697 not set the sh_link or sh_info fields. Hence we could
698 get the situation where elfsec is 0. */
701 const struct elf_backend_data
*bed
702 = get_elf_backend_data (abfd
);
703 if (bed
->link_order_error_handler
)
704 bed
->link_order_error_handler
705 (_("%B: warning: sh_link not set for section `%A'"),
712 this_hdr
= elf_elfsections (abfd
)[elfsec
];
715 Some strip/objcopy may leave an incorrect value in
716 sh_link. We don't want to proceed. */
717 link
= this_hdr
->bfd_section
;
720 (*_bfd_error_handler
)
721 (_("%B: sh_link [%d] in section `%A' is incorrect"),
722 s
->owner
, s
, elfsec
);
726 elf_linked_to_section (s
) = link
;
731 /* Process section groups. */
732 if (num_group
== (unsigned) -1)
735 for (i
= 0; i
< num_group
; i
++)
737 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
738 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
739 unsigned int n_elt
= shdr
->sh_size
/ 4;
742 if ((++idx
)->shdr
->bfd_section
)
743 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
744 else if (idx
->shdr
->sh_type
== SHT_RELA
745 || idx
->shdr
->sh_type
== SHT_REL
)
746 /* We won't include relocation sections in section groups in
747 output object files. We adjust the group section size here
748 so that relocatable link will work correctly when
749 relocation sections are in section group in input object
751 shdr
->bfd_section
->size
-= 4;
754 /* There are some unknown sections in the group. */
755 (*_bfd_error_handler
)
756 (_("%B: unknown [%d] section `%s' in group [%s]"),
758 (unsigned int) idx
->shdr
->sh_type
,
759 bfd_elf_string_from_elf_section (abfd
,
760 (elf_elfheader (abfd
)
763 shdr
->bfd_section
->name
);
771 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
773 return elf_next_in_group (sec
) != NULL
;
776 /* Make a BFD section from an ELF section. We store a pointer to the
777 BFD section in the bfd_section field of the header. */
780 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
781 Elf_Internal_Shdr
*hdr
,
787 const struct elf_backend_data
*bed
;
789 if (hdr
->bfd_section
!= NULL
)
791 BFD_ASSERT (strcmp (name
,
792 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
796 newsect
= bfd_make_section_anyway (abfd
, name
);
800 hdr
->bfd_section
= newsect
;
801 elf_section_data (newsect
)->this_hdr
= *hdr
;
802 elf_section_data (newsect
)->this_idx
= shindex
;
804 /* Always use the real type/flags. */
805 elf_section_type (newsect
) = hdr
->sh_type
;
806 elf_section_flags (newsect
) = hdr
->sh_flags
;
808 newsect
->filepos
= hdr
->sh_offset
;
810 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
811 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
812 || ! bfd_set_section_alignment (abfd
, newsect
,
813 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
816 flags
= SEC_NO_FLAGS
;
817 if (hdr
->sh_type
!= SHT_NOBITS
)
818 flags
|= SEC_HAS_CONTENTS
;
819 if (hdr
->sh_type
== SHT_GROUP
)
820 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
821 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
824 if (hdr
->sh_type
!= SHT_NOBITS
)
827 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
828 flags
|= SEC_READONLY
;
829 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
831 else if ((flags
& SEC_LOAD
) != 0)
833 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
836 newsect
->entsize
= hdr
->sh_entsize
;
837 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
838 flags
|= SEC_STRINGS
;
840 if (hdr
->sh_flags
& SHF_GROUP
)
841 if (!setup_group (abfd
, hdr
, newsect
))
843 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
844 flags
|= SEC_THREAD_LOCAL
;
846 if ((flags
& SEC_ALLOC
) == 0)
848 /* The debugging sections appear to be recognized only by name,
849 not any sort of flag. Their SEC_ALLOC bits are cleared. */
854 } debug_sections
[] =
856 { STRING_COMMA_LEN ("debug") }, /* 'd' */
857 { NULL
, 0 }, /* 'e' */
858 { NULL
, 0 }, /* 'f' */
859 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
860 { NULL
, 0 }, /* 'h' */
861 { NULL
, 0 }, /* 'i' */
862 { NULL
, 0 }, /* 'j' */
863 { NULL
, 0 }, /* 'k' */
864 { STRING_COMMA_LEN ("line") }, /* 'l' */
865 { NULL
, 0 }, /* 'm' */
866 { NULL
, 0 }, /* 'n' */
867 { NULL
, 0 }, /* 'o' */
868 { NULL
, 0 }, /* 'p' */
869 { NULL
, 0 }, /* 'q' */
870 { NULL
, 0 }, /* 'r' */
871 { STRING_COMMA_LEN ("stab") } /* 's' */
876 int i
= name
[1] - 'd';
878 && i
< (int) ARRAY_SIZE (debug_sections
)
879 && debug_sections
[i
].name
!= NULL
880 && strncmp (&name
[1], debug_sections
[i
].name
,
881 debug_sections
[i
].len
) == 0)
882 flags
|= SEC_DEBUGGING
;
886 /* As a GNU extension, if the name begins with .gnu.linkonce, we
887 only link a single copy of the section. This is used to support
888 g++. g++ will emit each template expansion in its own section.
889 The symbols will be defined as weak, so that multiple definitions
890 are permitted. The GNU linker extension is to actually discard
891 all but one of the sections. */
892 if (CONST_STRNEQ (name
, ".gnu.linkonce")
893 && elf_next_in_group (newsect
) == NULL
)
894 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
896 bed
= get_elf_backend_data (abfd
);
897 if (bed
->elf_backend_section_flags
)
898 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
901 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
904 /* We do not parse the PT_NOTE segments as we are interested even in the
905 separate debug info files which may have the segments offsets corrupted.
906 PT_NOTEs from the core files are currently not parsed using BFD. */
907 if (hdr
->sh_type
== SHT_NOTE
)
911 contents
= bfd_malloc (hdr
->sh_size
);
915 if (!bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
, 0,
917 || !elf_parse_notes (abfd
, contents
, hdr
->sh_size
, -1))
926 if ((flags
& SEC_ALLOC
) != 0)
928 Elf_Internal_Phdr
*phdr
;
931 /* Look through the phdrs to see if we need to adjust the lma.
932 If all the p_paddr fields are zero, we ignore them, since
933 some ELF linkers produce such output. */
934 phdr
= elf_tdata (abfd
)->phdr
;
935 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
937 if (phdr
->p_paddr
!= 0)
940 if (i
< elf_elfheader (abfd
)->e_phnum
)
942 phdr
= elf_tdata (abfd
)->phdr
;
943 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
945 /* This section is part of this segment if its file
946 offset plus size lies within the segment's memory
947 span and, if the section is loaded, the extent of the
948 loaded data lies within the extent of the segment.
950 Note - we used to check the p_paddr field as well, and
951 refuse to set the LMA if it was 0. This is wrong
952 though, as a perfectly valid initialised segment can
953 have a p_paddr of zero. Some architectures, eg ARM,
954 place special significance on the address 0 and
955 executables need to be able to have a segment which
956 covers this address. */
957 if (phdr
->p_type
== PT_LOAD
958 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
959 && (hdr
->sh_offset
+ hdr
->sh_size
960 <= phdr
->p_offset
+ phdr
->p_memsz
)
961 && ((flags
& SEC_LOAD
) == 0
962 || (hdr
->sh_offset
+ hdr
->sh_size
963 <= phdr
->p_offset
+ phdr
->p_filesz
)))
965 if ((flags
& SEC_LOAD
) == 0)
966 newsect
->lma
= (phdr
->p_paddr
967 + hdr
->sh_addr
- phdr
->p_vaddr
);
969 /* We used to use the same adjustment for SEC_LOAD
970 sections, but that doesn't work if the segment
971 is packed with code from multiple VMAs.
972 Instead we calculate the section LMA based on
973 the segment LMA. It is assumed that the
974 segment will contain sections with contiguous
975 LMAs, even if the VMAs are not. */
976 newsect
->lma
= (phdr
->p_paddr
977 + hdr
->sh_offset
- phdr
->p_offset
);
979 /* With contiguous segments, we can't tell from file
980 offsets whether a section with zero size should
981 be placed at the end of one segment or the
982 beginning of the next. Decide based on vaddr. */
983 if (hdr
->sh_addr
>= phdr
->p_vaddr
984 && (hdr
->sh_addr
+ hdr
->sh_size
985 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1000 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
1003 Helper functions for GDB to locate the string tables.
1004 Since BFD hides string tables from callers, GDB needs to use an
1005 internal hook to find them. Sun's .stabstr, in particular,
1006 isn't even pointed to by the .stab section, so ordinary
1007 mechanisms wouldn't work to find it, even if we had some.
1010 struct elf_internal_shdr
*
1011 bfd_elf_find_section (bfd
*abfd
, char *name
)
1013 Elf_Internal_Shdr
**i_shdrp
;
1018 i_shdrp
= elf_elfsections (abfd
);
1019 if (i_shdrp
!= NULL
)
1021 shstrtab
= bfd_elf_get_str_section (abfd
,
1022 elf_elfheader (abfd
)->e_shstrndx
);
1023 if (shstrtab
!= NULL
)
1025 max
= elf_numsections (abfd
);
1026 for (i
= 1; i
< max
; i
++)
1027 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
1034 const char *const bfd_elf_section_type_names
[] = {
1035 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1036 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1037 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1040 /* ELF relocs are against symbols. If we are producing relocatable
1041 output, and the reloc is against an external symbol, and nothing
1042 has given us any additional addend, the resulting reloc will also
1043 be against the same symbol. In such a case, we don't want to
1044 change anything about the way the reloc is handled, since it will
1045 all be done at final link time. Rather than put special case code
1046 into bfd_perform_relocation, all the reloc types use this howto
1047 function. It just short circuits the reloc if producing
1048 relocatable output against an external symbol. */
1050 bfd_reloc_status_type
1051 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1052 arelent
*reloc_entry
,
1054 void *data ATTRIBUTE_UNUSED
,
1055 asection
*input_section
,
1057 char **error_message ATTRIBUTE_UNUSED
)
1059 if (output_bfd
!= NULL
1060 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1061 && (! reloc_entry
->howto
->partial_inplace
1062 || reloc_entry
->addend
== 0))
1064 reloc_entry
->address
+= input_section
->output_offset
;
1065 return bfd_reloc_ok
;
1068 return bfd_reloc_continue
;
1071 /* Copy the program header and other data from one object module to
1075 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1077 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1078 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1081 BFD_ASSERT (!elf_flags_init (obfd
)
1082 || (elf_elfheader (obfd
)->e_flags
1083 == elf_elfheader (ibfd
)->e_flags
));
1085 elf_gp (obfd
) = elf_gp (ibfd
);
1086 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1087 elf_flags_init (obfd
) = TRUE
;
1089 /* Copy object attributes. */
1090 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1096 get_segment_type (unsigned int p_type
)
1101 case PT_NULL
: pt
= "NULL"; break;
1102 case PT_LOAD
: pt
= "LOAD"; break;
1103 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1104 case PT_INTERP
: pt
= "INTERP"; break;
1105 case PT_NOTE
: pt
= "NOTE"; break;
1106 case PT_SHLIB
: pt
= "SHLIB"; break;
1107 case PT_PHDR
: pt
= "PHDR"; break;
1108 case PT_TLS
: pt
= "TLS"; break;
1109 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1110 case PT_GNU_STACK
: pt
= "STACK"; break;
1111 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1112 default: pt
= NULL
; break;
1117 /* Print out the program headers. */
1120 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1123 Elf_Internal_Phdr
*p
;
1125 bfd_byte
*dynbuf
= NULL
;
1127 p
= elf_tdata (abfd
)->phdr
;
1132 fprintf (f
, _("\nProgram Header:\n"));
1133 c
= elf_elfheader (abfd
)->e_phnum
;
1134 for (i
= 0; i
< c
; i
++, p
++)
1136 const char *pt
= get_segment_type (p
->p_type
);
1141 sprintf (buf
, "0x%lx", p
->p_type
);
1144 fprintf (f
, "%8s off 0x", pt
);
1145 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1146 fprintf (f
, " vaddr 0x");
1147 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1148 fprintf (f
, " paddr 0x");
1149 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1150 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1151 fprintf (f
, " filesz 0x");
1152 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1153 fprintf (f
, " memsz 0x");
1154 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1155 fprintf (f
, " flags %c%c%c",
1156 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1157 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1158 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1159 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1160 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1165 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1169 unsigned long shlink
;
1170 bfd_byte
*extdyn
, *extdynend
;
1172 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1174 fprintf (f
, _("\nDynamic Section:\n"));
1176 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1179 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1182 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1184 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1185 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1188 extdynend
= extdyn
+ s
->size
;
1189 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1191 Elf_Internal_Dyn dyn
;
1194 bfd_boolean stringp
;
1196 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1198 if (dyn
.d_tag
== DT_NULL
)
1205 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1209 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1210 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1211 case DT_PLTGOT
: name
= "PLTGOT"; break;
1212 case DT_HASH
: name
= "HASH"; break;
1213 case DT_STRTAB
: name
= "STRTAB"; break;
1214 case DT_SYMTAB
: name
= "SYMTAB"; break;
1215 case DT_RELA
: name
= "RELA"; break;
1216 case DT_RELASZ
: name
= "RELASZ"; break;
1217 case DT_RELAENT
: name
= "RELAENT"; break;
1218 case DT_STRSZ
: name
= "STRSZ"; break;
1219 case DT_SYMENT
: name
= "SYMENT"; break;
1220 case DT_INIT
: name
= "INIT"; break;
1221 case DT_FINI
: name
= "FINI"; break;
1222 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1223 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1224 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1225 case DT_REL
: name
= "REL"; break;
1226 case DT_RELSZ
: name
= "RELSZ"; break;
1227 case DT_RELENT
: name
= "RELENT"; break;
1228 case DT_PLTREL
: name
= "PLTREL"; break;
1229 case DT_DEBUG
: name
= "DEBUG"; break;
1230 case DT_TEXTREL
: name
= "TEXTREL"; break;
1231 case DT_JMPREL
: name
= "JMPREL"; break;
1232 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1233 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1234 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1235 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1236 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1237 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1238 case DT_FLAGS
: name
= "FLAGS"; break;
1239 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1240 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1241 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1242 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1243 case DT_MOVEENT
: name
= "MOVEENT"; break;
1244 case DT_MOVESZ
: name
= "MOVESZ"; break;
1245 case DT_FEATURE
: name
= "FEATURE"; break;
1246 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1247 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1248 case DT_SYMINENT
: name
= "SYMINENT"; break;
1249 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1250 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1251 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1252 case DT_PLTPAD
: name
= "PLTPAD"; break;
1253 case DT_MOVETAB
: name
= "MOVETAB"; break;
1254 case DT_SYMINFO
: name
= "SYMINFO"; break;
1255 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1256 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1257 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1258 case DT_VERSYM
: name
= "VERSYM"; break;
1259 case DT_VERDEF
: name
= "VERDEF"; break;
1260 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1261 case DT_VERNEED
: name
= "VERNEED"; break;
1262 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1263 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1264 case DT_USED
: name
= "USED"; break;
1265 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1266 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1269 fprintf (f
, " %-11s ", name
);
1271 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1275 unsigned int tagv
= dyn
.d_un
.d_val
;
1277 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1280 fprintf (f
, "%s", string
);
1289 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1290 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1292 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1296 if (elf_dynverdef (abfd
) != 0)
1298 Elf_Internal_Verdef
*t
;
1300 fprintf (f
, _("\nVersion definitions:\n"));
1301 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1303 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1304 t
->vd_flags
, t
->vd_hash
,
1305 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1306 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1308 Elf_Internal_Verdaux
*a
;
1311 for (a
= t
->vd_auxptr
->vda_nextptr
;
1315 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1321 if (elf_dynverref (abfd
) != 0)
1323 Elf_Internal_Verneed
*t
;
1325 fprintf (f
, _("\nVersion References:\n"));
1326 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1328 Elf_Internal_Vernaux
*a
;
1330 fprintf (f
, _(" required from %s:\n"),
1331 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1332 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1333 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1334 a
->vna_flags
, a
->vna_other
,
1335 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1347 /* Display ELF-specific fields of a symbol. */
1350 bfd_elf_print_symbol (bfd
*abfd
,
1353 bfd_print_symbol_type how
)
1358 case bfd_print_symbol_name
:
1359 fprintf (file
, "%s", symbol
->name
);
1361 case bfd_print_symbol_more
:
1362 fprintf (file
, "elf ");
1363 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1364 fprintf (file
, " %lx", (long) symbol
->flags
);
1366 case bfd_print_symbol_all
:
1368 const char *section_name
;
1369 const char *name
= NULL
;
1370 const struct elf_backend_data
*bed
;
1371 unsigned char st_other
;
1374 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1376 bed
= get_elf_backend_data (abfd
);
1377 if (bed
->elf_backend_print_symbol_all
)
1378 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1382 name
= symbol
->name
;
1383 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1386 fprintf (file
, " %s\t", section_name
);
1387 /* Print the "other" value for a symbol. For common symbols,
1388 we've already printed the size; now print the alignment.
1389 For other symbols, we have no specified alignment, and
1390 we've printed the address; now print the size. */
1391 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1392 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1394 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1395 bfd_fprintf_vma (abfd
, file
, val
);
1397 /* If we have version information, print it. */
1398 if (elf_tdata (abfd
)->dynversym_section
!= 0
1399 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1400 || elf_tdata (abfd
)->dynverref_section
!= 0))
1402 unsigned int vernum
;
1403 const char *version_string
;
1405 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1408 version_string
= "";
1409 else if (vernum
== 1)
1410 version_string
= "Base";
1411 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1413 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1416 Elf_Internal_Verneed
*t
;
1418 version_string
= "";
1419 for (t
= elf_tdata (abfd
)->verref
;
1423 Elf_Internal_Vernaux
*a
;
1425 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1427 if (a
->vna_other
== vernum
)
1429 version_string
= a
->vna_nodename
;
1436 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1437 fprintf (file
, " %-11s", version_string
);
1442 fprintf (file
, " (%s)", version_string
);
1443 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1448 /* If the st_other field is not zero, print it. */
1449 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1454 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1455 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1456 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1458 /* Some other non-defined flags are also present, so print
1460 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1463 fprintf (file
, " %s", name
);
1469 /* Allocate an ELF string table--force the first byte to be zero. */
1471 struct bfd_strtab_hash
*
1472 _bfd_elf_stringtab_init (void)
1474 struct bfd_strtab_hash
*ret
;
1476 ret
= _bfd_stringtab_init ();
1481 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1482 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1483 if (loc
== (bfd_size_type
) -1)
1485 _bfd_stringtab_free (ret
);
1492 /* ELF .o/exec file reading */
1494 /* Create a new bfd section from an ELF section header. */
1497 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1499 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1500 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1501 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1504 name
= bfd_elf_string_from_elf_section (abfd
,
1505 elf_elfheader (abfd
)->e_shstrndx
,
1510 switch (hdr
->sh_type
)
1513 /* Inactive section. Throw it away. */
1516 case SHT_PROGBITS
: /* Normal section with contents. */
1517 case SHT_NOBITS
: /* .bss section. */
1518 case SHT_HASH
: /* .hash section. */
1519 case SHT_NOTE
: /* .note section. */
1520 case SHT_INIT_ARRAY
: /* .init_array section. */
1521 case SHT_FINI_ARRAY
: /* .fini_array section. */
1522 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1523 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1524 case SHT_GNU_HASH
: /* .gnu.hash section. */
1525 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1527 case SHT_DYNAMIC
: /* Dynamic linking information. */
1528 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1530 if (hdr
->sh_link
> elf_numsections (abfd
)
1531 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1533 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1535 Elf_Internal_Shdr
*dynsymhdr
;
1537 /* The shared libraries distributed with hpux11 have a bogus
1538 sh_link field for the ".dynamic" section. Find the
1539 string table for the ".dynsym" section instead. */
1540 if (elf_dynsymtab (abfd
) != 0)
1542 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1543 hdr
->sh_link
= dynsymhdr
->sh_link
;
1547 unsigned int i
, num_sec
;
1549 num_sec
= elf_numsections (abfd
);
1550 for (i
= 1; i
< num_sec
; i
++)
1552 dynsymhdr
= elf_elfsections (abfd
)[i
];
1553 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1555 hdr
->sh_link
= dynsymhdr
->sh_link
;
1563 case SHT_SYMTAB
: /* A symbol table */
1564 if (elf_onesymtab (abfd
) == shindex
)
1567 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1569 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1570 elf_onesymtab (abfd
) = shindex
;
1571 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1572 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1573 abfd
->flags
|= HAS_SYMS
;
1575 /* Sometimes a shared object will map in the symbol table. If
1576 SHF_ALLOC is set, and this is a shared object, then we also
1577 treat this section as a BFD section. We can not base the
1578 decision purely on SHF_ALLOC, because that flag is sometimes
1579 set in a relocatable object file, which would confuse the
1581 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1582 && (abfd
->flags
& DYNAMIC
) != 0
1583 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1587 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1588 can't read symbols without that section loaded as well. It
1589 is most likely specified by the next section header. */
1590 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1592 unsigned int i
, num_sec
;
1594 num_sec
= elf_numsections (abfd
);
1595 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1597 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1598 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1599 && hdr2
->sh_link
== shindex
)
1603 for (i
= 1; i
< shindex
; i
++)
1605 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1606 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1607 && hdr2
->sh_link
== shindex
)
1611 return bfd_section_from_shdr (abfd
, i
);
1615 case SHT_DYNSYM
: /* A dynamic symbol table */
1616 if (elf_dynsymtab (abfd
) == shindex
)
1619 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1621 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1622 elf_dynsymtab (abfd
) = shindex
;
1623 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1624 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1625 abfd
->flags
|= HAS_SYMS
;
1627 /* Besides being a symbol table, we also treat this as a regular
1628 section, so that objcopy can handle it. */
1629 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1631 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1632 if (elf_symtab_shndx (abfd
) == shindex
)
1635 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1636 elf_symtab_shndx (abfd
) = shindex
;
1637 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1638 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1641 case SHT_STRTAB
: /* A string table */
1642 if (hdr
->bfd_section
!= NULL
)
1644 if (ehdr
->e_shstrndx
== shindex
)
1646 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1647 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1650 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1653 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1654 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1657 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1660 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1661 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1662 elf_elfsections (abfd
)[shindex
] = hdr
;
1663 /* We also treat this as a regular section, so that objcopy
1665 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1669 /* If the string table isn't one of the above, then treat it as a
1670 regular section. We need to scan all the headers to be sure,
1671 just in case this strtab section appeared before the above. */
1672 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1674 unsigned int i
, num_sec
;
1676 num_sec
= elf_numsections (abfd
);
1677 for (i
= 1; i
< num_sec
; i
++)
1679 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1680 if (hdr2
->sh_link
== shindex
)
1682 /* Prevent endless recursion on broken objects. */
1685 if (! bfd_section_from_shdr (abfd
, i
))
1687 if (elf_onesymtab (abfd
) == i
)
1689 if (elf_dynsymtab (abfd
) == i
)
1690 goto dynsymtab_strtab
;
1694 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1698 /* *These* do a lot of work -- but build no sections! */
1700 asection
*target_sect
;
1701 Elf_Internal_Shdr
*hdr2
;
1702 unsigned int num_sec
= elf_numsections (abfd
);
1705 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1706 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1709 /* Check for a bogus link to avoid crashing. */
1710 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1711 || hdr
->sh_link
>= num_sec
)
1713 ((*_bfd_error_handler
)
1714 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1715 abfd
, hdr
->sh_link
, name
, shindex
));
1716 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1720 /* For some incomprehensible reason Oracle distributes
1721 libraries for Solaris in which some of the objects have
1722 bogus sh_link fields. It would be nice if we could just
1723 reject them, but, unfortunately, some people need to use
1724 them. We scan through the section headers; if we find only
1725 one suitable symbol table, we clobber the sh_link to point
1726 to it. I hope this doesn't break anything. */
1727 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1728 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1734 for (scan
= 1; scan
< num_sec
; scan
++)
1736 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1737 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1748 hdr
->sh_link
= found
;
1751 /* Get the symbol table. */
1752 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1753 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1754 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1757 /* If this reloc section does not use the main symbol table we
1758 don't treat it as a reloc section. BFD can't adequately
1759 represent such a section, so at least for now, we don't
1760 try. We just present it as a normal section. We also
1761 can't use it as a reloc section if it points to the null
1762 section, an invalid section, or another reloc section. */
1763 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1764 || hdr
->sh_info
== SHN_UNDEF
1765 || (hdr
->sh_info
>= SHN_LORESERVE
&& hdr
->sh_info
<= SHN_HIRESERVE
)
1766 || hdr
->sh_info
>= num_sec
1767 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1768 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1769 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1772 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1774 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1775 if (target_sect
== NULL
)
1778 if ((target_sect
->flags
& SEC_RELOC
) == 0
1779 || target_sect
->reloc_count
== 0)
1780 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1784 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1785 amt
= sizeof (*hdr2
);
1786 hdr2
= bfd_alloc (abfd
, amt
);
1789 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1792 elf_elfsections (abfd
)[shindex
] = hdr2
;
1793 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1794 target_sect
->flags
|= SEC_RELOC
;
1795 target_sect
->relocation
= NULL
;
1796 target_sect
->rel_filepos
= hdr
->sh_offset
;
1797 /* In the section to which the relocations apply, mark whether
1798 its relocations are of the REL or RELA variety. */
1799 if (hdr
->sh_size
!= 0)
1800 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1801 abfd
->flags
|= HAS_RELOC
;
1805 case SHT_GNU_verdef
:
1806 elf_dynverdef (abfd
) = shindex
;
1807 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1808 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1810 case SHT_GNU_versym
:
1811 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1813 elf_dynversym (abfd
) = shindex
;
1814 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1815 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1817 case SHT_GNU_verneed
:
1818 elf_dynverref (abfd
) = shindex
;
1819 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1820 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1826 /* We need a BFD section for objcopy and relocatable linking,
1827 and it's handy to have the signature available as the section
1829 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1831 name
= group_signature (abfd
, hdr
);
1834 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1836 if (hdr
->contents
!= NULL
)
1838 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1839 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1842 if (idx
->flags
& GRP_COMDAT
)
1843 hdr
->bfd_section
->flags
1844 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1846 /* We try to keep the same section order as it comes in. */
1848 while (--n_elt
!= 0)
1852 if (idx
->shdr
!= NULL
1853 && (s
= idx
->shdr
->bfd_section
) != NULL
1854 && elf_next_in_group (s
) != NULL
)
1856 elf_next_in_group (hdr
->bfd_section
) = s
;
1864 /* Possibly an attributes section. */
1865 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1866 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1868 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1870 _bfd_elf_parse_attributes (abfd
, hdr
);
1874 /* Check for any processor-specific section types. */
1875 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1878 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1880 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1881 /* FIXME: How to properly handle allocated section reserved
1882 for applications? */
1883 (*_bfd_error_handler
)
1884 (_("%B: don't know how to handle allocated, application "
1885 "specific section `%s' [0x%8x]"),
1886 abfd
, name
, hdr
->sh_type
);
1888 /* Allow sections reserved for applications. */
1889 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1892 else if (hdr
->sh_type
>= SHT_LOPROC
1893 && hdr
->sh_type
<= SHT_HIPROC
)
1894 /* FIXME: We should handle this section. */
1895 (*_bfd_error_handler
)
1896 (_("%B: don't know how to handle processor specific section "
1898 abfd
, name
, hdr
->sh_type
);
1899 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1901 /* Unrecognised OS-specific sections. */
1902 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1903 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1904 required to correctly process the section and the file should
1905 be rejected with an error message. */
1906 (*_bfd_error_handler
)
1907 (_("%B: don't know how to handle OS specific section "
1909 abfd
, name
, hdr
->sh_type
);
1911 /* Otherwise it should be processed. */
1912 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1915 /* FIXME: We should handle this section. */
1916 (*_bfd_error_handler
)
1917 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1918 abfd
, name
, hdr
->sh_type
);
1926 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1927 Return SEC for sections that have no elf section, and NULL on error. */
1930 bfd_section_from_r_symndx (bfd
*abfd
,
1931 struct sym_sec_cache
*cache
,
1933 unsigned long r_symndx
)
1935 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1938 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1940 Elf_Internal_Shdr
*symtab_hdr
;
1941 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1942 Elf_External_Sym_Shndx eshndx
;
1943 Elf_Internal_Sym isym
;
1945 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1946 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1947 &isym
, esym
, &eshndx
) == NULL
)
1950 if (cache
->abfd
!= abfd
)
1952 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1955 cache
->indx
[ent
] = r_symndx
;
1956 cache
->shndx
[ent
] = isym
.st_shndx
;
1959 s
= bfd_section_from_elf_index (abfd
, cache
->shndx
[ent
]);
1966 /* Given an ELF section number, retrieve the corresponding BFD
1970 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
1972 if (index
>= elf_numsections (abfd
))
1974 return elf_elfsections (abfd
)[index
]->bfd_section
;
1977 static const struct bfd_elf_special_section special_sections_b
[] =
1979 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1980 { NULL
, 0, 0, 0, 0 }
1983 static const struct bfd_elf_special_section special_sections_c
[] =
1985 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
1986 { NULL
, 0, 0, 0, 0 }
1989 static const struct bfd_elf_special_section special_sections_d
[] =
1991 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1992 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1993 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
1994 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
1995 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
1996 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
1997 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
1998 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
1999 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2000 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2001 { NULL
, 0, 0, 0, 0 }
2004 static const struct bfd_elf_special_section special_sections_f
[] =
2006 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2007 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2008 { NULL
, 0, 0, 0, 0 }
2011 static const struct bfd_elf_special_section special_sections_g
[] =
2013 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2014 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2015 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2016 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2017 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2018 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2019 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2020 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2021 { NULL
, 0, 0, 0, 0 }
2024 static const struct bfd_elf_special_section special_sections_h
[] =
2026 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2027 { NULL
, 0, 0, 0, 0 }
2030 static const struct bfd_elf_special_section special_sections_i
[] =
2032 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2033 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2034 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2035 { NULL
, 0, 0, 0, 0 }
2038 static const struct bfd_elf_special_section special_sections_l
[] =
2040 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2041 { NULL
, 0, 0, 0, 0 }
2044 static const struct bfd_elf_special_section special_sections_n
[] =
2046 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2047 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2048 { NULL
, 0, 0, 0, 0 }
2051 static const struct bfd_elf_special_section special_sections_p
[] =
2053 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2054 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2055 { NULL
, 0, 0, 0, 0 }
2058 static const struct bfd_elf_special_section special_sections_r
[] =
2060 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2061 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2062 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2063 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2064 { NULL
, 0, 0, 0, 0 }
2067 static const struct bfd_elf_special_section special_sections_s
[] =
2069 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2070 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2071 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2072 /* See struct bfd_elf_special_section declaration for the semantics of
2073 this special case where .prefix_length != strlen (.prefix). */
2074 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2075 { NULL
, 0, 0, 0, 0 }
2078 static const struct bfd_elf_special_section special_sections_t
[] =
2080 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2081 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2082 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2083 { NULL
, 0, 0, 0, 0 }
2086 static const struct bfd_elf_special_section
*special_sections
[] =
2088 special_sections_b
, /* 'b' */
2089 special_sections_c
, /* 'c' */
2090 special_sections_d
, /* 'd' */
2092 special_sections_f
, /* 'f' */
2093 special_sections_g
, /* 'g' */
2094 special_sections_h
, /* 'h' */
2095 special_sections_i
, /* 'i' */
2098 special_sections_l
, /* 'l' */
2100 special_sections_n
, /* 'n' */
2102 special_sections_p
, /* 'p' */
2104 special_sections_r
, /* 'r' */
2105 special_sections_s
, /* 's' */
2106 special_sections_t
, /* 't' */
2109 const struct bfd_elf_special_section
*
2110 _bfd_elf_get_special_section (const char *name
,
2111 const struct bfd_elf_special_section
*spec
,
2117 len
= strlen (name
);
2119 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2122 int prefix_len
= spec
[i
].prefix_length
;
2124 if (len
< prefix_len
)
2126 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2129 suffix_len
= spec
[i
].suffix_length
;
2130 if (suffix_len
<= 0)
2132 if (name
[prefix_len
] != 0)
2134 if (suffix_len
== 0)
2136 if (name
[prefix_len
] != '.'
2137 && (suffix_len
== -2
2138 || (rela
&& spec
[i
].type
== SHT_REL
)))
2144 if (len
< prefix_len
+ suffix_len
)
2146 if (memcmp (name
+ len
- suffix_len
,
2147 spec
[i
].prefix
+ prefix_len
,
2157 const struct bfd_elf_special_section
*
2158 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2161 const struct bfd_elf_special_section
*spec
;
2162 const struct elf_backend_data
*bed
;
2164 /* See if this is one of the special sections. */
2165 if (sec
->name
== NULL
)
2168 bed
= get_elf_backend_data (abfd
);
2169 spec
= bed
->special_sections
;
2172 spec
= _bfd_elf_get_special_section (sec
->name
,
2173 bed
->special_sections
,
2179 if (sec
->name
[0] != '.')
2182 i
= sec
->name
[1] - 'b';
2183 if (i
< 0 || i
> 't' - 'b')
2186 spec
= special_sections
[i
];
2191 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2195 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2197 struct bfd_elf_section_data
*sdata
;
2198 const struct elf_backend_data
*bed
;
2199 const struct bfd_elf_special_section
*ssect
;
2201 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2204 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2207 sec
->used_by_bfd
= sdata
;
2210 /* Indicate whether or not this section should use RELA relocations. */
2211 bed
= get_elf_backend_data (abfd
);
2212 sec
->use_rela_p
= bed
->default_use_rela_p
;
2214 /* When we read a file, we don't need to set ELF section type and
2215 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2216 anyway. We will set ELF section type and flags for all linker
2217 created sections. If user specifies BFD section flags, we will
2218 set ELF section type and flags based on BFD section flags in
2219 elf_fake_sections. */
2220 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2221 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2223 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2226 elf_section_type (sec
) = ssect
->type
;
2227 elf_section_flags (sec
) = ssect
->attr
;
2231 return _bfd_generic_new_section_hook (abfd
, sec
);
2234 /* Create a new bfd section from an ELF program header.
2236 Since program segments have no names, we generate a synthetic name
2237 of the form segment<NUM>, where NUM is generally the index in the
2238 program header table. For segments that are split (see below) we
2239 generate the names segment<NUM>a and segment<NUM>b.
2241 Note that some program segments may have a file size that is different than
2242 (less than) the memory size. All this means is that at execution the
2243 system must allocate the amount of memory specified by the memory size,
2244 but only initialize it with the first "file size" bytes read from the
2245 file. This would occur for example, with program segments consisting
2246 of combined data+bss.
2248 To handle the above situation, this routine generates TWO bfd sections
2249 for the single program segment. The first has the length specified by
2250 the file size of the segment, and the second has the length specified
2251 by the difference between the two sizes. In effect, the segment is split
2252 into its initialized and uninitialized parts.
2257 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2258 Elf_Internal_Phdr
*hdr
,
2260 const char *typename
)
2268 split
= ((hdr
->p_memsz
> 0)
2269 && (hdr
->p_filesz
> 0)
2270 && (hdr
->p_memsz
> hdr
->p_filesz
));
2272 if (hdr
->p_filesz
> 0)
2274 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2275 len
= strlen (namebuf
) + 1;
2276 name
= bfd_alloc (abfd
, len
);
2279 memcpy (name
, namebuf
, len
);
2280 newsect
= bfd_make_section (abfd
, name
);
2281 if (newsect
== NULL
)
2283 newsect
->vma
= hdr
->p_vaddr
;
2284 newsect
->lma
= hdr
->p_paddr
;
2285 newsect
->size
= hdr
->p_filesz
;
2286 newsect
->filepos
= hdr
->p_offset
;
2287 newsect
->flags
|= SEC_HAS_CONTENTS
;
2288 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2289 if (hdr
->p_type
== PT_LOAD
)
2291 newsect
->flags
|= SEC_ALLOC
;
2292 newsect
->flags
|= SEC_LOAD
;
2293 if (hdr
->p_flags
& PF_X
)
2295 /* FIXME: all we known is that it has execute PERMISSION,
2297 newsect
->flags
|= SEC_CODE
;
2300 if (!(hdr
->p_flags
& PF_W
))
2302 newsect
->flags
|= SEC_READONLY
;
2306 if (hdr
->p_memsz
> hdr
->p_filesz
)
2310 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "b" : "");
2311 len
= strlen (namebuf
) + 1;
2312 name
= bfd_alloc (abfd
, len
);
2315 memcpy (name
, namebuf
, len
);
2316 newsect
= bfd_make_section (abfd
, name
);
2317 if (newsect
== NULL
)
2319 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2320 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2321 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2322 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2323 align
= newsect
->vma
& -newsect
->vma
;
2324 if (align
== 0 || align
> hdr
->p_align
)
2325 align
= hdr
->p_align
;
2326 newsect
->alignment_power
= bfd_log2 (align
);
2327 if (hdr
->p_type
== PT_LOAD
)
2329 /* Hack for gdb. Segments that have not been modified do
2330 not have their contents written to a core file, on the
2331 assumption that a debugger can find the contents in the
2332 executable. We flag this case by setting the fake
2333 section size to zero. Note that "real" bss sections will
2334 always have their contents dumped to the core file. */
2335 if (bfd_get_format (abfd
) == bfd_core
)
2337 newsect
->flags
|= SEC_ALLOC
;
2338 if (hdr
->p_flags
& PF_X
)
2339 newsect
->flags
|= SEC_CODE
;
2341 if (!(hdr
->p_flags
& PF_W
))
2342 newsect
->flags
|= SEC_READONLY
;
2349 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2351 const struct elf_backend_data
*bed
;
2353 switch (hdr
->p_type
)
2356 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2359 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2362 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2365 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2368 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2370 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2375 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2378 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2380 case PT_GNU_EH_FRAME
:
2381 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2385 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2388 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2391 /* Check for any processor-specific program segment types. */
2392 bed
= get_elf_backend_data (abfd
);
2393 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2397 /* Initialize REL_HDR, the section-header for new section, containing
2398 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2399 relocations; otherwise, we use REL relocations. */
2402 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2403 Elf_Internal_Shdr
*rel_hdr
,
2405 bfd_boolean use_rela_p
)
2408 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2409 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2411 name
= bfd_alloc (abfd
, amt
);
2414 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2416 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2418 if (rel_hdr
->sh_name
== (unsigned int) -1)
2420 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2421 rel_hdr
->sh_entsize
= (use_rela_p
2422 ? bed
->s
->sizeof_rela
2423 : bed
->s
->sizeof_rel
);
2424 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2425 rel_hdr
->sh_flags
= 0;
2426 rel_hdr
->sh_addr
= 0;
2427 rel_hdr
->sh_size
= 0;
2428 rel_hdr
->sh_offset
= 0;
2433 /* Set up an ELF internal section header for a section. */
2436 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2438 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2439 bfd_boolean
*failedptr
= failedptrarg
;
2440 Elf_Internal_Shdr
*this_hdr
;
2441 unsigned int sh_type
;
2445 /* We already failed; just get out of the bfd_map_over_sections
2450 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2452 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2453 asect
->name
, FALSE
);
2454 if (this_hdr
->sh_name
== (unsigned int) -1)
2460 /* Don't clear sh_flags. Assembler may set additional bits. */
2462 if ((asect
->flags
& SEC_ALLOC
) != 0
2463 || asect
->user_set_vma
)
2464 this_hdr
->sh_addr
= asect
->vma
;
2466 this_hdr
->sh_addr
= 0;
2468 this_hdr
->sh_offset
= 0;
2469 this_hdr
->sh_size
= asect
->size
;
2470 this_hdr
->sh_link
= 0;
2471 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2472 /* The sh_entsize and sh_info fields may have been set already by
2473 copy_private_section_data. */
2475 this_hdr
->bfd_section
= asect
;
2476 this_hdr
->contents
= NULL
;
2478 /* If the section type is unspecified, we set it based on
2480 if ((asect
->flags
& SEC_GROUP
) != 0)
2481 sh_type
= SHT_GROUP
;
2482 else if ((asect
->flags
& SEC_ALLOC
) != 0
2483 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2484 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2485 sh_type
= SHT_NOBITS
;
2487 sh_type
= SHT_PROGBITS
;
2489 if (this_hdr
->sh_type
== SHT_NULL
)
2490 this_hdr
->sh_type
= sh_type
;
2491 else if (this_hdr
->sh_type
== SHT_NOBITS
2492 && sh_type
== SHT_PROGBITS
2493 && (asect
->flags
& SEC_ALLOC
) != 0)
2495 /* Warn if we are changing a NOBITS section to PROGBITS, but
2496 allow the link to proceed. This can happen when users link
2497 non-bss input sections to bss output sections, or emit data
2498 to a bss output section via a linker script. */
2499 (*_bfd_error_handler
)
2500 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2501 this_hdr
->sh_type
= sh_type
;
2504 switch (this_hdr
->sh_type
)
2510 case SHT_INIT_ARRAY
:
2511 case SHT_FINI_ARRAY
:
2512 case SHT_PREINIT_ARRAY
:
2519 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2523 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2527 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2531 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2532 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2536 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2537 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2540 case SHT_GNU_versym
:
2541 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2544 case SHT_GNU_verdef
:
2545 this_hdr
->sh_entsize
= 0;
2546 /* objcopy or strip will copy over sh_info, but may not set
2547 cverdefs. The linker will set cverdefs, but sh_info will be
2549 if (this_hdr
->sh_info
== 0)
2550 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2552 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2553 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2556 case SHT_GNU_verneed
:
2557 this_hdr
->sh_entsize
= 0;
2558 /* objcopy or strip will copy over sh_info, but may not set
2559 cverrefs. The linker will set cverrefs, but sh_info will be
2561 if (this_hdr
->sh_info
== 0)
2562 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2564 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2565 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2569 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2573 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2577 if ((asect
->flags
& SEC_ALLOC
) != 0)
2578 this_hdr
->sh_flags
|= SHF_ALLOC
;
2579 if ((asect
->flags
& SEC_READONLY
) == 0)
2580 this_hdr
->sh_flags
|= SHF_WRITE
;
2581 if ((asect
->flags
& SEC_CODE
) != 0)
2582 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2583 if ((asect
->flags
& SEC_MERGE
) != 0)
2585 this_hdr
->sh_flags
|= SHF_MERGE
;
2586 this_hdr
->sh_entsize
= asect
->entsize
;
2587 if ((asect
->flags
& SEC_STRINGS
) != 0)
2588 this_hdr
->sh_flags
|= SHF_STRINGS
;
2590 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2591 this_hdr
->sh_flags
|= SHF_GROUP
;
2592 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2594 this_hdr
->sh_flags
|= SHF_TLS
;
2595 if (asect
->size
== 0
2596 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2598 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2600 this_hdr
->sh_size
= 0;
2603 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2604 if (this_hdr
->sh_size
!= 0)
2605 this_hdr
->sh_type
= SHT_NOBITS
;
2610 /* Check for processor-specific section types. */
2611 sh_type
= this_hdr
->sh_type
;
2612 if (bed
->elf_backend_fake_sections
2613 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2616 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2618 /* Don't change the header type from NOBITS if we are being
2619 called for objcopy --only-keep-debug. */
2620 this_hdr
->sh_type
= sh_type
;
2623 /* If the section has relocs, set up a section header for the
2624 SHT_REL[A] section. If two relocation sections are required for
2625 this section, it is up to the processor-specific back-end to
2626 create the other. */
2627 if ((asect
->flags
& SEC_RELOC
) != 0
2628 && !_bfd_elf_init_reloc_shdr (abfd
,
2629 &elf_section_data (asect
)->rel_hdr
,
2635 /* Fill in the contents of a SHT_GROUP section. */
2638 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2640 bfd_boolean
*failedptr
= failedptrarg
;
2641 unsigned long symindx
;
2642 asection
*elt
, *first
;
2646 /* Ignore linker created group section. See elfNN_ia64_object_p in
2648 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2653 if (elf_group_id (sec
) != NULL
)
2654 symindx
= elf_group_id (sec
)->udata
.i
;
2658 /* If called from the assembler, swap_out_syms will have set up
2659 elf_section_syms; If called for "ld -r", use target_index. */
2660 if (elf_section_syms (abfd
) != NULL
)
2661 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2663 symindx
= sec
->target_index
;
2665 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2667 /* The contents won't be allocated for "ld -r" or objcopy. */
2669 if (sec
->contents
== NULL
)
2672 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2674 /* Arrange for the section to be written out. */
2675 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2676 if (sec
->contents
== NULL
)
2683 loc
= sec
->contents
+ sec
->size
;
2685 /* Get the pointer to the first section in the group that gas
2686 squirreled away here. objcopy arranges for this to be set to the
2687 start of the input section group. */
2688 first
= elt
= elf_next_in_group (sec
);
2690 /* First element is a flag word. Rest of section is elf section
2691 indices for all the sections of the group. Write them backwards
2692 just to keep the group in the same order as given in .section
2693 directives, not that it matters. */
2702 s
= s
->output_section
;
2705 idx
= elf_section_data (s
)->this_idx
;
2706 H_PUT_32 (abfd
, idx
, loc
);
2707 elt
= elf_next_in_group (elt
);
2712 if ((loc
-= 4) != sec
->contents
)
2715 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2718 /* Assign all ELF section numbers. The dummy first section is handled here
2719 too. The link/info pointers for the standard section types are filled
2720 in here too, while we're at it. */
2723 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2725 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2727 unsigned int section_number
, secn
;
2728 Elf_Internal_Shdr
**i_shdrp
;
2729 struct bfd_elf_section_data
*d
;
2733 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2735 /* SHT_GROUP sections are in relocatable files only. */
2736 if (link_info
== NULL
|| link_info
->relocatable
)
2738 /* Put SHT_GROUP sections first. */
2739 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2741 d
= elf_section_data (sec
);
2743 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2745 if (sec
->flags
& SEC_LINKER_CREATED
)
2747 /* Remove the linker created SHT_GROUP sections. */
2748 bfd_section_list_remove (abfd
, sec
);
2749 abfd
->section_count
--;
2753 if (section_number
== SHN_LORESERVE
)
2754 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2755 d
->this_idx
= section_number
++;
2761 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2763 d
= elf_section_data (sec
);
2765 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2767 if (section_number
== SHN_LORESERVE
)
2768 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2769 d
->this_idx
= section_number
++;
2771 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2772 if ((sec
->flags
& SEC_RELOC
) == 0)
2776 if (section_number
== SHN_LORESERVE
)
2777 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2778 d
->rel_idx
= section_number
++;
2779 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2784 if (section_number
== SHN_LORESERVE
)
2785 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2786 d
->rel_idx2
= section_number
++;
2787 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2793 if (section_number
== SHN_LORESERVE
)
2794 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2795 t
->shstrtab_section
= section_number
++;
2796 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2797 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2799 if (bfd_get_symcount (abfd
) > 0)
2801 if (section_number
== SHN_LORESERVE
)
2802 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2803 t
->symtab_section
= section_number
++;
2804 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2805 if (section_number
> SHN_LORESERVE
- 2)
2807 if (section_number
== SHN_LORESERVE
)
2808 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2809 t
->symtab_shndx_section
= section_number
++;
2810 t
->symtab_shndx_hdr
.sh_name
2811 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2812 ".symtab_shndx", FALSE
);
2813 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2816 if (section_number
== SHN_LORESERVE
)
2817 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2818 t
->strtab_section
= section_number
++;
2819 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2822 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2823 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2825 elf_numsections (abfd
) = section_number
;
2826 elf_elfheader (abfd
)->e_shnum
= section_number
;
2827 if (section_number
> SHN_LORESERVE
)
2828 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2830 /* Set up the list of section header pointers, in agreement with the
2832 i_shdrp
= bfd_zalloc2 (abfd
, section_number
, sizeof (Elf_Internal_Shdr
*));
2833 if (i_shdrp
== NULL
)
2836 i_shdrp
[0] = bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2837 if (i_shdrp
[0] == NULL
)
2839 bfd_release (abfd
, i_shdrp
);
2843 elf_elfsections (abfd
) = i_shdrp
;
2845 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2846 if (bfd_get_symcount (abfd
) > 0)
2848 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2849 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2851 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2852 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2854 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2855 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2858 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2860 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2864 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2865 if (d
->rel_idx
!= 0)
2866 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2867 if (d
->rel_idx2
!= 0)
2868 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2870 /* Fill in the sh_link and sh_info fields while we're at it. */
2872 /* sh_link of a reloc section is the section index of the symbol
2873 table. sh_info is the section index of the section to which
2874 the relocation entries apply. */
2875 if (d
->rel_idx
!= 0)
2877 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2878 d
->rel_hdr
.sh_info
= d
->this_idx
;
2880 if (d
->rel_idx2
!= 0)
2882 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2883 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2886 /* We need to set up sh_link for SHF_LINK_ORDER. */
2887 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2889 s
= elf_linked_to_section (sec
);
2892 /* elf_linked_to_section points to the input section. */
2893 if (link_info
!= NULL
)
2895 /* Check discarded linkonce section. */
2896 if (elf_discarded_section (s
))
2899 (*_bfd_error_handler
)
2900 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2901 abfd
, d
->this_hdr
.bfd_section
,
2903 /* Point to the kept section if it has the same
2904 size as the discarded one. */
2905 kept
= _bfd_elf_check_kept_section (s
, link_info
);
2908 bfd_set_error (bfd_error_bad_value
);
2914 s
= s
->output_section
;
2915 BFD_ASSERT (s
!= NULL
);
2919 /* Handle objcopy. */
2920 if (s
->output_section
== NULL
)
2922 (*_bfd_error_handler
)
2923 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2924 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
2925 bfd_set_error (bfd_error_bad_value
);
2928 s
= s
->output_section
;
2930 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2935 The Intel C compiler generates SHT_IA_64_UNWIND with
2936 SHF_LINK_ORDER. But it doesn't set the sh_link or
2937 sh_info fields. Hence we could get the situation
2939 const struct elf_backend_data
*bed
2940 = get_elf_backend_data (abfd
);
2941 if (bed
->link_order_error_handler
)
2942 bed
->link_order_error_handler
2943 (_("%B: warning: sh_link not set for section `%A'"),
2948 switch (d
->this_hdr
.sh_type
)
2952 /* A reloc section which we are treating as a normal BFD
2953 section. sh_link is the section index of the symbol
2954 table. sh_info is the section index of the section to
2955 which the relocation entries apply. We assume that an
2956 allocated reloc section uses the dynamic symbol table.
2957 FIXME: How can we be sure? */
2958 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2960 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2962 /* We look up the section the relocs apply to by name. */
2964 if (d
->this_hdr
.sh_type
== SHT_REL
)
2968 s
= bfd_get_section_by_name (abfd
, name
);
2970 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2974 /* We assume that a section named .stab*str is a stabs
2975 string section. We look for a section with the same name
2976 but without the trailing ``str'', and set its sh_link
2977 field to point to this section. */
2978 if (CONST_STRNEQ (sec
->name
, ".stab")
2979 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2984 len
= strlen (sec
->name
);
2985 alc
= bfd_malloc (len
- 2);
2988 memcpy (alc
, sec
->name
, len
- 3);
2989 alc
[len
- 3] = '\0';
2990 s
= bfd_get_section_by_name (abfd
, alc
);
2994 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2996 /* This is a .stab section. */
2997 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
2998 elf_section_data (s
)->this_hdr
.sh_entsize
2999 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3006 case SHT_GNU_verneed
:
3007 case SHT_GNU_verdef
:
3008 /* sh_link is the section header index of the string table
3009 used for the dynamic entries, or the symbol table, or the
3011 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3013 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3016 case SHT_GNU_LIBLIST
:
3017 /* sh_link is the section header index of the prelink library
3018 list used for the dynamic entries, or the symbol table, or
3019 the version strings. */
3020 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3021 ? ".dynstr" : ".gnu.libstr");
3023 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3028 case SHT_GNU_versym
:
3029 /* sh_link is the section header index of the symbol table
3030 this hash table or version table is for. */
3031 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3033 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3037 d
->this_hdr
.sh_link
= t
->symtab_section
;
3041 for (secn
= 1; secn
< section_number
; ++secn
)
3042 if (i_shdrp
[secn
] == NULL
)
3043 i_shdrp
[secn
] = i_shdrp
[0];
3045 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3046 i_shdrp
[secn
]->sh_name
);
3050 /* Map symbol from it's internal number to the external number, moving
3051 all local symbols to be at the head of the list. */
3054 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3056 /* If the backend has a special mapping, use it. */
3057 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3058 if (bed
->elf_backend_sym_is_global
)
3059 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3061 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3062 || bfd_is_und_section (bfd_get_section (sym
))
3063 || bfd_is_com_section (bfd_get_section (sym
)));
3066 /* Don't output section symbols for sections that are not going to be
3067 output. Also, don't output section symbols for reloc and other
3068 special sections. */
3071 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3073 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3075 || (sym
->section
->owner
!= abfd
3076 && (sym
->section
->output_section
->owner
!= abfd
3077 || sym
->section
->output_offset
!= 0))));
3081 elf_map_symbols (bfd
*abfd
)
3083 unsigned int symcount
= bfd_get_symcount (abfd
);
3084 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3085 asymbol
**sect_syms
;
3086 unsigned int num_locals
= 0;
3087 unsigned int num_globals
= 0;
3088 unsigned int num_locals2
= 0;
3089 unsigned int num_globals2
= 0;
3096 fprintf (stderr
, "elf_map_symbols\n");
3100 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3102 if (max_index
< asect
->index
)
3103 max_index
= asect
->index
;
3107 sect_syms
= bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3108 if (sect_syms
== NULL
)
3110 elf_section_syms (abfd
) = sect_syms
;
3111 elf_num_section_syms (abfd
) = max_index
;
3113 /* Init sect_syms entries for any section symbols we have already
3114 decided to output. */
3115 for (idx
= 0; idx
< symcount
; idx
++)
3117 asymbol
*sym
= syms
[idx
];
3119 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3120 && !ignore_section_sym (abfd
, sym
))
3122 asection
*sec
= sym
->section
;
3124 if (sec
->owner
!= abfd
)
3125 sec
= sec
->output_section
;
3127 sect_syms
[sec
->index
] = syms
[idx
];
3131 /* Classify all of the symbols. */
3132 for (idx
= 0; idx
< symcount
; idx
++)
3134 if (ignore_section_sym (abfd
, syms
[idx
]))
3136 if (!sym_is_global (abfd
, syms
[idx
]))
3142 /* We will be adding a section symbol for each normal BFD section. Most
3143 sections will already have a section symbol in outsymbols, but
3144 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3145 at least in that case. */
3146 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3148 if (sect_syms
[asect
->index
] == NULL
)
3150 if (!sym_is_global (abfd
, asect
->symbol
))
3157 /* Now sort the symbols so the local symbols are first. */
3158 new_syms
= bfd_alloc2 (abfd
, num_locals
+ num_globals
, sizeof (asymbol
*));
3160 if (new_syms
== NULL
)
3163 for (idx
= 0; idx
< symcount
; idx
++)
3165 asymbol
*sym
= syms
[idx
];
3168 if (ignore_section_sym (abfd
, sym
))
3170 if (!sym_is_global (abfd
, sym
))
3173 i
= num_locals
+ num_globals2
++;
3175 sym
->udata
.i
= i
+ 1;
3177 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3179 if (sect_syms
[asect
->index
] == NULL
)
3181 asymbol
*sym
= asect
->symbol
;
3184 sect_syms
[asect
->index
] = sym
;
3185 if (!sym_is_global (abfd
, sym
))
3188 i
= num_locals
+ num_globals2
++;
3190 sym
->udata
.i
= i
+ 1;
3194 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3196 elf_num_locals (abfd
) = num_locals
;
3197 elf_num_globals (abfd
) = num_globals
;
3201 /* Align to the maximum file alignment that could be required for any
3202 ELF data structure. */
3204 static inline file_ptr
3205 align_file_position (file_ptr off
, int align
)
3207 return (off
+ align
- 1) & ~(align
- 1);
3210 /* Assign a file position to a section, optionally aligning to the
3211 required section alignment. */
3214 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3222 al
= i_shdrp
->sh_addralign
;
3224 offset
= BFD_ALIGN (offset
, al
);
3226 i_shdrp
->sh_offset
= offset
;
3227 if (i_shdrp
->bfd_section
!= NULL
)
3228 i_shdrp
->bfd_section
->filepos
= offset
;
3229 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3230 offset
+= i_shdrp
->sh_size
;
3234 /* Compute the file positions we are going to put the sections at, and
3235 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3236 is not NULL, this is being called by the ELF backend linker. */
3239 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3240 struct bfd_link_info
*link_info
)
3242 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3244 struct bfd_strtab_hash
*strtab
= NULL
;
3245 Elf_Internal_Shdr
*shstrtab_hdr
;
3247 if (abfd
->output_has_begun
)
3250 /* Do any elf backend specific processing first. */
3251 if (bed
->elf_backend_begin_write_processing
)
3252 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3254 if (! prep_headers (abfd
))
3257 /* Post process the headers if necessary. */
3258 if (bed
->elf_backend_post_process_headers
)
3259 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3262 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3266 if (!assign_section_numbers (abfd
, link_info
))
3269 /* The backend linker builds symbol table information itself. */
3270 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3272 /* Non-zero if doing a relocatable link. */
3273 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3275 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3279 if (link_info
== NULL
)
3281 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3286 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3287 /* sh_name was set in prep_headers. */
3288 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3289 shstrtab_hdr
->sh_flags
= 0;
3290 shstrtab_hdr
->sh_addr
= 0;
3291 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3292 shstrtab_hdr
->sh_entsize
= 0;
3293 shstrtab_hdr
->sh_link
= 0;
3294 shstrtab_hdr
->sh_info
= 0;
3295 /* sh_offset is set in assign_file_positions_except_relocs. */
3296 shstrtab_hdr
->sh_addralign
= 1;
3298 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3301 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3304 Elf_Internal_Shdr
*hdr
;
3306 off
= elf_tdata (abfd
)->next_file_pos
;
3308 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3309 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3311 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3312 if (hdr
->sh_size
!= 0)
3313 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3315 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3316 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3318 elf_tdata (abfd
)->next_file_pos
= off
;
3320 /* Now that we know where the .strtab section goes, write it
3322 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3323 || ! _bfd_stringtab_emit (abfd
, strtab
))
3325 _bfd_stringtab_free (strtab
);
3328 abfd
->output_has_begun
= TRUE
;
3333 /* Make an initial estimate of the size of the program header. If we
3334 get the number wrong here, we'll redo section placement. */
3336 static bfd_size_type
3337 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3341 const struct elf_backend_data
*bed
;
3343 /* Assume we will need exactly two PT_LOAD segments: one for text
3344 and one for data. */
3347 s
= bfd_get_section_by_name (abfd
, ".interp");
3348 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3350 /* If we have a loadable interpreter section, we need a
3351 PT_INTERP segment. In this case, assume we also need a
3352 PT_PHDR segment, although that may not be true for all
3357 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3359 /* We need a PT_DYNAMIC segment. */
3365 /* We need a PT_GNU_RELRO segment. */
3369 if (elf_tdata (abfd
)->eh_frame_hdr
)
3371 /* We need a PT_GNU_EH_FRAME segment. */
3375 if (elf_tdata (abfd
)->stack_flags
)
3377 /* We need a PT_GNU_STACK segment. */
3381 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3383 if ((s
->flags
& SEC_LOAD
) != 0
3384 && CONST_STRNEQ (s
->name
, ".note"))
3386 /* We need a PT_NOTE segment. */
3388 /* Try to create just one PT_NOTE segment
3389 for all adjacent loadable .note* sections.
3390 gABI requires that within a PT_NOTE segment
3391 (and also inside of each SHT_NOTE section)
3392 each note is padded to a multiple of 4 size,
3393 so we check whether the sections are correctly
3395 if (s
->alignment_power
== 2)
3396 while (s
->next
!= NULL
3397 && s
->next
->alignment_power
== 2
3398 && (s
->next
->flags
& SEC_LOAD
) != 0
3399 && CONST_STRNEQ (s
->next
->name
, ".note"))
3404 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3406 if (s
->flags
& SEC_THREAD_LOCAL
)
3408 /* We need a PT_TLS segment. */
3414 /* Let the backend count up any program headers it might need. */
3415 bed
= get_elf_backend_data (abfd
);
3416 if (bed
->elf_backend_additional_program_headers
)
3420 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3426 return segs
* bed
->s
->sizeof_phdr
;
3429 /* Find the segment that contains the output_section of section. */
3432 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3434 struct elf_segment_map
*m
;
3435 Elf_Internal_Phdr
*p
;
3437 for (m
= elf_tdata (abfd
)->segment_map
,
3438 p
= elf_tdata (abfd
)->phdr
;
3444 for (i
= m
->count
- 1; i
>= 0; i
--)
3445 if (m
->sections
[i
] == section
)
3452 /* Create a mapping from a set of sections to a program segment. */
3454 static struct elf_segment_map
*
3455 make_mapping (bfd
*abfd
,
3456 asection
**sections
,
3461 struct elf_segment_map
*m
;
3466 amt
= sizeof (struct elf_segment_map
);
3467 amt
+= (to
- from
- 1) * sizeof (asection
*);
3468 m
= bfd_zalloc (abfd
, amt
);
3472 m
->p_type
= PT_LOAD
;
3473 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3474 m
->sections
[i
- from
] = *hdrpp
;
3475 m
->count
= to
- from
;
3477 if (from
== 0 && phdr
)
3479 /* Include the headers in the first PT_LOAD segment. */
3480 m
->includes_filehdr
= 1;
3481 m
->includes_phdrs
= 1;
3487 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3490 struct elf_segment_map
*
3491 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3493 struct elf_segment_map
*m
;
3495 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3499 m
->p_type
= PT_DYNAMIC
;
3501 m
->sections
[0] = dynsec
;
3506 /* Possibly add or remove segments from the segment map. */
3509 elf_modify_segment_map (bfd
*abfd
,
3510 struct bfd_link_info
*info
,
3511 bfd_boolean remove_empty_load
)
3513 struct elf_segment_map
**m
;
3514 const struct elf_backend_data
*bed
;
3516 /* The placement algorithm assumes that non allocated sections are
3517 not in PT_LOAD segments. We ensure this here by removing such
3518 sections from the segment map. We also remove excluded
3519 sections. Finally, any PT_LOAD segment without sections is
3521 m
= &elf_tdata (abfd
)->segment_map
;
3524 unsigned int i
, new_count
;
3526 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3528 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3529 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3530 || (*m
)->p_type
!= PT_LOAD
))
3532 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3536 (*m
)->count
= new_count
;
3538 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3544 bed
= get_elf_backend_data (abfd
);
3545 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3547 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3554 /* Set up a mapping from BFD sections to program segments. */
3557 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3560 struct elf_segment_map
*m
;
3561 asection
**sections
= NULL
;
3562 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3563 bfd_boolean no_user_phdrs
;
3565 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3566 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3570 struct elf_segment_map
*mfirst
;
3571 struct elf_segment_map
**pm
;
3574 unsigned int phdr_index
;
3575 bfd_vma maxpagesize
;
3577 bfd_boolean phdr_in_segment
= TRUE
;
3578 bfd_boolean writable
;
3580 asection
*first_tls
= NULL
;
3581 asection
*dynsec
, *eh_frame_hdr
;
3584 /* Select the allocated sections, and sort them. */
3586 sections
= bfd_malloc2 (bfd_count_sections (abfd
), sizeof (asection
*));
3587 if (sections
== NULL
)
3591 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3593 if ((s
->flags
& SEC_ALLOC
) != 0)
3599 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3602 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3604 /* Build the mapping. */
3609 /* If we have a .interp section, then create a PT_PHDR segment for
3610 the program headers and a PT_INTERP segment for the .interp
3612 s
= bfd_get_section_by_name (abfd
, ".interp");
3613 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3615 amt
= sizeof (struct elf_segment_map
);
3616 m
= bfd_zalloc (abfd
, amt
);
3620 m
->p_type
= PT_PHDR
;
3621 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3622 m
->p_flags
= PF_R
| PF_X
;
3623 m
->p_flags_valid
= 1;
3624 m
->includes_phdrs
= 1;
3629 amt
= sizeof (struct elf_segment_map
);
3630 m
= bfd_zalloc (abfd
, amt
);
3634 m
->p_type
= PT_INTERP
;
3642 /* Look through the sections. We put sections in the same program
3643 segment when the start of the second section can be placed within
3644 a few bytes of the end of the first section. */
3648 maxpagesize
= bed
->maxpagesize
;
3650 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3652 && (dynsec
->flags
& SEC_LOAD
) == 0)
3655 /* Deal with -Ttext or something similar such that the first section
3656 is not adjacent to the program headers. This is an
3657 approximation, since at this point we don't know exactly how many
3658 program headers we will need. */
3661 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3663 if (phdr_size
== (bfd_size_type
) -1)
3664 phdr_size
= get_program_header_size (abfd
, info
);
3665 if ((abfd
->flags
& D_PAGED
) == 0
3666 || sections
[0]->lma
< phdr_size
3667 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3668 phdr_in_segment
= FALSE
;
3671 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3674 bfd_boolean new_segment
;
3678 /* See if this section and the last one will fit in the same
3681 if (last_hdr
== NULL
)
3683 /* If we don't have a segment yet, then we don't need a new
3684 one (we build the last one after this loop). */
3685 new_segment
= FALSE
;
3687 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3689 /* If this section has a different relation between the
3690 virtual address and the load address, then we need a new
3694 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3695 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3697 /* If putting this section in this segment would force us to
3698 skip a page in the segment, then we need a new segment. */
3701 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3702 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3704 /* We don't want to put a loadable section after a
3705 nonloadable section in the same segment.
3706 Consider .tbss sections as loadable for this purpose. */
3709 else if ((abfd
->flags
& D_PAGED
) == 0)
3711 /* If the file is not demand paged, which means that we
3712 don't require the sections to be correctly aligned in the
3713 file, then there is no other reason for a new segment. */
3714 new_segment
= FALSE
;
3717 && (hdr
->flags
& SEC_READONLY
) == 0
3718 && (((last_hdr
->lma
+ last_size
- 1)
3719 & ~(maxpagesize
- 1))
3720 != (hdr
->lma
& ~(maxpagesize
- 1))))
3722 /* We don't want to put a writable section in a read only
3723 segment, unless they are on the same page in memory
3724 anyhow. We already know that the last section does not
3725 bring us past the current section on the page, so the
3726 only case in which the new section is not on the same
3727 page as the previous section is when the previous section
3728 ends precisely on a page boundary. */
3733 /* Otherwise, we can use the same segment. */
3734 new_segment
= FALSE
;
3737 /* Allow interested parties a chance to override our decision. */
3738 if (last_hdr
&& info
->callbacks
->override_segment_assignment
)
3739 new_segment
= info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
, last_hdr
, new_segment
);
3743 if ((hdr
->flags
& SEC_READONLY
) == 0)
3746 /* .tbss sections effectively have zero size. */
3747 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3748 != SEC_THREAD_LOCAL
)
3749 last_size
= hdr
->size
;
3755 /* We need a new program segment. We must create a new program
3756 header holding all the sections from phdr_index until hdr. */
3758 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3765 if ((hdr
->flags
& SEC_READONLY
) == 0)
3771 /* .tbss sections effectively have zero size. */
3772 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3773 last_size
= hdr
->size
;
3777 phdr_in_segment
= FALSE
;
3780 /* Create a final PT_LOAD program segment. */
3781 if (last_hdr
!= NULL
)
3783 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3791 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3794 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3801 /* For each batch of consecutive loadable .note sections,
3802 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3803 because if we link together nonloadable .note sections and
3804 loadable .note sections, we will generate two .note sections
3805 in the output file. FIXME: Using names for section types is
3807 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3809 if ((s
->flags
& SEC_LOAD
) != 0
3810 && CONST_STRNEQ (s
->name
, ".note"))
3814 amt
= sizeof (struct elf_segment_map
);
3815 if (s
->alignment_power
== 2)
3816 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3818 if (s2
->next
->alignment_power
== 2
3819 && (s2
->next
->flags
& SEC_LOAD
) != 0
3820 && CONST_STRNEQ (s2
->next
->name
, ".note")
3821 && align_power (s2
->vma
+ s2
->size
, 2)
3827 amt
+= (count
- 1) * sizeof (asection
*);
3828 m
= bfd_zalloc (abfd
, amt
);
3832 m
->p_type
= PT_NOTE
;
3836 m
->sections
[m
->count
- count
--] = s
;
3837 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3840 m
->sections
[m
->count
- 1] = s
;
3841 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3845 if (s
->flags
& SEC_THREAD_LOCAL
)
3853 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3858 amt
= sizeof (struct elf_segment_map
);
3859 amt
+= (tls_count
- 1) * sizeof (asection
*);
3860 m
= bfd_zalloc (abfd
, amt
);
3865 m
->count
= tls_count
;
3866 /* Mandated PF_R. */
3868 m
->p_flags_valid
= 1;
3869 for (i
= 0; i
< tls_count
; ++i
)
3871 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3872 m
->sections
[i
] = first_tls
;
3873 first_tls
= first_tls
->next
;
3880 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3882 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3883 if (eh_frame_hdr
!= NULL
3884 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3886 amt
= sizeof (struct elf_segment_map
);
3887 m
= bfd_zalloc (abfd
, amt
);
3891 m
->p_type
= PT_GNU_EH_FRAME
;
3893 m
->sections
[0] = eh_frame_hdr
->output_section
;
3899 if (elf_tdata (abfd
)->stack_flags
)
3901 amt
= sizeof (struct elf_segment_map
);
3902 m
= bfd_zalloc (abfd
, amt
);
3906 m
->p_type
= PT_GNU_STACK
;
3907 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3908 m
->p_flags_valid
= 1;
3916 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3918 if (m
->p_type
== PT_LOAD
)
3920 asection
*last
= m
->sections
[m
->count
- 1];
3921 bfd_vma vaddr
= m
->sections
[0]->vma
;
3922 bfd_vma filesz
= last
->vma
- vaddr
+ last
->size
;
3924 if (vaddr
< info
->relro_end
3925 && vaddr
>= info
->relro_start
3926 && (vaddr
+ filesz
) >= info
->relro_end
)
3931 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3934 amt
= sizeof (struct elf_segment_map
);
3935 m
= bfd_zalloc (abfd
, amt
);
3939 m
->p_type
= PT_GNU_RELRO
;
3941 m
->p_flags_valid
= 1;
3949 elf_tdata (abfd
)->segment_map
= mfirst
;
3952 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
3955 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3957 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
3962 if (sections
!= NULL
)
3967 /* Sort sections by address. */
3970 elf_sort_sections (const void *arg1
, const void *arg2
)
3972 const asection
*sec1
= *(const asection
**) arg1
;
3973 const asection
*sec2
= *(const asection
**) arg2
;
3974 bfd_size_type size1
, size2
;
3976 /* Sort by LMA first, since this is the address used to
3977 place the section into a segment. */
3978 if (sec1
->lma
< sec2
->lma
)
3980 else if (sec1
->lma
> sec2
->lma
)
3983 /* Then sort by VMA. Normally the LMA and the VMA will be
3984 the same, and this will do nothing. */
3985 if (sec1
->vma
< sec2
->vma
)
3987 else if (sec1
->vma
> sec2
->vma
)
3990 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3992 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3998 /* If the indicies are the same, do not return 0
3999 here, but continue to try the next comparison. */
4000 if (sec1
->target_index
- sec2
->target_index
!= 0)
4001 return sec1
->target_index
- sec2
->target_index
;
4006 else if (TOEND (sec2
))
4011 /* Sort by size, to put zero sized sections
4012 before others at the same address. */
4014 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4015 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4022 return sec1
->target_index
- sec2
->target_index
;
4025 /* Ian Lance Taylor writes:
4027 We shouldn't be using % with a negative signed number. That's just
4028 not good. We have to make sure either that the number is not
4029 negative, or that the number has an unsigned type. When the types
4030 are all the same size they wind up as unsigned. When file_ptr is a
4031 larger signed type, the arithmetic winds up as signed long long,
4034 What we're trying to say here is something like ``increase OFF by
4035 the least amount that will cause it to be equal to the VMA modulo
4037 /* In other words, something like:
4039 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4040 off_offset = off % bed->maxpagesize;
4041 if (vma_offset < off_offset)
4042 adjustment = vma_offset + bed->maxpagesize - off_offset;
4044 adjustment = vma_offset - off_offset;
4046 which can can be collapsed into the expression below. */
4049 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4051 return ((vma
- off
) % maxpagesize
);
4055 print_segment_map (const struct elf_segment_map
*m
)
4058 const char *pt
= get_segment_type (m
->p_type
);
4063 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4064 sprintf (buf
, "LOPROC+%7.7x",
4065 (unsigned int) (m
->p_type
- PT_LOPROC
));
4066 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4067 sprintf (buf
, "LOOS+%7.7x",
4068 (unsigned int) (m
->p_type
- PT_LOOS
));
4070 snprintf (buf
, sizeof (buf
), "%8.8x",
4071 (unsigned int) m
->p_type
);
4074 fprintf (stderr
, "%s:", pt
);
4075 for (j
= 0; j
< m
->count
; j
++)
4076 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4080 /* Assign file positions to the sections based on the mapping from
4081 sections to segments. This function also sets up some fields in
4085 assign_file_positions_for_load_sections (bfd
*abfd
,
4086 struct bfd_link_info
*link_info
)
4088 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4089 struct elf_segment_map
*m
;
4090 Elf_Internal_Phdr
*phdrs
;
4091 Elf_Internal_Phdr
*p
;
4093 bfd_size_type maxpagesize
;
4097 if (link_info
== NULL
4098 && !elf_modify_segment_map (abfd
, link_info
, FALSE
))
4102 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4105 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4106 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4107 elf_elfheader (abfd
)->e_phnum
= alloc
;
4109 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4110 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4112 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4113 >= alloc
* bed
->s
->sizeof_phdr
);
4117 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4121 phdrs
= bfd_alloc2 (abfd
, alloc
, sizeof (Elf_Internal_Phdr
));
4122 elf_tdata (abfd
)->phdr
= phdrs
;
4127 if ((abfd
->flags
& D_PAGED
) != 0)
4128 maxpagesize
= bed
->maxpagesize
;
4130 off
= bed
->s
->sizeof_ehdr
;
4131 off
+= alloc
* bed
->s
->sizeof_phdr
;
4133 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4135 m
= m
->next
, p
++, j
++)
4139 bfd_boolean no_contents
;
4141 /* If elf_segment_map is not from map_sections_to_segments, the
4142 sections may not be correctly ordered. NOTE: sorting should
4143 not be done to the PT_NOTE section of a corefile, which may
4144 contain several pseudo-sections artificially created by bfd.
4145 Sorting these pseudo-sections breaks things badly. */
4147 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4148 && m
->p_type
== PT_NOTE
))
4149 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4152 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4153 number of sections with contents contributing to both p_filesz
4154 and p_memsz, followed by a number of sections with no contents
4155 that just contribute to p_memsz. In this loop, OFF tracks next
4156 available file offset for PT_LOAD and PT_NOTE segments. */
4157 p
->p_type
= m
->p_type
;
4158 p
->p_flags
= m
->p_flags
;
4163 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4165 if (m
->p_paddr_valid
)
4166 p
->p_paddr
= m
->p_paddr
;
4167 else if (m
->count
== 0)
4170 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4172 if (p
->p_type
== PT_LOAD
4173 && (abfd
->flags
& D_PAGED
) != 0)
4175 /* p_align in demand paged PT_LOAD segments effectively stores
4176 the maximum page size. When copying an executable with
4177 objcopy, we set m->p_align from the input file. Use this
4178 value for maxpagesize rather than bed->maxpagesize, which
4179 may be different. Note that we use maxpagesize for PT_TLS
4180 segment alignment later in this function, so we are relying
4181 on at least one PT_LOAD segment appearing before a PT_TLS
4183 if (m
->p_align_valid
)
4184 maxpagesize
= m
->p_align
;
4186 p
->p_align
= maxpagesize
;
4188 else if (m
->p_align_valid
)
4189 p
->p_align
= m
->p_align
;
4190 else if (m
->count
== 0)
4191 p
->p_align
= 1 << bed
->s
->log_file_align
;
4195 no_contents
= FALSE
;
4197 if (p
->p_type
== PT_LOAD
4200 bfd_size_type align
;
4201 unsigned int align_power
= 0;
4203 if (m
->p_align_valid
)
4207 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4209 unsigned int secalign
;
4211 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4212 if (secalign
> align_power
)
4213 align_power
= secalign
;
4215 align
= (bfd_size_type
) 1 << align_power
;
4216 if (align
< maxpagesize
)
4217 align
= maxpagesize
;
4220 for (i
= 0; i
< m
->count
; i
++)
4221 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4222 /* If we aren't making room for this section, then
4223 it must be SHT_NOBITS regardless of what we've
4224 set via struct bfd_elf_special_section. */
4225 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4227 /* Find out whether this segment contains any loadable
4228 sections. If the first section isn't loadable, the same
4229 holds for any other sections. */
4231 while (elf_section_type (m
->sections
[i
]) == SHT_NOBITS
)
4233 /* If a segment starts with .tbss, we need to look
4234 at the next section to decide whether the segment
4235 has any loadable sections. */
4236 if ((elf_section_flags (m
->sections
[i
]) & SHF_TLS
) == 0
4244 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4248 /* We shouldn't need to align the segment on disk since
4249 the segment doesn't need file space, but the gABI
4250 arguably requires the alignment and glibc ld.so
4251 checks it. So to comply with the alignment
4252 requirement but not waste file space, we adjust
4253 p_offset for just this segment. (OFF_ADJUST is
4254 subtracted from OFF later.) This may put p_offset
4255 past the end of file, but that shouldn't matter. */
4260 /* Make sure the .dynamic section is the first section in the
4261 PT_DYNAMIC segment. */
4262 else if (p
->p_type
== PT_DYNAMIC
4264 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4267 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4269 bfd_set_error (bfd_error_bad_value
);
4277 if (m
->includes_filehdr
)
4279 if (!m
->p_flags_valid
)
4281 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4282 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4285 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4287 if (p
->p_vaddr
< (bfd_vma
) off
)
4289 (*_bfd_error_handler
)
4290 (_("%B: Not enough room for program headers, try linking with -N"),
4292 bfd_set_error (bfd_error_bad_value
);
4297 if (!m
->p_paddr_valid
)
4302 if (m
->includes_phdrs
)
4304 if (!m
->p_flags_valid
)
4307 if (!m
->includes_filehdr
)
4309 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4313 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4314 p
->p_vaddr
-= off
- p
->p_offset
;
4315 if (!m
->p_paddr_valid
)
4316 p
->p_paddr
-= off
- p
->p_offset
;
4320 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4321 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4324 if (p
->p_type
== PT_LOAD
4325 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4327 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4333 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4335 p
->p_filesz
+= adjust
;
4336 p
->p_memsz
+= adjust
;
4340 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4341 maps. Set filepos for sections in PT_LOAD segments, and in
4342 core files, for sections in PT_NOTE segments.
4343 assign_file_positions_for_non_load_sections will set filepos
4344 for other sections and update p_filesz for other segments. */
4345 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4348 bfd_size_type align
;
4349 Elf_Internal_Shdr
*this_hdr
;
4352 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4353 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4355 if (p
->p_type
== PT_LOAD
4356 || p
->p_type
== PT_TLS
)
4358 bfd_signed_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
4360 if (this_hdr
->sh_type
!= SHT_NOBITS
4361 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4362 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4363 || p
->p_type
== PT_TLS
)))
4367 (*_bfd_error_handler
)
4368 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4369 abfd
, sec
, (unsigned long) sec
->lma
);
4372 p
->p_memsz
+= adjust
;
4374 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4377 p
->p_filesz
+= adjust
;
4382 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4384 /* The section at i == 0 is the one that actually contains
4388 this_hdr
->sh_offset
= sec
->filepos
= off
;
4389 off
+= this_hdr
->sh_size
;
4390 p
->p_filesz
= this_hdr
->sh_size
;
4396 /* The rest are fake sections that shouldn't be written. */
4405 if (p
->p_type
== PT_LOAD
)
4407 this_hdr
->sh_offset
= sec
->filepos
= off
;
4408 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4409 off
+= this_hdr
->sh_size
;
4412 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4414 p
->p_filesz
+= this_hdr
->sh_size
;
4415 /* A load section without SHF_ALLOC is something like
4416 a note section in a PT_NOTE segment. These take
4417 file space but are not loaded into memory. */
4418 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4419 p
->p_memsz
+= this_hdr
->sh_size
;
4421 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4423 if (p
->p_type
== PT_TLS
)
4424 p
->p_memsz
+= this_hdr
->sh_size
;
4426 /* .tbss is special. It doesn't contribute to p_memsz of
4428 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4429 p
->p_memsz
+= this_hdr
->sh_size
;
4432 if (align
> p
->p_align
4433 && !m
->p_align_valid
4434 && (p
->p_type
!= PT_LOAD
4435 || (abfd
->flags
& D_PAGED
) == 0))
4439 if (!m
->p_flags_valid
)
4442 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4444 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4450 /* Check that all sections are in a PT_LOAD segment.
4451 Don't check funky gdb generated core files. */
4452 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4453 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4455 Elf_Internal_Shdr
*this_hdr
;
4459 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4460 if (this_hdr
->sh_size
!= 0
4461 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, p
))
4463 (*_bfd_error_handler
)
4464 (_("%B: section `%A' can't be allocated in segment %d"),
4466 print_segment_map (m
);
4467 bfd_set_error (bfd_error_bad_value
);
4473 elf_tdata (abfd
)->next_file_pos
= off
;
4477 /* Assign file positions for the other sections. */
4480 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4481 struct bfd_link_info
*link_info
)
4483 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4484 Elf_Internal_Shdr
**i_shdrpp
;
4485 Elf_Internal_Shdr
**hdrpp
;
4486 Elf_Internal_Phdr
*phdrs
;
4487 Elf_Internal_Phdr
*p
;
4488 struct elf_segment_map
*m
;
4489 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4490 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4492 unsigned int num_sec
;
4496 i_shdrpp
= elf_elfsections (abfd
);
4497 num_sec
= elf_numsections (abfd
);
4498 off
= elf_tdata (abfd
)->next_file_pos
;
4499 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4501 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4502 Elf_Internal_Shdr
*hdr
;
4505 if (hdr
->bfd_section
!= NULL
4506 && (hdr
->bfd_section
->filepos
!= 0
4507 || (hdr
->sh_type
== SHT_NOBITS
4508 && hdr
->contents
== NULL
)))
4509 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4510 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4512 if (hdr
->sh_size
!= 0)
4513 ((*_bfd_error_handler
)
4514 (_("%B: warning: allocated section `%s' not in segment"),
4516 (hdr
->bfd_section
== NULL
4518 : hdr
->bfd_section
->name
)));
4519 /* We don't need to page align empty sections. */
4520 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4521 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4524 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4526 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4529 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4530 && hdr
->bfd_section
== NULL
)
4531 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4532 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4533 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4534 hdr
->sh_offset
= -1;
4536 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4538 if (i
== SHN_LORESERVE
- 1)
4540 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4541 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4545 /* Now that we have set the section file positions, we can set up
4546 the file positions for the non PT_LOAD segments. */
4550 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4552 phdrs
= elf_tdata (abfd
)->phdr
;
4553 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4558 if (p
->p_type
!= PT_LOAD
)
4561 if (m
->includes_filehdr
)
4563 filehdr_vaddr
= p
->p_vaddr
;
4564 filehdr_paddr
= p
->p_paddr
;
4566 if (m
->includes_phdrs
)
4568 phdrs_vaddr
= p
->p_vaddr
;
4569 phdrs_paddr
= p
->p_paddr
;
4570 if (m
->includes_filehdr
)
4572 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4573 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4578 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4584 if (p
->p_type
!= PT_LOAD
4585 && (p
->p_type
!= PT_NOTE
4586 || bfd_get_format (abfd
) != bfd_core
))
4588 Elf_Internal_Shdr
*hdr
;
4591 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4593 sect
= m
->sections
[m
->count
- 1];
4594 hdr
= &elf_section_data (sect
)->this_hdr
;
4595 p
->p_filesz
= sect
->filepos
- m
->sections
[0]->filepos
;
4596 if (hdr
->sh_type
!= SHT_NOBITS
)
4597 p
->p_filesz
+= hdr
->sh_size
;
4599 if (p
->p_type
== PT_GNU_RELRO
)
4601 /* When we get here, we are copying executable
4602 or shared library. But we need to use the same
4604 Elf_Internal_Phdr
*lp
;
4606 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4608 if (lp
->p_type
== PT_LOAD
4609 && lp
->p_paddr
== p
->p_paddr
)
4613 if (lp
< phdrs
+ count
)
4615 /* We should use p_size if it is valid since it
4616 may contain the first few bytes of the next
4617 SEC_ALLOC section. */
4618 if (m
->p_size_valid
)
4619 p
->p_filesz
= m
->p_size
;
4622 p
->p_vaddr
= lp
->p_vaddr
;
4623 p
->p_offset
= lp
->p_offset
;
4624 p
->p_memsz
= p
->p_filesz
;
4631 p
->p_offset
= m
->sections
[0]->filepos
;
4636 if (m
->includes_filehdr
)
4638 p
->p_vaddr
= filehdr_vaddr
;
4639 if (! m
->p_paddr_valid
)
4640 p
->p_paddr
= filehdr_paddr
;
4642 else if (m
->includes_phdrs
)
4644 p
->p_vaddr
= phdrs_vaddr
;
4645 if (! m
->p_paddr_valid
)
4646 p
->p_paddr
= phdrs_paddr
;
4648 else if (p
->p_type
== PT_GNU_RELRO
)
4650 Elf_Internal_Phdr
*lp
;
4652 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4654 if (lp
->p_type
== PT_LOAD
4655 && lp
->p_vaddr
<= link_info
->relro_end
4656 && lp
->p_vaddr
>= link_info
->relro_start
4657 && (lp
->p_vaddr
+ lp
->p_filesz
4658 >= link_info
->relro_end
))
4662 if (lp
< phdrs
+ count
4663 && link_info
->relro_end
> lp
->p_vaddr
)
4665 p
->p_vaddr
= lp
->p_vaddr
;
4666 p
->p_paddr
= lp
->p_paddr
;
4667 p
->p_offset
= lp
->p_offset
;
4668 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4669 p
->p_memsz
= p
->p_filesz
;
4671 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4675 memset (p
, 0, sizeof *p
);
4676 p
->p_type
= PT_NULL
;
4682 elf_tdata (abfd
)->next_file_pos
= off
;
4687 /* Work out the file positions of all the sections. This is called by
4688 _bfd_elf_compute_section_file_positions. All the section sizes and
4689 VMAs must be known before this is called.
4691 Reloc sections come in two flavours: Those processed specially as
4692 "side-channel" data attached to a section to which they apply, and
4693 those that bfd doesn't process as relocations. The latter sort are
4694 stored in a normal bfd section by bfd_section_from_shdr. We don't
4695 consider the former sort here, unless they form part of the loadable
4696 image. Reloc sections not assigned here will be handled later by
4697 assign_file_positions_for_relocs.
4699 We also don't set the positions of the .symtab and .strtab here. */
4702 assign_file_positions_except_relocs (bfd
*abfd
,
4703 struct bfd_link_info
*link_info
)
4705 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4706 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4708 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4710 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4711 && bfd_get_format (abfd
) != bfd_core
)
4713 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4714 unsigned int num_sec
= elf_numsections (abfd
);
4715 Elf_Internal_Shdr
**hdrpp
;
4718 /* Start after the ELF header. */
4719 off
= i_ehdrp
->e_ehsize
;
4721 /* We are not creating an executable, which means that we are
4722 not creating a program header, and that the actual order of
4723 the sections in the file is unimportant. */
4724 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4726 Elf_Internal_Shdr
*hdr
;
4729 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4730 && hdr
->bfd_section
== NULL
)
4731 || i
== tdata
->symtab_section
4732 || i
== tdata
->symtab_shndx_section
4733 || i
== tdata
->strtab_section
)
4735 hdr
->sh_offset
= -1;
4738 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4740 if (i
== SHN_LORESERVE
- 1)
4742 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4743 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4751 /* Assign file positions for the loaded sections based on the
4752 assignment of sections to segments. */
4753 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4756 /* And for non-load sections. */
4757 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4760 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4762 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4766 /* Write out the program headers. */
4767 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4768 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4769 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4772 off
= tdata
->next_file_pos
;
4775 /* Place the section headers. */
4776 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4777 i_ehdrp
->e_shoff
= off
;
4778 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4780 tdata
->next_file_pos
= off
;
4786 prep_headers (bfd
*abfd
)
4788 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4789 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4790 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4791 struct elf_strtab_hash
*shstrtab
;
4792 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4794 i_ehdrp
= elf_elfheader (abfd
);
4795 i_shdrp
= elf_elfsections (abfd
);
4797 shstrtab
= _bfd_elf_strtab_init ();
4798 if (shstrtab
== NULL
)
4801 elf_shstrtab (abfd
) = shstrtab
;
4803 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4804 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4805 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4806 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4808 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4809 i_ehdrp
->e_ident
[EI_DATA
] =
4810 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4811 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4813 if ((abfd
->flags
& DYNAMIC
) != 0)
4814 i_ehdrp
->e_type
= ET_DYN
;
4815 else if ((abfd
->flags
& EXEC_P
) != 0)
4816 i_ehdrp
->e_type
= ET_EXEC
;
4817 else if (bfd_get_format (abfd
) == bfd_core
)
4818 i_ehdrp
->e_type
= ET_CORE
;
4820 i_ehdrp
->e_type
= ET_REL
;
4822 switch (bfd_get_arch (abfd
))
4824 case bfd_arch_unknown
:
4825 i_ehdrp
->e_machine
= EM_NONE
;
4828 /* There used to be a long list of cases here, each one setting
4829 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4830 in the corresponding bfd definition. To avoid duplication,
4831 the switch was removed. Machines that need special handling
4832 can generally do it in elf_backend_final_write_processing(),
4833 unless they need the information earlier than the final write.
4834 Such need can generally be supplied by replacing the tests for
4835 e_machine with the conditions used to determine it. */
4837 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4840 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4841 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4843 /* No program header, for now. */
4844 i_ehdrp
->e_phoff
= 0;
4845 i_ehdrp
->e_phentsize
= 0;
4846 i_ehdrp
->e_phnum
= 0;
4848 /* Each bfd section is section header entry. */
4849 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4850 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4852 /* If we're building an executable, we'll need a program header table. */
4853 if (abfd
->flags
& EXEC_P
)
4854 /* It all happens later. */
4858 i_ehdrp
->e_phentsize
= 0;
4860 i_ehdrp
->e_phoff
= 0;
4863 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4864 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4865 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4866 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4867 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4868 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4869 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4870 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4871 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4877 /* Assign file positions for all the reloc sections which are not part
4878 of the loadable file image. */
4881 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4884 unsigned int i
, num_sec
;
4885 Elf_Internal_Shdr
**shdrpp
;
4887 off
= elf_tdata (abfd
)->next_file_pos
;
4889 num_sec
= elf_numsections (abfd
);
4890 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4892 Elf_Internal_Shdr
*shdrp
;
4895 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4896 && shdrp
->sh_offset
== -1)
4897 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4900 elf_tdata (abfd
)->next_file_pos
= off
;
4904 _bfd_elf_write_object_contents (bfd
*abfd
)
4906 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4907 Elf_Internal_Ehdr
*i_ehdrp
;
4908 Elf_Internal_Shdr
**i_shdrp
;
4910 unsigned int count
, num_sec
;
4912 if (! abfd
->output_has_begun
4913 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4916 i_shdrp
= elf_elfsections (abfd
);
4917 i_ehdrp
= elf_elfheader (abfd
);
4920 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4924 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4926 /* After writing the headers, we need to write the sections too... */
4927 num_sec
= elf_numsections (abfd
);
4928 for (count
= 1; count
< num_sec
; count
++)
4930 if (bed
->elf_backend_section_processing
)
4931 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4932 if (i_shdrp
[count
]->contents
)
4934 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4936 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4937 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4940 if (count
== SHN_LORESERVE
- 1)
4941 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4944 /* Write out the section header names. */
4945 if (elf_shstrtab (abfd
) != NULL
4946 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4947 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
4950 if (bed
->elf_backend_final_write_processing
)
4951 (*bed
->elf_backend_final_write_processing
) (abfd
,
4952 elf_tdata (abfd
)->linker
);
4954 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
4957 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
4958 if (elf_tdata (abfd
)->after_write_object_contents
)
4959 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
4965 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4967 /* Hopefully this can be done just like an object file. */
4968 return _bfd_elf_write_object_contents (abfd
);
4971 /* Given a section, search the header to find them. */
4974 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4976 const struct elf_backend_data
*bed
;
4979 if (elf_section_data (asect
) != NULL
4980 && elf_section_data (asect
)->this_idx
!= 0)
4981 return elf_section_data (asect
)->this_idx
;
4983 if (bfd_is_abs_section (asect
))
4985 else if (bfd_is_com_section (asect
))
4987 else if (bfd_is_und_section (asect
))
4992 bed
= get_elf_backend_data (abfd
);
4993 if (bed
->elf_backend_section_from_bfd_section
)
4997 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5002 bfd_set_error (bfd_error_nonrepresentable_section
);
5007 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5011 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5013 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5015 flagword flags
= asym_ptr
->flags
;
5017 /* When gas creates relocations against local labels, it creates its
5018 own symbol for the section, but does put the symbol into the
5019 symbol chain, so udata is 0. When the linker is generating
5020 relocatable output, this section symbol may be for one of the
5021 input sections rather than the output section. */
5022 if (asym_ptr
->udata
.i
== 0
5023 && (flags
& BSF_SECTION_SYM
)
5024 && asym_ptr
->section
)
5029 sec
= asym_ptr
->section
;
5030 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5031 sec
= sec
->output_section
;
5032 if (sec
->owner
== abfd
5033 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5034 && elf_section_syms (abfd
)[indx
] != NULL
)
5035 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5038 idx
= asym_ptr
->udata
.i
;
5042 /* This case can occur when using --strip-symbol on a symbol
5043 which is used in a relocation entry. */
5044 (*_bfd_error_handler
)
5045 (_("%B: symbol `%s' required but not present"),
5046 abfd
, bfd_asymbol_name (asym_ptr
));
5047 bfd_set_error (bfd_error_no_symbols
);
5054 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5055 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5056 elf_symbol_flags (flags
));
5064 /* Rewrite program header information. */
5067 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5069 Elf_Internal_Ehdr
*iehdr
;
5070 struct elf_segment_map
*map
;
5071 struct elf_segment_map
*map_first
;
5072 struct elf_segment_map
**pointer_to_map
;
5073 Elf_Internal_Phdr
*segment
;
5076 unsigned int num_segments
;
5077 bfd_boolean phdr_included
= FALSE
;
5078 bfd_vma maxpagesize
;
5079 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5080 unsigned int phdr_adjust_num
= 0;
5081 const struct elf_backend_data
*bed
;
5083 bed
= get_elf_backend_data (ibfd
);
5084 iehdr
= elf_elfheader (ibfd
);
5087 pointer_to_map
= &map_first
;
5089 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5090 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5092 /* Returns the end address of the segment + 1. */
5093 #define SEGMENT_END(segment, start) \
5094 (start + (segment->p_memsz > segment->p_filesz \
5095 ? segment->p_memsz : segment->p_filesz))
5097 #define SECTION_SIZE(section, segment) \
5098 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5099 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5100 ? section->size : 0)
5102 /* Returns TRUE if the given section is contained within
5103 the given segment. VMA addresses are compared. */
5104 #define IS_CONTAINED_BY_VMA(section, segment) \
5105 (section->vma >= segment->p_vaddr \
5106 && (section->vma + SECTION_SIZE (section, segment) \
5107 <= (SEGMENT_END (segment, segment->p_vaddr))))
5109 /* Returns TRUE if the given section is contained within
5110 the given segment. LMA addresses are compared. */
5111 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5112 (section->lma >= base \
5113 && (section->lma + SECTION_SIZE (section, segment) \
5114 <= SEGMENT_END (segment, base)))
5116 /* Handle PT_NOTE segment. */
5117 #define IS_NOTE(p, s) \
5118 (p->p_type == PT_NOTE \
5119 && elf_section_type (s) == SHT_NOTE \
5120 && (bfd_vma) s->filepos >= p->p_offset \
5121 && ((bfd_vma) s->filepos + s->size \
5122 <= p->p_offset + p->p_filesz))
5124 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5126 #define IS_COREFILE_NOTE(p, s) \
5128 && bfd_get_format (ibfd) == bfd_core \
5132 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5133 linker, which generates a PT_INTERP section with p_vaddr and
5134 p_memsz set to 0. */
5135 #define IS_SOLARIS_PT_INTERP(p, s) \
5137 && p->p_paddr == 0 \
5138 && p->p_memsz == 0 \
5139 && p->p_filesz > 0 \
5140 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5142 && (bfd_vma) s->filepos >= p->p_offset \
5143 && ((bfd_vma) s->filepos + s->size \
5144 <= p->p_offset + p->p_filesz))
5146 /* Decide if the given section should be included in the given segment.
5147 A section will be included if:
5148 1. It is within the address space of the segment -- we use the LMA
5149 if that is set for the segment and the VMA otherwise,
5150 2. It is an allocated section or a NOTE section in a PT_NOTE
5152 3. There is an output section associated with it,
5153 4. The section has not already been allocated to a previous segment.
5154 5. PT_GNU_STACK segments do not include any sections.
5155 6. PT_TLS segment includes only SHF_TLS sections.
5156 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5157 8. PT_DYNAMIC should not contain empty sections at the beginning
5158 (with the possible exception of .dynamic). */
5159 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5160 ((((segment->p_paddr \
5161 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5162 : IS_CONTAINED_BY_VMA (section, segment)) \
5163 && (section->flags & SEC_ALLOC) != 0) \
5164 || IS_NOTE (segment, section)) \
5165 && segment->p_type != PT_GNU_STACK \
5166 && (segment->p_type != PT_TLS \
5167 || (section->flags & SEC_THREAD_LOCAL)) \
5168 && (segment->p_type == PT_LOAD \
5169 || segment->p_type == PT_TLS \
5170 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5171 && (segment->p_type != PT_DYNAMIC \
5172 || SECTION_SIZE (section, segment) > 0 \
5173 || (segment->p_paddr \
5174 ? segment->p_paddr != section->lma \
5175 : segment->p_vaddr != section->vma) \
5176 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5178 && !section->segment_mark)
5180 /* If the output section of a section in the input segment is NULL,
5181 it is removed from the corresponding output segment. */
5182 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5183 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5184 && section->output_section != NULL)
5186 /* Returns TRUE iff seg1 starts after the end of seg2. */
5187 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5188 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5190 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5191 their VMA address ranges and their LMA address ranges overlap.
5192 It is possible to have overlapping VMA ranges without overlapping LMA
5193 ranges. RedBoot images for example can have both .data and .bss mapped
5194 to the same VMA range, but with the .data section mapped to a different
5196 #define SEGMENT_OVERLAPS(seg1, seg2) \
5197 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5198 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5199 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5200 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5202 /* Initialise the segment mark field. */
5203 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5204 section
->segment_mark
= FALSE
;
5206 /* Scan through the segments specified in the program header
5207 of the input BFD. For this first scan we look for overlaps
5208 in the loadable segments. These can be created by weird
5209 parameters to objcopy. Also, fix some solaris weirdness. */
5210 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5215 Elf_Internal_Phdr
*segment2
;
5217 if (segment
->p_type
== PT_INTERP
)
5218 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5219 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5221 /* Mininal change so that the normal section to segment
5222 assignment code will work. */
5223 segment
->p_vaddr
= section
->vma
;
5227 if (segment
->p_type
!= PT_LOAD
)
5229 /* Remove PT_GNU_RELRO segment. */
5230 if (segment
->p_type
== PT_GNU_RELRO
)
5231 segment
->p_type
= PT_NULL
;
5235 /* Determine if this segment overlaps any previous segments. */
5236 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5238 bfd_signed_vma extra_length
;
5240 if (segment2
->p_type
!= PT_LOAD
5241 || !SEGMENT_OVERLAPS (segment
, segment2
))
5244 /* Merge the two segments together. */
5245 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5247 /* Extend SEGMENT2 to include SEGMENT and then delete
5249 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5250 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5252 if (extra_length
> 0)
5254 segment2
->p_memsz
+= extra_length
;
5255 segment2
->p_filesz
+= extra_length
;
5258 segment
->p_type
= PT_NULL
;
5260 /* Since we have deleted P we must restart the outer loop. */
5262 segment
= elf_tdata (ibfd
)->phdr
;
5267 /* Extend SEGMENT to include SEGMENT2 and then delete
5269 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5270 - SEGMENT_END (segment
, segment
->p_vaddr
));
5272 if (extra_length
> 0)
5274 segment
->p_memsz
+= extra_length
;
5275 segment
->p_filesz
+= extra_length
;
5278 segment2
->p_type
= PT_NULL
;
5283 /* The second scan attempts to assign sections to segments. */
5284 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5288 unsigned int section_count
;
5289 asection
**sections
;
5290 asection
*output_section
;
5292 bfd_vma matching_lma
;
5293 bfd_vma suggested_lma
;
5296 asection
*first_section
;
5297 bfd_boolean first_matching_lma
;
5298 bfd_boolean first_suggested_lma
;
5300 if (segment
->p_type
== PT_NULL
)
5303 first_section
= NULL
;
5304 /* Compute how many sections might be placed into this segment. */
5305 for (section
= ibfd
->sections
, section_count
= 0;
5307 section
= section
->next
)
5309 /* Find the first section in the input segment, which may be
5310 removed from the corresponding output segment. */
5311 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5313 if (first_section
== NULL
)
5314 first_section
= section
;
5315 if (section
->output_section
!= NULL
)
5320 /* Allocate a segment map big enough to contain
5321 all of the sections we have selected. */
5322 amt
= sizeof (struct elf_segment_map
);
5323 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5324 map
= bfd_zalloc (obfd
, amt
);
5328 /* Initialise the fields of the segment map. Default to
5329 using the physical address of the segment in the input BFD. */
5331 map
->p_type
= segment
->p_type
;
5332 map
->p_flags
= segment
->p_flags
;
5333 map
->p_flags_valid
= 1;
5335 /* If the first section in the input segment is removed, there is
5336 no need to preserve segment physical address in the corresponding
5338 if (!first_section
|| first_section
->output_section
!= NULL
)
5340 map
->p_paddr
= segment
->p_paddr
;
5341 map
->p_paddr_valid
= 1;
5344 /* Determine if this segment contains the ELF file header
5345 and if it contains the program headers themselves. */
5346 map
->includes_filehdr
= (segment
->p_offset
== 0
5347 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5348 map
->includes_phdrs
= 0;
5350 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5352 map
->includes_phdrs
=
5353 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5354 && (segment
->p_offset
+ segment
->p_filesz
5355 >= ((bfd_vma
) iehdr
->e_phoff
5356 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5358 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5359 phdr_included
= TRUE
;
5362 if (section_count
== 0)
5364 /* Special segments, such as the PT_PHDR segment, may contain
5365 no sections, but ordinary, loadable segments should contain
5366 something. They are allowed by the ELF spec however, so only
5367 a warning is produced. */
5368 if (segment
->p_type
== PT_LOAD
)
5369 (*_bfd_error_handler
) (_("%B: warning: Empty loadable segment"
5370 " detected, is this intentional ?\n"),
5374 *pointer_to_map
= map
;
5375 pointer_to_map
= &map
->next
;
5380 /* Now scan the sections in the input BFD again and attempt
5381 to add their corresponding output sections to the segment map.
5382 The problem here is how to handle an output section which has
5383 been moved (ie had its LMA changed). There are four possibilities:
5385 1. None of the sections have been moved.
5386 In this case we can continue to use the segment LMA from the
5389 2. All of the sections have been moved by the same amount.
5390 In this case we can change the segment's LMA to match the LMA
5391 of the first section.
5393 3. Some of the sections have been moved, others have not.
5394 In this case those sections which have not been moved can be
5395 placed in the current segment which will have to have its size,
5396 and possibly its LMA changed, and a new segment or segments will
5397 have to be created to contain the other sections.
5399 4. The sections have been moved, but not by the same amount.
5400 In this case we can change the segment's LMA to match the LMA
5401 of the first section and we will have to create a new segment
5402 or segments to contain the other sections.
5404 In order to save time, we allocate an array to hold the section
5405 pointers that we are interested in. As these sections get assigned
5406 to a segment, they are removed from this array. */
5408 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5409 to work around this long long bug. */
5410 sections
= bfd_malloc2 (section_count
, sizeof (asection
*));
5411 if (sections
== NULL
)
5414 /* Step One: Scan for segment vs section LMA conflicts.
5415 Also add the sections to the section array allocated above.
5416 Also add the sections to the current segment. In the common
5417 case, where the sections have not been moved, this means that
5418 we have completely filled the segment, and there is nothing
5423 first_matching_lma
= TRUE
;
5424 first_suggested_lma
= TRUE
;
5426 for (section
= ibfd
->sections
;
5428 section
= section
->next
)
5429 if (section
== first_section
)
5432 for (j
= 0; section
!= NULL
; section
= section
->next
)
5434 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5436 output_section
= section
->output_section
;
5438 sections
[j
++] = section
;
5440 /* The Solaris native linker always sets p_paddr to 0.
5441 We try to catch that case here, and set it to the
5442 correct value. Note - some backends require that
5443 p_paddr be left as zero. */
5444 if (segment
->p_paddr
== 0
5445 && segment
->p_vaddr
!= 0
5446 && !bed
->want_p_paddr_set_to_zero
5448 && output_section
->lma
!= 0
5449 && output_section
->vma
== (segment
->p_vaddr
5450 + (map
->includes_filehdr
5453 + (map
->includes_phdrs
5455 * iehdr
->e_phentsize
)
5457 map
->p_paddr
= segment
->p_vaddr
;
5459 /* Match up the physical address of the segment with the
5460 LMA address of the output section. */
5461 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5462 || IS_COREFILE_NOTE (segment
, section
)
5463 || (bed
->want_p_paddr_set_to_zero
5464 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
5466 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
5468 matching_lma
= output_section
->lma
;
5469 first_matching_lma
= FALSE
;
5472 /* We assume that if the section fits within the segment
5473 then it does not overlap any other section within that
5475 map
->sections
[isec
++] = output_section
;
5477 else if (first_suggested_lma
)
5479 suggested_lma
= output_section
->lma
;
5480 first_suggested_lma
= FALSE
;
5483 if (j
== section_count
)
5488 BFD_ASSERT (j
== section_count
);
5490 /* Step Two: Adjust the physical address of the current segment,
5492 if (isec
== section_count
)
5494 /* All of the sections fitted within the segment as currently
5495 specified. This is the default case. Add the segment to
5496 the list of built segments and carry on to process the next
5497 program header in the input BFD. */
5498 map
->count
= section_count
;
5499 *pointer_to_map
= map
;
5500 pointer_to_map
= &map
->next
;
5502 if (!bed
->want_p_paddr_set_to_zero
5503 && matching_lma
!= map
->p_paddr
5504 && !map
->includes_filehdr
&& !map
->includes_phdrs
)
5505 /* There is some padding before the first section in the
5506 segment. So, we must account for that in the output
5508 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5515 if (!first_matching_lma
)
5517 /* At least one section fits inside the current segment.
5518 Keep it, but modify its physical address to match the
5519 LMA of the first section that fitted. */
5520 map
->p_paddr
= matching_lma
;
5524 /* None of the sections fitted inside the current segment.
5525 Change the current segment's physical address to match
5526 the LMA of the first section. */
5527 map
->p_paddr
= suggested_lma
;
5530 /* Offset the segment physical address from the lma
5531 to allow for space taken up by elf headers. */
5532 if (map
->includes_filehdr
)
5533 map
->p_paddr
-= iehdr
->e_ehsize
;
5535 if (map
->includes_phdrs
)
5537 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5539 /* iehdr->e_phnum is just an estimate of the number
5540 of program headers that we will need. Make a note
5541 here of the number we used and the segment we chose
5542 to hold these headers, so that we can adjust the
5543 offset when we know the correct value. */
5544 phdr_adjust_num
= iehdr
->e_phnum
;
5545 phdr_adjust_seg
= map
;
5549 /* Step Three: Loop over the sections again, this time assigning
5550 those that fit to the current segment and removing them from the
5551 sections array; but making sure not to leave large gaps. Once all
5552 possible sections have been assigned to the current segment it is
5553 added to the list of built segments and if sections still remain
5554 to be assigned, a new segment is constructed before repeating
5561 first_suggested_lma
= TRUE
;
5563 /* Fill the current segment with sections that fit. */
5564 for (j
= 0; j
< section_count
; j
++)
5566 section
= sections
[j
];
5568 if (section
== NULL
)
5571 output_section
= section
->output_section
;
5573 BFD_ASSERT (output_section
!= NULL
);
5575 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5576 || IS_COREFILE_NOTE (segment
, section
))
5578 if (map
->count
== 0)
5580 /* If the first section in a segment does not start at
5581 the beginning of the segment, then something is
5583 if (output_section
->lma
5585 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5586 + (map
->includes_phdrs
5587 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5595 prev_sec
= map
->sections
[map
->count
- 1];
5597 /* If the gap between the end of the previous section
5598 and the start of this section is more than
5599 maxpagesize then we need to start a new segment. */
5600 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5602 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5603 || (prev_sec
->lma
+ prev_sec
->size
5604 > output_section
->lma
))
5606 if (first_suggested_lma
)
5608 suggested_lma
= output_section
->lma
;
5609 first_suggested_lma
= FALSE
;
5616 map
->sections
[map
->count
++] = output_section
;
5619 section
->segment_mark
= TRUE
;
5621 else if (first_suggested_lma
)
5623 suggested_lma
= output_section
->lma
;
5624 first_suggested_lma
= FALSE
;
5628 BFD_ASSERT (map
->count
> 0);
5630 /* Add the current segment to the list of built segments. */
5631 *pointer_to_map
= map
;
5632 pointer_to_map
= &map
->next
;
5634 if (isec
< section_count
)
5636 /* We still have not allocated all of the sections to
5637 segments. Create a new segment here, initialise it
5638 and carry on looping. */
5639 amt
= sizeof (struct elf_segment_map
);
5640 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5641 map
= bfd_alloc (obfd
, amt
);
5648 /* Initialise the fields of the segment map. Set the physical
5649 physical address to the LMA of the first section that has
5650 not yet been assigned. */
5652 map
->p_type
= segment
->p_type
;
5653 map
->p_flags
= segment
->p_flags
;
5654 map
->p_flags_valid
= 1;
5655 map
->p_paddr
= suggested_lma
;
5656 map
->p_paddr_valid
= 1;
5657 map
->includes_filehdr
= 0;
5658 map
->includes_phdrs
= 0;
5661 while (isec
< section_count
);
5666 /* The Solaris linker creates program headers in which all the
5667 p_paddr fields are zero. When we try to objcopy or strip such a
5668 file, we get confused. Check for this case, and if we find it
5669 reset the p_paddr_valid fields. */
5670 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5671 if (map
->p_paddr
!= 0)
5674 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5675 map
->p_paddr_valid
= 0;
5677 elf_tdata (obfd
)->segment_map
= map_first
;
5679 /* If we had to estimate the number of program headers that were
5680 going to be needed, then check our estimate now and adjust
5681 the offset if necessary. */
5682 if (phdr_adjust_seg
!= NULL
)
5686 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5689 if (count
> phdr_adjust_num
)
5690 phdr_adjust_seg
->p_paddr
5691 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5696 #undef IS_CONTAINED_BY_VMA
5697 #undef IS_CONTAINED_BY_LMA
5699 #undef IS_COREFILE_NOTE
5700 #undef IS_SOLARIS_PT_INTERP
5701 #undef IS_SECTION_IN_INPUT_SEGMENT
5702 #undef INCLUDE_SECTION_IN_SEGMENT
5703 #undef SEGMENT_AFTER_SEGMENT
5704 #undef SEGMENT_OVERLAPS
5708 /* Copy ELF program header information. */
5711 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5713 Elf_Internal_Ehdr
*iehdr
;
5714 struct elf_segment_map
*map
;
5715 struct elf_segment_map
*map_first
;
5716 struct elf_segment_map
**pointer_to_map
;
5717 Elf_Internal_Phdr
*segment
;
5719 unsigned int num_segments
;
5720 bfd_boolean phdr_included
= FALSE
;
5722 iehdr
= elf_elfheader (ibfd
);
5725 pointer_to_map
= &map_first
;
5727 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5728 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5733 unsigned int section_count
;
5735 Elf_Internal_Shdr
*this_hdr
;
5736 asection
*first_section
= NULL
;
5737 asection
*lowest_section
= NULL
;
5739 /* Compute how many sections are in this segment. */
5740 for (section
= ibfd
->sections
, section_count
= 0;
5742 section
= section
->next
)
5744 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5745 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5748 first_section
= lowest_section
= section
;
5749 if (section
->lma
< lowest_section
->lma
)
5750 lowest_section
= section
;
5755 /* Allocate a segment map big enough to contain
5756 all of the sections we have selected. */
5757 amt
= sizeof (struct elf_segment_map
);
5758 if (section_count
!= 0)
5759 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5760 map
= bfd_zalloc (obfd
, amt
);
5764 /* Initialize the fields of the output segment map with the
5767 map
->p_type
= segment
->p_type
;
5768 map
->p_flags
= segment
->p_flags
;
5769 map
->p_flags_valid
= 1;
5770 map
->p_paddr
= segment
->p_paddr
;
5771 map
->p_paddr_valid
= 1;
5772 map
->p_align
= segment
->p_align
;
5773 map
->p_align_valid
= 1;
5774 map
->p_vaddr_offset
= 0;
5776 if (map
->p_type
== PT_GNU_RELRO
5777 && segment
->p_filesz
== segment
->p_memsz
)
5779 /* The PT_GNU_RELRO segment may contain the first a few
5780 bytes in the .got.plt section even if the whole .got.plt
5781 section isn't in the PT_GNU_RELRO segment. We won't
5782 change the size of the PT_GNU_RELRO segment. */
5783 map
->p_size
= segment
->p_filesz
;
5784 map
->p_size_valid
= 1;
5787 /* Determine if this segment contains the ELF file header
5788 and if it contains the program headers themselves. */
5789 map
->includes_filehdr
= (segment
->p_offset
== 0
5790 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5792 map
->includes_phdrs
= 0;
5793 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5795 map
->includes_phdrs
=
5796 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5797 && (segment
->p_offset
+ segment
->p_filesz
5798 >= ((bfd_vma
) iehdr
->e_phoff
5799 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5801 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5802 phdr_included
= TRUE
;
5805 if (!map
->includes_phdrs
&& !map
->includes_filehdr
)
5806 /* There is some other padding before the first section. */
5807 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
5808 - segment
->p_paddr
);
5810 if (section_count
!= 0)
5812 unsigned int isec
= 0;
5814 for (section
= first_section
;
5816 section
= section
->next
)
5818 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5819 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5821 map
->sections
[isec
++] = section
->output_section
;
5822 if (isec
== section_count
)
5828 map
->count
= section_count
;
5829 *pointer_to_map
= map
;
5830 pointer_to_map
= &map
->next
;
5833 elf_tdata (obfd
)->segment_map
= map_first
;
5837 /* Copy private BFD data. This copies or rewrites ELF program header
5841 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5843 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5844 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5847 if (elf_tdata (ibfd
)->phdr
== NULL
)
5850 if (ibfd
->xvec
== obfd
->xvec
)
5852 /* Check to see if any sections in the input BFD
5853 covered by ELF program header have changed. */
5854 Elf_Internal_Phdr
*segment
;
5855 asection
*section
, *osec
;
5856 unsigned int i
, num_segments
;
5857 Elf_Internal_Shdr
*this_hdr
;
5858 const struct elf_backend_data
*bed
;
5860 bed
= get_elf_backend_data (ibfd
);
5862 /* Regenerate the segment map if p_paddr is set to 0. */
5863 if (bed
->want_p_paddr_set_to_zero
)
5866 /* Initialize the segment mark field. */
5867 for (section
= obfd
->sections
; section
!= NULL
;
5868 section
= section
->next
)
5869 section
->segment_mark
= FALSE
;
5871 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5872 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5876 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5877 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5878 which severly confuses things, so always regenerate the segment
5879 map in this case. */
5880 if (segment
->p_paddr
== 0
5881 && segment
->p_memsz
== 0
5882 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
5885 for (section
= ibfd
->sections
;
5886 section
!= NULL
; section
= section
->next
)
5888 /* We mark the output section so that we know it comes
5889 from the input BFD. */
5890 osec
= section
->output_section
;
5892 osec
->segment_mark
= TRUE
;
5894 /* Check if this section is covered by the segment. */
5895 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5896 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5898 /* FIXME: Check if its output section is changed or
5899 removed. What else do we need to check? */
5901 || section
->flags
!= osec
->flags
5902 || section
->lma
!= osec
->lma
5903 || section
->vma
!= osec
->vma
5904 || section
->size
!= osec
->size
5905 || section
->rawsize
!= osec
->rawsize
5906 || section
->alignment_power
!= osec
->alignment_power
)
5912 /* Check to see if any output section do not come from the
5914 for (section
= obfd
->sections
; section
!= NULL
;
5915 section
= section
->next
)
5917 if (section
->segment_mark
== FALSE
)
5920 section
->segment_mark
= FALSE
;
5923 return copy_elf_program_header (ibfd
, obfd
);
5927 return rewrite_elf_program_header (ibfd
, obfd
);
5930 /* Initialize private output section information from input section. */
5933 _bfd_elf_init_private_section_data (bfd
*ibfd
,
5937 struct bfd_link_info
*link_info
)
5940 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5941 bfd_boolean need_group
= link_info
== NULL
|| link_info
->relocatable
;
5943 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5944 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5947 /* Don't copy the output ELF section type from input if the
5948 output BFD section flags have been set to something different.
5949 elf_fake_sections will set ELF section type based on BFD
5951 if (elf_section_type (osec
) == SHT_NULL
5952 && (osec
->flags
== isec
->flags
|| !osec
->flags
))
5953 elf_section_type (osec
) = elf_section_type (isec
);
5955 /* FIXME: Is this correct for all OS/PROC specific flags? */
5956 elf_section_flags (osec
) |= (elf_section_flags (isec
)
5957 & (SHF_MASKOS
| SHF_MASKPROC
));
5959 /* Set things up for objcopy and relocatable link. The output
5960 SHT_GROUP section will have its elf_next_in_group pointing back
5961 to the input group members. Ignore linker created group section.
5962 See elfNN_ia64_object_p in elfxx-ia64.c. */
5965 if (elf_sec_group (isec
) == NULL
5966 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
5968 if (elf_section_flags (isec
) & SHF_GROUP
)
5969 elf_section_flags (osec
) |= SHF_GROUP
;
5970 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5971 elf_group_name (osec
) = elf_group_name (isec
);
5975 ihdr
= &elf_section_data (isec
)->this_hdr
;
5977 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5978 don't use the output section of the linked-to section since it
5979 may be NULL at this point. */
5980 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
5982 ohdr
= &elf_section_data (osec
)->this_hdr
;
5983 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
5984 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
5987 osec
->use_rela_p
= isec
->use_rela_p
;
5992 /* Copy private section information. This copies over the entsize
5993 field, and sometimes the info field. */
5996 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6001 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6003 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6004 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6007 ihdr
= &elf_section_data (isec
)->this_hdr
;
6008 ohdr
= &elf_section_data (osec
)->this_hdr
;
6010 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6012 if (ihdr
->sh_type
== SHT_SYMTAB
6013 || ihdr
->sh_type
== SHT_DYNSYM
6014 || ihdr
->sh_type
== SHT_GNU_verneed
6015 || ihdr
->sh_type
== SHT_GNU_verdef
)
6016 ohdr
->sh_info
= ihdr
->sh_info
;
6018 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6022 /* Copy private header information. */
6025 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6029 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6030 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6033 /* Copy over private BFD data if it has not already been copied.
6034 This must be done here, rather than in the copy_private_bfd_data
6035 entry point, because the latter is called after the section
6036 contents have been set, which means that the program headers have
6037 already been worked out. */
6038 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6040 if (! copy_private_bfd_data (ibfd
, obfd
))
6044 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6045 but this might be wrong if we deleted the group section. */
6046 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6047 if (elf_section_type (isec
) == SHT_GROUP
6048 && isec
->output_section
== NULL
)
6050 asection
*first
= elf_next_in_group (isec
);
6051 asection
*s
= first
;
6054 if (s
->output_section
!= NULL
)
6056 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6057 elf_group_name (s
->output_section
) = NULL
;
6059 s
= elf_next_in_group (s
);
6068 /* Copy private symbol information. If this symbol is in a section
6069 which we did not map into a BFD section, try to map the section
6070 index correctly. We use special macro definitions for the mapped
6071 section indices; these definitions are interpreted by the
6072 swap_out_syms function. */
6074 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6075 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6076 #define MAP_STRTAB (SHN_HIOS + 3)
6077 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6078 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6081 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6086 elf_symbol_type
*isym
, *osym
;
6088 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6089 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6092 isym
= elf_symbol_from (ibfd
, isymarg
);
6093 osym
= elf_symbol_from (obfd
, osymarg
);
6096 && isym
->internal_elf_sym
.st_shndx
!= 0
6098 && bfd_is_abs_section (isym
->symbol
.section
))
6102 shndx
= isym
->internal_elf_sym
.st_shndx
;
6103 if (shndx
== elf_onesymtab (ibfd
))
6104 shndx
= MAP_ONESYMTAB
;
6105 else if (shndx
== elf_dynsymtab (ibfd
))
6106 shndx
= MAP_DYNSYMTAB
;
6107 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6109 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6110 shndx
= MAP_SHSTRTAB
;
6111 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6112 shndx
= MAP_SYM_SHNDX
;
6113 osym
->internal_elf_sym
.st_shndx
= shndx
;
6119 /* Swap out the symbols. */
6122 swap_out_syms (bfd
*abfd
,
6123 struct bfd_strtab_hash
**sttp
,
6126 const struct elf_backend_data
*bed
;
6129 struct bfd_strtab_hash
*stt
;
6130 Elf_Internal_Shdr
*symtab_hdr
;
6131 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6132 Elf_Internal_Shdr
*symstrtab_hdr
;
6133 bfd_byte
*outbound_syms
;
6134 bfd_byte
*outbound_shndx
;
6137 bfd_boolean name_local_sections
;
6139 if (!elf_map_symbols (abfd
))
6142 /* Dump out the symtabs. */
6143 stt
= _bfd_elf_stringtab_init ();
6147 bed
= get_elf_backend_data (abfd
);
6148 symcount
= bfd_get_symcount (abfd
);
6149 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6150 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6151 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6152 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6153 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6154 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
6156 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6157 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6159 outbound_syms
= bfd_alloc2 (abfd
, 1 + symcount
, bed
->s
->sizeof_sym
);
6160 if (outbound_syms
== NULL
)
6162 _bfd_stringtab_free (stt
);
6165 symtab_hdr
->contents
= outbound_syms
;
6167 outbound_shndx
= NULL
;
6168 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6169 if (symtab_shndx_hdr
->sh_name
!= 0)
6171 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6172 outbound_shndx
= bfd_zalloc2 (abfd
, 1 + symcount
,
6173 sizeof (Elf_External_Sym_Shndx
));
6174 if (outbound_shndx
== NULL
)
6176 _bfd_stringtab_free (stt
);
6180 symtab_shndx_hdr
->contents
= outbound_shndx
;
6181 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6182 symtab_shndx_hdr
->sh_size
= amt
;
6183 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6184 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6187 /* Now generate the data (for "contents"). */
6189 /* Fill in zeroth symbol and swap it out. */
6190 Elf_Internal_Sym sym
;
6196 sym
.st_shndx
= SHN_UNDEF
;
6197 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6198 outbound_syms
+= bed
->s
->sizeof_sym
;
6199 if (outbound_shndx
!= NULL
)
6200 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6204 = (bed
->elf_backend_name_local_section_symbols
6205 && bed
->elf_backend_name_local_section_symbols (abfd
));
6207 syms
= bfd_get_outsymbols (abfd
);
6208 for (idx
= 0; idx
< symcount
; idx
++)
6210 Elf_Internal_Sym sym
;
6211 bfd_vma value
= syms
[idx
]->value
;
6212 elf_symbol_type
*type_ptr
;
6213 flagword flags
= syms
[idx
]->flags
;
6216 if (!name_local_sections
6217 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6219 /* Local section symbols have no name. */
6224 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6227 if (sym
.st_name
== (unsigned long) -1)
6229 _bfd_stringtab_free (stt
);
6234 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6236 if ((flags
& BSF_SECTION_SYM
) == 0
6237 && bfd_is_com_section (syms
[idx
]->section
))
6239 /* ELF common symbols put the alignment into the `value' field,
6240 and the size into the `size' field. This is backwards from
6241 how BFD handles it, so reverse it here. */
6242 sym
.st_size
= value
;
6243 if (type_ptr
== NULL
6244 || type_ptr
->internal_elf_sym
.st_value
== 0)
6245 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6247 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6248 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6249 (abfd
, syms
[idx
]->section
);
6253 asection
*sec
= syms
[idx
]->section
;
6256 if (sec
->output_section
)
6258 value
+= sec
->output_offset
;
6259 sec
= sec
->output_section
;
6262 /* Don't add in the section vma for relocatable output. */
6263 if (! relocatable_p
)
6265 sym
.st_value
= value
;
6266 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6268 if (bfd_is_abs_section (sec
)
6270 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6272 /* This symbol is in a real ELF section which we did
6273 not create as a BFD section. Undo the mapping done
6274 by copy_private_symbol_data. */
6275 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6279 shndx
= elf_onesymtab (abfd
);
6282 shndx
= elf_dynsymtab (abfd
);
6285 shndx
= elf_tdata (abfd
)->strtab_section
;
6288 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6291 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6299 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6305 /* Writing this would be a hell of a lot easier if
6306 we had some decent documentation on bfd, and
6307 knew what to expect of the library, and what to
6308 demand of applications. For example, it
6309 appears that `objcopy' might not set the
6310 section of a symbol to be a section that is
6311 actually in the output file. */
6312 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6315 _bfd_error_handler (_("\
6316 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6317 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6319 bfd_set_error (bfd_error_invalid_operation
);
6320 _bfd_stringtab_free (stt
);
6324 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6325 BFD_ASSERT (shndx
!= -1);
6329 sym
.st_shndx
= shndx
;
6332 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6334 else if ((flags
& BSF_FUNCTION
) != 0)
6336 else if ((flags
& BSF_OBJECT
) != 0)
6338 else if ((flags
& BSF_RELC
) != 0)
6340 else if ((flags
& BSF_SRELC
) != 0)
6345 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6348 /* Processor-specific types. */
6349 if (type_ptr
!= NULL
6350 && bed
->elf_backend_get_symbol_type
)
6351 type
= ((*bed
->elf_backend_get_symbol_type
)
6352 (&type_ptr
->internal_elf_sym
, type
));
6354 if (flags
& BSF_SECTION_SYM
)
6356 if (flags
& BSF_GLOBAL
)
6357 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6359 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6361 else if (bfd_is_com_section (syms
[idx
]->section
))
6362 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
,
6363 #ifdef USE_STT_COMMON
6364 type
== STT_OBJECT
? STT_COMMON
:
6367 else if (bfd_is_und_section (syms
[idx
]->section
))
6368 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6372 else if (flags
& BSF_FILE
)
6373 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6376 int bind
= STB_LOCAL
;
6378 if (flags
& BSF_LOCAL
)
6380 else if (flags
& BSF_WEAK
)
6382 else if (flags
& BSF_GLOBAL
)
6385 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6388 if (type_ptr
!= NULL
)
6389 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6393 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6394 outbound_syms
+= bed
->s
->sizeof_sym
;
6395 if (outbound_shndx
!= NULL
)
6396 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6400 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6401 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6403 symstrtab_hdr
->sh_flags
= 0;
6404 symstrtab_hdr
->sh_addr
= 0;
6405 symstrtab_hdr
->sh_entsize
= 0;
6406 symstrtab_hdr
->sh_link
= 0;
6407 symstrtab_hdr
->sh_info
= 0;
6408 symstrtab_hdr
->sh_addralign
= 1;
6413 /* Return the number of bytes required to hold the symtab vector.
6415 Note that we base it on the count plus 1, since we will null terminate
6416 the vector allocated based on this size. However, the ELF symbol table
6417 always has a dummy entry as symbol #0, so it ends up even. */
6420 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6424 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6426 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6427 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6429 symtab_size
-= sizeof (asymbol
*);
6435 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6439 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6441 if (elf_dynsymtab (abfd
) == 0)
6443 bfd_set_error (bfd_error_invalid_operation
);
6447 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6448 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6450 symtab_size
-= sizeof (asymbol
*);
6456 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6459 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6462 /* Canonicalize the relocs. */
6465 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6472 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6474 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6477 tblptr
= section
->relocation
;
6478 for (i
= 0; i
< section
->reloc_count
; i
++)
6479 *relptr
++ = tblptr
++;
6483 return section
->reloc_count
;
6487 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6489 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6490 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6493 bfd_get_symcount (abfd
) = symcount
;
6498 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6499 asymbol
**allocation
)
6501 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6502 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6505 bfd_get_dynamic_symcount (abfd
) = symcount
;
6509 /* Return the size required for the dynamic reloc entries. Any loadable
6510 section that was actually installed in the BFD, and has type SHT_REL
6511 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6512 dynamic reloc section. */
6515 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6520 if (elf_dynsymtab (abfd
) == 0)
6522 bfd_set_error (bfd_error_invalid_operation
);
6526 ret
= sizeof (arelent
*);
6527 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6528 if ((s
->flags
& SEC_LOAD
) != 0
6529 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6530 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6531 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6532 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6533 * sizeof (arelent
*));
6538 /* Canonicalize the dynamic relocation entries. Note that we return the
6539 dynamic relocations as a single block, although they are actually
6540 associated with particular sections; the interface, which was
6541 designed for SunOS style shared libraries, expects that there is only
6542 one set of dynamic relocs. Any loadable section that was actually
6543 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6544 dynamic symbol table, is considered to be a dynamic reloc section. */
6547 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6551 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6555 if (elf_dynsymtab (abfd
) == 0)
6557 bfd_set_error (bfd_error_invalid_operation
);
6561 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6563 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6565 if ((s
->flags
& SEC_LOAD
) != 0
6566 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6567 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6568 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6573 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6575 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6577 for (i
= 0; i
< count
; i
++)
6588 /* Read in the version information. */
6591 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6593 bfd_byte
*contents
= NULL
;
6594 unsigned int freeidx
= 0;
6596 if (elf_dynverref (abfd
) != 0)
6598 Elf_Internal_Shdr
*hdr
;
6599 Elf_External_Verneed
*everneed
;
6600 Elf_Internal_Verneed
*iverneed
;
6602 bfd_byte
*contents_end
;
6604 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6606 elf_tdata (abfd
)->verref
= bfd_zalloc2 (abfd
, hdr
->sh_info
,
6607 sizeof (Elf_Internal_Verneed
));
6608 if (elf_tdata (abfd
)->verref
== NULL
)
6611 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6613 contents
= bfd_malloc (hdr
->sh_size
);
6614 if (contents
== NULL
)
6616 error_return_verref
:
6617 elf_tdata (abfd
)->verref
= NULL
;
6618 elf_tdata (abfd
)->cverrefs
= 0;
6621 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6622 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6623 goto error_return_verref
;
6625 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6626 goto error_return_verref
;
6628 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6629 == sizeof (Elf_External_Vernaux
));
6630 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6631 everneed
= (Elf_External_Verneed
*) contents
;
6632 iverneed
= elf_tdata (abfd
)->verref
;
6633 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6635 Elf_External_Vernaux
*evernaux
;
6636 Elf_Internal_Vernaux
*ivernaux
;
6639 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6641 iverneed
->vn_bfd
= abfd
;
6643 iverneed
->vn_filename
=
6644 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6646 if (iverneed
->vn_filename
== NULL
)
6647 goto error_return_verref
;
6649 if (iverneed
->vn_cnt
== 0)
6650 iverneed
->vn_auxptr
= NULL
;
6653 iverneed
->vn_auxptr
= bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6654 sizeof (Elf_Internal_Vernaux
));
6655 if (iverneed
->vn_auxptr
== NULL
)
6656 goto error_return_verref
;
6659 if (iverneed
->vn_aux
6660 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6661 goto error_return_verref
;
6663 evernaux
= ((Elf_External_Vernaux
*)
6664 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6665 ivernaux
= iverneed
->vn_auxptr
;
6666 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6668 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6670 ivernaux
->vna_nodename
=
6671 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6672 ivernaux
->vna_name
);
6673 if (ivernaux
->vna_nodename
== NULL
)
6674 goto error_return_verref
;
6676 if (j
+ 1 < iverneed
->vn_cnt
)
6677 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6679 ivernaux
->vna_nextptr
= NULL
;
6681 if (ivernaux
->vna_next
6682 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6683 goto error_return_verref
;
6685 evernaux
= ((Elf_External_Vernaux
*)
6686 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6688 if (ivernaux
->vna_other
> freeidx
)
6689 freeidx
= ivernaux
->vna_other
;
6692 if (i
+ 1 < hdr
->sh_info
)
6693 iverneed
->vn_nextref
= iverneed
+ 1;
6695 iverneed
->vn_nextref
= NULL
;
6697 if (iverneed
->vn_next
6698 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6699 goto error_return_verref
;
6701 everneed
= ((Elf_External_Verneed
*)
6702 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6709 if (elf_dynverdef (abfd
) != 0)
6711 Elf_Internal_Shdr
*hdr
;
6712 Elf_External_Verdef
*everdef
;
6713 Elf_Internal_Verdef
*iverdef
;
6714 Elf_Internal_Verdef
*iverdefarr
;
6715 Elf_Internal_Verdef iverdefmem
;
6717 unsigned int maxidx
;
6718 bfd_byte
*contents_end_def
, *contents_end_aux
;
6720 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6722 contents
= bfd_malloc (hdr
->sh_size
);
6723 if (contents
== NULL
)
6725 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6726 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6729 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6732 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6733 >= sizeof (Elf_External_Verdaux
));
6734 contents_end_def
= contents
+ hdr
->sh_size
6735 - sizeof (Elf_External_Verdef
);
6736 contents_end_aux
= contents
+ hdr
->sh_size
6737 - sizeof (Elf_External_Verdaux
);
6739 /* We know the number of entries in the section but not the maximum
6740 index. Therefore we have to run through all entries and find
6742 everdef
= (Elf_External_Verdef
*) contents
;
6744 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6746 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6748 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6749 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6751 if (iverdefmem
.vd_next
6752 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6755 everdef
= ((Elf_External_Verdef
*)
6756 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6759 if (default_imported_symver
)
6761 if (freeidx
> maxidx
)
6766 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, maxidx
,
6767 sizeof (Elf_Internal_Verdef
));
6768 if (elf_tdata (abfd
)->verdef
== NULL
)
6771 elf_tdata (abfd
)->cverdefs
= maxidx
;
6773 everdef
= (Elf_External_Verdef
*) contents
;
6774 iverdefarr
= elf_tdata (abfd
)->verdef
;
6775 for (i
= 0; i
< hdr
->sh_info
; i
++)
6777 Elf_External_Verdaux
*everdaux
;
6778 Elf_Internal_Verdaux
*iverdaux
;
6781 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6783 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6785 error_return_verdef
:
6786 elf_tdata (abfd
)->verdef
= NULL
;
6787 elf_tdata (abfd
)->cverdefs
= 0;
6791 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6792 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6794 iverdef
->vd_bfd
= abfd
;
6796 if (iverdef
->vd_cnt
== 0)
6797 iverdef
->vd_auxptr
= NULL
;
6800 iverdef
->vd_auxptr
= bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6801 sizeof (Elf_Internal_Verdaux
));
6802 if (iverdef
->vd_auxptr
== NULL
)
6803 goto error_return_verdef
;
6807 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6808 goto error_return_verdef
;
6810 everdaux
= ((Elf_External_Verdaux
*)
6811 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6812 iverdaux
= iverdef
->vd_auxptr
;
6813 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6815 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6817 iverdaux
->vda_nodename
=
6818 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6819 iverdaux
->vda_name
);
6820 if (iverdaux
->vda_nodename
== NULL
)
6821 goto error_return_verdef
;
6823 if (j
+ 1 < iverdef
->vd_cnt
)
6824 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6826 iverdaux
->vda_nextptr
= NULL
;
6828 if (iverdaux
->vda_next
6829 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
6830 goto error_return_verdef
;
6832 everdaux
= ((Elf_External_Verdaux
*)
6833 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6836 if (iverdef
->vd_cnt
)
6837 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6839 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
6840 iverdef
->vd_nextdef
= iverdef
+ 1;
6842 iverdef
->vd_nextdef
= NULL
;
6844 everdef
= ((Elf_External_Verdef
*)
6845 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6851 else if (default_imported_symver
)
6858 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, freeidx
,
6859 sizeof (Elf_Internal_Verdef
));
6860 if (elf_tdata (abfd
)->verdef
== NULL
)
6863 elf_tdata (abfd
)->cverdefs
= freeidx
;
6866 /* Create a default version based on the soname. */
6867 if (default_imported_symver
)
6869 Elf_Internal_Verdef
*iverdef
;
6870 Elf_Internal_Verdaux
*iverdaux
;
6872 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6874 iverdef
->vd_version
= VER_DEF_CURRENT
;
6875 iverdef
->vd_flags
= 0;
6876 iverdef
->vd_ndx
= freeidx
;
6877 iverdef
->vd_cnt
= 1;
6879 iverdef
->vd_bfd
= abfd
;
6881 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6882 if (iverdef
->vd_nodename
== NULL
)
6883 goto error_return_verdef
;
6884 iverdef
->vd_nextdef
= NULL
;
6885 iverdef
->vd_auxptr
= bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
6886 if (iverdef
->vd_auxptr
== NULL
)
6887 goto error_return_verdef
;
6889 iverdaux
= iverdef
->vd_auxptr
;
6890 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
6891 iverdaux
->vda_nextptr
= NULL
;
6897 if (contents
!= NULL
)
6903 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6905 elf_symbol_type
*newsym
;
6906 bfd_size_type amt
= sizeof (elf_symbol_type
);
6908 newsym
= bfd_zalloc (abfd
, amt
);
6913 newsym
->symbol
.the_bfd
= abfd
;
6914 return &newsym
->symbol
;
6919 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6923 bfd_symbol_info (symbol
, ret
);
6926 /* Return whether a symbol name implies a local symbol. Most targets
6927 use this function for the is_local_label_name entry point, but some
6931 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6934 /* Normal local symbols start with ``.L''. */
6935 if (name
[0] == '.' && name
[1] == 'L')
6938 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6939 DWARF debugging symbols starting with ``..''. */
6940 if (name
[0] == '.' && name
[1] == '.')
6943 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6944 emitting DWARF debugging output. I suspect this is actually a
6945 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6946 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6947 underscore to be emitted on some ELF targets). For ease of use,
6948 we treat such symbols as local. */
6949 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6956 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6957 asymbol
*symbol ATTRIBUTE_UNUSED
)
6964 _bfd_elf_set_arch_mach (bfd
*abfd
,
6965 enum bfd_architecture arch
,
6966 unsigned long machine
)
6968 /* If this isn't the right architecture for this backend, and this
6969 isn't the generic backend, fail. */
6970 if (arch
!= get_elf_backend_data (abfd
)->arch
6971 && arch
!= bfd_arch_unknown
6972 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6975 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6978 /* Find the function to a particular section and offset,
6979 for error reporting. */
6982 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
6986 const char **filename_ptr
,
6987 const char **functionname_ptr
)
6989 const char *filename
;
6990 asymbol
*func
, *file
;
6993 /* ??? Given multiple file symbols, it is impossible to reliably
6994 choose the right file name for global symbols. File symbols are
6995 local symbols, and thus all file symbols must sort before any
6996 global symbols. The ELF spec may be interpreted to say that a
6997 file symbol must sort before other local symbols, but currently
6998 ld -r doesn't do this. So, for ld -r output, it is possible to
6999 make a better choice of file name for local symbols by ignoring
7000 file symbols appearing after a given local symbol. */
7001 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7007 state
= nothing_seen
;
7009 for (p
= symbols
; *p
!= NULL
; p
++)
7013 q
= (elf_symbol_type
*) *p
;
7015 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
7021 if (state
== symbol_seen
)
7022 state
= file_after_symbol_seen
;
7026 if (bfd_get_section (&q
->symbol
) == section
7027 && q
->symbol
.value
>= low_func
7028 && q
->symbol
.value
<= offset
)
7030 func
= (asymbol
*) q
;
7031 low_func
= q
->symbol
.value
;
7034 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7035 || state
!= file_after_symbol_seen
))
7036 filename
= bfd_asymbol_name (file
);
7040 if (state
== nothing_seen
)
7041 state
= symbol_seen
;
7048 *filename_ptr
= filename
;
7049 if (functionname_ptr
)
7050 *functionname_ptr
= bfd_asymbol_name (func
);
7055 /* Find the nearest line to a particular section and offset,
7056 for error reporting. */
7059 _bfd_elf_find_nearest_line (bfd
*abfd
,
7063 const char **filename_ptr
,
7064 const char **functionname_ptr
,
7065 unsigned int *line_ptr
)
7069 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7070 filename_ptr
, functionname_ptr
,
7073 if (!*functionname_ptr
)
7074 elf_find_function (abfd
, section
, symbols
, offset
,
7075 *filename_ptr
? NULL
: filename_ptr
,
7081 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7082 filename_ptr
, functionname_ptr
,
7084 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7086 if (!*functionname_ptr
)
7087 elf_find_function (abfd
, section
, symbols
, offset
,
7088 *filename_ptr
? NULL
: filename_ptr
,
7094 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7095 &found
, filename_ptr
,
7096 functionname_ptr
, line_ptr
,
7097 &elf_tdata (abfd
)->line_info
))
7099 if (found
&& (*functionname_ptr
|| *line_ptr
))
7102 if (symbols
== NULL
)
7105 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7106 filename_ptr
, functionname_ptr
))
7113 /* Find the line for a symbol. */
7116 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7117 const char **filename_ptr
, unsigned int *line_ptr
)
7119 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7120 filename_ptr
, line_ptr
, 0,
7121 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7124 /* After a call to bfd_find_nearest_line, successive calls to
7125 bfd_find_inliner_info can be used to get source information about
7126 each level of function inlining that terminated at the address
7127 passed to bfd_find_nearest_line. Currently this is only supported
7128 for DWARF2 with appropriate DWARF3 extensions. */
7131 _bfd_elf_find_inliner_info (bfd
*abfd
,
7132 const char **filename_ptr
,
7133 const char **functionname_ptr
,
7134 unsigned int *line_ptr
)
7137 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7138 functionname_ptr
, line_ptr
,
7139 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7144 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7146 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7147 int ret
= bed
->s
->sizeof_ehdr
;
7149 if (!info
->relocatable
)
7151 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7153 if (phdr_size
== (bfd_size_type
) -1)
7155 struct elf_segment_map
*m
;
7158 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7159 phdr_size
+= bed
->s
->sizeof_phdr
;
7162 phdr_size
= get_program_header_size (abfd
, info
);
7165 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7173 _bfd_elf_set_section_contents (bfd
*abfd
,
7175 const void *location
,
7177 bfd_size_type count
)
7179 Elf_Internal_Shdr
*hdr
;
7182 if (! abfd
->output_has_begun
7183 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7186 hdr
= &elf_section_data (section
)->this_hdr
;
7187 pos
= hdr
->sh_offset
+ offset
;
7188 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7189 || bfd_bwrite (location
, count
, abfd
) != count
)
7196 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7197 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7198 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7203 /* Try to convert a non-ELF reloc into an ELF one. */
7206 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7208 /* Check whether we really have an ELF howto. */
7210 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7212 bfd_reloc_code_real_type code
;
7213 reloc_howto_type
*howto
;
7215 /* Alien reloc: Try to determine its type to replace it with an
7216 equivalent ELF reloc. */
7218 if (areloc
->howto
->pc_relative
)
7220 switch (areloc
->howto
->bitsize
)
7223 code
= BFD_RELOC_8_PCREL
;
7226 code
= BFD_RELOC_12_PCREL
;
7229 code
= BFD_RELOC_16_PCREL
;
7232 code
= BFD_RELOC_24_PCREL
;
7235 code
= BFD_RELOC_32_PCREL
;
7238 code
= BFD_RELOC_64_PCREL
;
7244 howto
= bfd_reloc_type_lookup (abfd
, code
);
7246 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7248 if (howto
->pcrel_offset
)
7249 areloc
->addend
+= areloc
->address
;
7251 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7256 switch (areloc
->howto
->bitsize
)
7262 code
= BFD_RELOC_14
;
7265 code
= BFD_RELOC_16
;
7268 code
= BFD_RELOC_26
;
7271 code
= BFD_RELOC_32
;
7274 code
= BFD_RELOC_64
;
7280 howto
= bfd_reloc_type_lookup (abfd
, code
);
7284 areloc
->howto
= howto
;
7292 (*_bfd_error_handler
)
7293 (_("%B: unsupported relocation type %s"),
7294 abfd
, areloc
->howto
->name
);
7295 bfd_set_error (bfd_error_bad_value
);
7300 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7302 if (bfd_get_format (abfd
) == bfd_object
)
7304 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7305 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7306 _bfd_dwarf2_cleanup_debug_info (abfd
);
7309 return _bfd_generic_close_and_cleanup (abfd
);
7312 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7313 in the relocation's offset. Thus we cannot allow any sort of sanity
7314 range-checking to interfere. There is nothing else to do in processing
7317 bfd_reloc_status_type
7318 _bfd_elf_rel_vtable_reloc_fn
7319 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7320 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7321 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7322 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7324 return bfd_reloc_ok
;
7327 /* Elf core file support. Much of this only works on native
7328 toolchains, since we rely on knowing the
7329 machine-dependent procfs structure in order to pick
7330 out details about the corefile. */
7332 #ifdef HAVE_SYS_PROCFS_H
7333 # include <sys/procfs.h>
7336 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7339 elfcore_make_pid (bfd
*abfd
)
7341 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7342 + (elf_tdata (abfd
)->core_pid
));
7345 /* If there isn't a section called NAME, make one, using
7346 data from SECT. Note, this function will generate a
7347 reference to NAME, so you shouldn't deallocate or
7351 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7355 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7358 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7362 sect2
->size
= sect
->size
;
7363 sect2
->filepos
= sect
->filepos
;
7364 sect2
->alignment_power
= sect
->alignment_power
;
7368 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7369 actually creates up to two pseudosections:
7370 - For the single-threaded case, a section named NAME, unless
7371 such a section already exists.
7372 - For the multi-threaded case, a section named "NAME/PID", where
7373 PID is elfcore_make_pid (abfd).
7374 Both pseudosections have identical contents. */
7376 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7382 char *threaded_name
;
7386 /* Build the section name. */
7388 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7389 len
= strlen (buf
) + 1;
7390 threaded_name
= bfd_alloc (abfd
, len
);
7391 if (threaded_name
== NULL
)
7393 memcpy (threaded_name
, buf
, len
);
7395 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7400 sect
->filepos
= filepos
;
7401 sect
->alignment_power
= 2;
7403 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7406 /* prstatus_t exists on:
7408 linux 2.[01] + glibc
7412 #if defined (HAVE_PRSTATUS_T)
7415 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7420 if (note
->descsz
== sizeof (prstatus_t
))
7424 size
= sizeof (prstat
.pr_reg
);
7425 offset
= offsetof (prstatus_t
, pr_reg
);
7426 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7428 /* Do not overwrite the core signal if it
7429 has already been set by another thread. */
7430 if (elf_tdata (abfd
)->core_signal
== 0)
7431 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7432 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7434 /* pr_who exists on:
7437 pr_who doesn't exist on:
7440 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7441 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7444 #if defined (HAVE_PRSTATUS32_T)
7445 else if (note
->descsz
== sizeof (prstatus32_t
))
7447 /* 64-bit host, 32-bit corefile */
7448 prstatus32_t prstat
;
7450 size
= sizeof (prstat
.pr_reg
);
7451 offset
= offsetof (prstatus32_t
, pr_reg
);
7452 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7454 /* Do not overwrite the core signal if it
7455 has already been set by another thread. */
7456 if (elf_tdata (abfd
)->core_signal
== 0)
7457 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7458 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7460 /* pr_who exists on:
7463 pr_who doesn't exist on:
7466 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7467 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7470 #endif /* HAVE_PRSTATUS32_T */
7473 /* Fail - we don't know how to handle any other
7474 note size (ie. data object type). */
7478 /* Make a ".reg/999" section and a ".reg" section. */
7479 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7480 size
, note
->descpos
+ offset
);
7482 #endif /* defined (HAVE_PRSTATUS_T) */
7484 /* Create a pseudosection containing the exact contents of NOTE. */
7486 elfcore_make_note_pseudosection (bfd
*abfd
,
7488 Elf_Internal_Note
*note
)
7490 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7491 note
->descsz
, note
->descpos
);
7494 /* There isn't a consistent prfpregset_t across platforms,
7495 but it doesn't matter, because we don't have to pick this
7496 data structure apart. */
7499 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7501 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7504 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7505 type of NT_PRXFPREG. Just include the whole note's contents
7509 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7511 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7515 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
7517 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
7521 #if defined (HAVE_PRPSINFO_T)
7522 typedef prpsinfo_t elfcore_psinfo_t
;
7523 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7524 typedef prpsinfo32_t elfcore_psinfo32_t
;
7528 #if defined (HAVE_PSINFO_T)
7529 typedef psinfo_t elfcore_psinfo_t
;
7530 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7531 typedef psinfo32_t elfcore_psinfo32_t
;
7535 /* return a malloc'ed copy of a string at START which is at
7536 most MAX bytes long, possibly without a terminating '\0'.
7537 the copy will always have a terminating '\0'. */
7540 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7543 char *end
= memchr (start
, '\0', max
);
7551 dups
= bfd_alloc (abfd
, len
+ 1);
7555 memcpy (dups
, start
, len
);
7561 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7563 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7565 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7567 elfcore_psinfo_t psinfo
;
7569 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7571 elf_tdata (abfd
)->core_program
7572 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7573 sizeof (psinfo
.pr_fname
));
7575 elf_tdata (abfd
)->core_command
7576 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7577 sizeof (psinfo
.pr_psargs
));
7579 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7580 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7582 /* 64-bit host, 32-bit corefile */
7583 elfcore_psinfo32_t psinfo
;
7585 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7587 elf_tdata (abfd
)->core_program
7588 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7589 sizeof (psinfo
.pr_fname
));
7591 elf_tdata (abfd
)->core_command
7592 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7593 sizeof (psinfo
.pr_psargs
));
7599 /* Fail - we don't know how to handle any other
7600 note size (ie. data object type). */
7604 /* Note that for some reason, a spurious space is tacked
7605 onto the end of the args in some (at least one anyway)
7606 implementations, so strip it off if it exists. */
7609 char *command
= elf_tdata (abfd
)->core_command
;
7610 int n
= strlen (command
);
7612 if (0 < n
&& command
[n
- 1] == ' ')
7613 command
[n
- 1] = '\0';
7618 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7620 #if defined (HAVE_PSTATUS_T)
7622 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7624 if (note
->descsz
== sizeof (pstatus_t
)
7625 #if defined (HAVE_PXSTATUS_T)
7626 || note
->descsz
== sizeof (pxstatus_t
)
7632 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7634 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7636 #if defined (HAVE_PSTATUS32_T)
7637 else if (note
->descsz
== sizeof (pstatus32_t
))
7639 /* 64-bit host, 32-bit corefile */
7642 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7644 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7647 /* Could grab some more details from the "representative"
7648 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7649 NT_LWPSTATUS note, presumably. */
7653 #endif /* defined (HAVE_PSTATUS_T) */
7655 #if defined (HAVE_LWPSTATUS_T)
7657 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7659 lwpstatus_t lwpstat
;
7665 if (note
->descsz
!= sizeof (lwpstat
)
7666 #if defined (HAVE_LWPXSTATUS_T)
7667 && note
->descsz
!= sizeof (lwpxstatus_t
)
7672 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7674 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7675 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7677 /* Make a ".reg/999" section. */
7679 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7680 len
= strlen (buf
) + 1;
7681 name
= bfd_alloc (abfd
, len
);
7684 memcpy (name
, buf
, len
);
7686 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7690 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7691 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7692 sect
->filepos
= note
->descpos
7693 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7696 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7697 sect
->size
= sizeof (lwpstat
.pr_reg
);
7698 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7701 sect
->alignment_power
= 2;
7703 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7706 /* Make a ".reg2/999" section */
7708 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7709 len
= strlen (buf
) + 1;
7710 name
= bfd_alloc (abfd
, len
);
7713 memcpy (name
, buf
, len
);
7715 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7719 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7720 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7721 sect
->filepos
= note
->descpos
7722 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7725 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7726 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7727 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7730 sect
->alignment_power
= 2;
7732 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7734 #endif /* defined (HAVE_LWPSTATUS_T) */
7737 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7744 int is_active_thread
;
7747 if (note
->descsz
< 728)
7750 if (! CONST_STRNEQ (note
->namedata
, "win32"))
7753 type
= bfd_get_32 (abfd
, note
->descdata
);
7757 case 1 /* NOTE_INFO_PROCESS */:
7758 /* FIXME: need to add ->core_command. */
7759 /* process_info.pid */
7760 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7761 /* process_info.signal */
7762 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
7765 case 2 /* NOTE_INFO_THREAD */:
7766 /* Make a ".reg/999" section. */
7767 /* thread_info.tid */
7768 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
7770 len
= strlen (buf
) + 1;
7771 name
= bfd_alloc (abfd
, len
);
7775 memcpy (name
, buf
, len
);
7777 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7781 /* sizeof (thread_info.thread_context) */
7783 /* offsetof (thread_info.thread_context) */
7784 sect
->filepos
= note
->descpos
+ 12;
7785 sect
->alignment_power
= 2;
7787 /* thread_info.is_active_thread */
7788 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7790 if (is_active_thread
)
7791 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7795 case 3 /* NOTE_INFO_MODULE */:
7796 /* Make a ".module/xxxxxxxx" section. */
7797 /* module_info.base_address */
7798 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
7799 sprintf (buf
, ".module/%08lx", (long) base_addr
);
7801 len
= strlen (buf
) + 1;
7802 name
= bfd_alloc (abfd
, len
);
7806 memcpy (name
, buf
, len
);
7808 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7813 sect
->size
= note
->descsz
;
7814 sect
->filepos
= note
->descpos
;
7815 sect
->alignment_power
= 2;
7826 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7828 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7836 if (bed
->elf_backend_grok_prstatus
)
7837 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7839 #if defined (HAVE_PRSTATUS_T)
7840 return elfcore_grok_prstatus (abfd
, note
);
7845 #if defined (HAVE_PSTATUS_T)
7847 return elfcore_grok_pstatus (abfd
, note
);
7850 #if defined (HAVE_LWPSTATUS_T)
7852 return elfcore_grok_lwpstatus (abfd
, note
);
7855 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7856 return elfcore_grok_prfpreg (abfd
, note
);
7858 case NT_WIN32PSTATUS
:
7859 return elfcore_grok_win32pstatus (abfd
, note
);
7861 case NT_PRXFPREG
: /* Linux SSE extension */
7862 if (note
->namesz
== 6
7863 && strcmp (note
->namedata
, "LINUX") == 0)
7864 return elfcore_grok_prxfpreg (abfd
, note
);
7869 if (note
->namesz
== 6
7870 && strcmp (note
->namedata
, "LINUX") == 0)
7871 return elfcore_grok_ppc_vmx (abfd
, note
);
7877 if (bed
->elf_backend_grok_psinfo
)
7878 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7880 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7881 return elfcore_grok_psinfo (abfd
, note
);
7888 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
7893 sect
->size
= note
->descsz
;
7894 sect
->filepos
= note
->descpos
;
7895 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7903 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
7905 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
7906 elf_tdata (abfd
)->build_id
= bfd_alloc (abfd
, note
->descsz
);
7907 if (elf_tdata (abfd
)->build_id
== NULL
)
7910 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
7916 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7923 case NT_GNU_BUILD_ID
:
7924 return elfobj_grok_gnu_build_id (abfd
, note
);
7929 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
7933 cp
= strchr (note
->namedata
, '@');
7936 *lwpidp
= atoi(cp
+ 1);
7943 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7945 /* Signal number at offset 0x08. */
7946 elf_tdata (abfd
)->core_signal
7947 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
7949 /* Process ID at offset 0x50. */
7950 elf_tdata (abfd
)->core_pid
7951 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
7953 /* Command name at 0x7c (max 32 bytes, including nul). */
7954 elf_tdata (abfd
)->core_command
7955 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7957 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7962 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7966 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7967 elf_tdata (abfd
)->core_lwpid
= lwp
;
7969 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7971 /* NetBSD-specific core "procinfo". Note that we expect to
7972 find this note before any of the others, which is fine,
7973 since the kernel writes this note out first when it
7974 creates a core file. */
7976 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7979 /* As of Jan 2002 there are no other machine-independent notes
7980 defined for NetBSD core files. If the note type is less
7981 than the start of the machine-dependent note types, we don't
7984 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
7988 switch (bfd_get_arch (abfd
))
7990 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7991 PT_GETFPREGS == mach+2. */
7993 case bfd_arch_alpha
:
7994 case bfd_arch_sparc
:
7997 case NT_NETBSDCORE_FIRSTMACH
+0:
7998 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8000 case NT_NETBSDCORE_FIRSTMACH
+2:
8001 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8007 /* On all other arch's, PT_GETREGS == mach+1 and
8008 PT_GETFPREGS == mach+3. */
8013 case NT_NETBSDCORE_FIRSTMACH
+1:
8014 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8016 case NT_NETBSDCORE_FIRSTMACH
+3:
8017 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8027 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8029 void *ddata
= note
->descdata
;
8036 /* nto_procfs_status 'pid' field is at offset 0. */
8037 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8039 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8040 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8042 /* nto_procfs_status 'flags' field is at offset 8. */
8043 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8045 /* nto_procfs_status 'what' field is at offset 14. */
8046 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8048 elf_tdata (abfd
)->core_signal
= sig
;
8049 elf_tdata (abfd
)->core_lwpid
= *tid
;
8052 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8053 do not come from signals so we make sure we set the current
8054 thread just in case. */
8055 if (flags
& 0x00000080)
8056 elf_tdata (abfd
)->core_lwpid
= *tid
;
8058 /* Make a ".qnx_core_status/%d" section. */
8059 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8061 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8066 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8070 sect
->size
= note
->descsz
;
8071 sect
->filepos
= note
->descpos
;
8072 sect
->alignment_power
= 2;
8074 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8078 elfcore_grok_nto_regs (bfd
*abfd
,
8079 Elf_Internal_Note
*note
,
8087 /* Make a "(base)/%d" section. */
8088 sprintf (buf
, "%s/%ld", base
, tid
);
8090 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8095 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8099 sect
->size
= note
->descsz
;
8100 sect
->filepos
= note
->descpos
;
8101 sect
->alignment_power
= 2;
8103 /* This is the current thread. */
8104 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8105 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8110 #define BFD_QNT_CORE_INFO 7
8111 #define BFD_QNT_CORE_STATUS 8
8112 #define BFD_QNT_CORE_GREG 9
8113 #define BFD_QNT_CORE_FPREG 10
8116 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8118 /* Every GREG section has a STATUS section before it. Store the
8119 tid from the previous call to pass down to the next gregs
8121 static long tid
= 1;
8125 case BFD_QNT_CORE_INFO
:
8126 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8127 case BFD_QNT_CORE_STATUS
:
8128 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8129 case BFD_QNT_CORE_GREG
:
8130 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8131 case BFD_QNT_CORE_FPREG
:
8132 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8139 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8145 /* Use note name as section name. */
8147 name
= bfd_alloc (abfd
, len
);
8150 memcpy (name
, note
->namedata
, len
);
8151 name
[len
- 1] = '\0';
8153 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8157 sect
->size
= note
->descsz
;
8158 sect
->filepos
= note
->descpos
;
8159 sect
->alignment_power
= 1;
8164 /* Function: elfcore_write_note
8167 buffer to hold note, and current size of buffer
8171 size of data for note
8173 Writes note to end of buffer. ELF64 notes are written exactly as
8174 for ELF32, despite the current (as of 2006) ELF gabi specifying
8175 that they ought to have 8-byte namesz and descsz field, and have
8176 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8179 Pointer to realloc'd buffer, *BUFSIZ updated. */
8182 elfcore_write_note (bfd
*abfd
,
8190 Elf_External_Note
*xnp
;
8197 namesz
= strlen (name
) + 1;
8199 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8201 buf
= realloc (buf
, *bufsiz
+ newspace
);
8204 dest
= buf
+ *bufsiz
;
8205 *bufsiz
+= newspace
;
8206 xnp
= (Elf_External_Note
*) dest
;
8207 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8208 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8209 H_PUT_32 (abfd
, type
, xnp
->type
);
8213 memcpy (dest
, name
, namesz
);
8221 memcpy (dest
, input
, size
);
8231 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8233 elfcore_write_prpsinfo (bfd
*abfd
,
8239 const char *note_name
= "CORE";
8240 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8242 if (bed
->elf_backend_write_core_note
!= NULL
)
8245 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8246 NT_PRPSINFO
, fname
, psargs
);
8251 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8252 if (bed
->s
->elfclass
== ELFCLASS32
)
8254 #if defined (HAVE_PSINFO32_T)
8256 int note_type
= NT_PSINFO
;
8259 int note_type
= NT_PRPSINFO
;
8262 memset (&data
, 0, sizeof (data
));
8263 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8264 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8265 return elfcore_write_note (abfd
, buf
, bufsiz
,
8266 note_name
, note_type
, &data
, sizeof (data
));
8271 #if defined (HAVE_PSINFO_T)
8273 int note_type
= NT_PSINFO
;
8276 int note_type
= NT_PRPSINFO
;
8279 memset (&data
, 0, sizeof (data
));
8280 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8281 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8282 return elfcore_write_note (abfd
, buf
, bufsiz
,
8283 note_name
, note_type
, &data
, sizeof (data
));
8286 #endif /* PSINFO_T or PRPSINFO_T */
8288 #if defined (HAVE_PRSTATUS_T)
8290 elfcore_write_prstatus (bfd
*abfd
,
8297 const char *note_name
= "CORE";
8298 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8300 if (bed
->elf_backend_write_core_note
!= NULL
)
8303 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8305 pid
, cursig
, gregs
);
8310 #if defined (HAVE_PRSTATUS32_T)
8311 if (bed
->s
->elfclass
== ELFCLASS32
)
8313 prstatus32_t prstat
;
8315 memset (&prstat
, 0, sizeof (prstat
));
8316 prstat
.pr_pid
= pid
;
8317 prstat
.pr_cursig
= cursig
;
8318 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8319 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8320 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8327 memset (&prstat
, 0, sizeof (prstat
));
8328 prstat
.pr_pid
= pid
;
8329 prstat
.pr_cursig
= cursig
;
8330 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8331 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8332 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8335 #endif /* HAVE_PRSTATUS_T */
8337 #if defined (HAVE_LWPSTATUS_T)
8339 elfcore_write_lwpstatus (bfd
*abfd
,
8346 lwpstatus_t lwpstat
;
8347 const char *note_name
= "CORE";
8349 memset (&lwpstat
, 0, sizeof (lwpstat
));
8350 lwpstat
.pr_lwpid
= pid
>> 16;
8351 lwpstat
.pr_cursig
= cursig
;
8352 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8353 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8354 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8356 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8357 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8359 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8360 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8363 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8364 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8366 #endif /* HAVE_LWPSTATUS_T */
8368 #if defined (HAVE_PSTATUS_T)
8370 elfcore_write_pstatus (bfd
*abfd
,
8374 int cursig ATTRIBUTE_UNUSED
,
8375 const void *gregs ATTRIBUTE_UNUSED
)
8377 const char *note_name
= "CORE";
8378 #if defined (HAVE_PSTATUS32_T)
8379 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8381 if (bed
->s
->elfclass
== ELFCLASS32
)
8385 memset (&pstat
, 0, sizeof (pstat
));
8386 pstat
.pr_pid
= pid
& 0xffff;
8387 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8388 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8396 memset (&pstat
, 0, sizeof (pstat
));
8397 pstat
.pr_pid
= pid
& 0xffff;
8398 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8399 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8403 #endif /* HAVE_PSTATUS_T */
8406 elfcore_write_prfpreg (bfd
*abfd
,
8412 const char *note_name
= "CORE";
8413 return elfcore_write_note (abfd
, buf
, bufsiz
,
8414 note_name
, NT_FPREGSET
, fpregs
, size
);
8418 elfcore_write_prxfpreg (bfd
*abfd
,
8421 const void *xfpregs
,
8424 char *note_name
= "LINUX";
8425 return elfcore_write_note (abfd
, buf
, bufsiz
,
8426 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8430 elfcore_write_ppc_vmx (bfd
*abfd
,
8433 const void *ppc_vmx
,
8436 char *note_name
= "LINUX";
8437 return elfcore_write_note (abfd
, buf
, bufsiz
,
8438 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
8442 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
8447 while (p
< buf
+ size
)
8449 /* FIXME: bad alignment assumption. */
8450 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8451 Elf_Internal_Note in
;
8453 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8455 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8456 in
.namedata
= xnp
->name
;
8458 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8459 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8460 in
.descpos
= offset
+ (in
.descdata
- buf
);
8462 switch (bfd_get_format (abfd
))
8468 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8470 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8473 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8475 if (! elfcore_grok_nto_note (abfd
, &in
))
8478 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
8480 if (! elfcore_grok_spu_note (abfd
, &in
))
8485 if (! elfcore_grok_note (abfd
, &in
))
8491 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
8493 if (! elfobj_grok_gnu_note (abfd
, &in
))
8499 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
8506 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
8513 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
8516 buf
= bfd_malloc (size
);
8520 if (bfd_bread (buf
, size
, abfd
) != size
8521 || !elf_parse_notes (abfd
, buf
, size
, offset
))
8531 /* Providing external access to the ELF program header table. */
8533 /* Return an upper bound on the number of bytes required to store a
8534 copy of ABFD's program header table entries. Return -1 if an error
8535 occurs; bfd_get_error will return an appropriate code. */
8538 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
8540 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8542 bfd_set_error (bfd_error_wrong_format
);
8546 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
8549 /* Copy ABFD's program header table entries to *PHDRS. The entries
8550 will be stored as an array of Elf_Internal_Phdr structures, as
8551 defined in include/elf/internal.h. To find out how large the
8552 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8554 Return the number of program header table entries read, or -1 if an
8555 error occurs; bfd_get_error will return an appropriate code. */
8558 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
8562 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8564 bfd_set_error (bfd_error_wrong_format
);
8568 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
8569 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
8570 num_phdrs
* sizeof (Elf_Internal_Phdr
));
8575 enum elf_reloc_type_class
8576 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
8578 return reloc_class_normal
;
8581 /* For RELA architectures, return the relocation value for a
8582 relocation against a local symbol. */
8585 _bfd_elf_rela_local_sym (bfd
*abfd
,
8586 Elf_Internal_Sym
*sym
,
8588 Elf_Internal_Rela
*rel
)
8590 asection
*sec
= *psec
;
8593 relocation
= (sec
->output_section
->vma
8594 + sec
->output_offset
8596 if ((sec
->flags
& SEC_MERGE
)
8597 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8598 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8601 _bfd_merged_section_offset (abfd
, psec
,
8602 elf_section_data (sec
)->sec_info
,
8603 sym
->st_value
+ rel
->r_addend
);
8606 /* If we have changed the section, and our original section is
8607 marked with SEC_EXCLUDE, it means that the original
8608 SEC_MERGE section has been completely subsumed in some
8609 other SEC_MERGE section. In this case, we need to leave
8610 some info around for --emit-relocs. */
8611 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8612 sec
->kept_section
= *psec
;
8615 rel
->r_addend
-= relocation
;
8616 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8622 _bfd_elf_rel_local_sym (bfd
*abfd
,
8623 Elf_Internal_Sym
*sym
,
8627 asection
*sec
= *psec
;
8629 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8630 return sym
->st_value
+ addend
;
8632 return _bfd_merged_section_offset (abfd
, psec
,
8633 elf_section_data (sec
)->sec_info
,
8634 sym
->st_value
+ addend
);
8638 _bfd_elf_section_offset (bfd
*abfd
,
8639 struct bfd_link_info
*info
,
8643 switch (sec
->sec_info_type
)
8645 case ELF_INFO_TYPE_STABS
:
8646 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8648 case ELF_INFO_TYPE_EH_FRAME
:
8649 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8655 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8656 reconstruct an ELF file by reading the segments out of remote memory
8657 based on the ELF file header at EHDR_VMA and the ELF program headers it
8658 points to. If not null, *LOADBASEP is filled in with the difference
8659 between the VMAs from which the segments were read, and the VMAs the
8660 file headers (and hence BFD's idea of each section's VMA) put them at.
8662 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8663 remote memory at target address VMA into the local buffer at MYADDR; it
8664 should return zero on success or an `errno' code on failure. TEMPL must
8665 be a BFD for an ELF target with the word size and byte order found in
8666 the remote memory. */
8669 bfd_elf_bfd_from_remote_memory
8673 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8675 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8676 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8680 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8681 long symcount ATTRIBUTE_UNUSED
,
8682 asymbol
**syms ATTRIBUTE_UNUSED
,
8687 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8690 const char *relplt_name
;
8691 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8695 Elf_Internal_Shdr
*hdr
;
8701 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8704 if (dynsymcount
<= 0)
8707 if (!bed
->plt_sym_val
)
8710 relplt_name
= bed
->relplt_name
;
8711 if (relplt_name
== NULL
)
8712 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8713 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8717 hdr
= &elf_section_data (relplt
)->this_hdr
;
8718 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8719 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8722 plt
= bfd_get_section_by_name (abfd
, ".plt");
8726 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8727 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8730 count
= relplt
->size
/ hdr
->sh_entsize
;
8731 size
= count
* sizeof (asymbol
);
8732 p
= relplt
->relocation
;
8733 for (i
= 0; i
< count
; i
++, p
++)
8734 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8736 s
= *ret
= bfd_malloc (size
);
8740 names
= (char *) (s
+ count
);
8741 p
= relplt
->relocation
;
8743 for (i
= 0; i
< count
; i
++, p
++)
8748 addr
= bed
->plt_sym_val (i
, plt
, p
);
8749 if (addr
== (bfd_vma
) -1)
8752 *s
= **p
->sym_ptr_ptr
;
8753 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8754 we are defining a symbol, ensure one of them is set. */
8755 if ((s
->flags
& BSF_LOCAL
) == 0)
8756 s
->flags
|= BSF_GLOBAL
;
8758 s
->value
= addr
- plt
->vma
;
8761 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8762 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8764 memcpy (names
, "@plt", sizeof ("@plt"));
8765 names
+= sizeof ("@plt");
8772 /* It is only used by x86-64 so far. */
8773 asection _bfd_elf_large_com_section
8774 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
8775 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
8778 _bfd_elf_set_osabi (bfd
* abfd
,
8779 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
8781 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
8783 i_ehdrp
= elf_elfheader (abfd
);
8785 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
8789 /* Return TRUE for ELF symbol types that represent functions.
8790 This is the default version of this function, which is sufficient for
8791 most targets. It returns true if TYPE is STT_FUNC. */
8794 _bfd_elf_is_function_type (unsigned int type
)
8796 return (type
== STT_FUNC
);