1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008 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;
229 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
230 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
232 bfd_elf_allocate_object (bfd
*abfd
,
234 enum elf_object_id object_id
)
236 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
237 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
238 if (abfd
->tdata
.any
== NULL
)
241 elf_object_id (abfd
) = object_id
;
242 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
248 bfd_elf_make_generic_object (bfd
*abfd
)
250 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
255 bfd_elf_mkcorefile (bfd
*abfd
)
257 /* I think this can be done just like an object file. */
258 return bfd_elf_make_generic_object (abfd
);
262 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
264 Elf_Internal_Shdr
**i_shdrp
;
265 bfd_byte
*shstrtab
= NULL
;
267 bfd_size_type shstrtabsize
;
269 i_shdrp
= elf_elfsections (abfd
);
271 || shindex
>= elf_numsections (abfd
)
272 || i_shdrp
[shindex
] == 0)
275 shstrtab
= i_shdrp
[shindex
]->contents
;
276 if (shstrtab
== NULL
)
278 /* No cached one, attempt to read, and cache what we read. */
279 offset
= i_shdrp
[shindex
]->sh_offset
;
280 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
282 /* Allocate and clear an extra byte at the end, to prevent crashes
283 in case the string table is not terminated. */
284 if (shstrtabsize
+ 1 <= 1
285 || (shstrtab
= bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
286 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
288 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
290 if (bfd_get_error () != bfd_error_system_call
)
291 bfd_set_error (bfd_error_file_truncated
);
293 /* Once we've failed to read it, make sure we don't keep
294 trying. Otherwise, we'll keep allocating space for
295 the string table over and over. */
296 i_shdrp
[shindex
]->sh_size
= 0;
299 shstrtab
[shstrtabsize
] = '\0';
300 i_shdrp
[shindex
]->contents
= shstrtab
;
302 return (char *) shstrtab
;
306 bfd_elf_string_from_elf_section (bfd
*abfd
,
307 unsigned int shindex
,
308 unsigned int strindex
)
310 Elf_Internal_Shdr
*hdr
;
315 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
318 hdr
= elf_elfsections (abfd
)[shindex
];
320 if (hdr
->contents
== NULL
321 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
324 if (strindex
>= hdr
->sh_size
)
326 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
327 (*_bfd_error_handler
)
328 (_("%B: invalid string offset %u >= %lu for section `%s'"),
329 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
330 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
332 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
336 return ((char *) hdr
->contents
) + strindex
;
339 /* Read and convert symbols to internal format.
340 SYMCOUNT specifies the number of symbols to read, starting from
341 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
342 are non-NULL, they are used to store the internal symbols, external
343 symbols, and symbol section index extensions, respectively.
344 Returns a pointer to the internal symbol buffer (malloced if necessary)
345 or NULL if there were no symbols or some kind of problem. */
348 bfd_elf_get_elf_syms (bfd
*ibfd
,
349 Elf_Internal_Shdr
*symtab_hdr
,
352 Elf_Internal_Sym
*intsym_buf
,
354 Elf_External_Sym_Shndx
*extshndx_buf
)
356 Elf_Internal_Shdr
*shndx_hdr
;
358 const bfd_byte
*esym
;
359 Elf_External_Sym_Shndx
*alloc_extshndx
;
360 Elf_External_Sym_Shndx
*shndx
;
361 Elf_Internal_Sym
*isym
;
362 Elf_Internal_Sym
*isymend
;
363 const struct elf_backend_data
*bed
;
368 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
374 /* Normal syms might have section extension entries. */
376 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
377 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
379 /* Read the symbols. */
381 alloc_extshndx
= NULL
;
382 bed
= get_elf_backend_data (ibfd
);
383 extsym_size
= bed
->s
->sizeof_sym
;
384 amt
= symcount
* extsym_size
;
385 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
386 if (extsym_buf
== NULL
)
388 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
389 extsym_buf
= alloc_ext
;
391 if (extsym_buf
== NULL
392 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
393 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
399 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
403 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
404 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
405 if (extshndx_buf
== NULL
)
407 alloc_extshndx
= bfd_malloc2 (symcount
,
408 sizeof (Elf_External_Sym_Shndx
));
409 extshndx_buf
= alloc_extshndx
;
411 if (extshndx_buf
== NULL
412 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
413 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
420 if (intsym_buf
== NULL
)
422 intsym_buf
= bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
423 if (intsym_buf
== NULL
)
427 /* Convert the symbols to internal form. */
428 isymend
= intsym_buf
+ symcount
;
429 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
431 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
432 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
434 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
435 (*_bfd_error_handler
) (_("%B symbol number %lu references "
436 "nonexistent SHT_SYMTAB_SHNDX section"),
437 ibfd
, (unsigned long) symoffset
);
443 if (alloc_ext
!= NULL
)
445 if (alloc_extshndx
!= NULL
)
446 free (alloc_extshndx
);
451 /* Look up a symbol name. */
453 bfd_elf_sym_name (bfd
*abfd
,
454 Elf_Internal_Shdr
*symtab_hdr
,
455 Elf_Internal_Sym
*isym
,
459 unsigned int iname
= isym
->st_name
;
460 unsigned int shindex
= symtab_hdr
->sh_link
;
462 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
463 /* Check for a bogus st_shndx to avoid crashing. */
464 && isym
->st_shndx
< elf_numsections (abfd
))
466 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
467 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
470 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
473 else if (sym_sec
&& *name
== '\0')
474 name
= bfd_section_name (abfd
, sym_sec
);
479 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
480 sections. The first element is the flags, the rest are section
483 typedef union elf_internal_group
{
484 Elf_Internal_Shdr
*shdr
;
486 } Elf_Internal_Group
;
488 /* Return the name of the group signature symbol. Why isn't the
489 signature just a string? */
492 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
494 Elf_Internal_Shdr
*hdr
;
495 unsigned char esym
[sizeof (Elf64_External_Sym
)];
496 Elf_External_Sym_Shndx eshndx
;
497 Elf_Internal_Sym isym
;
499 /* First we need to ensure the symbol table is available. Make sure
500 that it is a symbol table section. */
501 if (ghdr
->sh_link
>= elf_numsections (abfd
))
503 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
504 if (hdr
->sh_type
!= SHT_SYMTAB
505 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
508 /* Go read the symbol. */
509 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
510 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
511 &isym
, esym
, &eshndx
) == NULL
)
514 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
517 /* Set next_in_group list pointer, and group name for NEWSECT. */
520 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
522 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
524 /* If num_group is zero, read in all SHT_GROUP sections. The count
525 is set to -1 if there are no SHT_GROUP sections. */
528 unsigned int i
, shnum
;
530 /* First count the number of groups. If we have a SHT_GROUP
531 section with just a flag word (ie. sh_size is 4), ignore it. */
532 shnum
= elf_numsections (abfd
);
535 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
536 ( (shdr)->sh_type == SHT_GROUP \
537 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
538 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
539 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
541 for (i
= 0; i
< shnum
; i
++)
543 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
545 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
551 num_group
= (unsigned) -1;
552 elf_tdata (abfd
)->num_group
= num_group
;
556 /* We keep a list of elf section headers for group sections,
557 so we can find them quickly. */
560 elf_tdata (abfd
)->num_group
= num_group
;
561 elf_tdata (abfd
)->group_sect_ptr
562 = bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
563 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
567 for (i
= 0; i
< shnum
; i
++)
569 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
571 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
574 Elf_Internal_Group
*dest
;
576 /* Add to list of sections. */
577 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
580 /* Read the raw contents. */
581 BFD_ASSERT (sizeof (*dest
) >= 4);
582 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
583 shdr
->contents
= bfd_alloc2 (abfd
, shdr
->sh_size
,
585 /* PR binutils/4110: Handle corrupt group headers. */
586 if (shdr
->contents
== NULL
)
589 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
590 bfd_set_error (bfd_error_bad_value
);
594 memset (shdr
->contents
, 0, amt
);
596 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
597 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
601 /* Translate raw contents, a flag word followed by an
602 array of elf section indices all in target byte order,
603 to the flag word followed by an array of elf section
605 src
= shdr
->contents
+ shdr
->sh_size
;
606 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
613 idx
= H_GET_32 (abfd
, src
);
614 if (src
== shdr
->contents
)
617 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
618 shdr
->bfd_section
->flags
619 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
624 ((*_bfd_error_handler
)
625 (_("%B: invalid SHT_GROUP entry"), abfd
));
628 dest
->shdr
= elf_elfsections (abfd
)[idx
];
635 if (num_group
!= (unsigned) -1)
639 for (i
= 0; i
< num_group
; i
++)
641 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
642 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
643 unsigned int n_elt
= shdr
->sh_size
/ 4;
645 /* Look through this group's sections to see if current
646 section is a member. */
648 if ((++idx
)->shdr
== hdr
)
652 /* We are a member of this group. Go looking through
653 other members to see if any others are linked via
655 idx
= (Elf_Internal_Group
*) shdr
->contents
;
656 n_elt
= shdr
->sh_size
/ 4;
658 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
659 && elf_next_in_group (s
) != NULL
)
663 /* Snarf the group name from other member, and
664 insert current section in circular list. */
665 elf_group_name (newsect
) = elf_group_name (s
);
666 elf_next_in_group (newsect
) = elf_next_in_group (s
);
667 elf_next_in_group (s
) = newsect
;
673 gname
= group_signature (abfd
, shdr
);
676 elf_group_name (newsect
) = gname
;
678 /* Start a circular list with one element. */
679 elf_next_in_group (newsect
) = newsect
;
682 /* If the group section has been created, point to the
684 if (shdr
->bfd_section
!= NULL
)
685 elf_next_in_group (shdr
->bfd_section
) = newsect
;
693 if (elf_group_name (newsect
) == NULL
)
695 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
702 _bfd_elf_setup_sections (bfd
*abfd
)
705 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
706 bfd_boolean result
= TRUE
;
709 /* Process SHF_LINK_ORDER. */
710 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
712 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
713 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
715 unsigned int elfsec
= this_hdr
->sh_link
;
716 /* FIXME: The old Intel compiler and old strip/objcopy may
717 not set the sh_link or sh_info fields. Hence we could
718 get the situation where elfsec is 0. */
721 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
722 if (bed
->link_order_error_handler
)
723 bed
->link_order_error_handler
724 (_("%B: warning: sh_link not set for section `%A'"),
729 asection
*link
= NULL
;
731 if (elfsec
< elf_numsections (abfd
))
733 this_hdr
= elf_elfsections (abfd
)[elfsec
];
734 link
= this_hdr
->bfd_section
;
738 Some strip/objcopy may leave an incorrect value in
739 sh_link. We don't want to proceed. */
742 (*_bfd_error_handler
)
743 (_("%B: sh_link [%d] in section `%A' is incorrect"),
744 s
->owner
, s
, elfsec
);
748 elf_linked_to_section (s
) = link
;
753 /* Process section groups. */
754 if (num_group
== (unsigned) -1)
757 for (i
= 0; i
< num_group
; i
++)
759 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
760 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
761 unsigned int n_elt
= shdr
->sh_size
/ 4;
764 if ((++idx
)->shdr
->bfd_section
)
765 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
766 else if (idx
->shdr
->sh_type
== SHT_RELA
767 || idx
->shdr
->sh_type
== SHT_REL
)
768 /* We won't include relocation sections in section groups in
769 output object files. We adjust the group section size here
770 so that relocatable link will work correctly when
771 relocation sections are in section group in input object
773 shdr
->bfd_section
->size
-= 4;
776 /* There are some unknown sections in the group. */
777 (*_bfd_error_handler
)
778 (_("%B: unknown [%d] section `%s' in group [%s]"),
780 (unsigned int) idx
->shdr
->sh_type
,
781 bfd_elf_string_from_elf_section (abfd
,
782 (elf_elfheader (abfd
)
785 shdr
->bfd_section
->name
);
793 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
795 return elf_next_in_group (sec
) != NULL
;
798 /* Make a BFD section from an ELF section. We store a pointer to the
799 BFD section in the bfd_section field of the header. */
802 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
803 Elf_Internal_Shdr
*hdr
,
809 const struct elf_backend_data
*bed
;
811 if (hdr
->bfd_section
!= NULL
)
813 BFD_ASSERT (strcmp (name
,
814 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
818 newsect
= bfd_make_section_anyway (abfd
, name
);
822 hdr
->bfd_section
= newsect
;
823 elf_section_data (newsect
)->this_hdr
= *hdr
;
824 elf_section_data (newsect
)->this_idx
= shindex
;
826 /* Always use the real type/flags. */
827 elf_section_type (newsect
) = hdr
->sh_type
;
828 elf_section_flags (newsect
) = hdr
->sh_flags
;
830 newsect
->filepos
= hdr
->sh_offset
;
832 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
833 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
834 || ! bfd_set_section_alignment (abfd
, newsect
,
835 bfd_log2 (hdr
->sh_addralign
)))
838 flags
= SEC_NO_FLAGS
;
839 if (hdr
->sh_type
!= SHT_NOBITS
)
840 flags
|= SEC_HAS_CONTENTS
;
841 if (hdr
->sh_type
== SHT_GROUP
)
842 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
843 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
846 if (hdr
->sh_type
!= SHT_NOBITS
)
849 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
850 flags
|= SEC_READONLY
;
851 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
853 else if ((flags
& SEC_LOAD
) != 0)
855 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
858 newsect
->entsize
= hdr
->sh_entsize
;
859 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
860 flags
|= SEC_STRINGS
;
862 if (hdr
->sh_flags
& SHF_GROUP
)
863 if (!setup_group (abfd
, hdr
, newsect
))
865 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
866 flags
|= SEC_THREAD_LOCAL
;
868 if ((flags
& SEC_ALLOC
) == 0)
870 /* The debugging sections appear to be recognized only by name,
871 not any sort of flag. Their SEC_ALLOC bits are cleared. */
876 } debug_sections
[] =
878 { STRING_COMMA_LEN ("debug") }, /* 'd' */
879 { NULL
, 0 }, /* 'e' */
880 { NULL
, 0 }, /* 'f' */
881 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
882 { NULL
, 0 }, /* 'h' */
883 { NULL
, 0 }, /* 'i' */
884 { NULL
, 0 }, /* 'j' */
885 { NULL
, 0 }, /* 'k' */
886 { STRING_COMMA_LEN ("line") }, /* 'l' */
887 { NULL
, 0 }, /* 'm' */
888 { NULL
, 0 }, /* 'n' */
889 { NULL
, 0 }, /* 'o' */
890 { NULL
, 0 }, /* 'p' */
891 { NULL
, 0 }, /* 'q' */
892 { NULL
, 0 }, /* 'r' */
893 { STRING_COMMA_LEN ("stab") } /* 's' */
898 int i
= name
[1] - 'd';
900 && i
< (int) ARRAY_SIZE (debug_sections
)
901 && debug_sections
[i
].name
!= NULL
902 && strncmp (&name
[1], debug_sections
[i
].name
,
903 debug_sections
[i
].len
) == 0)
904 flags
|= SEC_DEBUGGING
;
908 /* As a GNU extension, if the name begins with .gnu.linkonce, we
909 only link a single copy of the section. This is used to support
910 g++. g++ will emit each template expansion in its own section.
911 The symbols will be defined as weak, so that multiple definitions
912 are permitted. The GNU linker extension is to actually discard
913 all but one of the sections. */
914 if (CONST_STRNEQ (name
, ".gnu.linkonce")
915 && elf_next_in_group (newsect
) == NULL
)
916 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
918 bed
= get_elf_backend_data (abfd
);
919 if (bed
->elf_backend_section_flags
)
920 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
923 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
926 /* We do not parse the PT_NOTE segments as we are interested even in the
927 separate debug info files which may have the segments offsets corrupted.
928 PT_NOTEs from the core files are currently not parsed using BFD. */
929 if (hdr
->sh_type
== SHT_NOTE
)
933 contents
= bfd_malloc (hdr
->sh_size
);
937 if (!bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
, 0,
939 || !elf_parse_notes (abfd
, contents
, hdr
->sh_size
, -1))
948 if ((flags
& SEC_ALLOC
) != 0)
950 Elf_Internal_Phdr
*phdr
;
951 unsigned int i
, nload
;
953 /* Some ELF linkers produce binaries with all the program header
954 p_paddr fields zero. If we have such a binary with more than
955 one PT_LOAD header, then leave the section lma equal to vma
956 so that we don't create sections with overlapping lma. */
957 phdr
= elf_tdata (abfd
)->phdr
;
958 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
959 if (phdr
->p_paddr
!= 0)
961 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
963 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
966 phdr
= elf_tdata (abfd
)->phdr
;
967 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
969 /* This section is part of this segment if its file
970 offset plus size lies within the segment's memory
971 span and, if the section is loaded, the extent of the
972 loaded data lies within the extent of the segment.
974 Note - we used to check the p_paddr field as well, and
975 refuse to set the LMA if it was 0. This is wrong
976 though, as a perfectly valid initialised segment can
977 have a p_paddr of zero. Some architectures, eg ARM,
978 place special significance on the address 0 and
979 executables need to be able to have a segment which
980 covers this address. */
981 if (phdr
->p_type
== PT_LOAD
982 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
983 && (hdr
->sh_offset
+ hdr
->sh_size
984 <= phdr
->p_offset
+ phdr
->p_memsz
)
985 && ((flags
& SEC_LOAD
) == 0
986 || (hdr
->sh_offset
+ hdr
->sh_size
987 <= phdr
->p_offset
+ phdr
->p_filesz
)))
989 if ((flags
& SEC_LOAD
) == 0)
990 newsect
->lma
= (phdr
->p_paddr
991 + hdr
->sh_addr
- phdr
->p_vaddr
);
993 /* We used to use the same adjustment for SEC_LOAD
994 sections, but that doesn't work if the segment
995 is packed with code from multiple VMAs.
996 Instead we calculate the section LMA based on
997 the segment LMA. It is assumed that the
998 segment will contain sections with contiguous
999 LMAs, even if the VMAs are not. */
1000 newsect
->lma
= (phdr
->p_paddr
1001 + hdr
->sh_offset
- phdr
->p_offset
);
1003 /* With contiguous segments, we can't tell from file
1004 offsets whether a section with zero size should
1005 be placed at the end of one segment or the
1006 beginning of the next. Decide based on vaddr. */
1007 if (hdr
->sh_addr
>= phdr
->p_vaddr
1008 && (hdr
->sh_addr
+ hdr
->sh_size
1009 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1020 bfd_elf_find_section
1023 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
1026 Helper functions for GDB to locate the string tables.
1027 Since BFD hides string tables from callers, GDB needs to use an
1028 internal hook to find them. Sun's .stabstr, in particular,
1029 isn't even pointed to by the .stab section, so ordinary
1030 mechanisms wouldn't work to find it, even if we had some.
1033 struct elf_internal_shdr
*
1034 bfd_elf_find_section (bfd
*abfd
, char *name
)
1036 Elf_Internal_Shdr
**i_shdrp
;
1041 i_shdrp
= elf_elfsections (abfd
);
1042 if (i_shdrp
!= NULL
)
1044 shstrtab
= bfd_elf_get_str_section (abfd
,
1045 elf_elfheader (abfd
)->e_shstrndx
);
1046 if (shstrtab
!= NULL
)
1048 max
= elf_numsections (abfd
);
1049 for (i
= 1; i
< max
; i
++)
1050 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
1057 const char *const bfd_elf_section_type_names
[] = {
1058 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1059 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1060 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1063 /* ELF relocs are against symbols. If we are producing relocatable
1064 output, and the reloc is against an external symbol, and nothing
1065 has given us any additional addend, the resulting reloc will also
1066 be against the same symbol. In such a case, we don't want to
1067 change anything about the way the reloc is handled, since it will
1068 all be done at final link time. Rather than put special case code
1069 into bfd_perform_relocation, all the reloc types use this howto
1070 function. It just short circuits the reloc if producing
1071 relocatable output against an external symbol. */
1073 bfd_reloc_status_type
1074 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1075 arelent
*reloc_entry
,
1077 void *data ATTRIBUTE_UNUSED
,
1078 asection
*input_section
,
1080 char **error_message ATTRIBUTE_UNUSED
)
1082 if (output_bfd
!= NULL
1083 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1084 && (! reloc_entry
->howto
->partial_inplace
1085 || reloc_entry
->addend
== 0))
1087 reloc_entry
->address
+= input_section
->output_offset
;
1088 return bfd_reloc_ok
;
1091 return bfd_reloc_continue
;
1094 /* Copy the program header and other data from one object module to
1098 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1100 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1101 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1104 BFD_ASSERT (!elf_flags_init (obfd
)
1105 || (elf_elfheader (obfd
)->e_flags
1106 == elf_elfheader (ibfd
)->e_flags
));
1108 elf_gp (obfd
) = elf_gp (ibfd
);
1109 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1110 elf_flags_init (obfd
) = TRUE
;
1112 /* Copy object attributes. */
1113 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1119 get_segment_type (unsigned int p_type
)
1124 case PT_NULL
: pt
= "NULL"; break;
1125 case PT_LOAD
: pt
= "LOAD"; break;
1126 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1127 case PT_INTERP
: pt
= "INTERP"; break;
1128 case PT_NOTE
: pt
= "NOTE"; break;
1129 case PT_SHLIB
: pt
= "SHLIB"; break;
1130 case PT_PHDR
: pt
= "PHDR"; break;
1131 case PT_TLS
: pt
= "TLS"; break;
1132 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1133 case PT_GNU_STACK
: pt
= "STACK"; break;
1134 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1135 default: pt
= NULL
; break;
1140 /* Print out the program headers. */
1143 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1146 Elf_Internal_Phdr
*p
;
1148 bfd_byte
*dynbuf
= NULL
;
1150 p
= elf_tdata (abfd
)->phdr
;
1155 fprintf (f
, _("\nProgram Header:\n"));
1156 c
= elf_elfheader (abfd
)->e_phnum
;
1157 for (i
= 0; i
< c
; i
++, p
++)
1159 const char *pt
= get_segment_type (p
->p_type
);
1164 sprintf (buf
, "0x%lx", p
->p_type
);
1167 fprintf (f
, "%8s off 0x", pt
);
1168 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1169 fprintf (f
, " vaddr 0x");
1170 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1171 fprintf (f
, " paddr 0x");
1172 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1173 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1174 fprintf (f
, " filesz 0x");
1175 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1176 fprintf (f
, " memsz 0x");
1177 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1178 fprintf (f
, " flags %c%c%c",
1179 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1180 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1181 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1182 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1183 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1188 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1191 unsigned int elfsec
;
1192 unsigned long shlink
;
1193 bfd_byte
*extdyn
, *extdynend
;
1195 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1197 fprintf (f
, _("\nDynamic Section:\n"));
1199 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1202 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1203 if (elfsec
== SHN_BAD
)
1205 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1207 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1208 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1211 extdynend
= extdyn
+ s
->size
;
1212 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1214 Elf_Internal_Dyn dyn
;
1215 const char *name
= "";
1217 bfd_boolean stringp
;
1218 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1220 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1222 if (dyn
.d_tag
== DT_NULL
)
1229 if (bed
->elf_backend_get_target_dtag
)
1230 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1232 if (!strcmp (name
, ""))
1234 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1239 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1240 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1241 case DT_PLTGOT
: name
= "PLTGOT"; break;
1242 case DT_HASH
: name
= "HASH"; break;
1243 case DT_STRTAB
: name
= "STRTAB"; break;
1244 case DT_SYMTAB
: name
= "SYMTAB"; break;
1245 case DT_RELA
: name
= "RELA"; break;
1246 case DT_RELASZ
: name
= "RELASZ"; break;
1247 case DT_RELAENT
: name
= "RELAENT"; break;
1248 case DT_STRSZ
: name
= "STRSZ"; break;
1249 case DT_SYMENT
: name
= "SYMENT"; break;
1250 case DT_INIT
: name
= "INIT"; break;
1251 case DT_FINI
: name
= "FINI"; break;
1252 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1253 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1254 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1255 case DT_REL
: name
= "REL"; break;
1256 case DT_RELSZ
: name
= "RELSZ"; break;
1257 case DT_RELENT
: name
= "RELENT"; break;
1258 case DT_PLTREL
: name
= "PLTREL"; break;
1259 case DT_DEBUG
: name
= "DEBUG"; break;
1260 case DT_TEXTREL
: name
= "TEXTREL"; break;
1261 case DT_JMPREL
: name
= "JMPREL"; break;
1262 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1263 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1264 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1265 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1266 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1267 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1268 case DT_FLAGS
: name
= "FLAGS"; break;
1269 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1270 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1271 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1272 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1273 case DT_MOVEENT
: name
= "MOVEENT"; break;
1274 case DT_MOVESZ
: name
= "MOVESZ"; break;
1275 case DT_FEATURE
: name
= "FEATURE"; break;
1276 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1277 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1278 case DT_SYMINENT
: name
= "SYMINENT"; break;
1279 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1280 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1281 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1282 case DT_PLTPAD
: name
= "PLTPAD"; break;
1283 case DT_MOVETAB
: name
= "MOVETAB"; break;
1284 case DT_SYMINFO
: name
= "SYMINFO"; break;
1285 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1286 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1287 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1288 case DT_VERSYM
: name
= "VERSYM"; break;
1289 case DT_VERDEF
: name
= "VERDEF"; break;
1290 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1291 case DT_VERNEED
: name
= "VERNEED"; break;
1292 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1293 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1294 case DT_USED
: name
= "USED"; break;
1295 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1296 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1299 fprintf (f
, " %-20s ", name
);
1303 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1308 unsigned int tagv
= dyn
.d_un
.d_val
;
1310 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1313 fprintf (f
, "%s", string
);
1322 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1323 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1325 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1329 if (elf_dynverdef (abfd
) != 0)
1331 Elf_Internal_Verdef
*t
;
1333 fprintf (f
, _("\nVersion definitions:\n"));
1334 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1336 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1337 t
->vd_flags
, t
->vd_hash
,
1338 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1339 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1341 Elf_Internal_Verdaux
*a
;
1344 for (a
= t
->vd_auxptr
->vda_nextptr
;
1348 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1354 if (elf_dynverref (abfd
) != 0)
1356 Elf_Internal_Verneed
*t
;
1358 fprintf (f
, _("\nVersion References:\n"));
1359 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1361 Elf_Internal_Vernaux
*a
;
1363 fprintf (f
, _(" required from %s:\n"),
1364 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1365 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1366 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1367 a
->vna_flags
, a
->vna_other
,
1368 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1380 /* Display ELF-specific fields of a symbol. */
1383 bfd_elf_print_symbol (bfd
*abfd
,
1386 bfd_print_symbol_type how
)
1391 case bfd_print_symbol_name
:
1392 fprintf (file
, "%s", symbol
->name
);
1394 case bfd_print_symbol_more
:
1395 fprintf (file
, "elf ");
1396 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1397 fprintf (file
, " %lx", (long) symbol
->flags
);
1399 case bfd_print_symbol_all
:
1401 const char *section_name
;
1402 const char *name
= NULL
;
1403 const struct elf_backend_data
*bed
;
1404 unsigned char st_other
;
1407 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1409 bed
= get_elf_backend_data (abfd
);
1410 if (bed
->elf_backend_print_symbol_all
)
1411 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1415 name
= symbol
->name
;
1416 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1419 fprintf (file
, " %s\t", section_name
);
1420 /* Print the "other" value for a symbol. For common symbols,
1421 we've already printed the size; now print the alignment.
1422 For other symbols, we have no specified alignment, and
1423 we've printed the address; now print the size. */
1424 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1425 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1427 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1428 bfd_fprintf_vma (abfd
, file
, val
);
1430 /* If we have version information, print it. */
1431 if (elf_tdata (abfd
)->dynversym_section
!= 0
1432 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1433 || elf_tdata (abfd
)->dynverref_section
!= 0))
1435 unsigned int vernum
;
1436 const char *version_string
;
1438 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1441 version_string
= "";
1442 else if (vernum
== 1)
1443 version_string
= "Base";
1444 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1446 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1449 Elf_Internal_Verneed
*t
;
1451 version_string
= "";
1452 for (t
= elf_tdata (abfd
)->verref
;
1456 Elf_Internal_Vernaux
*a
;
1458 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1460 if (a
->vna_other
== vernum
)
1462 version_string
= a
->vna_nodename
;
1469 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1470 fprintf (file
, " %-11s", version_string
);
1475 fprintf (file
, " (%s)", version_string
);
1476 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1481 /* If the st_other field is not zero, print it. */
1482 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1487 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1488 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1489 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1491 /* Some other non-defined flags are also present, so print
1493 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1496 fprintf (file
, " %s", name
);
1502 /* Allocate an ELF string table--force the first byte to be zero. */
1504 struct bfd_strtab_hash
*
1505 _bfd_elf_stringtab_init (void)
1507 struct bfd_strtab_hash
*ret
;
1509 ret
= _bfd_stringtab_init ();
1514 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1515 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1516 if (loc
== (bfd_size_type
) -1)
1518 _bfd_stringtab_free (ret
);
1525 /* ELF .o/exec file reading */
1527 /* Create a new bfd section from an ELF section header. */
1530 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1532 Elf_Internal_Shdr
*hdr
;
1533 Elf_Internal_Ehdr
*ehdr
;
1534 const struct elf_backend_data
*bed
;
1537 if (shindex
>= elf_numsections (abfd
))
1540 hdr
= elf_elfsections (abfd
)[shindex
];
1541 ehdr
= elf_elfheader (abfd
);
1542 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1547 bed
= get_elf_backend_data (abfd
);
1548 switch (hdr
->sh_type
)
1551 /* Inactive section. Throw it away. */
1554 case SHT_PROGBITS
: /* Normal section with contents. */
1555 case SHT_NOBITS
: /* .bss section. */
1556 case SHT_HASH
: /* .hash section. */
1557 case SHT_NOTE
: /* .note section. */
1558 case SHT_INIT_ARRAY
: /* .init_array section. */
1559 case SHT_FINI_ARRAY
: /* .fini_array section. */
1560 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1561 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1562 case SHT_GNU_HASH
: /* .gnu.hash section. */
1563 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1565 case SHT_DYNAMIC
: /* Dynamic linking information. */
1566 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1568 if (hdr
->sh_link
> elf_numsections (abfd
)
1569 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1571 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1573 Elf_Internal_Shdr
*dynsymhdr
;
1575 /* The shared libraries distributed with hpux11 have a bogus
1576 sh_link field for the ".dynamic" section. Find the
1577 string table for the ".dynsym" section instead. */
1578 if (elf_dynsymtab (abfd
) != 0)
1580 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1581 hdr
->sh_link
= dynsymhdr
->sh_link
;
1585 unsigned int i
, num_sec
;
1587 num_sec
= elf_numsections (abfd
);
1588 for (i
= 1; i
< num_sec
; i
++)
1590 dynsymhdr
= elf_elfsections (abfd
)[i
];
1591 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1593 hdr
->sh_link
= dynsymhdr
->sh_link
;
1601 case SHT_SYMTAB
: /* A symbol table */
1602 if (elf_onesymtab (abfd
) == shindex
)
1605 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1607 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1608 elf_onesymtab (abfd
) = shindex
;
1609 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1610 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1611 abfd
->flags
|= HAS_SYMS
;
1613 /* Sometimes a shared object will map in the symbol table. If
1614 SHF_ALLOC is set, and this is a shared object, then we also
1615 treat this section as a BFD section. We can not base the
1616 decision purely on SHF_ALLOC, because that flag is sometimes
1617 set in a relocatable object file, which would confuse the
1619 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1620 && (abfd
->flags
& DYNAMIC
) != 0
1621 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1625 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1626 can't read symbols without that section loaded as well. It
1627 is most likely specified by the next section header. */
1628 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1630 unsigned int i
, num_sec
;
1632 num_sec
= elf_numsections (abfd
);
1633 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1635 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1636 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1637 && hdr2
->sh_link
== shindex
)
1641 for (i
= 1; i
< shindex
; i
++)
1643 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1644 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1645 && hdr2
->sh_link
== shindex
)
1649 return bfd_section_from_shdr (abfd
, i
);
1653 case SHT_DYNSYM
: /* A dynamic symbol table */
1654 if (elf_dynsymtab (abfd
) == shindex
)
1657 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1659 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1660 elf_dynsymtab (abfd
) = shindex
;
1661 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1662 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1663 abfd
->flags
|= HAS_SYMS
;
1665 /* Besides being a symbol table, we also treat this as a regular
1666 section, so that objcopy can handle it. */
1667 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1669 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1670 if (elf_symtab_shndx (abfd
) == shindex
)
1673 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1674 elf_symtab_shndx (abfd
) = shindex
;
1675 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1676 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1679 case SHT_STRTAB
: /* A string table */
1680 if (hdr
->bfd_section
!= NULL
)
1682 if (ehdr
->e_shstrndx
== shindex
)
1684 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1685 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1688 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1691 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1692 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1695 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1698 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1699 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1700 elf_elfsections (abfd
)[shindex
] = hdr
;
1701 /* We also treat this as a regular section, so that objcopy
1703 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1707 /* If the string table isn't one of the above, then treat it as a
1708 regular section. We need to scan all the headers to be sure,
1709 just in case this strtab section appeared before the above. */
1710 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1712 unsigned int i
, num_sec
;
1714 num_sec
= elf_numsections (abfd
);
1715 for (i
= 1; i
< num_sec
; i
++)
1717 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1718 if (hdr2
->sh_link
== shindex
)
1720 /* Prevent endless recursion on broken objects. */
1723 if (! bfd_section_from_shdr (abfd
, i
))
1725 if (elf_onesymtab (abfd
) == i
)
1727 if (elf_dynsymtab (abfd
) == i
)
1728 goto dynsymtab_strtab
;
1732 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1736 /* *These* do a lot of work -- but build no sections! */
1738 asection
*target_sect
;
1739 Elf_Internal_Shdr
*hdr2
;
1740 unsigned int num_sec
= elf_numsections (abfd
);
1743 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1744 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1747 /* Check for a bogus link to avoid crashing. */
1748 if (hdr
->sh_link
>= num_sec
)
1750 ((*_bfd_error_handler
)
1751 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1752 abfd
, hdr
->sh_link
, name
, shindex
));
1753 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1757 /* For some incomprehensible reason Oracle distributes
1758 libraries for Solaris in which some of the objects have
1759 bogus sh_link fields. It would be nice if we could just
1760 reject them, but, unfortunately, some people need to use
1761 them. We scan through the section headers; if we find only
1762 one suitable symbol table, we clobber the sh_link to point
1763 to it. I hope this doesn't break anything. */
1764 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1765 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1771 for (scan
= 1; scan
< num_sec
; scan
++)
1773 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1774 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1785 hdr
->sh_link
= found
;
1788 /* Get the symbol table. */
1789 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1790 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1791 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1794 /* If this reloc section does not use the main symbol table we
1795 don't treat it as a reloc section. BFD can't adequately
1796 represent such a section, so at least for now, we don't
1797 try. We just present it as a normal section. We also
1798 can't use it as a reloc section if it points to the null
1799 section, an invalid section, or another reloc section. */
1800 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1801 || hdr
->sh_info
== SHN_UNDEF
1802 || hdr
->sh_info
>= num_sec
1803 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1804 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1805 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1808 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1810 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1811 if (target_sect
== NULL
)
1814 if ((target_sect
->flags
& SEC_RELOC
) == 0
1815 || target_sect
->reloc_count
== 0)
1816 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1820 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1821 amt
= sizeof (*hdr2
);
1822 hdr2
= bfd_alloc (abfd
, amt
);
1825 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1828 elf_elfsections (abfd
)[shindex
] = hdr2
;
1829 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1830 target_sect
->flags
|= SEC_RELOC
;
1831 target_sect
->relocation
= NULL
;
1832 target_sect
->rel_filepos
= hdr
->sh_offset
;
1833 /* In the section to which the relocations apply, mark whether
1834 its relocations are of the REL or RELA variety. */
1835 if (hdr
->sh_size
!= 0)
1836 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1837 abfd
->flags
|= HAS_RELOC
;
1841 case SHT_GNU_verdef
:
1842 elf_dynverdef (abfd
) = shindex
;
1843 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1844 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1846 case SHT_GNU_versym
:
1847 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1849 elf_dynversym (abfd
) = shindex
;
1850 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1851 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1853 case SHT_GNU_verneed
:
1854 elf_dynverref (abfd
) = shindex
;
1855 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1856 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1862 /* We need a BFD section for objcopy and relocatable linking,
1863 and it's handy to have the signature available as the section
1865 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1867 name
= group_signature (abfd
, hdr
);
1870 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1872 if (hdr
->contents
!= NULL
)
1874 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1875 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1878 if (idx
->flags
& GRP_COMDAT
)
1879 hdr
->bfd_section
->flags
1880 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1882 /* We try to keep the same section order as it comes in. */
1884 while (--n_elt
!= 0)
1888 if (idx
->shdr
!= NULL
1889 && (s
= idx
->shdr
->bfd_section
) != NULL
1890 && elf_next_in_group (s
) != NULL
)
1892 elf_next_in_group (hdr
->bfd_section
) = s
;
1900 /* Possibly an attributes section. */
1901 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1902 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1904 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1906 _bfd_elf_parse_attributes (abfd
, hdr
);
1910 /* Check for any processor-specific section types. */
1911 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1914 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1916 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1917 /* FIXME: How to properly handle allocated section reserved
1918 for applications? */
1919 (*_bfd_error_handler
)
1920 (_("%B: don't know how to handle allocated, application "
1921 "specific section `%s' [0x%8x]"),
1922 abfd
, name
, hdr
->sh_type
);
1924 /* Allow sections reserved for applications. */
1925 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1928 else if (hdr
->sh_type
>= SHT_LOPROC
1929 && hdr
->sh_type
<= SHT_HIPROC
)
1930 /* FIXME: We should handle this section. */
1931 (*_bfd_error_handler
)
1932 (_("%B: don't know how to handle processor specific section "
1934 abfd
, name
, hdr
->sh_type
);
1935 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1937 /* Unrecognised OS-specific sections. */
1938 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1939 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1940 required to correctly process the section and the file should
1941 be rejected with an error message. */
1942 (*_bfd_error_handler
)
1943 (_("%B: don't know how to handle OS specific section "
1945 abfd
, name
, hdr
->sh_type
);
1947 /* Otherwise it should be processed. */
1948 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1951 /* FIXME: We should handle this section. */
1952 (*_bfd_error_handler
)
1953 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1954 abfd
, name
, hdr
->sh_type
);
1962 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1963 Return SEC for sections that have no elf section, and NULL on error. */
1966 bfd_section_from_r_symndx (bfd
*abfd
,
1967 struct sym_sec_cache
*cache
,
1969 unsigned long r_symndx
)
1971 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1974 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1976 Elf_Internal_Shdr
*symtab_hdr
;
1977 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1978 Elf_External_Sym_Shndx eshndx
;
1979 Elf_Internal_Sym isym
;
1981 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1982 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1983 &isym
, esym
, &eshndx
) == NULL
)
1986 if (cache
->abfd
!= abfd
)
1988 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1991 cache
->indx
[ent
] = r_symndx
;
1992 cache
->shndx
[ent
] = isym
.st_shndx
;
1995 s
= bfd_section_from_elf_index (abfd
, cache
->shndx
[ent
]);
2002 /* Given an ELF section number, retrieve the corresponding BFD
2006 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2008 if (index
>= elf_numsections (abfd
))
2010 return elf_elfsections (abfd
)[index
]->bfd_section
;
2013 static const struct bfd_elf_special_section special_sections_b
[] =
2015 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2016 { NULL
, 0, 0, 0, 0 }
2019 static const struct bfd_elf_special_section special_sections_c
[] =
2021 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2022 { NULL
, 0, 0, 0, 0 }
2025 static const struct bfd_elf_special_section special_sections_d
[] =
2027 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2028 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2029 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2030 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2031 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2032 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2033 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2034 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2035 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2036 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2037 { NULL
, 0, 0, 0, 0 }
2040 static const struct bfd_elf_special_section special_sections_f
[] =
2042 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2043 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2044 { NULL
, 0, 0, 0, 0 }
2047 static const struct bfd_elf_special_section special_sections_g
[] =
2049 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2050 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2051 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2052 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2053 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2054 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2055 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2056 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2057 { NULL
, 0, 0, 0, 0 }
2060 static const struct bfd_elf_special_section special_sections_h
[] =
2062 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2063 { NULL
, 0, 0, 0, 0 }
2066 static const struct bfd_elf_special_section special_sections_i
[] =
2068 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2069 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2070 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2071 { NULL
, 0, 0, 0, 0 }
2074 static const struct bfd_elf_special_section special_sections_l
[] =
2076 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2077 { NULL
, 0, 0, 0, 0 }
2080 static const struct bfd_elf_special_section special_sections_n
[] =
2082 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2083 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2084 { NULL
, 0, 0, 0, 0 }
2087 static const struct bfd_elf_special_section special_sections_p
[] =
2089 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2090 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2091 { NULL
, 0, 0, 0, 0 }
2094 static const struct bfd_elf_special_section special_sections_r
[] =
2096 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2097 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2098 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2099 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2100 { NULL
, 0, 0, 0, 0 }
2103 static const struct bfd_elf_special_section special_sections_s
[] =
2105 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2106 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2107 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2108 /* See struct bfd_elf_special_section declaration for the semantics of
2109 this special case where .prefix_length != strlen (.prefix). */
2110 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2111 { NULL
, 0, 0, 0, 0 }
2114 static const struct bfd_elf_special_section special_sections_t
[] =
2116 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2117 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2118 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2119 { NULL
, 0, 0, 0, 0 }
2122 static const struct bfd_elf_special_section
*special_sections
[] =
2124 special_sections_b
, /* 'b' */
2125 special_sections_c
, /* 'c' */
2126 special_sections_d
, /* 'd' */
2128 special_sections_f
, /* 'f' */
2129 special_sections_g
, /* 'g' */
2130 special_sections_h
, /* 'h' */
2131 special_sections_i
, /* 'i' */
2134 special_sections_l
, /* 'l' */
2136 special_sections_n
, /* 'n' */
2138 special_sections_p
, /* 'p' */
2140 special_sections_r
, /* 'r' */
2141 special_sections_s
, /* 's' */
2142 special_sections_t
, /* 't' */
2145 const struct bfd_elf_special_section
*
2146 _bfd_elf_get_special_section (const char *name
,
2147 const struct bfd_elf_special_section
*spec
,
2153 len
= strlen (name
);
2155 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2158 int prefix_len
= spec
[i
].prefix_length
;
2160 if (len
< prefix_len
)
2162 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2165 suffix_len
= spec
[i
].suffix_length
;
2166 if (suffix_len
<= 0)
2168 if (name
[prefix_len
] != 0)
2170 if (suffix_len
== 0)
2172 if (name
[prefix_len
] != '.'
2173 && (suffix_len
== -2
2174 || (rela
&& spec
[i
].type
== SHT_REL
)))
2180 if (len
< prefix_len
+ suffix_len
)
2182 if (memcmp (name
+ len
- suffix_len
,
2183 spec
[i
].prefix
+ prefix_len
,
2193 const struct bfd_elf_special_section
*
2194 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2197 const struct bfd_elf_special_section
*spec
;
2198 const struct elf_backend_data
*bed
;
2200 /* See if this is one of the special sections. */
2201 if (sec
->name
== NULL
)
2204 bed
= get_elf_backend_data (abfd
);
2205 spec
= bed
->special_sections
;
2208 spec
= _bfd_elf_get_special_section (sec
->name
,
2209 bed
->special_sections
,
2215 if (sec
->name
[0] != '.')
2218 i
= sec
->name
[1] - 'b';
2219 if (i
< 0 || i
> 't' - 'b')
2222 spec
= special_sections
[i
];
2227 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2231 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2233 struct bfd_elf_section_data
*sdata
;
2234 const struct elf_backend_data
*bed
;
2235 const struct bfd_elf_special_section
*ssect
;
2237 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2240 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2243 sec
->used_by_bfd
= sdata
;
2246 /* Indicate whether or not this section should use RELA relocations. */
2247 bed
= get_elf_backend_data (abfd
);
2248 sec
->use_rela_p
= bed
->default_use_rela_p
;
2250 /* When we read a file, we don't need to set ELF section type and
2251 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2252 anyway. We will set ELF section type and flags for all linker
2253 created sections. If user specifies BFD section flags, we will
2254 set ELF section type and flags based on BFD section flags in
2255 elf_fake_sections. */
2256 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2257 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2259 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2262 elf_section_type (sec
) = ssect
->type
;
2263 elf_section_flags (sec
) = ssect
->attr
;
2267 return _bfd_generic_new_section_hook (abfd
, sec
);
2270 /* Create a new bfd section from an ELF program header.
2272 Since program segments have no names, we generate a synthetic name
2273 of the form segment<NUM>, where NUM is generally the index in the
2274 program header table. For segments that are split (see below) we
2275 generate the names segment<NUM>a and segment<NUM>b.
2277 Note that some program segments may have a file size that is different than
2278 (less than) the memory size. All this means is that at execution the
2279 system must allocate the amount of memory specified by the memory size,
2280 but only initialize it with the first "file size" bytes read from the
2281 file. This would occur for example, with program segments consisting
2282 of combined data+bss.
2284 To handle the above situation, this routine generates TWO bfd sections
2285 for the single program segment. The first has the length specified by
2286 the file size of the segment, and the second has the length specified
2287 by the difference between the two sizes. In effect, the segment is split
2288 into its initialized and uninitialized parts.
2293 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2294 Elf_Internal_Phdr
*hdr
,
2296 const char *typename
)
2304 split
= ((hdr
->p_memsz
> 0)
2305 && (hdr
->p_filesz
> 0)
2306 && (hdr
->p_memsz
> hdr
->p_filesz
));
2308 if (hdr
->p_filesz
> 0)
2310 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
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
;
2320 newsect
->lma
= hdr
->p_paddr
;
2321 newsect
->size
= hdr
->p_filesz
;
2322 newsect
->filepos
= hdr
->p_offset
;
2323 newsect
->flags
|= SEC_HAS_CONTENTS
;
2324 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2325 if (hdr
->p_type
== PT_LOAD
)
2327 newsect
->flags
|= SEC_ALLOC
;
2328 newsect
->flags
|= SEC_LOAD
;
2329 if (hdr
->p_flags
& PF_X
)
2331 /* FIXME: all we known is that it has execute PERMISSION,
2333 newsect
->flags
|= SEC_CODE
;
2336 if (!(hdr
->p_flags
& PF_W
))
2338 newsect
->flags
|= SEC_READONLY
;
2342 if (hdr
->p_memsz
> hdr
->p_filesz
)
2346 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "b" : "");
2347 len
= strlen (namebuf
) + 1;
2348 name
= bfd_alloc (abfd
, len
);
2351 memcpy (name
, namebuf
, len
);
2352 newsect
= bfd_make_section (abfd
, name
);
2353 if (newsect
== NULL
)
2355 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2356 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2357 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2358 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2359 align
= newsect
->vma
& -newsect
->vma
;
2360 if (align
== 0 || align
> hdr
->p_align
)
2361 align
= hdr
->p_align
;
2362 newsect
->alignment_power
= bfd_log2 (align
);
2363 if (hdr
->p_type
== PT_LOAD
)
2365 /* Hack for gdb. Segments that have not been modified do
2366 not have their contents written to a core file, on the
2367 assumption that a debugger can find the contents in the
2368 executable. We flag this case by setting the fake
2369 section size to zero. Note that "real" bss sections will
2370 always have their contents dumped to the core file. */
2371 if (bfd_get_format (abfd
) == bfd_core
)
2373 newsect
->flags
|= SEC_ALLOC
;
2374 if (hdr
->p_flags
& PF_X
)
2375 newsect
->flags
|= SEC_CODE
;
2377 if (!(hdr
->p_flags
& PF_W
))
2378 newsect
->flags
|= SEC_READONLY
;
2385 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2387 const struct elf_backend_data
*bed
;
2389 switch (hdr
->p_type
)
2392 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2395 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2398 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2401 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2404 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2406 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2411 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2414 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2416 case PT_GNU_EH_FRAME
:
2417 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2421 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2424 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2427 /* Check for any processor-specific program segment types. */
2428 bed
= get_elf_backend_data (abfd
);
2429 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2433 /* Initialize REL_HDR, the section-header for new section, containing
2434 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2435 relocations; otherwise, we use REL relocations. */
2438 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2439 Elf_Internal_Shdr
*rel_hdr
,
2441 bfd_boolean use_rela_p
)
2444 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2445 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2447 name
= bfd_alloc (abfd
, amt
);
2450 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2452 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2454 if (rel_hdr
->sh_name
== (unsigned int) -1)
2456 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2457 rel_hdr
->sh_entsize
= (use_rela_p
2458 ? bed
->s
->sizeof_rela
2459 : bed
->s
->sizeof_rel
);
2460 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2461 rel_hdr
->sh_flags
= 0;
2462 rel_hdr
->sh_addr
= 0;
2463 rel_hdr
->sh_size
= 0;
2464 rel_hdr
->sh_offset
= 0;
2469 /* Set up an ELF internal section header for a section. */
2472 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2474 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2475 bfd_boolean
*failedptr
= failedptrarg
;
2476 Elf_Internal_Shdr
*this_hdr
;
2477 unsigned int sh_type
;
2481 /* We already failed; just get out of the bfd_map_over_sections
2486 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2488 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2489 asect
->name
, FALSE
);
2490 if (this_hdr
->sh_name
== (unsigned int) -1)
2496 /* Don't clear sh_flags. Assembler may set additional bits. */
2498 if ((asect
->flags
& SEC_ALLOC
) != 0
2499 || asect
->user_set_vma
)
2500 this_hdr
->sh_addr
= asect
->vma
;
2502 this_hdr
->sh_addr
= 0;
2504 this_hdr
->sh_offset
= 0;
2505 this_hdr
->sh_size
= asect
->size
;
2506 this_hdr
->sh_link
= 0;
2507 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2508 /* The sh_entsize and sh_info fields may have been set already by
2509 copy_private_section_data. */
2511 this_hdr
->bfd_section
= asect
;
2512 this_hdr
->contents
= NULL
;
2514 /* If the section type is unspecified, we set it based on
2516 if ((asect
->flags
& SEC_GROUP
) != 0)
2517 sh_type
= SHT_GROUP
;
2518 else if ((asect
->flags
& SEC_ALLOC
) != 0
2519 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2520 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2521 sh_type
= SHT_NOBITS
;
2523 sh_type
= SHT_PROGBITS
;
2525 if (this_hdr
->sh_type
== SHT_NULL
)
2526 this_hdr
->sh_type
= sh_type
;
2527 else if (this_hdr
->sh_type
== SHT_NOBITS
2528 && sh_type
== SHT_PROGBITS
2529 && (asect
->flags
& SEC_ALLOC
) != 0)
2531 /* Warn if we are changing a NOBITS section to PROGBITS, but
2532 allow the link to proceed. This can happen when users link
2533 non-bss input sections to bss output sections, or emit data
2534 to a bss output section via a linker script. */
2535 (*_bfd_error_handler
)
2536 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2537 this_hdr
->sh_type
= sh_type
;
2540 switch (this_hdr
->sh_type
)
2546 case SHT_INIT_ARRAY
:
2547 case SHT_FINI_ARRAY
:
2548 case SHT_PREINIT_ARRAY
:
2555 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2559 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2563 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2567 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2568 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2572 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2573 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2576 case SHT_GNU_versym
:
2577 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2580 case SHT_GNU_verdef
:
2581 this_hdr
->sh_entsize
= 0;
2582 /* objcopy or strip will copy over sh_info, but may not set
2583 cverdefs. The linker will set cverdefs, but sh_info will be
2585 if (this_hdr
->sh_info
== 0)
2586 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2588 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2589 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2592 case SHT_GNU_verneed
:
2593 this_hdr
->sh_entsize
= 0;
2594 /* objcopy or strip will copy over sh_info, but may not set
2595 cverrefs. The linker will set cverrefs, but sh_info will be
2597 if (this_hdr
->sh_info
== 0)
2598 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2600 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2601 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2605 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2609 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2613 if ((asect
->flags
& SEC_ALLOC
) != 0)
2614 this_hdr
->sh_flags
|= SHF_ALLOC
;
2615 if ((asect
->flags
& SEC_READONLY
) == 0)
2616 this_hdr
->sh_flags
|= SHF_WRITE
;
2617 if ((asect
->flags
& SEC_CODE
) != 0)
2618 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2619 if ((asect
->flags
& SEC_MERGE
) != 0)
2621 this_hdr
->sh_flags
|= SHF_MERGE
;
2622 this_hdr
->sh_entsize
= asect
->entsize
;
2623 if ((asect
->flags
& SEC_STRINGS
) != 0)
2624 this_hdr
->sh_flags
|= SHF_STRINGS
;
2626 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2627 this_hdr
->sh_flags
|= SHF_GROUP
;
2628 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2630 this_hdr
->sh_flags
|= SHF_TLS
;
2631 if (asect
->size
== 0
2632 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2634 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2636 this_hdr
->sh_size
= 0;
2639 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2640 if (this_hdr
->sh_size
!= 0)
2641 this_hdr
->sh_type
= SHT_NOBITS
;
2646 /* Check for processor-specific section types. */
2647 sh_type
= this_hdr
->sh_type
;
2648 if (bed
->elf_backend_fake_sections
2649 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2652 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2654 /* Don't change the header type from NOBITS if we are being
2655 called for objcopy --only-keep-debug. */
2656 this_hdr
->sh_type
= sh_type
;
2659 /* If the section has relocs, set up a section header for the
2660 SHT_REL[A] section. If two relocation sections are required for
2661 this section, it is up to the processor-specific back-end to
2662 create the other. */
2663 if ((asect
->flags
& SEC_RELOC
) != 0
2664 && !_bfd_elf_init_reloc_shdr (abfd
,
2665 &elf_section_data (asect
)->rel_hdr
,
2671 /* Fill in the contents of a SHT_GROUP section. */
2674 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2676 bfd_boolean
*failedptr
= failedptrarg
;
2677 unsigned long symindx
;
2678 asection
*elt
, *first
;
2682 /* Ignore linker created group section. See elfNN_ia64_object_p in
2684 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2689 if (elf_group_id (sec
) != NULL
)
2690 symindx
= elf_group_id (sec
)->udata
.i
;
2694 /* If called from the assembler, swap_out_syms will have set up
2695 elf_section_syms; If called for "ld -r", use target_index. */
2696 if (elf_section_syms (abfd
) != NULL
)
2697 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2699 symindx
= sec
->target_index
;
2701 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2703 /* The contents won't be allocated for "ld -r" or objcopy. */
2705 if (sec
->contents
== NULL
)
2708 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2710 /* Arrange for the section to be written out. */
2711 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2712 if (sec
->contents
== NULL
)
2719 loc
= sec
->contents
+ sec
->size
;
2721 /* Get the pointer to the first section in the group that gas
2722 squirreled away here. objcopy arranges for this to be set to the
2723 start of the input section group. */
2724 first
= elt
= elf_next_in_group (sec
);
2726 /* First element is a flag word. Rest of section is elf section
2727 indices for all the sections of the group. Write them backwards
2728 just to keep the group in the same order as given in .section
2729 directives, not that it matters. */
2738 s
= s
->output_section
;
2741 idx
= elf_section_data (s
)->this_idx
;
2742 H_PUT_32 (abfd
, idx
, loc
);
2743 elt
= elf_next_in_group (elt
);
2748 if ((loc
-= 4) != sec
->contents
)
2751 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2754 /* Assign all ELF section numbers. The dummy first section is handled here
2755 too. The link/info pointers for the standard section types are filled
2756 in here too, while we're at it. */
2759 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2761 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2763 unsigned int section_number
, secn
;
2764 Elf_Internal_Shdr
**i_shdrp
;
2765 struct bfd_elf_section_data
*d
;
2769 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2771 /* SHT_GROUP sections are in relocatable files only. */
2772 if (link_info
== NULL
|| link_info
->relocatable
)
2774 /* Put SHT_GROUP sections first. */
2775 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2777 d
= elf_section_data (sec
);
2779 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2781 if (sec
->flags
& SEC_LINKER_CREATED
)
2783 /* Remove the linker created SHT_GROUP sections. */
2784 bfd_section_list_remove (abfd
, sec
);
2785 abfd
->section_count
--;
2788 d
->this_idx
= section_number
++;
2793 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2795 d
= elf_section_data (sec
);
2797 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2798 d
->this_idx
= section_number
++;
2799 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2800 if ((sec
->flags
& SEC_RELOC
) == 0)
2804 d
->rel_idx
= section_number
++;
2805 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2810 d
->rel_idx2
= section_number
++;
2811 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2817 t
->shstrtab_section
= section_number
++;
2818 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2819 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2821 if (bfd_get_symcount (abfd
) > 0)
2823 t
->symtab_section
= section_number
++;
2824 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2825 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
2827 t
->symtab_shndx_section
= section_number
++;
2828 t
->symtab_shndx_hdr
.sh_name
2829 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2830 ".symtab_shndx", FALSE
);
2831 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2834 t
->strtab_section
= section_number
++;
2835 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2838 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2839 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2841 elf_numsections (abfd
) = section_number
;
2842 elf_elfheader (abfd
)->e_shnum
= section_number
;
2844 /* Set up the list of section header pointers, in agreement with the
2846 i_shdrp
= bfd_zalloc2 (abfd
, section_number
, sizeof (Elf_Internal_Shdr
*));
2847 if (i_shdrp
== NULL
)
2850 i_shdrp
[0] = bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2851 if (i_shdrp
[0] == NULL
)
2853 bfd_release (abfd
, i_shdrp
);
2857 elf_elfsections (abfd
) = i_shdrp
;
2859 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2860 if (bfd_get_symcount (abfd
) > 0)
2862 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2863 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
2865 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2866 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2868 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2869 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2872 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2874 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2878 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2879 if (d
->rel_idx
!= 0)
2880 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2881 if (d
->rel_idx2
!= 0)
2882 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2884 /* Fill in the sh_link and sh_info fields while we're at it. */
2886 /* sh_link of a reloc section is the section index of the symbol
2887 table. sh_info is the section index of the section to which
2888 the relocation entries apply. */
2889 if (d
->rel_idx
!= 0)
2891 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2892 d
->rel_hdr
.sh_info
= d
->this_idx
;
2894 if (d
->rel_idx2
!= 0)
2896 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2897 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2900 /* We need to set up sh_link for SHF_LINK_ORDER. */
2901 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2903 s
= elf_linked_to_section (sec
);
2906 /* elf_linked_to_section points to the input section. */
2907 if (link_info
!= NULL
)
2909 /* Check discarded linkonce section. */
2910 if (elf_discarded_section (s
))
2913 (*_bfd_error_handler
)
2914 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2915 abfd
, d
->this_hdr
.bfd_section
,
2917 /* Point to the kept section if it has the same
2918 size as the discarded one. */
2919 kept
= _bfd_elf_check_kept_section (s
, link_info
);
2922 bfd_set_error (bfd_error_bad_value
);
2928 s
= s
->output_section
;
2929 BFD_ASSERT (s
!= NULL
);
2933 /* Handle objcopy. */
2934 if (s
->output_section
== NULL
)
2936 (*_bfd_error_handler
)
2937 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2938 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
2939 bfd_set_error (bfd_error_bad_value
);
2942 s
= s
->output_section
;
2944 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2949 The Intel C compiler generates SHT_IA_64_UNWIND with
2950 SHF_LINK_ORDER. But it doesn't set the sh_link or
2951 sh_info fields. Hence we could get the situation
2953 const struct elf_backend_data
*bed
2954 = get_elf_backend_data (abfd
);
2955 if (bed
->link_order_error_handler
)
2956 bed
->link_order_error_handler
2957 (_("%B: warning: sh_link not set for section `%A'"),
2962 switch (d
->this_hdr
.sh_type
)
2966 /* A reloc section which we are treating as a normal BFD
2967 section. sh_link is the section index of the symbol
2968 table. sh_info is the section index of the section to
2969 which the relocation entries apply. We assume that an
2970 allocated reloc section uses the dynamic symbol table.
2971 FIXME: How can we be sure? */
2972 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2974 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2976 /* We look up the section the relocs apply to by name. */
2978 if (d
->this_hdr
.sh_type
== SHT_REL
)
2982 s
= bfd_get_section_by_name (abfd
, name
);
2984 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2988 /* We assume that a section named .stab*str is a stabs
2989 string section. We look for a section with the same name
2990 but without the trailing ``str'', and set its sh_link
2991 field to point to this section. */
2992 if (CONST_STRNEQ (sec
->name
, ".stab")
2993 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2998 len
= strlen (sec
->name
);
2999 alc
= bfd_malloc (len
- 2);
3002 memcpy (alc
, sec
->name
, len
- 3);
3003 alc
[len
- 3] = '\0';
3004 s
= bfd_get_section_by_name (abfd
, alc
);
3008 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3010 /* This is a .stab section. */
3011 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3012 elf_section_data (s
)->this_hdr
.sh_entsize
3013 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3020 case SHT_GNU_verneed
:
3021 case SHT_GNU_verdef
:
3022 /* sh_link is the section header index of the string table
3023 used for the dynamic entries, or the symbol table, or the
3025 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3027 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3030 case SHT_GNU_LIBLIST
:
3031 /* sh_link is the section header index of the prelink library
3032 list used for the dynamic entries, or the symbol table, or
3033 the version strings. */
3034 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3035 ? ".dynstr" : ".gnu.libstr");
3037 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3042 case SHT_GNU_versym
:
3043 /* sh_link is the section header index of the symbol table
3044 this hash table or version table is for. */
3045 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3047 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3051 d
->this_hdr
.sh_link
= t
->symtab_section
;
3055 for (secn
= 1; secn
< section_number
; ++secn
)
3056 if (i_shdrp
[secn
] == NULL
)
3057 i_shdrp
[secn
] = i_shdrp
[0];
3059 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3060 i_shdrp
[secn
]->sh_name
);
3064 /* Map symbol from it's internal number to the external number, moving
3065 all local symbols to be at the head of the list. */
3068 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3070 /* If the backend has a special mapping, use it. */
3071 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3072 if (bed
->elf_backend_sym_is_global
)
3073 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3075 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3076 || bfd_is_und_section (bfd_get_section (sym
))
3077 || bfd_is_com_section (bfd_get_section (sym
)));
3080 /* Don't output section symbols for sections that are not going to be
3081 output. Also, don't output section symbols for reloc and other
3082 special sections. */
3085 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3087 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3089 || (sym
->section
->owner
!= abfd
3090 && (sym
->section
->output_section
->owner
!= abfd
3091 || sym
->section
->output_offset
!= 0))));
3095 elf_map_symbols (bfd
*abfd
)
3097 unsigned int symcount
= bfd_get_symcount (abfd
);
3098 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3099 asymbol
**sect_syms
;
3100 unsigned int num_locals
= 0;
3101 unsigned int num_globals
= 0;
3102 unsigned int num_locals2
= 0;
3103 unsigned int num_globals2
= 0;
3110 fprintf (stderr
, "elf_map_symbols\n");
3114 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3116 if (max_index
< asect
->index
)
3117 max_index
= asect
->index
;
3121 sect_syms
= bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3122 if (sect_syms
== NULL
)
3124 elf_section_syms (abfd
) = sect_syms
;
3125 elf_num_section_syms (abfd
) = max_index
;
3127 /* Init sect_syms entries for any section symbols we have already
3128 decided to output. */
3129 for (idx
= 0; idx
< symcount
; idx
++)
3131 asymbol
*sym
= syms
[idx
];
3133 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3134 && !ignore_section_sym (abfd
, sym
))
3136 asection
*sec
= sym
->section
;
3138 if (sec
->owner
!= abfd
)
3139 sec
= sec
->output_section
;
3141 sect_syms
[sec
->index
] = syms
[idx
];
3145 /* Classify all of the symbols. */
3146 for (idx
= 0; idx
< symcount
; idx
++)
3148 if (ignore_section_sym (abfd
, syms
[idx
]))
3150 if (!sym_is_global (abfd
, syms
[idx
]))
3156 /* We will be adding a section symbol for each normal BFD section. Most
3157 sections will already have a section symbol in outsymbols, but
3158 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3159 at least in that case. */
3160 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3162 if (sect_syms
[asect
->index
] == NULL
)
3164 if (!sym_is_global (abfd
, asect
->symbol
))
3171 /* Now sort the symbols so the local symbols are first. */
3172 new_syms
= bfd_alloc2 (abfd
, num_locals
+ num_globals
, sizeof (asymbol
*));
3174 if (new_syms
== NULL
)
3177 for (idx
= 0; idx
< symcount
; idx
++)
3179 asymbol
*sym
= syms
[idx
];
3182 if (ignore_section_sym (abfd
, sym
))
3184 if (!sym_is_global (abfd
, sym
))
3187 i
= num_locals
+ num_globals2
++;
3189 sym
->udata
.i
= i
+ 1;
3191 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3193 if (sect_syms
[asect
->index
] == NULL
)
3195 asymbol
*sym
= asect
->symbol
;
3198 sect_syms
[asect
->index
] = sym
;
3199 if (!sym_is_global (abfd
, sym
))
3202 i
= num_locals
+ num_globals2
++;
3204 sym
->udata
.i
= i
+ 1;
3208 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3210 elf_num_locals (abfd
) = num_locals
;
3211 elf_num_globals (abfd
) = num_globals
;
3215 /* Align to the maximum file alignment that could be required for any
3216 ELF data structure. */
3218 static inline file_ptr
3219 align_file_position (file_ptr off
, int align
)
3221 return (off
+ align
- 1) & ~(align
- 1);
3224 /* Assign a file position to a section, optionally aligning to the
3225 required section alignment. */
3228 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3232 if (align
&& i_shdrp
->sh_addralign
> 1)
3233 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3234 i_shdrp
->sh_offset
= offset
;
3235 if (i_shdrp
->bfd_section
!= NULL
)
3236 i_shdrp
->bfd_section
->filepos
= offset
;
3237 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3238 offset
+= i_shdrp
->sh_size
;
3242 /* Compute the file positions we are going to put the sections at, and
3243 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3244 is not NULL, this is being called by the ELF backend linker. */
3247 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3248 struct bfd_link_info
*link_info
)
3250 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3252 struct bfd_strtab_hash
*strtab
= NULL
;
3253 Elf_Internal_Shdr
*shstrtab_hdr
;
3255 if (abfd
->output_has_begun
)
3258 /* Do any elf backend specific processing first. */
3259 if (bed
->elf_backend_begin_write_processing
)
3260 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3262 if (! prep_headers (abfd
))
3265 /* Post process the headers if necessary. */
3266 if (bed
->elf_backend_post_process_headers
)
3267 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3270 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3274 if (!assign_section_numbers (abfd
, link_info
))
3277 /* The backend linker builds symbol table information itself. */
3278 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3280 /* Non-zero if doing a relocatable link. */
3281 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3283 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3287 if (link_info
== NULL
)
3289 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3294 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3295 /* sh_name was set in prep_headers. */
3296 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3297 shstrtab_hdr
->sh_flags
= 0;
3298 shstrtab_hdr
->sh_addr
= 0;
3299 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3300 shstrtab_hdr
->sh_entsize
= 0;
3301 shstrtab_hdr
->sh_link
= 0;
3302 shstrtab_hdr
->sh_info
= 0;
3303 /* sh_offset is set in assign_file_positions_except_relocs. */
3304 shstrtab_hdr
->sh_addralign
= 1;
3306 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3309 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3312 Elf_Internal_Shdr
*hdr
;
3314 off
= elf_tdata (abfd
)->next_file_pos
;
3316 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3317 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3319 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3320 if (hdr
->sh_size
!= 0)
3321 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3323 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3324 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3326 elf_tdata (abfd
)->next_file_pos
= off
;
3328 /* Now that we know where the .strtab section goes, write it
3330 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3331 || ! _bfd_stringtab_emit (abfd
, strtab
))
3333 _bfd_stringtab_free (strtab
);
3336 abfd
->output_has_begun
= TRUE
;
3341 /* Make an initial estimate of the size of the program header. If we
3342 get the number wrong here, we'll redo section placement. */
3344 static bfd_size_type
3345 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3349 const struct elf_backend_data
*bed
;
3351 /* Assume we will need exactly two PT_LOAD segments: one for text
3352 and one for data. */
3355 s
= bfd_get_section_by_name (abfd
, ".interp");
3356 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3358 /* If we have a loadable interpreter section, we need a
3359 PT_INTERP segment. In this case, assume we also need a
3360 PT_PHDR segment, although that may not be true for all
3365 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3367 /* We need a PT_DYNAMIC segment. */
3373 /* We need a PT_GNU_RELRO segment. */
3377 if (elf_tdata (abfd
)->eh_frame_hdr
)
3379 /* We need a PT_GNU_EH_FRAME segment. */
3383 if (elf_tdata (abfd
)->stack_flags
)
3385 /* We need a PT_GNU_STACK segment. */
3389 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3391 if ((s
->flags
& SEC_LOAD
) != 0
3392 && CONST_STRNEQ (s
->name
, ".note"))
3394 /* We need a PT_NOTE segment. */
3396 /* Try to create just one PT_NOTE segment
3397 for all adjacent loadable .note* sections.
3398 gABI requires that within a PT_NOTE segment
3399 (and also inside of each SHT_NOTE section)
3400 each note is padded to a multiple of 4 size,
3401 so we check whether the sections are correctly
3403 if (s
->alignment_power
== 2)
3404 while (s
->next
!= NULL
3405 && s
->next
->alignment_power
== 2
3406 && (s
->next
->flags
& SEC_LOAD
) != 0
3407 && CONST_STRNEQ (s
->next
->name
, ".note"))
3412 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3414 if (s
->flags
& SEC_THREAD_LOCAL
)
3416 /* We need a PT_TLS segment. */
3422 /* Let the backend count up any program headers it might need. */
3423 bed
= get_elf_backend_data (abfd
);
3424 if (bed
->elf_backend_additional_program_headers
)
3428 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3434 return segs
* bed
->s
->sizeof_phdr
;
3437 /* Find the segment that contains the output_section of section. */
3440 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3442 struct elf_segment_map
*m
;
3443 Elf_Internal_Phdr
*p
;
3445 for (m
= elf_tdata (abfd
)->segment_map
,
3446 p
= elf_tdata (abfd
)->phdr
;
3452 for (i
= m
->count
- 1; i
>= 0; i
--)
3453 if (m
->sections
[i
] == section
)
3460 /* Create a mapping from a set of sections to a program segment. */
3462 static struct elf_segment_map
*
3463 make_mapping (bfd
*abfd
,
3464 asection
**sections
,
3469 struct elf_segment_map
*m
;
3474 amt
= sizeof (struct elf_segment_map
);
3475 amt
+= (to
- from
- 1) * sizeof (asection
*);
3476 m
= bfd_zalloc (abfd
, amt
);
3480 m
->p_type
= PT_LOAD
;
3481 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3482 m
->sections
[i
- from
] = *hdrpp
;
3483 m
->count
= to
- from
;
3485 if (from
== 0 && phdr
)
3487 /* Include the headers in the first PT_LOAD segment. */
3488 m
->includes_filehdr
= 1;
3489 m
->includes_phdrs
= 1;
3495 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3498 struct elf_segment_map
*
3499 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3501 struct elf_segment_map
*m
;
3503 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3507 m
->p_type
= PT_DYNAMIC
;
3509 m
->sections
[0] = dynsec
;
3514 /* Possibly add or remove segments from the segment map. */
3517 elf_modify_segment_map (bfd
*abfd
,
3518 struct bfd_link_info
*info
,
3519 bfd_boolean remove_empty_load
)
3521 struct elf_segment_map
**m
;
3522 const struct elf_backend_data
*bed
;
3524 /* The placement algorithm assumes that non allocated sections are
3525 not in PT_LOAD segments. We ensure this here by removing such
3526 sections from the segment map. We also remove excluded
3527 sections. Finally, any PT_LOAD segment without sections is
3529 m
= &elf_tdata (abfd
)->segment_map
;
3532 unsigned int i
, new_count
;
3534 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3536 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3537 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3538 || (*m
)->p_type
!= PT_LOAD
))
3540 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3544 (*m
)->count
= new_count
;
3546 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3552 bed
= get_elf_backend_data (abfd
);
3553 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3555 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3562 /* Set up a mapping from BFD sections to program segments. */
3565 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3568 struct elf_segment_map
*m
;
3569 asection
**sections
= NULL
;
3570 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3571 bfd_boolean no_user_phdrs
;
3573 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3574 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3578 struct elf_segment_map
*mfirst
;
3579 struct elf_segment_map
**pm
;
3582 unsigned int phdr_index
;
3583 bfd_vma maxpagesize
;
3585 bfd_boolean phdr_in_segment
= TRUE
;
3586 bfd_boolean writable
;
3588 asection
*first_tls
= NULL
;
3589 asection
*dynsec
, *eh_frame_hdr
;
3592 /* Select the allocated sections, and sort them. */
3594 sections
= bfd_malloc2 (bfd_count_sections (abfd
), sizeof (asection
*));
3595 if (sections
== NULL
)
3599 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3601 if ((s
->flags
& SEC_ALLOC
) != 0)
3607 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3610 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3612 /* Build the mapping. */
3617 /* If we have a .interp section, then create a PT_PHDR segment for
3618 the program headers and a PT_INTERP segment for the .interp
3620 s
= bfd_get_section_by_name (abfd
, ".interp");
3621 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3623 amt
= sizeof (struct elf_segment_map
);
3624 m
= bfd_zalloc (abfd
, amt
);
3628 m
->p_type
= PT_PHDR
;
3629 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3630 m
->p_flags
= PF_R
| PF_X
;
3631 m
->p_flags_valid
= 1;
3632 m
->includes_phdrs
= 1;
3637 amt
= sizeof (struct elf_segment_map
);
3638 m
= bfd_zalloc (abfd
, amt
);
3642 m
->p_type
= PT_INTERP
;
3650 /* Look through the sections. We put sections in the same program
3651 segment when the start of the second section can be placed within
3652 a few bytes of the end of the first section. */
3656 maxpagesize
= bed
->maxpagesize
;
3658 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3660 && (dynsec
->flags
& SEC_LOAD
) == 0)
3663 /* Deal with -Ttext or something similar such that the first section
3664 is not adjacent to the program headers. This is an
3665 approximation, since at this point we don't know exactly how many
3666 program headers we will need. */
3669 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3671 if (phdr_size
== (bfd_size_type
) -1)
3672 phdr_size
= get_program_header_size (abfd
, info
);
3673 if ((abfd
->flags
& D_PAGED
) == 0
3674 || sections
[0]->lma
< phdr_size
3675 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3676 phdr_in_segment
= FALSE
;
3679 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3682 bfd_boolean new_segment
;
3686 /* See if this section and the last one will fit in the same
3689 if (last_hdr
== NULL
)
3691 /* If we don't have a segment yet, then we don't need a new
3692 one (we build the last one after this loop). */
3693 new_segment
= FALSE
;
3695 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3697 /* If this section has a different relation between the
3698 virtual address and the load address, then we need a new
3702 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3703 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3705 /* If putting this section in this segment would force us to
3706 skip a page in the segment, then we need a new segment. */
3709 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3710 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3712 /* We don't want to put a loadable section after a
3713 nonloadable section in the same segment.
3714 Consider .tbss sections as loadable for this purpose. */
3717 else if ((abfd
->flags
& D_PAGED
) == 0)
3719 /* If the file is not demand paged, which means that we
3720 don't require the sections to be correctly aligned in the
3721 file, then there is no other reason for a new segment. */
3722 new_segment
= FALSE
;
3725 && (hdr
->flags
& SEC_READONLY
) == 0
3726 && (((last_hdr
->lma
+ last_size
- 1)
3727 & ~(maxpagesize
- 1))
3728 != (hdr
->lma
& ~(maxpagesize
- 1))))
3730 /* We don't want to put a writable section in a read only
3731 segment, unless they are on the same page in memory
3732 anyhow. We already know that the last section does not
3733 bring us past the current section on the page, so the
3734 only case in which the new section is not on the same
3735 page as the previous section is when the previous section
3736 ends precisely on a page boundary. */
3741 /* Otherwise, we can use the same segment. */
3742 new_segment
= FALSE
;
3745 /* Allow interested parties a chance to override our decision. */
3746 if (last_hdr
&& info
->callbacks
->override_segment_assignment
)
3747 new_segment
= info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
, last_hdr
, new_segment
);
3751 if ((hdr
->flags
& SEC_READONLY
) == 0)
3754 /* .tbss sections effectively have zero size. */
3755 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3756 != SEC_THREAD_LOCAL
)
3757 last_size
= hdr
->size
;
3763 /* We need a new program segment. We must create a new program
3764 header holding all the sections from phdr_index until hdr. */
3766 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3773 if ((hdr
->flags
& SEC_READONLY
) == 0)
3779 /* .tbss sections effectively have zero size. */
3780 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3781 last_size
= hdr
->size
;
3785 phdr_in_segment
= FALSE
;
3788 /* Create a final PT_LOAD program segment. */
3789 if (last_hdr
!= NULL
)
3791 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3799 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3802 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3809 /* For each batch of consecutive loadable .note sections,
3810 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3811 because if we link together nonloadable .note sections and
3812 loadable .note sections, we will generate two .note sections
3813 in the output file. FIXME: Using names for section types is
3815 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3817 if ((s
->flags
& SEC_LOAD
) != 0
3818 && CONST_STRNEQ (s
->name
, ".note"))
3822 amt
= sizeof (struct elf_segment_map
);
3823 if (s
->alignment_power
== 2)
3824 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3826 if (s2
->next
->alignment_power
== 2
3827 && (s2
->next
->flags
& SEC_LOAD
) != 0
3828 && CONST_STRNEQ (s2
->next
->name
, ".note")
3829 && align_power (s2
->vma
+ s2
->size
, 2)
3835 amt
+= (count
- 1) * sizeof (asection
*);
3836 m
= bfd_zalloc (abfd
, amt
);
3840 m
->p_type
= PT_NOTE
;
3844 m
->sections
[m
->count
- count
--] = s
;
3845 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3848 m
->sections
[m
->count
- 1] = s
;
3849 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3853 if (s
->flags
& SEC_THREAD_LOCAL
)
3861 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3866 amt
= sizeof (struct elf_segment_map
);
3867 amt
+= (tls_count
- 1) * sizeof (asection
*);
3868 m
= bfd_zalloc (abfd
, amt
);
3873 m
->count
= tls_count
;
3874 /* Mandated PF_R. */
3876 m
->p_flags_valid
= 1;
3877 for (i
= 0; i
< tls_count
; ++i
)
3879 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3880 m
->sections
[i
] = first_tls
;
3881 first_tls
= first_tls
->next
;
3888 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3890 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3891 if (eh_frame_hdr
!= NULL
3892 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3894 amt
= sizeof (struct elf_segment_map
);
3895 m
= bfd_zalloc (abfd
, amt
);
3899 m
->p_type
= PT_GNU_EH_FRAME
;
3901 m
->sections
[0] = eh_frame_hdr
->output_section
;
3907 if (elf_tdata (abfd
)->stack_flags
)
3909 amt
= sizeof (struct elf_segment_map
);
3910 m
= bfd_zalloc (abfd
, amt
);
3914 m
->p_type
= PT_GNU_STACK
;
3915 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3916 m
->p_flags_valid
= 1;
3924 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3926 if (m
->p_type
== PT_LOAD
)
3928 asection
*last
= m
->sections
[m
->count
- 1];
3929 bfd_vma vaddr
= m
->sections
[0]->vma
;
3930 bfd_vma filesz
= last
->vma
- vaddr
+ last
->size
;
3932 if (vaddr
< info
->relro_end
3933 && vaddr
>= info
->relro_start
3934 && (vaddr
+ filesz
) >= info
->relro_end
)
3939 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3942 amt
= sizeof (struct elf_segment_map
);
3943 m
= bfd_zalloc (abfd
, amt
);
3947 m
->p_type
= PT_GNU_RELRO
;
3949 m
->p_flags_valid
= 1;
3957 elf_tdata (abfd
)->segment_map
= mfirst
;
3960 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
3963 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3965 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
3970 if (sections
!= NULL
)
3975 /* Sort sections by address. */
3978 elf_sort_sections (const void *arg1
, const void *arg2
)
3980 const asection
*sec1
= *(const asection
**) arg1
;
3981 const asection
*sec2
= *(const asection
**) arg2
;
3982 bfd_size_type size1
, size2
;
3984 /* Sort by LMA first, since this is the address used to
3985 place the section into a segment. */
3986 if (sec1
->lma
< sec2
->lma
)
3988 else if (sec1
->lma
> sec2
->lma
)
3991 /* Then sort by VMA. Normally the LMA and the VMA will be
3992 the same, and this will do nothing. */
3993 if (sec1
->vma
< sec2
->vma
)
3995 else if (sec1
->vma
> sec2
->vma
)
3998 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4000 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4006 /* If the indicies are the same, do not return 0
4007 here, but continue to try the next comparison. */
4008 if (sec1
->target_index
- sec2
->target_index
!= 0)
4009 return sec1
->target_index
- sec2
->target_index
;
4014 else if (TOEND (sec2
))
4019 /* Sort by size, to put zero sized sections
4020 before others at the same address. */
4022 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4023 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4030 return sec1
->target_index
- sec2
->target_index
;
4033 /* Ian Lance Taylor writes:
4035 We shouldn't be using % with a negative signed number. That's just
4036 not good. We have to make sure either that the number is not
4037 negative, or that the number has an unsigned type. When the types
4038 are all the same size they wind up as unsigned. When file_ptr is a
4039 larger signed type, the arithmetic winds up as signed long long,
4042 What we're trying to say here is something like ``increase OFF by
4043 the least amount that will cause it to be equal to the VMA modulo
4045 /* In other words, something like:
4047 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4048 off_offset = off % bed->maxpagesize;
4049 if (vma_offset < off_offset)
4050 adjustment = vma_offset + bed->maxpagesize - off_offset;
4052 adjustment = vma_offset - off_offset;
4054 which can can be collapsed into the expression below. */
4057 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4059 return ((vma
- off
) % maxpagesize
);
4063 print_segment_map (const struct elf_segment_map
*m
)
4066 const char *pt
= get_segment_type (m
->p_type
);
4071 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4072 sprintf (buf
, "LOPROC+%7.7x",
4073 (unsigned int) (m
->p_type
- PT_LOPROC
));
4074 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4075 sprintf (buf
, "LOOS+%7.7x",
4076 (unsigned int) (m
->p_type
- PT_LOOS
));
4078 snprintf (buf
, sizeof (buf
), "%8.8x",
4079 (unsigned int) m
->p_type
);
4082 fprintf (stderr
, "%s:", pt
);
4083 for (j
= 0; j
< m
->count
; j
++)
4084 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4088 /* Assign file positions to the sections based on the mapping from
4089 sections to segments. This function also sets up some fields in
4093 assign_file_positions_for_load_sections (bfd
*abfd
,
4094 struct bfd_link_info
*link_info
)
4096 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4097 struct elf_segment_map
*m
;
4098 Elf_Internal_Phdr
*phdrs
;
4099 Elf_Internal_Phdr
*p
;
4101 bfd_size_type maxpagesize
;
4105 if (link_info
== NULL
4106 && !elf_modify_segment_map (abfd
, link_info
, FALSE
))
4110 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4113 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4114 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4115 elf_elfheader (abfd
)->e_phnum
= alloc
;
4117 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4118 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4120 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4121 >= alloc
* bed
->s
->sizeof_phdr
);
4125 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4129 phdrs
= bfd_alloc2 (abfd
, alloc
, sizeof (Elf_Internal_Phdr
));
4130 elf_tdata (abfd
)->phdr
= phdrs
;
4135 if ((abfd
->flags
& D_PAGED
) != 0)
4136 maxpagesize
= bed
->maxpagesize
;
4138 off
= bed
->s
->sizeof_ehdr
;
4139 off
+= alloc
* bed
->s
->sizeof_phdr
;
4141 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4143 m
= m
->next
, p
++, j
++)
4147 bfd_boolean no_contents
;
4149 /* If elf_segment_map is not from map_sections_to_segments, the
4150 sections may not be correctly ordered. NOTE: sorting should
4151 not be done to the PT_NOTE section of a corefile, which may
4152 contain several pseudo-sections artificially created by bfd.
4153 Sorting these pseudo-sections breaks things badly. */
4155 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4156 && m
->p_type
== PT_NOTE
))
4157 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4160 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4161 number of sections with contents contributing to both p_filesz
4162 and p_memsz, followed by a number of sections with no contents
4163 that just contribute to p_memsz. In this loop, OFF tracks next
4164 available file offset for PT_LOAD and PT_NOTE segments. */
4165 p
->p_type
= m
->p_type
;
4166 p
->p_flags
= m
->p_flags
;
4171 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4173 if (m
->p_paddr_valid
)
4174 p
->p_paddr
= m
->p_paddr
;
4175 else if (m
->count
== 0)
4178 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4180 if (p
->p_type
== PT_LOAD
4181 && (abfd
->flags
& D_PAGED
) != 0)
4183 /* p_align in demand paged PT_LOAD segments effectively stores
4184 the maximum page size. When copying an executable with
4185 objcopy, we set m->p_align from the input file. Use this
4186 value for maxpagesize rather than bed->maxpagesize, which
4187 may be different. Note that we use maxpagesize for PT_TLS
4188 segment alignment later in this function, so we are relying
4189 on at least one PT_LOAD segment appearing before a PT_TLS
4191 if (m
->p_align_valid
)
4192 maxpagesize
= m
->p_align
;
4194 p
->p_align
= maxpagesize
;
4196 else if (m
->p_align_valid
)
4197 p
->p_align
= m
->p_align
;
4198 else if (m
->count
== 0)
4199 p
->p_align
= 1 << bed
->s
->log_file_align
;
4203 no_contents
= FALSE
;
4205 if (p
->p_type
== PT_LOAD
4208 bfd_size_type align
;
4209 unsigned int align_power
= 0;
4211 if (m
->p_align_valid
)
4215 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4217 unsigned int secalign
;
4219 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4220 if (secalign
> align_power
)
4221 align_power
= secalign
;
4223 align
= (bfd_size_type
) 1 << align_power
;
4224 if (align
< maxpagesize
)
4225 align
= maxpagesize
;
4228 for (i
= 0; i
< m
->count
; i
++)
4229 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4230 /* If we aren't making room for this section, then
4231 it must be SHT_NOBITS regardless of what we've
4232 set via struct bfd_elf_special_section. */
4233 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4235 /* Find out whether this segment contains any loadable
4236 sections. If the first section isn't loadable, the same
4237 holds for any other sections. */
4239 while (elf_section_type (m
->sections
[i
]) == SHT_NOBITS
)
4241 /* If a segment starts with .tbss, we need to look
4242 at the next section to decide whether the segment
4243 has any loadable sections. */
4244 if ((elf_section_flags (m
->sections
[i
]) & SHF_TLS
) == 0
4252 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4256 /* We shouldn't need to align the segment on disk since
4257 the segment doesn't need file space, but the gABI
4258 arguably requires the alignment and glibc ld.so
4259 checks it. So to comply with the alignment
4260 requirement but not waste file space, we adjust
4261 p_offset for just this segment. (OFF_ADJUST is
4262 subtracted from OFF later.) This may put p_offset
4263 past the end of file, but that shouldn't matter. */
4268 /* Make sure the .dynamic section is the first section in the
4269 PT_DYNAMIC segment. */
4270 else if (p
->p_type
== PT_DYNAMIC
4272 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4275 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4277 bfd_set_error (bfd_error_bad_value
);
4280 /* Set the note section type to SHT_NOTE. */
4281 else if (p
->p_type
== PT_NOTE
)
4282 for (i
= 0; i
< m
->count
; i
++)
4283 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4289 if (m
->includes_filehdr
)
4291 if (!m
->p_flags_valid
)
4293 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4294 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4297 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4299 if (p
->p_vaddr
< (bfd_vma
) off
)
4301 (*_bfd_error_handler
)
4302 (_("%B: Not enough room for program headers, try linking with -N"),
4304 bfd_set_error (bfd_error_bad_value
);
4309 if (!m
->p_paddr_valid
)
4314 if (m
->includes_phdrs
)
4316 if (!m
->p_flags_valid
)
4319 if (!m
->includes_filehdr
)
4321 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4325 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4326 p
->p_vaddr
-= off
- p
->p_offset
;
4327 if (!m
->p_paddr_valid
)
4328 p
->p_paddr
-= off
- p
->p_offset
;
4332 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4333 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4336 if (p
->p_type
== PT_LOAD
4337 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4339 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4345 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4347 p
->p_filesz
+= adjust
;
4348 p
->p_memsz
+= adjust
;
4352 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4353 maps. Set filepos for sections in PT_LOAD segments, and in
4354 core files, for sections in PT_NOTE segments.
4355 assign_file_positions_for_non_load_sections will set filepos
4356 for other sections and update p_filesz for other segments. */
4357 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4360 bfd_size_type align
;
4361 Elf_Internal_Shdr
*this_hdr
;
4364 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4365 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4367 if ((p
->p_type
== PT_LOAD
4368 || p
->p_type
== PT_TLS
)
4369 && (this_hdr
->sh_type
!= SHT_NOBITS
4370 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4371 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4372 || p
->p_type
== PT_TLS
))))
4374 bfd_signed_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
4378 (*_bfd_error_handler
)
4379 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4380 abfd
, sec
, (unsigned long) sec
->lma
);
4383 p
->p_memsz
+= adjust
;
4385 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4388 p
->p_filesz
+= adjust
;
4392 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4394 /* The section at i == 0 is the one that actually contains
4398 this_hdr
->sh_offset
= sec
->filepos
= off
;
4399 off
+= this_hdr
->sh_size
;
4400 p
->p_filesz
= this_hdr
->sh_size
;
4406 /* The rest are fake sections that shouldn't be written. */
4415 if (p
->p_type
== PT_LOAD
)
4417 this_hdr
->sh_offset
= sec
->filepos
= off
;
4418 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4419 off
+= this_hdr
->sh_size
;
4422 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4424 p
->p_filesz
+= this_hdr
->sh_size
;
4425 /* A load section without SHF_ALLOC is something like
4426 a note section in a PT_NOTE segment. These take
4427 file space but are not loaded into memory. */
4428 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4429 p
->p_memsz
+= this_hdr
->sh_size
;
4431 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4433 if (p
->p_type
== PT_TLS
)
4434 p
->p_memsz
+= this_hdr
->sh_size
;
4436 /* .tbss is special. It doesn't contribute to p_memsz of
4438 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4439 p
->p_memsz
+= this_hdr
->sh_size
;
4442 if (align
> p
->p_align
4443 && !m
->p_align_valid
4444 && (p
->p_type
!= PT_LOAD
4445 || (abfd
->flags
& D_PAGED
) == 0))
4449 if (!m
->p_flags_valid
)
4452 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4454 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4460 /* Check that all sections are in a PT_LOAD segment.
4461 Don't check funky gdb generated core files. */
4462 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4463 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4465 Elf_Internal_Shdr
*this_hdr
;
4469 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4470 if (this_hdr
->sh_size
!= 0
4471 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, p
))
4473 (*_bfd_error_handler
)
4474 (_("%B: section `%A' can't be allocated in segment %d"),
4476 print_segment_map (m
);
4477 bfd_set_error (bfd_error_bad_value
);
4483 elf_tdata (abfd
)->next_file_pos
= off
;
4487 /* Assign file positions for the other sections. */
4490 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4491 struct bfd_link_info
*link_info
)
4493 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4494 Elf_Internal_Shdr
**i_shdrpp
;
4495 Elf_Internal_Shdr
**hdrpp
;
4496 Elf_Internal_Phdr
*phdrs
;
4497 Elf_Internal_Phdr
*p
;
4498 struct elf_segment_map
*m
;
4499 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4500 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4502 unsigned int num_sec
;
4506 i_shdrpp
= elf_elfsections (abfd
);
4507 num_sec
= elf_numsections (abfd
);
4508 off
= elf_tdata (abfd
)->next_file_pos
;
4509 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4511 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4512 Elf_Internal_Shdr
*hdr
;
4515 if (hdr
->bfd_section
!= NULL
4516 && (hdr
->bfd_section
->filepos
!= 0
4517 || (hdr
->sh_type
== SHT_NOBITS
4518 && hdr
->contents
== NULL
)))
4519 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4520 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4522 if (hdr
->sh_size
!= 0)
4523 ((*_bfd_error_handler
)
4524 (_("%B: warning: allocated section `%s' not in segment"),
4526 (hdr
->bfd_section
== NULL
4528 : hdr
->bfd_section
->name
)));
4529 /* We don't need to page align empty sections. */
4530 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4531 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4534 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4536 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4539 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4540 && hdr
->bfd_section
== NULL
)
4541 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4542 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4543 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4544 hdr
->sh_offset
= -1;
4546 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4549 /* Now that we have set the section file positions, we can set up
4550 the file positions for the non PT_LOAD segments. */
4554 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4556 phdrs
= elf_tdata (abfd
)->phdr
;
4557 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4562 if (p
->p_type
!= PT_LOAD
)
4565 if (m
->includes_filehdr
)
4567 filehdr_vaddr
= p
->p_vaddr
;
4568 filehdr_paddr
= p
->p_paddr
;
4570 if (m
->includes_phdrs
)
4572 phdrs_vaddr
= p
->p_vaddr
;
4573 phdrs_paddr
= p
->p_paddr
;
4574 if (m
->includes_filehdr
)
4576 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4577 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4582 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4588 if (p
->p_type
!= PT_LOAD
4589 && (p
->p_type
!= PT_NOTE
4590 || bfd_get_format (abfd
) != bfd_core
))
4592 Elf_Internal_Shdr
*hdr
;
4595 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4597 sect
= m
->sections
[m
->count
- 1];
4598 hdr
= &elf_section_data (sect
)->this_hdr
;
4599 p
->p_filesz
= sect
->filepos
- m
->sections
[0]->filepos
;
4600 if (hdr
->sh_type
!= SHT_NOBITS
)
4601 p
->p_filesz
+= hdr
->sh_size
;
4603 if (p
->p_type
== PT_GNU_RELRO
)
4605 /* When we get here, we are copying executable
4606 or shared library. But we need to use the same
4608 Elf_Internal_Phdr
*lp
;
4610 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4612 if (lp
->p_type
== PT_LOAD
4613 && lp
->p_paddr
== p
->p_paddr
)
4617 if (lp
< phdrs
+ count
)
4619 /* We should use p_size if it is valid since it
4620 may contain the first few bytes of the next
4621 SEC_ALLOC section. */
4622 if (m
->p_size_valid
)
4623 p
->p_filesz
= m
->p_size
;
4626 p
->p_vaddr
= lp
->p_vaddr
;
4627 p
->p_offset
= lp
->p_offset
;
4628 p
->p_memsz
= p
->p_filesz
;
4635 p
->p_offset
= m
->sections
[0]->filepos
;
4640 if (m
->includes_filehdr
)
4642 p
->p_vaddr
= filehdr_vaddr
;
4643 if (! m
->p_paddr_valid
)
4644 p
->p_paddr
= filehdr_paddr
;
4646 else if (m
->includes_phdrs
)
4648 p
->p_vaddr
= phdrs_vaddr
;
4649 if (! m
->p_paddr_valid
)
4650 p
->p_paddr
= phdrs_paddr
;
4652 else if (p
->p_type
== PT_GNU_RELRO
)
4654 Elf_Internal_Phdr
*lp
;
4656 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4658 if (lp
->p_type
== PT_LOAD
4659 && lp
->p_vaddr
<= link_info
->relro_end
4660 && lp
->p_vaddr
>= link_info
->relro_start
4661 && (lp
->p_vaddr
+ lp
->p_filesz
4662 >= link_info
->relro_end
))
4666 if (lp
< phdrs
+ count
4667 && link_info
->relro_end
> lp
->p_vaddr
)
4669 p
->p_vaddr
= lp
->p_vaddr
;
4670 p
->p_paddr
= lp
->p_paddr
;
4671 p
->p_offset
= lp
->p_offset
;
4672 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4673 p
->p_memsz
= p
->p_filesz
;
4675 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4679 memset (p
, 0, sizeof *p
);
4680 p
->p_type
= PT_NULL
;
4686 elf_tdata (abfd
)->next_file_pos
= off
;
4691 /* Work out the file positions of all the sections. This is called by
4692 _bfd_elf_compute_section_file_positions. All the section sizes and
4693 VMAs must be known before this is called.
4695 Reloc sections come in two flavours: Those processed specially as
4696 "side-channel" data attached to a section to which they apply, and
4697 those that bfd doesn't process as relocations. The latter sort are
4698 stored in a normal bfd section by bfd_section_from_shdr. We don't
4699 consider the former sort here, unless they form part of the loadable
4700 image. Reloc sections not assigned here will be handled later by
4701 assign_file_positions_for_relocs.
4703 We also don't set the positions of the .symtab and .strtab here. */
4706 assign_file_positions_except_relocs (bfd
*abfd
,
4707 struct bfd_link_info
*link_info
)
4709 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4710 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4712 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4714 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4715 && bfd_get_format (abfd
) != bfd_core
)
4717 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4718 unsigned int num_sec
= elf_numsections (abfd
);
4719 Elf_Internal_Shdr
**hdrpp
;
4722 /* Start after the ELF header. */
4723 off
= i_ehdrp
->e_ehsize
;
4725 /* We are not creating an executable, which means that we are
4726 not creating a program header, and that the actual order of
4727 the sections in the file is unimportant. */
4728 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4730 Elf_Internal_Shdr
*hdr
;
4733 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4734 && hdr
->bfd_section
== NULL
)
4735 || i
== tdata
->symtab_section
4736 || i
== tdata
->symtab_shndx_section
4737 || i
== tdata
->strtab_section
)
4739 hdr
->sh_offset
= -1;
4742 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4749 /* Assign file positions for the loaded sections based on the
4750 assignment of sections to segments. */
4751 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4754 /* And for non-load sections. */
4755 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4758 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4760 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4764 /* Write out the program headers. */
4765 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4766 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4767 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4770 off
= tdata
->next_file_pos
;
4773 /* Place the section headers. */
4774 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4775 i_ehdrp
->e_shoff
= off
;
4776 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4778 tdata
->next_file_pos
= off
;
4784 prep_headers (bfd
*abfd
)
4786 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4787 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4788 struct elf_strtab_hash
*shstrtab
;
4789 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4791 i_ehdrp
= elf_elfheader (abfd
);
4793 shstrtab
= _bfd_elf_strtab_init ();
4794 if (shstrtab
== NULL
)
4797 elf_shstrtab (abfd
) = shstrtab
;
4799 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4800 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4801 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4802 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4804 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4805 i_ehdrp
->e_ident
[EI_DATA
] =
4806 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4807 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4809 if ((abfd
->flags
& DYNAMIC
) != 0)
4810 i_ehdrp
->e_type
= ET_DYN
;
4811 else if ((abfd
->flags
& EXEC_P
) != 0)
4812 i_ehdrp
->e_type
= ET_EXEC
;
4813 else if (bfd_get_format (abfd
) == bfd_core
)
4814 i_ehdrp
->e_type
= ET_CORE
;
4816 i_ehdrp
->e_type
= ET_REL
;
4818 switch (bfd_get_arch (abfd
))
4820 case bfd_arch_unknown
:
4821 i_ehdrp
->e_machine
= EM_NONE
;
4824 /* There used to be a long list of cases here, each one setting
4825 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4826 in the corresponding bfd definition. To avoid duplication,
4827 the switch was removed. Machines that need special handling
4828 can generally do it in elf_backend_final_write_processing(),
4829 unless they need the information earlier than the final write.
4830 Such need can generally be supplied by replacing the tests for
4831 e_machine with the conditions used to determine it. */
4833 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4836 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4837 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4839 /* No program header, for now. */
4840 i_ehdrp
->e_phoff
= 0;
4841 i_ehdrp
->e_phentsize
= 0;
4842 i_ehdrp
->e_phnum
= 0;
4844 /* Each bfd section is section header entry. */
4845 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4846 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4848 /* If we're building an executable, we'll need a program header table. */
4849 if (abfd
->flags
& EXEC_P
)
4850 /* It all happens later. */
4854 i_ehdrp
->e_phentsize
= 0;
4856 i_ehdrp
->e_phoff
= 0;
4859 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4860 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4861 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4862 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4863 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4864 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4865 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4866 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4867 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4873 /* Assign file positions for all the reloc sections which are not part
4874 of the loadable file image. */
4877 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4880 unsigned int i
, num_sec
;
4881 Elf_Internal_Shdr
**shdrpp
;
4883 off
= elf_tdata (abfd
)->next_file_pos
;
4885 num_sec
= elf_numsections (abfd
);
4886 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4888 Elf_Internal_Shdr
*shdrp
;
4891 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4892 && shdrp
->sh_offset
== -1)
4893 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4896 elf_tdata (abfd
)->next_file_pos
= off
;
4900 _bfd_elf_write_object_contents (bfd
*abfd
)
4902 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4903 Elf_Internal_Ehdr
*i_ehdrp
;
4904 Elf_Internal_Shdr
**i_shdrp
;
4906 unsigned int count
, num_sec
;
4908 if (! abfd
->output_has_begun
4909 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4912 i_shdrp
= elf_elfsections (abfd
);
4913 i_ehdrp
= elf_elfheader (abfd
);
4916 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4920 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4922 /* After writing the headers, we need to write the sections too... */
4923 num_sec
= elf_numsections (abfd
);
4924 for (count
= 1; count
< num_sec
; count
++)
4926 if (bed
->elf_backend_section_processing
)
4927 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4928 if (i_shdrp
[count
]->contents
)
4930 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4932 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4933 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4938 /* Write out the section header names. */
4939 if (elf_shstrtab (abfd
) != NULL
4940 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4941 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
4944 if (bed
->elf_backend_final_write_processing
)
4945 (*bed
->elf_backend_final_write_processing
) (abfd
,
4946 elf_tdata (abfd
)->linker
);
4948 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
4951 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
4952 if (elf_tdata (abfd
)->after_write_object_contents
)
4953 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
4959 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4961 /* Hopefully this can be done just like an object file. */
4962 return _bfd_elf_write_object_contents (abfd
);
4965 /* Given a section, search the header to find them. */
4968 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4970 const struct elf_backend_data
*bed
;
4973 if (elf_section_data (asect
) != NULL
4974 && elf_section_data (asect
)->this_idx
!= 0)
4975 return elf_section_data (asect
)->this_idx
;
4977 if (bfd_is_abs_section (asect
))
4979 else if (bfd_is_com_section (asect
))
4981 else if (bfd_is_und_section (asect
))
4986 bed
= get_elf_backend_data (abfd
);
4987 if (bed
->elf_backend_section_from_bfd_section
)
4991 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4995 if (index
== SHN_BAD
)
4996 bfd_set_error (bfd_error_nonrepresentable_section
);
5001 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5005 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5007 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5009 flagword flags
= asym_ptr
->flags
;
5011 /* When gas creates relocations against local labels, it creates its
5012 own symbol for the section, but does put the symbol into the
5013 symbol chain, so udata is 0. When the linker is generating
5014 relocatable output, this section symbol may be for one of the
5015 input sections rather than the output section. */
5016 if (asym_ptr
->udata
.i
== 0
5017 && (flags
& BSF_SECTION_SYM
)
5018 && asym_ptr
->section
)
5023 sec
= asym_ptr
->section
;
5024 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5025 sec
= sec
->output_section
;
5026 if (sec
->owner
== abfd
5027 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5028 && elf_section_syms (abfd
)[indx
] != NULL
)
5029 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5032 idx
= asym_ptr
->udata
.i
;
5036 /* This case can occur when using --strip-symbol on a symbol
5037 which is used in a relocation entry. */
5038 (*_bfd_error_handler
)
5039 (_("%B: symbol `%s' required but not present"),
5040 abfd
, bfd_asymbol_name (asym_ptr
));
5041 bfd_set_error (bfd_error_no_symbols
);
5048 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5049 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5050 elf_symbol_flags (flags
));
5058 /* Rewrite program header information. */
5061 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5063 Elf_Internal_Ehdr
*iehdr
;
5064 struct elf_segment_map
*map
;
5065 struct elf_segment_map
*map_first
;
5066 struct elf_segment_map
**pointer_to_map
;
5067 Elf_Internal_Phdr
*segment
;
5070 unsigned int num_segments
;
5071 bfd_boolean phdr_included
= FALSE
;
5072 bfd_boolean p_paddr_valid
;
5073 bfd_vma maxpagesize
;
5074 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5075 unsigned int phdr_adjust_num
= 0;
5076 const struct elf_backend_data
*bed
;
5078 bed
= get_elf_backend_data (ibfd
);
5079 iehdr
= elf_elfheader (ibfd
);
5082 pointer_to_map
= &map_first
;
5084 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5085 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5087 /* Returns the end address of the segment + 1. */
5088 #define SEGMENT_END(segment, start) \
5089 (start + (segment->p_memsz > segment->p_filesz \
5090 ? segment->p_memsz : segment->p_filesz))
5092 #define SECTION_SIZE(section, segment) \
5093 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5094 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5095 ? section->size : 0)
5097 /* Returns TRUE if the given section is contained within
5098 the given segment. VMA addresses are compared. */
5099 #define IS_CONTAINED_BY_VMA(section, segment) \
5100 (section->vma >= segment->p_vaddr \
5101 && (section->vma + SECTION_SIZE (section, segment) \
5102 <= (SEGMENT_END (segment, segment->p_vaddr))))
5104 /* Returns TRUE if the given section is contained within
5105 the given segment. LMA addresses are compared. */
5106 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5107 (section->lma >= base \
5108 && (section->lma + SECTION_SIZE (section, segment) \
5109 <= SEGMENT_END (segment, base)))
5111 /* Handle PT_NOTE segment. */
5112 #define IS_NOTE(p, s) \
5113 (p->p_type == PT_NOTE \
5114 && elf_section_type (s) == SHT_NOTE \
5115 && (bfd_vma) s->filepos >= p->p_offset \
5116 && ((bfd_vma) s->filepos + s->size \
5117 <= p->p_offset + p->p_filesz))
5119 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5121 #define IS_COREFILE_NOTE(p, s) \
5123 && bfd_get_format (ibfd) == bfd_core \
5127 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5128 linker, which generates a PT_INTERP section with p_vaddr and
5129 p_memsz set to 0. */
5130 #define IS_SOLARIS_PT_INTERP(p, s) \
5132 && p->p_paddr == 0 \
5133 && p->p_memsz == 0 \
5134 && p->p_filesz > 0 \
5135 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5137 && (bfd_vma) s->filepos >= p->p_offset \
5138 && ((bfd_vma) s->filepos + s->size \
5139 <= p->p_offset + p->p_filesz))
5141 /* Decide if the given section should be included in the given segment.
5142 A section will be included if:
5143 1. It is within the address space of the segment -- we use the LMA
5144 if that is set for the segment and the VMA otherwise,
5145 2. It is an allocated section or a NOTE section in a PT_NOTE
5147 3. There is an output section associated with it,
5148 4. The section has not already been allocated to a previous segment.
5149 5. PT_GNU_STACK segments do not include any sections.
5150 6. PT_TLS segment includes only SHF_TLS sections.
5151 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5152 8. PT_DYNAMIC should not contain empty sections at the beginning
5153 (with the possible exception of .dynamic). */
5154 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5155 ((((segment->p_paddr \
5156 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5157 : IS_CONTAINED_BY_VMA (section, segment)) \
5158 && (section->flags & SEC_ALLOC) != 0) \
5159 || IS_NOTE (segment, section)) \
5160 && segment->p_type != PT_GNU_STACK \
5161 && (segment->p_type != PT_TLS \
5162 || (section->flags & SEC_THREAD_LOCAL)) \
5163 && (segment->p_type == PT_LOAD \
5164 || segment->p_type == PT_TLS \
5165 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5166 && (segment->p_type != PT_DYNAMIC \
5167 || SECTION_SIZE (section, segment) > 0 \
5168 || (segment->p_paddr \
5169 ? segment->p_paddr != section->lma \
5170 : segment->p_vaddr != section->vma) \
5171 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5173 && !section->segment_mark)
5175 /* If the output section of a section in the input segment is NULL,
5176 it is removed from the corresponding output segment. */
5177 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5178 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5179 && section->output_section != NULL)
5181 /* Returns TRUE iff seg1 starts after the end of seg2. */
5182 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5183 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5185 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5186 their VMA address ranges and their LMA address ranges overlap.
5187 It is possible to have overlapping VMA ranges without overlapping LMA
5188 ranges. RedBoot images for example can have both .data and .bss mapped
5189 to the same VMA range, but with the .data section mapped to a different
5191 #define SEGMENT_OVERLAPS(seg1, seg2) \
5192 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5193 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5194 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5195 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5197 /* Initialise the segment mark field. */
5198 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5199 section
->segment_mark
= FALSE
;
5201 /* The Solaris linker creates program headers in which all the
5202 p_paddr fields are zero. When we try to objcopy or strip such a
5203 file, we get confused. Check for this case, and if we find it
5204 don't set the p_paddr_valid fields. */
5205 p_paddr_valid
= FALSE
;
5206 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5209 if (segment
->p_paddr
!= 0)
5211 p_paddr_valid
= TRUE
;
5215 /* Scan through the segments specified in the program header
5216 of the input BFD. For this first scan we look for overlaps
5217 in the loadable segments. These can be created by weird
5218 parameters to objcopy. Also, fix some solaris weirdness. */
5219 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5224 Elf_Internal_Phdr
*segment2
;
5226 if (segment
->p_type
== PT_INTERP
)
5227 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5228 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5230 /* Mininal change so that the normal section to segment
5231 assignment code will work. */
5232 segment
->p_vaddr
= section
->vma
;
5236 if (segment
->p_type
!= PT_LOAD
)
5238 /* Remove PT_GNU_RELRO segment. */
5239 if (segment
->p_type
== PT_GNU_RELRO
)
5240 segment
->p_type
= PT_NULL
;
5244 /* Determine if this segment overlaps any previous segments. */
5245 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5247 bfd_signed_vma extra_length
;
5249 if (segment2
->p_type
!= PT_LOAD
5250 || !SEGMENT_OVERLAPS (segment
, segment2
))
5253 /* Merge the two segments together. */
5254 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5256 /* Extend SEGMENT2 to include SEGMENT and then delete
5258 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5259 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5261 if (extra_length
> 0)
5263 segment2
->p_memsz
+= extra_length
;
5264 segment2
->p_filesz
+= extra_length
;
5267 segment
->p_type
= PT_NULL
;
5269 /* Since we have deleted P we must restart the outer loop. */
5271 segment
= elf_tdata (ibfd
)->phdr
;
5276 /* Extend SEGMENT to include SEGMENT2 and then delete
5278 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5279 - SEGMENT_END (segment
, segment
->p_vaddr
));
5281 if (extra_length
> 0)
5283 segment
->p_memsz
+= extra_length
;
5284 segment
->p_filesz
+= extra_length
;
5287 segment2
->p_type
= PT_NULL
;
5292 /* The second scan attempts to assign sections to segments. */
5293 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5297 unsigned int section_count
;
5298 asection
**sections
;
5299 asection
*output_section
;
5301 bfd_vma matching_lma
;
5302 bfd_vma suggested_lma
;
5305 asection
*first_section
;
5306 bfd_boolean first_matching_lma
;
5307 bfd_boolean first_suggested_lma
;
5309 if (segment
->p_type
== PT_NULL
)
5312 first_section
= NULL
;
5313 /* Compute how many sections might be placed into this segment. */
5314 for (section
= ibfd
->sections
, section_count
= 0;
5316 section
= section
->next
)
5318 /* Find the first section in the input segment, which may be
5319 removed from the corresponding output segment. */
5320 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5322 if (first_section
== NULL
)
5323 first_section
= section
;
5324 if (section
->output_section
!= NULL
)
5329 /* Allocate a segment map big enough to contain
5330 all of the sections we have selected. */
5331 amt
= sizeof (struct elf_segment_map
);
5332 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5333 map
= bfd_zalloc (obfd
, amt
);
5337 /* Initialise the fields of the segment map. Default to
5338 using the physical address of the segment in the input BFD. */
5340 map
->p_type
= segment
->p_type
;
5341 map
->p_flags
= segment
->p_flags
;
5342 map
->p_flags_valid
= 1;
5344 /* If the first section in the input segment is removed, there is
5345 no need to preserve segment physical address in the corresponding
5347 if (!first_section
|| first_section
->output_section
!= NULL
)
5349 map
->p_paddr
= segment
->p_paddr
;
5350 map
->p_paddr_valid
= p_paddr_valid
;
5353 /* Determine if this segment contains the ELF file header
5354 and if it contains the program headers themselves. */
5355 map
->includes_filehdr
= (segment
->p_offset
== 0
5356 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5357 map
->includes_phdrs
= 0;
5359 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5361 map
->includes_phdrs
=
5362 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5363 && (segment
->p_offset
+ segment
->p_filesz
5364 >= ((bfd_vma
) iehdr
->e_phoff
5365 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5367 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5368 phdr_included
= TRUE
;
5371 if (section_count
== 0)
5373 /* Special segments, such as the PT_PHDR segment, may contain
5374 no sections, but ordinary, loadable segments should contain
5375 something. They are allowed by the ELF spec however, so only
5376 a warning is produced. */
5377 if (segment
->p_type
== PT_LOAD
)
5378 (*_bfd_error_handler
) (_("%B: warning: Empty loadable segment"
5379 " detected, is this intentional ?\n"),
5383 *pointer_to_map
= map
;
5384 pointer_to_map
= &map
->next
;
5389 /* Now scan the sections in the input BFD again and attempt
5390 to add their corresponding output sections to the segment map.
5391 The problem here is how to handle an output section which has
5392 been moved (ie had its LMA changed). There are four possibilities:
5394 1. None of the sections have been moved.
5395 In this case we can continue to use the segment LMA from the
5398 2. All of the sections have been moved by the same amount.
5399 In this case we can change the segment's LMA to match the LMA
5400 of the first section.
5402 3. Some of the sections have been moved, others have not.
5403 In this case those sections which have not been moved can be
5404 placed in the current segment which will have to have its size,
5405 and possibly its LMA changed, and a new segment or segments will
5406 have to be created to contain the other sections.
5408 4. The sections have been moved, but not by the same amount.
5409 In this case we can change the segment's LMA to match the LMA
5410 of the first section and we will have to create a new segment
5411 or segments to contain the other sections.
5413 In order to save time, we allocate an array to hold the section
5414 pointers that we are interested in. As these sections get assigned
5415 to a segment, they are removed from this array. */
5417 sections
= bfd_malloc2 (section_count
, sizeof (asection
*));
5418 if (sections
== NULL
)
5421 /* Step One: Scan for segment vs section LMA conflicts.
5422 Also add the sections to the section array allocated above.
5423 Also add the sections to the current segment. In the common
5424 case, where the sections have not been moved, this means that
5425 we have completely filled the segment, and there is nothing
5430 first_matching_lma
= TRUE
;
5431 first_suggested_lma
= TRUE
;
5433 for (section
= ibfd
->sections
;
5435 section
= section
->next
)
5436 if (section
== first_section
)
5439 for (j
= 0; section
!= NULL
; section
= section
->next
)
5441 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5443 output_section
= section
->output_section
;
5445 sections
[j
++] = section
;
5447 /* The Solaris native linker always sets p_paddr to 0.
5448 We try to catch that case here, and set it to the
5449 correct value. Note - some backends require that
5450 p_paddr be left as zero. */
5452 && segment
->p_vaddr
!= 0
5453 && !bed
->want_p_paddr_set_to_zero
5455 && output_section
->lma
!= 0
5456 && output_section
->vma
== (segment
->p_vaddr
5457 + (map
->includes_filehdr
5460 + (map
->includes_phdrs
5462 * iehdr
->e_phentsize
)
5464 map
->p_paddr
= segment
->p_vaddr
;
5466 /* Match up the physical address of the segment with the
5467 LMA address of the output section. */
5468 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5469 || IS_COREFILE_NOTE (segment
, section
)
5470 || (bed
->want_p_paddr_set_to_zero
5471 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
5473 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
5475 matching_lma
= output_section
->lma
;
5476 first_matching_lma
= FALSE
;
5479 /* We assume that if the section fits within the segment
5480 then it does not overlap any other section within that
5482 map
->sections
[isec
++] = output_section
;
5484 else if (first_suggested_lma
)
5486 suggested_lma
= output_section
->lma
;
5487 first_suggested_lma
= FALSE
;
5490 if (j
== section_count
)
5495 BFD_ASSERT (j
== section_count
);
5497 /* Step Two: Adjust the physical address of the current segment,
5499 if (isec
== section_count
)
5501 /* All of the sections fitted within the segment as currently
5502 specified. This is the default case. Add the segment to
5503 the list of built segments and carry on to process the next
5504 program header in the input BFD. */
5505 map
->count
= section_count
;
5506 *pointer_to_map
= map
;
5507 pointer_to_map
= &map
->next
;
5510 && !bed
->want_p_paddr_set_to_zero
5511 && matching_lma
!= map
->p_paddr
5512 && !map
->includes_filehdr
5513 && !map
->includes_phdrs
)
5514 /* There is some padding before the first section in the
5515 segment. So, we must account for that in the output
5517 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5524 if (!first_matching_lma
)
5526 /* At least one section fits inside the current segment.
5527 Keep it, but modify its physical address to match the
5528 LMA of the first section that fitted. */
5529 map
->p_paddr
= matching_lma
;
5533 /* None of the sections fitted inside the current segment.
5534 Change the current segment's physical address to match
5535 the LMA of the first section. */
5536 map
->p_paddr
= suggested_lma
;
5539 /* Offset the segment physical address from the lma
5540 to allow for space taken up by elf headers. */
5541 if (map
->includes_filehdr
)
5542 map
->p_paddr
-= iehdr
->e_ehsize
;
5544 if (map
->includes_phdrs
)
5546 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5548 /* iehdr->e_phnum is just an estimate of the number
5549 of program headers that we will need. Make a note
5550 here of the number we used and the segment we chose
5551 to hold these headers, so that we can adjust the
5552 offset when we know the correct value. */
5553 phdr_adjust_num
= iehdr
->e_phnum
;
5554 phdr_adjust_seg
= map
;
5558 /* Step Three: Loop over the sections again, this time assigning
5559 those that fit to the current segment and removing them from the
5560 sections array; but making sure not to leave large gaps. Once all
5561 possible sections have been assigned to the current segment it is
5562 added to the list of built segments and if sections still remain
5563 to be assigned, a new segment is constructed before repeating
5570 first_suggested_lma
= TRUE
;
5572 /* Fill the current segment with sections that fit. */
5573 for (j
= 0; j
< section_count
; j
++)
5575 section
= sections
[j
];
5577 if (section
== NULL
)
5580 output_section
= section
->output_section
;
5582 BFD_ASSERT (output_section
!= NULL
);
5584 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5585 || IS_COREFILE_NOTE (segment
, section
))
5587 if (map
->count
== 0)
5589 /* If the first section in a segment does not start at
5590 the beginning of the segment, then something is
5592 if (output_section
->lma
5594 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5595 + (map
->includes_phdrs
5596 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5604 prev_sec
= map
->sections
[map
->count
- 1];
5606 /* If the gap between the end of the previous section
5607 and the start of this section is more than
5608 maxpagesize then we need to start a new segment. */
5609 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5611 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5612 || (prev_sec
->lma
+ prev_sec
->size
5613 > output_section
->lma
))
5615 if (first_suggested_lma
)
5617 suggested_lma
= output_section
->lma
;
5618 first_suggested_lma
= FALSE
;
5625 map
->sections
[map
->count
++] = output_section
;
5628 section
->segment_mark
= TRUE
;
5630 else if (first_suggested_lma
)
5632 suggested_lma
= output_section
->lma
;
5633 first_suggested_lma
= FALSE
;
5637 BFD_ASSERT (map
->count
> 0);
5639 /* Add the current segment to the list of built segments. */
5640 *pointer_to_map
= map
;
5641 pointer_to_map
= &map
->next
;
5643 if (isec
< section_count
)
5645 /* We still have not allocated all of the sections to
5646 segments. Create a new segment here, initialise it
5647 and carry on looping. */
5648 amt
= sizeof (struct elf_segment_map
);
5649 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5650 map
= bfd_alloc (obfd
, amt
);
5657 /* Initialise the fields of the segment map. Set the physical
5658 physical address to the LMA of the first section that has
5659 not yet been assigned. */
5661 map
->p_type
= segment
->p_type
;
5662 map
->p_flags
= segment
->p_flags
;
5663 map
->p_flags_valid
= 1;
5664 map
->p_paddr
= suggested_lma
;
5665 map
->p_paddr_valid
= p_paddr_valid
;
5666 map
->includes_filehdr
= 0;
5667 map
->includes_phdrs
= 0;
5670 while (isec
< section_count
);
5675 elf_tdata (obfd
)->segment_map
= map_first
;
5677 /* If we had to estimate the number of program headers that were
5678 going to be needed, then check our estimate now and adjust
5679 the offset if necessary. */
5680 if (phdr_adjust_seg
!= NULL
)
5684 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5687 if (count
> phdr_adjust_num
)
5688 phdr_adjust_seg
->p_paddr
5689 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5694 #undef IS_CONTAINED_BY_VMA
5695 #undef IS_CONTAINED_BY_LMA
5697 #undef IS_COREFILE_NOTE
5698 #undef IS_SOLARIS_PT_INTERP
5699 #undef IS_SECTION_IN_INPUT_SEGMENT
5700 #undef INCLUDE_SECTION_IN_SEGMENT
5701 #undef SEGMENT_AFTER_SEGMENT
5702 #undef SEGMENT_OVERLAPS
5706 /* Copy ELF program header information. */
5709 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5711 Elf_Internal_Ehdr
*iehdr
;
5712 struct elf_segment_map
*map
;
5713 struct elf_segment_map
*map_first
;
5714 struct elf_segment_map
**pointer_to_map
;
5715 Elf_Internal_Phdr
*segment
;
5717 unsigned int num_segments
;
5718 bfd_boolean phdr_included
= FALSE
;
5719 bfd_boolean p_paddr_valid
;
5721 iehdr
= elf_elfheader (ibfd
);
5724 pointer_to_map
= &map_first
;
5726 /* If all the segment p_paddr fields are zero, don't set
5727 map->p_paddr_valid. */
5728 p_paddr_valid
= FALSE
;
5729 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5730 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5733 if (segment
->p_paddr
!= 0)
5735 p_paddr_valid
= TRUE
;
5739 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5744 unsigned int section_count
;
5746 Elf_Internal_Shdr
*this_hdr
;
5747 asection
*first_section
= NULL
;
5748 asection
*lowest_section
= NULL
;
5750 /* Compute how many sections are in this segment. */
5751 for (section
= ibfd
->sections
, section_count
= 0;
5753 section
= section
->next
)
5755 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5756 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5759 first_section
= lowest_section
= section
;
5760 if (section
->lma
< lowest_section
->lma
)
5761 lowest_section
= section
;
5766 /* Allocate a segment map big enough to contain
5767 all of the sections we have selected. */
5768 amt
= sizeof (struct elf_segment_map
);
5769 if (section_count
!= 0)
5770 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5771 map
= bfd_zalloc (obfd
, amt
);
5775 /* Initialize the fields of the output segment map with the
5778 map
->p_type
= segment
->p_type
;
5779 map
->p_flags
= segment
->p_flags
;
5780 map
->p_flags_valid
= 1;
5781 map
->p_paddr
= segment
->p_paddr
;
5782 map
->p_paddr_valid
= p_paddr_valid
;
5783 map
->p_align
= segment
->p_align
;
5784 map
->p_align_valid
= 1;
5785 map
->p_vaddr_offset
= 0;
5787 if (map
->p_type
== PT_GNU_RELRO
5788 && segment
->p_filesz
== segment
->p_memsz
)
5790 /* The PT_GNU_RELRO segment may contain the first a few
5791 bytes in the .got.plt section even if the whole .got.plt
5792 section isn't in the PT_GNU_RELRO segment. We won't
5793 change the size of the PT_GNU_RELRO segment. */
5794 map
->p_size
= segment
->p_filesz
;
5795 map
->p_size_valid
= 1;
5798 /* Determine if this segment contains the ELF file header
5799 and if it contains the program headers themselves. */
5800 map
->includes_filehdr
= (segment
->p_offset
== 0
5801 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5803 map
->includes_phdrs
= 0;
5804 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5806 map
->includes_phdrs
=
5807 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5808 && (segment
->p_offset
+ segment
->p_filesz
5809 >= ((bfd_vma
) iehdr
->e_phoff
5810 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5812 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5813 phdr_included
= TRUE
;
5816 if (!map
->includes_phdrs
5817 && !map
->includes_filehdr
5818 && map
->p_paddr_valid
)
5819 /* There is some other padding before the first section. */
5820 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
5821 - segment
->p_paddr
);
5823 if (section_count
!= 0)
5825 unsigned int isec
= 0;
5827 for (section
= first_section
;
5829 section
= section
->next
)
5831 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5832 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5834 map
->sections
[isec
++] = section
->output_section
;
5835 if (isec
== section_count
)
5841 map
->count
= section_count
;
5842 *pointer_to_map
= map
;
5843 pointer_to_map
= &map
->next
;
5846 elf_tdata (obfd
)->segment_map
= map_first
;
5850 /* Copy private BFD data. This copies or rewrites ELF program header
5854 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5856 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5857 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5860 if (elf_tdata (ibfd
)->phdr
== NULL
)
5863 if (ibfd
->xvec
== obfd
->xvec
)
5865 /* Check to see if any sections in the input BFD
5866 covered by ELF program header have changed. */
5867 Elf_Internal_Phdr
*segment
;
5868 asection
*section
, *osec
;
5869 unsigned int i
, num_segments
;
5870 Elf_Internal_Shdr
*this_hdr
;
5871 const struct elf_backend_data
*bed
;
5873 bed
= get_elf_backend_data (ibfd
);
5875 /* Regenerate the segment map if p_paddr is set to 0. */
5876 if (bed
->want_p_paddr_set_to_zero
)
5879 /* Initialize the segment mark field. */
5880 for (section
= obfd
->sections
; section
!= NULL
;
5881 section
= section
->next
)
5882 section
->segment_mark
= FALSE
;
5884 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5885 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5889 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5890 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5891 which severly confuses things, so always regenerate the segment
5892 map in this case. */
5893 if (segment
->p_paddr
== 0
5894 && segment
->p_memsz
== 0
5895 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
5898 for (section
= ibfd
->sections
;
5899 section
!= NULL
; section
= section
->next
)
5901 /* We mark the output section so that we know it comes
5902 from the input BFD. */
5903 osec
= section
->output_section
;
5905 osec
->segment_mark
= TRUE
;
5907 /* Check if this section is covered by the segment. */
5908 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5909 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5911 /* FIXME: Check if its output section is changed or
5912 removed. What else do we need to check? */
5914 || section
->flags
!= osec
->flags
5915 || section
->lma
!= osec
->lma
5916 || section
->vma
!= osec
->vma
5917 || section
->size
!= osec
->size
5918 || section
->rawsize
!= osec
->rawsize
5919 || section
->alignment_power
!= osec
->alignment_power
)
5925 /* Check to see if any output section do not come from the
5927 for (section
= obfd
->sections
; section
!= NULL
;
5928 section
= section
->next
)
5930 if (section
->segment_mark
== FALSE
)
5933 section
->segment_mark
= FALSE
;
5936 return copy_elf_program_header (ibfd
, obfd
);
5940 return rewrite_elf_program_header (ibfd
, obfd
);
5943 /* Initialize private output section information from input section. */
5946 _bfd_elf_init_private_section_data (bfd
*ibfd
,
5950 struct bfd_link_info
*link_info
)
5953 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5954 bfd_boolean need_group
= link_info
== NULL
|| link_info
->relocatable
;
5956 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5957 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5960 /* Don't copy the output ELF section type from input if the
5961 output BFD section flags have been set to something different.
5962 elf_fake_sections will set ELF section type based on BFD
5964 if (elf_section_type (osec
) == SHT_NULL
5965 && (osec
->flags
== isec
->flags
|| !osec
->flags
))
5966 elf_section_type (osec
) = elf_section_type (isec
);
5968 /* FIXME: Is this correct for all OS/PROC specific flags? */
5969 elf_section_flags (osec
) |= (elf_section_flags (isec
)
5970 & (SHF_MASKOS
| SHF_MASKPROC
));
5972 /* Set things up for objcopy and relocatable link. The output
5973 SHT_GROUP section will have its elf_next_in_group pointing back
5974 to the input group members. Ignore linker created group section.
5975 See elfNN_ia64_object_p in elfxx-ia64.c. */
5978 if (elf_sec_group (isec
) == NULL
5979 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
5981 if (elf_section_flags (isec
) & SHF_GROUP
)
5982 elf_section_flags (osec
) |= SHF_GROUP
;
5983 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5984 elf_group_name (osec
) = elf_group_name (isec
);
5988 ihdr
= &elf_section_data (isec
)->this_hdr
;
5990 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5991 don't use the output section of the linked-to section since it
5992 may be NULL at this point. */
5993 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
5995 ohdr
= &elf_section_data (osec
)->this_hdr
;
5996 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
5997 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6000 osec
->use_rela_p
= isec
->use_rela_p
;
6005 /* Copy private section information. This copies over the entsize
6006 field, and sometimes the info field. */
6009 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6014 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6016 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6017 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6020 ihdr
= &elf_section_data (isec
)->this_hdr
;
6021 ohdr
= &elf_section_data (osec
)->this_hdr
;
6023 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6025 if (ihdr
->sh_type
== SHT_SYMTAB
6026 || ihdr
->sh_type
== SHT_DYNSYM
6027 || ihdr
->sh_type
== SHT_GNU_verneed
6028 || ihdr
->sh_type
== SHT_GNU_verdef
)
6029 ohdr
->sh_info
= ihdr
->sh_info
;
6031 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6035 /* Copy private header information. */
6038 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6042 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6043 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6046 /* Copy over private BFD data if it has not already been copied.
6047 This must be done here, rather than in the copy_private_bfd_data
6048 entry point, because the latter is called after the section
6049 contents have been set, which means that the program headers have
6050 already been worked out. */
6051 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6053 if (! copy_private_bfd_data (ibfd
, obfd
))
6057 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6058 but this might be wrong if we deleted the group section. */
6059 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6060 if (elf_section_type (isec
) == SHT_GROUP
6061 && isec
->output_section
== NULL
)
6063 asection
*first
= elf_next_in_group (isec
);
6064 asection
*s
= first
;
6067 if (s
->output_section
!= NULL
)
6069 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6070 elf_group_name (s
->output_section
) = NULL
;
6072 s
= elf_next_in_group (s
);
6081 /* Copy private symbol information. If this symbol is in a section
6082 which we did not map into a BFD section, try to map the section
6083 index correctly. We use special macro definitions for the mapped
6084 section indices; these definitions are interpreted by the
6085 swap_out_syms function. */
6087 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6088 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6089 #define MAP_STRTAB (SHN_HIOS + 3)
6090 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6091 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6094 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6099 elf_symbol_type
*isym
, *osym
;
6101 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6102 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6105 isym
= elf_symbol_from (ibfd
, isymarg
);
6106 osym
= elf_symbol_from (obfd
, osymarg
);
6109 && isym
->internal_elf_sym
.st_shndx
!= 0
6111 && bfd_is_abs_section (isym
->symbol
.section
))
6115 shndx
= isym
->internal_elf_sym
.st_shndx
;
6116 if (shndx
== elf_onesymtab (ibfd
))
6117 shndx
= MAP_ONESYMTAB
;
6118 else if (shndx
== elf_dynsymtab (ibfd
))
6119 shndx
= MAP_DYNSYMTAB
;
6120 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6122 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6123 shndx
= MAP_SHSTRTAB
;
6124 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6125 shndx
= MAP_SYM_SHNDX
;
6126 osym
->internal_elf_sym
.st_shndx
= shndx
;
6132 /* Swap out the symbols. */
6135 swap_out_syms (bfd
*abfd
,
6136 struct bfd_strtab_hash
**sttp
,
6139 const struct elf_backend_data
*bed
;
6142 struct bfd_strtab_hash
*stt
;
6143 Elf_Internal_Shdr
*symtab_hdr
;
6144 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6145 Elf_Internal_Shdr
*symstrtab_hdr
;
6146 bfd_byte
*outbound_syms
;
6147 bfd_byte
*outbound_shndx
;
6150 bfd_boolean name_local_sections
;
6152 if (!elf_map_symbols (abfd
))
6155 /* Dump out the symtabs. */
6156 stt
= _bfd_elf_stringtab_init ();
6160 bed
= get_elf_backend_data (abfd
);
6161 symcount
= bfd_get_symcount (abfd
);
6162 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6163 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6164 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6165 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6166 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6167 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6169 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6170 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6172 outbound_syms
= bfd_alloc2 (abfd
, 1 + symcount
, bed
->s
->sizeof_sym
);
6173 if (outbound_syms
== NULL
)
6175 _bfd_stringtab_free (stt
);
6178 symtab_hdr
->contents
= outbound_syms
;
6180 outbound_shndx
= NULL
;
6181 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6182 if (symtab_shndx_hdr
->sh_name
!= 0)
6184 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6185 outbound_shndx
= bfd_zalloc2 (abfd
, 1 + symcount
,
6186 sizeof (Elf_External_Sym_Shndx
));
6187 if (outbound_shndx
== NULL
)
6189 _bfd_stringtab_free (stt
);
6193 symtab_shndx_hdr
->contents
= outbound_shndx
;
6194 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6195 symtab_shndx_hdr
->sh_size
= amt
;
6196 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6197 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6200 /* Now generate the data (for "contents"). */
6202 /* Fill in zeroth symbol and swap it out. */
6203 Elf_Internal_Sym sym
;
6209 sym
.st_shndx
= SHN_UNDEF
;
6210 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6211 outbound_syms
+= bed
->s
->sizeof_sym
;
6212 if (outbound_shndx
!= NULL
)
6213 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6217 = (bed
->elf_backend_name_local_section_symbols
6218 && bed
->elf_backend_name_local_section_symbols (abfd
));
6220 syms
= bfd_get_outsymbols (abfd
);
6221 for (idx
= 0; idx
< symcount
; idx
++)
6223 Elf_Internal_Sym sym
;
6224 bfd_vma value
= syms
[idx
]->value
;
6225 elf_symbol_type
*type_ptr
;
6226 flagword flags
= syms
[idx
]->flags
;
6229 if (!name_local_sections
6230 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6232 /* Local section symbols have no name. */
6237 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6240 if (sym
.st_name
== (unsigned long) -1)
6242 _bfd_stringtab_free (stt
);
6247 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6249 if ((flags
& BSF_SECTION_SYM
) == 0
6250 && bfd_is_com_section (syms
[idx
]->section
))
6252 /* ELF common symbols put the alignment into the `value' field,
6253 and the size into the `size' field. This is backwards from
6254 how BFD handles it, so reverse it here. */
6255 sym
.st_size
= value
;
6256 if (type_ptr
== NULL
6257 || type_ptr
->internal_elf_sym
.st_value
== 0)
6258 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6260 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6261 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6262 (abfd
, syms
[idx
]->section
);
6266 asection
*sec
= syms
[idx
]->section
;
6269 if (sec
->output_section
)
6271 value
+= sec
->output_offset
;
6272 sec
= sec
->output_section
;
6275 /* Don't add in the section vma for relocatable output. */
6276 if (! relocatable_p
)
6278 sym
.st_value
= value
;
6279 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6281 if (bfd_is_abs_section (sec
)
6283 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6285 /* This symbol is in a real ELF section which we did
6286 not create as a BFD section. Undo the mapping done
6287 by copy_private_symbol_data. */
6288 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6292 shndx
= elf_onesymtab (abfd
);
6295 shndx
= elf_dynsymtab (abfd
);
6298 shndx
= elf_tdata (abfd
)->strtab_section
;
6301 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6304 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6312 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6314 if (shndx
== SHN_BAD
)
6318 /* Writing this would be a hell of a lot easier if
6319 we had some decent documentation on bfd, and
6320 knew what to expect of the library, and what to
6321 demand of applications. For example, it
6322 appears that `objcopy' might not set the
6323 section of a symbol to be a section that is
6324 actually in the output file. */
6325 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6328 _bfd_error_handler (_("\
6329 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6330 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6332 bfd_set_error (bfd_error_invalid_operation
);
6333 _bfd_stringtab_free (stt
);
6337 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6338 BFD_ASSERT (shndx
!= SHN_BAD
);
6342 sym
.st_shndx
= shndx
;
6345 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6347 else if ((flags
& BSF_FUNCTION
) != 0)
6349 else if ((flags
& BSF_OBJECT
) != 0)
6351 else if ((flags
& BSF_RELC
) != 0)
6353 else if ((flags
& BSF_SRELC
) != 0)
6358 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6361 /* Processor-specific types. */
6362 if (type_ptr
!= NULL
6363 && bed
->elf_backend_get_symbol_type
)
6364 type
= ((*bed
->elf_backend_get_symbol_type
)
6365 (&type_ptr
->internal_elf_sym
, type
));
6367 if (flags
& BSF_SECTION_SYM
)
6369 if (flags
& BSF_GLOBAL
)
6370 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6372 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6374 else if (bfd_is_com_section (syms
[idx
]->section
))
6376 #ifdef USE_STT_COMMON
6377 if (type
== STT_OBJECT
)
6378 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
6381 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6384 else if (bfd_is_und_section (syms
[idx
]->section
))
6385 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6389 else if (flags
& BSF_FILE
)
6390 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6393 int bind
= STB_LOCAL
;
6395 if (flags
& BSF_LOCAL
)
6397 else if (flags
& BSF_WEAK
)
6399 else if (flags
& BSF_GLOBAL
)
6402 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6405 if (type_ptr
!= NULL
)
6406 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6410 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6411 outbound_syms
+= bed
->s
->sizeof_sym
;
6412 if (outbound_shndx
!= NULL
)
6413 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6417 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6418 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6420 symstrtab_hdr
->sh_flags
= 0;
6421 symstrtab_hdr
->sh_addr
= 0;
6422 symstrtab_hdr
->sh_entsize
= 0;
6423 symstrtab_hdr
->sh_link
= 0;
6424 symstrtab_hdr
->sh_info
= 0;
6425 symstrtab_hdr
->sh_addralign
= 1;
6430 /* Return the number of bytes required to hold the symtab vector.
6432 Note that we base it on the count plus 1, since we will null terminate
6433 the vector allocated based on this size. However, the ELF symbol table
6434 always has a dummy entry as symbol #0, so it ends up even. */
6437 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6441 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6443 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6444 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6446 symtab_size
-= sizeof (asymbol
*);
6452 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6456 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6458 if (elf_dynsymtab (abfd
) == 0)
6460 bfd_set_error (bfd_error_invalid_operation
);
6464 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6465 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6467 symtab_size
-= sizeof (asymbol
*);
6473 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6476 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6479 /* Canonicalize the relocs. */
6482 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6489 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6491 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6494 tblptr
= section
->relocation
;
6495 for (i
= 0; i
< section
->reloc_count
; i
++)
6496 *relptr
++ = tblptr
++;
6500 return section
->reloc_count
;
6504 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6506 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6507 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6510 bfd_get_symcount (abfd
) = symcount
;
6515 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6516 asymbol
**allocation
)
6518 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6519 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6522 bfd_get_dynamic_symcount (abfd
) = symcount
;
6526 /* Return the size required for the dynamic reloc entries. Any loadable
6527 section that was actually installed in the BFD, and has type SHT_REL
6528 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6529 dynamic reloc section. */
6532 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6537 if (elf_dynsymtab (abfd
) == 0)
6539 bfd_set_error (bfd_error_invalid_operation
);
6543 ret
= sizeof (arelent
*);
6544 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6545 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6546 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6547 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6548 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6549 * sizeof (arelent
*));
6554 /* Canonicalize the dynamic relocation entries. Note that we return the
6555 dynamic relocations as a single block, although they are actually
6556 associated with particular sections; the interface, which was
6557 designed for SunOS style shared libraries, expects that there is only
6558 one set of dynamic relocs. Any loadable section that was actually
6559 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6560 dynamic symbol table, is considered to be a dynamic reloc section. */
6563 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6567 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6571 if (elf_dynsymtab (abfd
) == 0)
6573 bfd_set_error (bfd_error_invalid_operation
);
6577 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6579 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6581 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6582 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6583 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6588 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6590 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6592 for (i
= 0; i
< count
; i
++)
6603 /* Read in the version information. */
6606 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6608 bfd_byte
*contents
= NULL
;
6609 unsigned int freeidx
= 0;
6611 if (elf_dynverref (abfd
) != 0)
6613 Elf_Internal_Shdr
*hdr
;
6614 Elf_External_Verneed
*everneed
;
6615 Elf_Internal_Verneed
*iverneed
;
6617 bfd_byte
*contents_end
;
6619 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6621 elf_tdata (abfd
)->verref
= bfd_zalloc2 (abfd
, hdr
->sh_info
,
6622 sizeof (Elf_Internal_Verneed
));
6623 if (elf_tdata (abfd
)->verref
== NULL
)
6626 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6628 contents
= bfd_malloc (hdr
->sh_size
);
6629 if (contents
== NULL
)
6631 error_return_verref
:
6632 elf_tdata (abfd
)->verref
= NULL
;
6633 elf_tdata (abfd
)->cverrefs
= 0;
6636 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6637 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6638 goto error_return_verref
;
6640 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6641 goto error_return_verref
;
6643 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6644 == sizeof (Elf_External_Vernaux
));
6645 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6646 everneed
= (Elf_External_Verneed
*) contents
;
6647 iverneed
= elf_tdata (abfd
)->verref
;
6648 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6650 Elf_External_Vernaux
*evernaux
;
6651 Elf_Internal_Vernaux
*ivernaux
;
6654 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6656 iverneed
->vn_bfd
= abfd
;
6658 iverneed
->vn_filename
=
6659 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6661 if (iverneed
->vn_filename
== NULL
)
6662 goto error_return_verref
;
6664 if (iverneed
->vn_cnt
== 0)
6665 iverneed
->vn_auxptr
= NULL
;
6668 iverneed
->vn_auxptr
= bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6669 sizeof (Elf_Internal_Vernaux
));
6670 if (iverneed
->vn_auxptr
== NULL
)
6671 goto error_return_verref
;
6674 if (iverneed
->vn_aux
6675 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6676 goto error_return_verref
;
6678 evernaux
= ((Elf_External_Vernaux
*)
6679 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6680 ivernaux
= iverneed
->vn_auxptr
;
6681 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6683 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6685 ivernaux
->vna_nodename
=
6686 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6687 ivernaux
->vna_name
);
6688 if (ivernaux
->vna_nodename
== NULL
)
6689 goto error_return_verref
;
6691 if (j
+ 1 < iverneed
->vn_cnt
)
6692 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6694 ivernaux
->vna_nextptr
= NULL
;
6696 if (ivernaux
->vna_next
6697 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6698 goto error_return_verref
;
6700 evernaux
= ((Elf_External_Vernaux
*)
6701 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6703 if (ivernaux
->vna_other
> freeidx
)
6704 freeidx
= ivernaux
->vna_other
;
6707 if (i
+ 1 < hdr
->sh_info
)
6708 iverneed
->vn_nextref
= iverneed
+ 1;
6710 iverneed
->vn_nextref
= NULL
;
6712 if (iverneed
->vn_next
6713 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6714 goto error_return_verref
;
6716 everneed
= ((Elf_External_Verneed
*)
6717 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6724 if (elf_dynverdef (abfd
) != 0)
6726 Elf_Internal_Shdr
*hdr
;
6727 Elf_External_Verdef
*everdef
;
6728 Elf_Internal_Verdef
*iverdef
;
6729 Elf_Internal_Verdef
*iverdefarr
;
6730 Elf_Internal_Verdef iverdefmem
;
6732 unsigned int maxidx
;
6733 bfd_byte
*contents_end_def
, *contents_end_aux
;
6735 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6737 contents
= bfd_malloc (hdr
->sh_size
);
6738 if (contents
== NULL
)
6740 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6741 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6744 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6747 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6748 >= sizeof (Elf_External_Verdaux
));
6749 contents_end_def
= contents
+ hdr
->sh_size
6750 - sizeof (Elf_External_Verdef
);
6751 contents_end_aux
= contents
+ hdr
->sh_size
6752 - sizeof (Elf_External_Verdaux
);
6754 /* We know the number of entries in the section but not the maximum
6755 index. Therefore we have to run through all entries and find
6757 everdef
= (Elf_External_Verdef
*) contents
;
6759 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6761 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6763 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6764 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6766 if (iverdefmem
.vd_next
6767 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6770 everdef
= ((Elf_External_Verdef
*)
6771 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6774 if (default_imported_symver
)
6776 if (freeidx
> maxidx
)
6781 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, maxidx
,
6782 sizeof (Elf_Internal_Verdef
));
6783 if (elf_tdata (abfd
)->verdef
== NULL
)
6786 elf_tdata (abfd
)->cverdefs
= maxidx
;
6788 everdef
= (Elf_External_Verdef
*) contents
;
6789 iverdefarr
= elf_tdata (abfd
)->verdef
;
6790 for (i
= 0; i
< hdr
->sh_info
; i
++)
6792 Elf_External_Verdaux
*everdaux
;
6793 Elf_Internal_Verdaux
*iverdaux
;
6796 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6798 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6800 error_return_verdef
:
6801 elf_tdata (abfd
)->verdef
= NULL
;
6802 elf_tdata (abfd
)->cverdefs
= 0;
6806 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6807 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6809 iverdef
->vd_bfd
= abfd
;
6811 if (iverdef
->vd_cnt
== 0)
6812 iverdef
->vd_auxptr
= NULL
;
6815 iverdef
->vd_auxptr
= bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6816 sizeof (Elf_Internal_Verdaux
));
6817 if (iverdef
->vd_auxptr
== NULL
)
6818 goto error_return_verdef
;
6822 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6823 goto error_return_verdef
;
6825 everdaux
= ((Elf_External_Verdaux
*)
6826 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6827 iverdaux
= iverdef
->vd_auxptr
;
6828 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6830 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6832 iverdaux
->vda_nodename
=
6833 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6834 iverdaux
->vda_name
);
6835 if (iverdaux
->vda_nodename
== NULL
)
6836 goto error_return_verdef
;
6838 if (j
+ 1 < iverdef
->vd_cnt
)
6839 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6841 iverdaux
->vda_nextptr
= NULL
;
6843 if (iverdaux
->vda_next
6844 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
6845 goto error_return_verdef
;
6847 everdaux
= ((Elf_External_Verdaux
*)
6848 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6851 if (iverdef
->vd_cnt
)
6852 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6854 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
6855 iverdef
->vd_nextdef
= iverdef
+ 1;
6857 iverdef
->vd_nextdef
= NULL
;
6859 everdef
= ((Elf_External_Verdef
*)
6860 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6866 else if (default_imported_symver
)
6873 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, freeidx
,
6874 sizeof (Elf_Internal_Verdef
));
6875 if (elf_tdata (abfd
)->verdef
== NULL
)
6878 elf_tdata (abfd
)->cverdefs
= freeidx
;
6881 /* Create a default version based on the soname. */
6882 if (default_imported_symver
)
6884 Elf_Internal_Verdef
*iverdef
;
6885 Elf_Internal_Verdaux
*iverdaux
;
6887 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6889 iverdef
->vd_version
= VER_DEF_CURRENT
;
6890 iverdef
->vd_flags
= 0;
6891 iverdef
->vd_ndx
= freeidx
;
6892 iverdef
->vd_cnt
= 1;
6894 iverdef
->vd_bfd
= abfd
;
6896 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6897 if (iverdef
->vd_nodename
== NULL
)
6898 goto error_return_verdef
;
6899 iverdef
->vd_nextdef
= NULL
;
6900 iverdef
->vd_auxptr
= bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
6901 if (iverdef
->vd_auxptr
== NULL
)
6902 goto error_return_verdef
;
6904 iverdaux
= iverdef
->vd_auxptr
;
6905 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
6906 iverdaux
->vda_nextptr
= NULL
;
6912 if (contents
!= NULL
)
6918 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6920 elf_symbol_type
*newsym
;
6921 bfd_size_type amt
= sizeof (elf_symbol_type
);
6923 newsym
= bfd_zalloc (abfd
, amt
);
6928 newsym
->symbol
.the_bfd
= abfd
;
6929 return &newsym
->symbol
;
6934 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6938 bfd_symbol_info (symbol
, ret
);
6941 /* Return whether a symbol name implies a local symbol. Most targets
6942 use this function for the is_local_label_name entry point, but some
6946 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6949 /* Normal local symbols start with ``.L''. */
6950 if (name
[0] == '.' && name
[1] == 'L')
6953 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6954 DWARF debugging symbols starting with ``..''. */
6955 if (name
[0] == '.' && name
[1] == '.')
6958 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6959 emitting DWARF debugging output. I suspect this is actually a
6960 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6961 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6962 underscore to be emitted on some ELF targets). For ease of use,
6963 we treat such symbols as local. */
6964 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6971 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6972 asymbol
*symbol ATTRIBUTE_UNUSED
)
6979 _bfd_elf_set_arch_mach (bfd
*abfd
,
6980 enum bfd_architecture arch
,
6981 unsigned long machine
)
6983 /* If this isn't the right architecture for this backend, and this
6984 isn't the generic backend, fail. */
6985 if (arch
!= get_elf_backend_data (abfd
)->arch
6986 && arch
!= bfd_arch_unknown
6987 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6990 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6993 /* Find the function to a particular section and offset,
6994 for error reporting. */
6997 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
7001 const char **filename_ptr
,
7002 const char **functionname_ptr
)
7004 const char *filename
;
7005 asymbol
*func
, *file
;
7008 /* ??? Given multiple file symbols, it is impossible to reliably
7009 choose the right file name for global symbols. File symbols are
7010 local symbols, and thus all file symbols must sort before any
7011 global symbols. The ELF spec may be interpreted to say that a
7012 file symbol must sort before other local symbols, but currently
7013 ld -r doesn't do this. So, for ld -r output, it is possible to
7014 make a better choice of file name for local symbols by ignoring
7015 file symbols appearing after a given local symbol. */
7016 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7022 state
= nothing_seen
;
7024 for (p
= symbols
; *p
!= NULL
; p
++)
7028 q
= (elf_symbol_type
*) *p
;
7030 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
7036 if (state
== symbol_seen
)
7037 state
= file_after_symbol_seen
;
7041 if (bfd_get_section (&q
->symbol
) == section
7042 && q
->symbol
.value
>= low_func
7043 && q
->symbol
.value
<= offset
)
7045 func
= (asymbol
*) q
;
7046 low_func
= q
->symbol
.value
;
7049 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7050 || state
!= file_after_symbol_seen
))
7051 filename
= bfd_asymbol_name (file
);
7055 if (state
== nothing_seen
)
7056 state
= symbol_seen
;
7063 *filename_ptr
= filename
;
7064 if (functionname_ptr
)
7065 *functionname_ptr
= bfd_asymbol_name (func
);
7070 /* Find the nearest line to a particular section and offset,
7071 for error reporting. */
7074 _bfd_elf_find_nearest_line (bfd
*abfd
,
7078 const char **filename_ptr
,
7079 const char **functionname_ptr
,
7080 unsigned int *line_ptr
)
7084 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7085 filename_ptr
, functionname_ptr
,
7088 if (!*functionname_ptr
)
7089 elf_find_function (abfd
, section
, symbols
, offset
,
7090 *filename_ptr
? NULL
: filename_ptr
,
7096 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7097 filename_ptr
, functionname_ptr
,
7099 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7101 if (!*functionname_ptr
)
7102 elf_find_function (abfd
, section
, symbols
, offset
,
7103 *filename_ptr
? NULL
: filename_ptr
,
7109 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7110 &found
, filename_ptr
,
7111 functionname_ptr
, line_ptr
,
7112 &elf_tdata (abfd
)->line_info
))
7114 if (found
&& (*functionname_ptr
|| *line_ptr
))
7117 if (symbols
== NULL
)
7120 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7121 filename_ptr
, functionname_ptr
))
7128 /* Find the line for a symbol. */
7131 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7132 const char **filename_ptr
, unsigned int *line_ptr
)
7134 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7135 filename_ptr
, line_ptr
, 0,
7136 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7139 /* After a call to bfd_find_nearest_line, successive calls to
7140 bfd_find_inliner_info can be used to get source information about
7141 each level of function inlining that terminated at the address
7142 passed to bfd_find_nearest_line. Currently this is only supported
7143 for DWARF2 with appropriate DWARF3 extensions. */
7146 _bfd_elf_find_inliner_info (bfd
*abfd
,
7147 const char **filename_ptr
,
7148 const char **functionname_ptr
,
7149 unsigned int *line_ptr
)
7152 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7153 functionname_ptr
, line_ptr
,
7154 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7159 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7161 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7162 int ret
= bed
->s
->sizeof_ehdr
;
7164 if (!info
->relocatable
)
7166 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7168 if (phdr_size
== (bfd_size_type
) -1)
7170 struct elf_segment_map
*m
;
7173 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7174 phdr_size
+= bed
->s
->sizeof_phdr
;
7177 phdr_size
= get_program_header_size (abfd
, info
);
7180 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7188 _bfd_elf_set_section_contents (bfd
*abfd
,
7190 const void *location
,
7192 bfd_size_type count
)
7194 Elf_Internal_Shdr
*hdr
;
7197 if (! abfd
->output_has_begun
7198 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7201 hdr
= &elf_section_data (section
)->this_hdr
;
7202 pos
= hdr
->sh_offset
+ offset
;
7203 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7204 || bfd_bwrite (location
, count
, abfd
) != count
)
7211 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7212 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7213 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7218 /* Try to convert a non-ELF reloc into an ELF one. */
7221 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7223 /* Check whether we really have an ELF howto. */
7225 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7227 bfd_reloc_code_real_type code
;
7228 reloc_howto_type
*howto
;
7230 /* Alien reloc: Try to determine its type to replace it with an
7231 equivalent ELF reloc. */
7233 if (areloc
->howto
->pc_relative
)
7235 switch (areloc
->howto
->bitsize
)
7238 code
= BFD_RELOC_8_PCREL
;
7241 code
= BFD_RELOC_12_PCREL
;
7244 code
= BFD_RELOC_16_PCREL
;
7247 code
= BFD_RELOC_24_PCREL
;
7250 code
= BFD_RELOC_32_PCREL
;
7253 code
= BFD_RELOC_64_PCREL
;
7259 howto
= bfd_reloc_type_lookup (abfd
, code
);
7261 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7263 if (howto
->pcrel_offset
)
7264 areloc
->addend
+= areloc
->address
;
7266 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7271 switch (areloc
->howto
->bitsize
)
7277 code
= BFD_RELOC_14
;
7280 code
= BFD_RELOC_16
;
7283 code
= BFD_RELOC_26
;
7286 code
= BFD_RELOC_32
;
7289 code
= BFD_RELOC_64
;
7295 howto
= bfd_reloc_type_lookup (abfd
, code
);
7299 areloc
->howto
= howto
;
7307 (*_bfd_error_handler
)
7308 (_("%B: unsupported relocation type %s"),
7309 abfd
, areloc
->howto
->name
);
7310 bfd_set_error (bfd_error_bad_value
);
7315 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7317 if (bfd_get_format (abfd
) == bfd_object
)
7319 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7320 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7321 _bfd_dwarf2_cleanup_debug_info (abfd
);
7324 return _bfd_generic_close_and_cleanup (abfd
);
7327 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7328 in the relocation's offset. Thus we cannot allow any sort of sanity
7329 range-checking to interfere. There is nothing else to do in processing
7332 bfd_reloc_status_type
7333 _bfd_elf_rel_vtable_reloc_fn
7334 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7335 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7336 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7337 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7339 return bfd_reloc_ok
;
7342 /* Elf core file support. Much of this only works on native
7343 toolchains, since we rely on knowing the
7344 machine-dependent procfs structure in order to pick
7345 out details about the corefile. */
7347 #ifdef HAVE_SYS_PROCFS_H
7348 # include <sys/procfs.h>
7351 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7354 elfcore_make_pid (bfd
*abfd
)
7356 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7357 + (elf_tdata (abfd
)->core_pid
));
7360 /* If there isn't a section called NAME, make one, using
7361 data from SECT. Note, this function will generate a
7362 reference to NAME, so you shouldn't deallocate or
7366 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7370 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7373 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7377 sect2
->size
= sect
->size
;
7378 sect2
->filepos
= sect
->filepos
;
7379 sect2
->alignment_power
= sect
->alignment_power
;
7383 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7384 actually creates up to two pseudosections:
7385 - For the single-threaded case, a section named NAME, unless
7386 such a section already exists.
7387 - For the multi-threaded case, a section named "NAME/PID", where
7388 PID is elfcore_make_pid (abfd).
7389 Both pseudosections have identical contents. */
7391 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7397 char *threaded_name
;
7401 /* Build the section name. */
7403 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7404 len
= strlen (buf
) + 1;
7405 threaded_name
= bfd_alloc (abfd
, len
);
7406 if (threaded_name
== NULL
)
7408 memcpy (threaded_name
, buf
, len
);
7410 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7415 sect
->filepos
= filepos
;
7416 sect
->alignment_power
= 2;
7418 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7421 /* prstatus_t exists on:
7423 linux 2.[01] + glibc
7427 #if defined (HAVE_PRSTATUS_T)
7430 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7435 if (note
->descsz
== sizeof (prstatus_t
))
7439 size
= sizeof (prstat
.pr_reg
);
7440 offset
= offsetof (prstatus_t
, pr_reg
);
7441 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7443 /* Do not overwrite the core signal if it
7444 has already been set by another thread. */
7445 if (elf_tdata (abfd
)->core_signal
== 0)
7446 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7447 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7449 /* pr_who exists on:
7452 pr_who doesn't exist on:
7455 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7456 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7459 #if defined (HAVE_PRSTATUS32_T)
7460 else if (note
->descsz
== sizeof (prstatus32_t
))
7462 /* 64-bit host, 32-bit corefile */
7463 prstatus32_t prstat
;
7465 size
= sizeof (prstat
.pr_reg
);
7466 offset
= offsetof (prstatus32_t
, pr_reg
);
7467 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7469 /* Do not overwrite the core signal if it
7470 has already been set by another thread. */
7471 if (elf_tdata (abfd
)->core_signal
== 0)
7472 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7473 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7475 /* pr_who exists on:
7478 pr_who doesn't exist on:
7481 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7482 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7485 #endif /* HAVE_PRSTATUS32_T */
7488 /* Fail - we don't know how to handle any other
7489 note size (ie. data object type). */
7493 /* Make a ".reg/999" section and a ".reg" section. */
7494 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7495 size
, note
->descpos
+ offset
);
7497 #endif /* defined (HAVE_PRSTATUS_T) */
7499 /* Create a pseudosection containing the exact contents of NOTE. */
7501 elfcore_make_note_pseudosection (bfd
*abfd
,
7503 Elf_Internal_Note
*note
)
7505 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7506 note
->descsz
, note
->descpos
);
7509 /* There isn't a consistent prfpregset_t across platforms,
7510 but it doesn't matter, because we don't have to pick this
7511 data structure apart. */
7514 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7516 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7519 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7520 type of NT_PRXFPREG. Just include the whole note's contents
7524 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7526 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7530 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
7532 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
7536 #if defined (HAVE_PRPSINFO_T)
7537 typedef prpsinfo_t elfcore_psinfo_t
;
7538 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7539 typedef prpsinfo32_t elfcore_psinfo32_t
;
7543 #if defined (HAVE_PSINFO_T)
7544 typedef psinfo_t elfcore_psinfo_t
;
7545 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7546 typedef psinfo32_t elfcore_psinfo32_t
;
7550 /* return a malloc'ed copy of a string at START which is at
7551 most MAX bytes long, possibly without a terminating '\0'.
7552 the copy will always have a terminating '\0'. */
7555 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7558 char *end
= memchr (start
, '\0', max
);
7566 dups
= bfd_alloc (abfd
, len
+ 1);
7570 memcpy (dups
, start
, len
);
7576 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7578 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7580 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7582 elfcore_psinfo_t psinfo
;
7584 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7586 elf_tdata (abfd
)->core_program
7587 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7588 sizeof (psinfo
.pr_fname
));
7590 elf_tdata (abfd
)->core_command
7591 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7592 sizeof (psinfo
.pr_psargs
));
7594 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7595 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7597 /* 64-bit host, 32-bit corefile */
7598 elfcore_psinfo32_t psinfo
;
7600 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7602 elf_tdata (abfd
)->core_program
7603 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7604 sizeof (psinfo
.pr_fname
));
7606 elf_tdata (abfd
)->core_command
7607 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7608 sizeof (psinfo
.pr_psargs
));
7614 /* Fail - we don't know how to handle any other
7615 note size (ie. data object type). */
7619 /* Note that for some reason, a spurious space is tacked
7620 onto the end of the args in some (at least one anyway)
7621 implementations, so strip it off if it exists. */
7624 char *command
= elf_tdata (abfd
)->core_command
;
7625 int n
= strlen (command
);
7627 if (0 < n
&& command
[n
- 1] == ' ')
7628 command
[n
- 1] = '\0';
7633 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7635 #if defined (HAVE_PSTATUS_T)
7637 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7639 if (note
->descsz
== sizeof (pstatus_t
)
7640 #if defined (HAVE_PXSTATUS_T)
7641 || note
->descsz
== sizeof (pxstatus_t
)
7647 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7649 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7651 #if defined (HAVE_PSTATUS32_T)
7652 else if (note
->descsz
== sizeof (pstatus32_t
))
7654 /* 64-bit host, 32-bit corefile */
7657 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7659 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7662 /* Could grab some more details from the "representative"
7663 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7664 NT_LWPSTATUS note, presumably. */
7668 #endif /* defined (HAVE_PSTATUS_T) */
7670 #if defined (HAVE_LWPSTATUS_T)
7672 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7674 lwpstatus_t lwpstat
;
7680 if (note
->descsz
!= sizeof (lwpstat
)
7681 #if defined (HAVE_LWPXSTATUS_T)
7682 && note
->descsz
!= sizeof (lwpxstatus_t
)
7687 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7689 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7690 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7692 /* Make a ".reg/999" section. */
7694 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7695 len
= strlen (buf
) + 1;
7696 name
= bfd_alloc (abfd
, len
);
7699 memcpy (name
, buf
, len
);
7701 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7705 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7706 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7707 sect
->filepos
= note
->descpos
7708 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7711 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7712 sect
->size
= sizeof (lwpstat
.pr_reg
);
7713 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7716 sect
->alignment_power
= 2;
7718 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7721 /* Make a ".reg2/999" section */
7723 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7724 len
= strlen (buf
) + 1;
7725 name
= bfd_alloc (abfd
, len
);
7728 memcpy (name
, buf
, len
);
7730 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7734 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7735 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7736 sect
->filepos
= note
->descpos
7737 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7740 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7741 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7742 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7745 sect
->alignment_power
= 2;
7747 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7749 #endif /* defined (HAVE_LWPSTATUS_T) */
7752 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7759 int is_active_thread
;
7762 if (note
->descsz
< 728)
7765 if (! CONST_STRNEQ (note
->namedata
, "win32"))
7768 type
= bfd_get_32 (abfd
, note
->descdata
);
7772 case 1 /* NOTE_INFO_PROCESS */:
7773 /* FIXME: need to add ->core_command. */
7774 /* process_info.pid */
7775 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7776 /* process_info.signal */
7777 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
7780 case 2 /* NOTE_INFO_THREAD */:
7781 /* Make a ".reg/999" section. */
7782 /* thread_info.tid */
7783 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
7785 len
= strlen (buf
) + 1;
7786 name
= bfd_alloc (abfd
, len
);
7790 memcpy (name
, buf
, len
);
7792 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7796 /* sizeof (thread_info.thread_context) */
7798 /* offsetof (thread_info.thread_context) */
7799 sect
->filepos
= note
->descpos
+ 12;
7800 sect
->alignment_power
= 2;
7802 /* thread_info.is_active_thread */
7803 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7805 if (is_active_thread
)
7806 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7810 case 3 /* NOTE_INFO_MODULE */:
7811 /* Make a ".module/xxxxxxxx" section. */
7812 /* module_info.base_address */
7813 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
7814 sprintf (buf
, ".module/%08lx", (long) base_addr
);
7816 len
= strlen (buf
) + 1;
7817 name
= bfd_alloc (abfd
, len
);
7821 memcpy (name
, buf
, len
);
7823 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7828 sect
->size
= note
->descsz
;
7829 sect
->filepos
= note
->descpos
;
7830 sect
->alignment_power
= 2;
7841 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7843 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7851 if (bed
->elf_backend_grok_prstatus
)
7852 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7854 #if defined (HAVE_PRSTATUS_T)
7855 return elfcore_grok_prstatus (abfd
, note
);
7860 #if defined (HAVE_PSTATUS_T)
7862 return elfcore_grok_pstatus (abfd
, note
);
7865 #if defined (HAVE_LWPSTATUS_T)
7867 return elfcore_grok_lwpstatus (abfd
, note
);
7870 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7871 return elfcore_grok_prfpreg (abfd
, note
);
7873 case NT_WIN32PSTATUS
:
7874 return elfcore_grok_win32pstatus (abfd
, note
);
7876 case NT_PRXFPREG
: /* Linux SSE extension */
7877 if (note
->namesz
== 6
7878 && strcmp (note
->namedata
, "LINUX") == 0)
7879 return elfcore_grok_prxfpreg (abfd
, note
);
7884 if (note
->namesz
== 6
7885 && strcmp (note
->namedata
, "LINUX") == 0)
7886 return elfcore_grok_ppc_vmx (abfd
, note
);
7892 if (bed
->elf_backend_grok_psinfo
)
7893 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7895 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7896 return elfcore_grok_psinfo (abfd
, note
);
7903 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
7908 sect
->size
= note
->descsz
;
7909 sect
->filepos
= note
->descpos
;
7910 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7918 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
7920 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
7921 elf_tdata (abfd
)->build_id
= bfd_alloc (abfd
, note
->descsz
);
7922 if (elf_tdata (abfd
)->build_id
== NULL
)
7925 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
7931 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7938 case NT_GNU_BUILD_ID
:
7939 return elfobj_grok_gnu_build_id (abfd
, note
);
7944 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
7948 cp
= strchr (note
->namedata
, '@');
7951 *lwpidp
= atoi(cp
+ 1);
7958 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7960 /* Signal number at offset 0x08. */
7961 elf_tdata (abfd
)->core_signal
7962 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
7964 /* Process ID at offset 0x50. */
7965 elf_tdata (abfd
)->core_pid
7966 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
7968 /* Command name at 0x7c (max 32 bytes, including nul). */
7969 elf_tdata (abfd
)->core_command
7970 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7972 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7977 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7981 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7982 elf_tdata (abfd
)->core_lwpid
= lwp
;
7984 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7986 /* NetBSD-specific core "procinfo". Note that we expect to
7987 find this note before any of the others, which is fine,
7988 since the kernel writes this note out first when it
7989 creates a core file. */
7991 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7994 /* As of Jan 2002 there are no other machine-independent notes
7995 defined for NetBSD core files. If the note type is less
7996 than the start of the machine-dependent note types, we don't
7999 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8003 switch (bfd_get_arch (abfd
))
8005 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8006 PT_GETFPREGS == mach+2. */
8008 case bfd_arch_alpha
:
8009 case bfd_arch_sparc
:
8012 case NT_NETBSDCORE_FIRSTMACH
+0:
8013 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8015 case NT_NETBSDCORE_FIRSTMACH
+2:
8016 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8022 /* On all other arch's, PT_GETREGS == mach+1 and
8023 PT_GETFPREGS == mach+3. */
8028 case NT_NETBSDCORE_FIRSTMACH
+1:
8029 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8031 case NT_NETBSDCORE_FIRSTMACH
+3:
8032 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8042 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8044 void *ddata
= note
->descdata
;
8051 /* nto_procfs_status 'pid' field is at offset 0. */
8052 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8054 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8055 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8057 /* nto_procfs_status 'flags' field is at offset 8. */
8058 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8060 /* nto_procfs_status 'what' field is at offset 14. */
8061 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8063 elf_tdata (abfd
)->core_signal
= sig
;
8064 elf_tdata (abfd
)->core_lwpid
= *tid
;
8067 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8068 do not come from signals so we make sure we set the current
8069 thread just in case. */
8070 if (flags
& 0x00000080)
8071 elf_tdata (abfd
)->core_lwpid
= *tid
;
8073 /* Make a ".qnx_core_status/%d" section. */
8074 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8076 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8081 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8085 sect
->size
= note
->descsz
;
8086 sect
->filepos
= note
->descpos
;
8087 sect
->alignment_power
= 2;
8089 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8093 elfcore_grok_nto_regs (bfd
*abfd
,
8094 Elf_Internal_Note
*note
,
8102 /* Make a "(base)/%d" section. */
8103 sprintf (buf
, "%s/%ld", base
, tid
);
8105 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8110 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8114 sect
->size
= note
->descsz
;
8115 sect
->filepos
= note
->descpos
;
8116 sect
->alignment_power
= 2;
8118 /* This is the current thread. */
8119 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8120 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8125 #define BFD_QNT_CORE_INFO 7
8126 #define BFD_QNT_CORE_STATUS 8
8127 #define BFD_QNT_CORE_GREG 9
8128 #define BFD_QNT_CORE_FPREG 10
8131 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8133 /* Every GREG section has a STATUS section before it. Store the
8134 tid from the previous call to pass down to the next gregs
8136 static long tid
= 1;
8140 case BFD_QNT_CORE_INFO
:
8141 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8142 case BFD_QNT_CORE_STATUS
:
8143 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8144 case BFD_QNT_CORE_GREG
:
8145 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8146 case BFD_QNT_CORE_FPREG
:
8147 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8154 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8160 /* Use note name as section name. */
8162 name
= bfd_alloc (abfd
, len
);
8165 memcpy (name
, note
->namedata
, len
);
8166 name
[len
- 1] = '\0';
8168 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8172 sect
->size
= note
->descsz
;
8173 sect
->filepos
= note
->descpos
;
8174 sect
->alignment_power
= 1;
8179 /* Function: elfcore_write_note
8182 buffer to hold note, and current size of buffer
8186 size of data for note
8188 Writes note to end of buffer. ELF64 notes are written exactly as
8189 for ELF32, despite the current (as of 2006) ELF gabi specifying
8190 that they ought to have 8-byte namesz and descsz field, and have
8191 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8194 Pointer to realloc'd buffer, *BUFSIZ updated. */
8197 elfcore_write_note (bfd
*abfd
,
8205 Elf_External_Note
*xnp
;
8212 namesz
= strlen (name
) + 1;
8214 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8216 buf
= realloc (buf
, *bufsiz
+ newspace
);
8219 dest
= buf
+ *bufsiz
;
8220 *bufsiz
+= newspace
;
8221 xnp
= (Elf_External_Note
*) dest
;
8222 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8223 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8224 H_PUT_32 (abfd
, type
, xnp
->type
);
8228 memcpy (dest
, name
, namesz
);
8236 memcpy (dest
, input
, size
);
8246 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8248 elfcore_write_prpsinfo (bfd
*abfd
,
8254 const char *note_name
= "CORE";
8255 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8257 if (bed
->elf_backend_write_core_note
!= NULL
)
8260 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8261 NT_PRPSINFO
, fname
, psargs
);
8266 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8267 if (bed
->s
->elfclass
== ELFCLASS32
)
8269 #if defined (HAVE_PSINFO32_T)
8271 int note_type
= NT_PSINFO
;
8274 int note_type
= NT_PRPSINFO
;
8277 memset (&data
, 0, sizeof (data
));
8278 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8279 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8280 return elfcore_write_note (abfd
, buf
, bufsiz
,
8281 note_name
, note_type
, &data
, sizeof (data
));
8286 #if defined (HAVE_PSINFO_T)
8288 int note_type
= NT_PSINFO
;
8291 int note_type
= NT_PRPSINFO
;
8294 memset (&data
, 0, sizeof (data
));
8295 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8296 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8297 return elfcore_write_note (abfd
, buf
, bufsiz
,
8298 note_name
, note_type
, &data
, sizeof (data
));
8301 #endif /* PSINFO_T or PRPSINFO_T */
8303 #if defined (HAVE_PRSTATUS_T)
8305 elfcore_write_prstatus (bfd
*abfd
,
8312 const char *note_name
= "CORE";
8313 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8315 if (bed
->elf_backend_write_core_note
!= NULL
)
8318 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8320 pid
, cursig
, gregs
);
8325 #if defined (HAVE_PRSTATUS32_T)
8326 if (bed
->s
->elfclass
== ELFCLASS32
)
8328 prstatus32_t prstat
;
8330 memset (&prstat
, 0, sizeof (prstat
));
8331 prstat
.pr_pid
= pid
;
8332 prstat
.pr_cursig
= cursig
;
8333 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8334 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8335 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8342 memset (&prstat
, 0, sizeof (prstat
));
8343 prstat
.pr_pid
= pid
;
8344 prstat
.pr_cursig
= cursig
;
8345 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8346 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8347 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8350 #endif /* HAVE_PRSTATUS_T */
8352 #if defined (HAVE_LWPSTATUS_T)
8354 elfcore_write_lwpstatus (bfd
*abfd
,
8361 lwpstatus_t lwpstat
;
8362 const char *note_name
= "CORE";
8364 memset (&lwpstat
, 0, sizeof (lwpstat
));
8365 lwpstat
.pr_lwpid
= pid
>> 16;
8366 lwpstat
.pr_cursig
= cursig
;
8367 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8368 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8369 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8371 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8372 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8374 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8375 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8378 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8379 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8381 #endif /* HAVE_LWPSTATUS_T */
8383 #if defined (HAVE_PSTATUS_T)
8385 elfcore_write_pstatus (bfd
*abfd
,
8389 int cursig ATTRIBUTE_UNUSED
,
8390 const void *gregs ATTRIBUTE_UNUSED
)
8392 const char *note_name
= "CORE";
8393 #if defined (HAVE_PSTATUS32_T)
8394 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8396 if (bed
->s
->elfclass
== ELFCLASS32
)
8400 memset (&pstat
, 0, sizeof (pstat
));
8401 pstat
.pr_pid
= pid
& 0xffff;
8402 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8403 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8411 memset (&pstat
, 0, sizeof (pstat
));
8412 pstat
.pr_pid
= pid
& 0xffff;
8413 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8414 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8418 #endif /* HAVE_PSTATUS_T */
8421 elfcore_write_prfpreg (bfd
*abfd
,
8427 const char *note_name
= "CORE";
8428 return elfcore_write_note (abfd
, buf
, bufsiz
,
8429 note_name
, NT_FPREGSET
, fpregs
, size
);
8433 elfcore_write_prxfpreg (bfd
*abfd
,
8436 const void *xfpregs
,
8439 char *note_name
= "LINUX";
8440 return elfcore_write_note (abfd
, buf
, bufsiz
,
8441 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8445 elfcore_write_ppc_vmx (bfd
*abfd
,
8448 const void *ppc_vmx
,
8451 char *note_name
= "LINUX";
8452 return elfcore_write_note (abfd
, buf
, bufsiz
,
8453 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
8457 elfcore_write_register_note (bfd
*abfd
,
8460 const char *section
,
8464 if (strcmp (section
, ".reg2") == 0)
8465 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
8466 if (strcmp (section
, ".reg-xfp") == 0)
8467 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
8468 if (strcmp (section
, ".reg-ppc-vmx") == 0)
8469 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
8474 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
8479 while (p
< buf
+ size
)
8481 /* FIXME: bad alignment assumption. */
8482 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8483 Elf_Internal_Note in
;
8485 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8487 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8488 in
.namedata
= xnp
->name
;
8490 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8491 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8492 in
.descpos
= offset
+ (in
.descdata
- buf
);
8494 switch (bfd_get_format (abfd
))
8500 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8502 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8505 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8507 if (! elfcore_grok_nto_note (abfd
, &in
))
8510 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
8512 if (! elfcore_grok_spu_note (abfd
, &in
))
8517 if (! elfcore_grok_note (abfd
, &in
))
8523 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
8525 if (! elfobj_grok_gnu_note (abfd
, &in
))
8531 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
8538 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
8545 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
8548 buf
= bfd_malloc (size
);
8552 if (bfd_bread (buf
, size
, abfd
) != size
8553 || !elf_parse_notes (abfd
, buf
, size
, offset
))
8563 /* Providing external access to the ELF program header table. */
8565 /* Return an upper bound on the number of bytes required to store a
8566 copy of ABFD's program header table entries. Return -1 if an error
8567 occurs; bfd_get_error will return an appropriate code. */
8570 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
8572 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8574 bfd_set_error (bfd_error_wrong_format
);
8578 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
8581 /* Copy ABFD's program header table entries to *PHDRS. The entries
8582 will be stored as an array of Elf_Internal_Phdr structures, as
8583 defined in include/elf/internal.h. To find out how large the
8584 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8586 Return the number of program header table entries read, or -1 if an
8587 error occurs; bfd_get_error will return an appropriate code. */
8590 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
8594 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8596 bfd_set_error (bfd_error_wrong_format
);
8600 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
8601 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
8602 num_phdrs
* sizeof (Elf_Internal_Phdr
));
8607 enum elf_reloc_type_class
8608 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
8610 return reloc_class_normal
;
8613 /* For RELA architectures, return the relocation value for a
8614 relocation against a local symbol. */
8617 _bfd_elf_rela_local_sym (bfd
*abfd
,
8618 Elf_Internal_Sym
*sym
,
8620 Elf_Internal_Rela
*rel
)
8622 asection
*sec
= *psec
;
8625 relocation
= (sec
->output_section
->vma
8626 + sec
->output_offset
8628 if ((sec
->flags
& SEC_MERGE
)
8629 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8630 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8633 _bfd_merged_section_offset (abfd
, psec
,
8634 elf_section_data (sec
)->sec_info
,
8635 sym
->st_value
+ rel
->r_addend
);
8638 /* If we have changed the section, and our original section is
8639 marked with SEC_EXCLUDE, it means that the original
8640 SEC_MERGE section has been completely subsumed in some
8641 other SEC_MERGE section. In this case, we need to leave
8642 some info around for --emit-relocs. */
8643 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8644 sec
->kept_section
= *psec
;
8647 rel
->r_addend
-= relocation
;
8648 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8654 _bfd_elf_rel_local_sym (bfd
*abfd
,
8655 Elf_Internal_Sym
*sym
,
8659 asection
*sec
= *psec
;
8661 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8662 return sym
->st_value
+ addend
;
8664 return _bfd_merged_section_offset (abfd
, psec
,
8665 elf_section_data (sec
)->sec_info
,
8666 sym
->st_value
+ addend
);
8670 _bfd_elf_section_offset (bfd
*abfd
,
8671 struct bfd_link_info
*info
,
8675 switch (sec
->sec_info_type
)
8677 case ELF_INFO_TYPE_STABS
:
8678 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8680 case ELF_INFO_TYPE_EH_FRAME
:
8681 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8687 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8688 reconstruct an ELF file by reading the segments out of remote memory
8689 based on the ELF file header at EHDR_VMA and the ELF program headers it
8690 points to. If not null, *LOADBASEP is filled in with the difference
8691 between the VMAs from which the segments were read, and the VMAs the
8692 file headers (and hence BFD's idea of each section's VMA) put them at.
8694 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8695 remote memory at target address VMA into the local buffer at MYADDR; it
8696 should return zero on success or an `errno' code on failure. TEMPL must
8697 be a BFD for an ELF target with the word size and byte order found in
8698 the remote memory. */
8701 bfd_elf_bfd_from_remote_memory
8705 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8707 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8708 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8712 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8713 long symcount ATTRIBUTE_UNUSED
,
8714 asymbol
**syms ATTRIBUTE_UNUSED
,
8719 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8722 const char *relplt_name
;
8723 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8727 Elf_Internal_Shdr
*hdr
;
8733 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8736 if (dynsymcount
<= 0)
8739 if (!bed
->plt_sym_val
)
8742 relplt_name
= bed
->relplt_name
;
8743 if (relplt_name
== NULL
)
8744 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8745 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8749 hdr
= &elf_section_data (relplt
)->this_hdr
;
8750 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8751 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8754 plt
= bfd_get_section_by_name (abfd
, ".plt");
8758 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8759 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8762 count
= relplt
->size
/ hdr
->sh_entsize
;
8763 size
= count
* sizeof (asymbol
);
8764 p
= relplt
->relocation
;
8765 for (i
= 0; i
< count
; i
++, p
++)
8766 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8768 s
= *ret
= bfd_malloc (size
);
8772 names
= (char *) (s
+ count
);
8773 p
= relplt
->relocation
;
8775 for (i
= 0; i
< count
; i
++, p
++)
8780 addr
= bed
->plt_sym_val (i
, plt
, p
);
8781 if (addr
== (bfd_vma
) -1)
8784 *s
= **p
->sym_ptr_ptr
;
8785 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8786 we are defining a symbol, ensure one of them is set. */
8787 if ((s
->flags
& BSF_LOCAL
) == 0)
8788 s
->flags
|= BSF_GLOBAL
;
8790 s
->value
= addr
- plt
->vma
;
8793 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8794 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8796 memcpy (names
, "@plt", sizeof ("@plt"));
8797 names
+= sizeof ("@plt");
8804 /* It is only used by x86-64 so far. */
8805 asection _bfd_elf_large_com_section
8806 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
8807 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
8810 _bfd_elf_set_osabi (bfd
* abfd
,
8811 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
8813 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
8815 i_ehdrp
= elf_elfheader (abfd
);
8817 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
8821 /* Return TRUE for ELF symbol types that represent functions.
8822 This is the default version of this function, which is sufficient for
8823 most targets. It returns true if TYPE is STT_FUNC. */
8826 _bfd_elf_is_function_type (unsigned int type
)
8828 return (type
== STT_FUNC
);