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' */
894 { NULL
, 0 }, /* 't' */
895 { NULL
, 0 }, /* 'u' */
896 { NULL
, 0 }, /* 'v' */
897 { NULL
, 0 }, /* 'w' */
898 { NULL
, 0 }, /* 'x' */
899 { NULL
, 0 }, /* 'y' */
900 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
905 int i
= name
[1] - 'd';
907 && i
< (int) ARRAY_SIZE (debug_sections
)
908 && debug_sections
[i
].name
!= NULL
909 && strncmp (&name
[1], debug_sections
[i
].name
,
910 debug_sections
[i
].len
) == 0)
911 flags
|= SEC_DEBUGGING
;
915 /* As a GNU extension, if the name begins with .gnu.linkonce, we
916 only link a single copy of the section. This is used to support
917 g++. g++ will emit each template expansion in its own section.
918 The symbols will be defined as weak, so that multiple definitions
919 are permitted. The GNU linker extension is to actually discard
920 all but one of the sections. */
921 if (CONST_STRNEQ (name
, ".gnu.linkonce")
922 && elf_next_in_group (newsect
) == NULL
)
923 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
925 bed
= get_elf_backend_data (abfd
);
926 if (bed
->elf_backend_section_flags
)
927 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
930 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
933 /* We do not parse the PT_NOTE segments as we are interested even in the
934 separate debug info files which may have the segments offsets corrupted.
935 PT_NOTEs from the core files are currently not parsed using BFD. */
936 if (hdr
->sh_type
== SHT_NOTE
)
940 contents
= bfd_malloc (hdr
->sh_size
);
944 if (!bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
, 0,
946 || !elf_parse_notes (abfd
, contents
, hdr
->sh_size
, -1))
955 if ((flags
& SEC_ALLOC
) != 0)
957 Elf_Internal_Phdr
*phdr
;
958 unsigned int i
, nload
;
960 /* Some ELF linkers produce binaries with all the program header
961 p_paddr fields zero. If we have such a binary with more than
962 one PT_LOAD header, then leave the section lma equal to vma
963 so that we don't create sections with overlapping lma. */
964 phdr
= elf_tdata (abfd
)->phdr
;
965 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
966 if (phdr
->p_paddr
!= 0)
968 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
970 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
973 phdr
= elf_tdata (abfd
)->phdr
;
974 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
976 /* This section is part of this segment if its file
977 offset plus size lies within the segment's memory
978 span and, if the section is loaded, the extent of the
979 loaded data lies within the extent of the segment.
981 Note - we used to check the p_paddr field as well, and
982 refuse to set the LMA if it was 0. This is wrong
983 though, as a perfectly valid initialised segment can
984 have a p_paddr of zero. Some architectures, eg ARM,
985 place special significance on the address 0 and
986 executables need to be able to have a segment which
987 covers this address. */
988 if (phdr
->p_type
== PT_LOAD
989 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
990 && (hdr
->sh_offset
+ hdr
->sh_size
991 <= phdr
->p_offset
+ phdr
->p_memsz
)
992 && ((flags
& SEC_LOAD
) == 0
993 || (hdr
->sh_offset
+ hdr
->sh_size
994 <= phdr
->p_offset
+ phdr
->p_filesz
)))
996 if ((flags
& SEC_LOAD
) == 0)
997 newsect
->lma
= (phdr
->p_paddr
998 + hdr
->sh_addr
- phdr
->p_vaddr
);
1000 /* We used to use the same adjustment for SEC_LOAD
1001 sections, but that doesn't work if the segment
1002 is packed with code from multiple VMAs.
1003 Instead we calculate the section LMA based on
1004 the segment LMA. It is assumed that the
1005 segment will contain sections with contiguous
1006 LMAs, even if the VMAs are not. */
1007 newsect
->lma
= (phdr
->p_paddr
1008 + hdr
->sh_offset
- phdr
->p_offset
);
1010 /* With contiguous segments, we can't tell from file
1011 offsets whether a section with zero size should
1012 be placed at the end of one segment or the
1013 beginning of the next. Decide based on vaddr. */
1014 if (hdr
->sh_addr
>= phdr
->p_vaddr
1015 && (hdr
->sh_addr
+ hdr
->sh_size
1016 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1027 bfd_elf_find_section
1030 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
1033 Helper functions for GDB to locate the string tables.
1034 Since BFD hides string tables from callers, GDB needs to use an
1035 internal hook to find them. Sun's .stabstr, in particular,
1036 isn't even pointed to by the .stab section, so ordinary
1037 mechanisms wouldn't work to find it, even if we had some.
1040 struct elf_internal_shdr
*
1041 bfd_elf_find_section (bfd
*abfd
, char *name
)
1043 Elf_Internal_Shdr
**i_shdrp
;
1048 i_shdrp
= elf_elfsections (abfd
);
1049 if (i_shdrp
!= NULL
)
1051 shstrtab
= bfd_elf_get_str_section (abfd
,
1052 elf_elfheader (abfd
)->e_shstrndx
);
1053 if (shstrtab
!= NULL
)
1055 max
= elf_numsections (abfd
);
1056 for (i
= 1; i
< max
; i
++)
1057 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
1064 const char *const bfd_elf_section_type_names
[] = {
1065 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1066 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1067 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1070 /* ELF relocs are against symbols. If we are producing relocatable
1071 output, and the reloc is against an external symbol, and nothing
1072 has given us any additional addend, the resulting reloc will also
1073 be against the same symbol. In such a case, we don't want to
1074 change anything about the way the reloc is handled, since it will
1075 all be done at final link time. Rather than put special case code
1076 into bfd_perform_relocation, all the reloc types use this howto
1077 function. It just short circuits the reloc if producing
1078 relocatable output against an external symbol. */
1080 bfd_reloc_status_type
1081 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1082 arelent
*reloc_entry
,
1084 void *data ATTRIBUTE_UNUSED
,
1085 asection
*input_section
,
1087 char **error_message ATTRIBUTE_UNUSED
)
1089 if (output_bfd
!= NULL
1090 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1091 && (! reloc_entry
->howto
->partial_inplace
1092 || reloc_entry
->addend
== 0))
1094 reloc_entry
->address
+= input_section
->output_offset
;
1095 return bfd_reloc_ok
;
1098 return bfd_reloc_continue
;
1101 /* Copy the program header and other data from one object module to
1105 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1107 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1108 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1111 BFD_ASSERT (!elf_flags_init (obfd
)
1112 || (elf_elfheader (obfd
)->e_flags
1113 == elf_elfheader (ibfd
)->e_flags
));
1115 elf_gp (obfd
) = elf_gp (ibfd
);
1116 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1117 elf_flags_init (obfd
) = TRUE
;
1119 /* Copy object attributes. */
1120 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1126 get_segment_type (unsigned int p_type
)
1131 case PT_NULL
: pt
= "NULL"; break;
1132 case PT_LOAD
: pt
= "LOAD"; break;
1133 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1134 case PT_INTERP
: pt
= "INTERP"; break;
1135 case PT_NOTE
: pt
= "NOTE"; break;
1136 case PT_SHLIB
: pt
= "SHLIB"; break;
1137 case PT_PHDR
: pt
= "PHDR"; break;
1138 case PT_TLS
: pt
= "TLS"; break;
1139 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1140 case PT_GNU_STACK
: pt
= "STACK"; break;
1141 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1142 default: pt
= NULL
; break;
1147 /* Print out the program headers. */
1150 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1153 Elf_Internal_Phdr
*p
;
1155 bfd_byte
*dynbuf
= NULL
;
1157 p
= elf_tdata (abfd
)->phdr
;
1162 fprintf (f
, _("\nProgram Header:\n"));
1163 c
= elf_elfheader (abfd
)->e_phnum
;
1164 for (i
= 0; i
< c
; i
++, p
++)
1166 const char *pt
= get_segment_type (p
->p_type
);
1171 sprintf (buf
, "0x%lx", p
->p_type
);
1174 fprintf (f
, "%8s off 0x", pt
);
1175 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1176 fprintf (f
, " vaddr 0x");
1177 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1178 fprintf (f
, " paddr 0x");
1179 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1180 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1181 fprintf (f
, " filesz 0x");
1182 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1183 fprintf (f
, " memsz 0x");
1184 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1185 fprintf (f
, " flags %c%c%c",
1186 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1187 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1188 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1189 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1190 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1195 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1198 unsigned int elfsec
;
1199 unsigned long shlink
;
1200 bfd_byte
*extdyn
, *extdynend
;
1202 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1204 fprintf (f
, _("\nDynamic Section:\n"));
1206 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1209 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1210 if (elfsec
== SHN_BAD
)
1212 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1214 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1215 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1218 extdynend
= extdyn
+ s
->size
;
1219 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1221 Elf_Internal_Dyn dyn
;
1222 const char *name
= "";
1224 bfd_boolean stringp
;
1225 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1227 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1229 if (dyn
.d_tag
== DT_NULL
)
1236 if (bed
->elf_backend_get_target_dtag
)
1237 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1239 if (!strcmp (name
, ""))
1241 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1246 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1247 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1248 case DT_PLTGOT
: name
= "PLTGOT"; break;
1249 case DT_HASH
: name
= "HASH"; break;
1250 case DT_STRTAB
: name
= "STRTAB"; break;
1251 case DT_SYMTAB
: name
= "SYMTAB"; break;
1252 case DT_RELA
: name
= "RELA"; break;
1253 case DT_RELASZ
: name
= "RELASZ"; break;
1254 case DT_RELAENT
: name
= "RELAENT"; break;
1255 case DT_STRSZ
: name
= "STRSZ"; break;
1256 case DT_SYMENT
: name
= "SYMENT"; break;
1257 case DT_INIT
: name
= "INIT"; break;
1258 case DT_FINI
: name
= "FINI"; break;
1259 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1260 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1261 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1262 case DT_REL
: name
= "REL"; break;
1263 case DT_RELSZ
: name
= "RELSZ"; break;
1264 case DT_RELENT
: name
= "RELENT"; break;
1265 case DT_PLTREL
: name
= "PLTREL"; break;
1266 case DT_DEBUG
: name
= "DEBUG"; break;
1267 case DT_TEXTREL
: name
= "TEXTREL"; break;
1268 case DT_JMPREL
: name
= "JMPREL"; break;
1269 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1270 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1271 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1272 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1273 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1274 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1275 case DT_FLAGS
: name
= "FLAGS"; break;
1276 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1277 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1278 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1279 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1280 case DT_MOVEENT
: name
= "MOVEENT"; break;
1281 case DT_MOVESZ
: name
= "MOVESZ"; break;
1282 case DT_FEATURE
: name
= "FEATURE"; break;
1283 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1284 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1285 case DT_SYMINENT
: name
= "SYMINENT"; break;
1286 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1287 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1288 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1289 case DT_PLTPAD
: name
= "PLTPAD"; break;
1290 case DT_MOVETAB
: name
= "MOVETAB"; break;
1291 case DT_SYMINFO
: name
= "SYMINFO"; break;
1292 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1293 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1294 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1295 case DT_VERSYM
: name
= "VERSYM"; break;
1296 case DT_VERDEF
: name
= "VERDEF"; break;
1297 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1298 case DT_VERNEED
: name
= "VERNEED"; break;
1299 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1300 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1301 case DT_USED
: name
= "USED"; break;
1302 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1303 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1306 fprintf (f
, " %-20s ", name
);
1310 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1315 unsigned int tagv
= dyn
.d_un
.d_val
;
1317 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1320 fprintf (f
, "%s", string
);
1329 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1330 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1332 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1336 if (elf_dynverdef (abfd
) != 0)
1338 Elf_Internal_Verdef
*t
;
1340 fprintf (f
, _("\nVersion definitions:\n"));
1341 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1343 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1344 t
->vd_flags
, t
->vd_hash
,
1345 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1346 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1348 Elf_Internal_Verdaux
*a
;
1351 for (a
= t
->vd_auxptr
->vda_nextptr
;
1355 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1361 if (elf_dynverref (abfd
) != 0)
1363 Elf_Internal_Verneed
*t
;
1365 fprintf (f
, _("\nVersion References:\n"));
1366 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1368 Elf_Internal_Vernaux
*a
;
1370 fprintf (f
, _(" required from %s:\n"),
1371 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1372 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1373 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1374 a
->vna_flags
, a
->vna_other
,
1375 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1387 /* Display ELF-specific fields of a symbol. */
1390 bfd_elf_print_symbol (bfd
*abfd
,
1393 bfd_print_symbol_type how
)
1398 case bfd_print_symbol_name
:
1399 fprintf (file
, "%s", symbol
->name
);
1401 case bfd_print_symbol_more
:
1402 fprintf (file
, "elf ");
1403 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1404 fprintf (file
, " %lx", (long) symbol
->flags
);
1406 case bfd_print_symbol_all
:
1408 const char *section_name
;
1409 const char *name
= NULL
;
1410 const struct elf_backend_data
*bed
;
1411 unsigned char st_other
;
1414 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1416 bed
= get_elf_backend_data (abfd
);
1417 if (bed
->elf_backend_print_symbol_all
)
1418 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1422 name
= symbol
->name
;
1423 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1426 fprintf (file
, " %s\t", section_name
);
1427 /* Print the "other" value for a symbol. For common symbols,
1428 we've already printed the size; now print the alignment.
1429 For other symbols, we have no specified alignment, and
1430 we've printed the address; now print the size. */
1431 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1432 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1434 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1435 bfd_fprintf_vma (abfd
, file
, val
);
1437 /* If we have version information, print it. */
1438 if (elf_tdata (abfd
)->dynversym_section
!= 0
1439 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1440 || elf_tdata (abfd
)->dynverref_section
!= 0))
1442 unsigned int vernum
;
1443 const char *version_string
;
1445 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1448 version_string
= "";
1449 else if (vernum
== 1)
1450 version_string
= "Base";
1451 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1453 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1456 Elf_Internal_Verneed
*t
;
1458 version_string
= "";
1459 for (t
= elf_tdata (abfd
)->verref
;
1463 Elf_Internal_Vernaux
*a
;
1465 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1467 if (a
->vna_other
== vernum
)
1469 version_string
= a
->vna_nodename
;
1476 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1477 fprintf (file
, " %-11s", version_string
);
1482 fprintf (file
, " (%s)", version_string
);
1483 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1488 /* If the st_other field is not zero, print it. */
1489 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1494 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1495 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1496 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1498 /* Some other non-defined flags are also present, so print
1500 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1503 fprintf (file
, " %s", name
);
1509 /* Allocate an ELF string table--force the first byte to be zero. */
1511 struct bfd_strtab_hash
*
1512 _bfd_elf_stringtab_init (void)
1514 struct bfd_strtab_hash
*ret
;
1516 ret
= _bfd_stringtab_init ();
1521 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1522 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1523 if (loc
== (bfd_size_type
) -1)
1525 _bfd_stringtab_free (ret
);
1532 /* ELF .o/exec file reading */
1534 /* Create a new bfd section from an ELF section header. */
1537 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1539 Elf_Internal_Shdr
*hdr
;
1540 Elf_Internal_Ehdr
*ehdr
;
1541 const struct elf_backend_data
*bed
;
1544 if (shindex
>= elf_numsections (abfd
))
1547 hdr
= elf_elfsections (abfd
)[shindex
];
1548 ehdr
= elf_elfheader (abfd
);
1549 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1554 bed
= get_elf_backend_data (abfd
);
1555 switch (hdr
->sh_type
)
1558 /* Inactive section. Throw it away. */
1561 case SHT_PROGBITS
: /* Normal section with contents. */
1562 case SHT_NOBITS
: /* .bss section. */
1563 case SHT_HASH
: /* .hash section. */
1564 case SHT_NOTE
: /* .note section. */
1565 case SHT_INIT_ARRAY
: /* .init_array section. */
1566 case SHT_FINI_ARRAY
: /* .fini_array section. */
1567 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1568 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1569 case SHT_GNU_HASH
: /* .gnu.hash section. */
1570 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1572 case SHT_DYNAMIC
: /* Dynamic linking information. */
1573 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1575 if (hdr
->sh_link
> elf_numsections (abfd
)
1576 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1578 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1580 Elf_Internal_Shdr
*dynsymhdr
;
1582 /* The shared libraries distributed with hpux11 have a bogus
1583 sh_link field for the ".dynamic" section. Find the
1584 string table for the ".dynsym" section instead. */
1585 if (elf_dynsymtab (abfd
) != 0)
1587 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1588 hdr
->sh_link
= dynsymhdr
->sh_link
;
1592 unsigned int i
, num_sec
;
1594 num_sec
= elf_numsections (abfd
);
1595 for (i
= 1; i
< num_sec
; i
++)
1597 dynsymhdr
= elf_elfsections (abfd
)[i
];
1598 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1600 hdr
->sh_link
= dynsymhdr
->sh_link
;
1608 case SHT_SYMTAB
: /* A symbol table */
1609 if (elf_onesymtab (abfd
) == shindex
)
1612 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1614 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1615 elf_onesymtab (abfd
) = shindex
;
1616 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1617 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1618 abfd
->flags
|= HAS_SYMS
;
1620 /* Sometimes a shared object will map in the symbol table. If
1621 SHF_ALLOC is set, and this is a shared object, then we also
1622 treat this section as a BFD section. We can not base the
1623 decision purely on SHF_ALLOC, because that flag is sometimes
1624 set in a relocatable object file, which would confuse the
1626 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1627 && (abfd
->flags
& DYNAMIC
) != 0
1628 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1632 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1633 can't read symbols without that section loaded as well. It
1634 is most likely specified by the next section header. */
1635 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1637 unsigned int i
, num_sec
;
1639 num_sec
= elf_numsections (abfd
);
1640 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1642 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1643 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1644 && hdr2
->sh_link
== shindex
)
1648 for (i
= 1; i
< shindex
; i
++)
1650 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1651 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1652 && hdr2
->sh_link
== shindex
)
1656 return bfd_section_from_shdr (abfd
, i
);
1660 case SHT_DYNSYM
: /* A dynamic symbol table */
1661 if (elf_dynsymtab (abfd
) == shindex
)
1664 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1666 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1667 elf_dynsymtab (abfd
) = shindex
;
1668 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1669 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1670 abfd
->flags
|= HAS_SYMS
;
1672 /* Besides being a symbol table, we also treat this as a regular
1673 section, so that objcopy can handle it. */
1674 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1676 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1677 if (elf_symtab_shndx (abfd
) == shindex
)
1680 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1681 elf_symtab_shndx (abfd
) = shindex
;
1682 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1683 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1686 case SHT_STRTAB
: /* A string table */
1687 if (hdr
->bfd_section
!= NULL
)
1689 if (ehdr
->e_shstrndx
== shindex
)
1691 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1692 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1695 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1698 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1699 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1702 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1705 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1706 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1707 elf_elfsections (abfd
)[shindex
] = hdr
;
1708 /* We also treat this as a regular section, so that objcopy
1710 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1714 /* If the string table isn't one of the above, then treat it as a
1715 regular section. We need to scan all the headers to be sure,
1716 just in case this strtab section appeared before the above. */
1717 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1719 unsigned int i
, num_sec
;
1721 num_sec
= elf_numsections (abfd
);
1722 for (i
= 1; i
< num_sec
; i
++)
1724 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1725 if (hdr2
->sh_link
== shindex
)
1727 /* Prevent endless recursion on broken objects. */
1730 if (! bfd_section_from_shdr (abfd
, i
))
1732 if (elf_onesymtab (abfd
) == i
)
1734 if (elf_dynsymtab (abfd
) == i
)
1735 goto dynsymtab_strtab
;
1739 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1743 /* *These* do a lot of work -- but build no sections! */
1745 asection
*target_sect
;
1746 Elf_Internal_Shdr
*hdr2
;
1747 unsigned int num_sec
= elf_numsections (abfd
);
1750 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1751 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1754 /* Check for a bogus link to avoid crashing. */
1755 if (hdr
->sh_link
>= num_sec
)
1757 ((*_bfd_error_handler
)
1758 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1759 abfd
, hdr
->sh_link
, name
, shindex
));
1760 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1764 /* For some incomprehensible reason Oracle distributes
1765 libraries for Solaris in which some of the objects have
1766 bogus sh_link fields. It would be nice if we could just
1767 reject them, but, unfortunately, some people need to use
1768 them. We scan through the section headers; if we find only
1769 one suitable symbol table, we clobber the sh_link to point
1770 to it. I hope this doesn't break anything. */
1771 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1772 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1778 for (scan
= 1; scan
< num_sec
; scan
++)
1780 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1781 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1792 hdr
->sh_link
= found
;
1795 /* Get the symbol table. */
1796 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1797 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1798 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1801 /* If this reloc section does not use the main symbol table we
1802 don't treat it as a reloc section. BFD can't adequately
1803 represent such a section, so at least for now, we don't
1804 try. We just present it as a normal section. We also
1805 can't use it as a reloc section if it points to the null
1806 section, an invalid section, or another reloc section. */
1807 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1808 || hdr
->sh_info
== SHN_UNDEF
1809 || hdr
->sh_info
>= num_sec
1810 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1811 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1812 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1815 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1817 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1818 if (target_sect
== NULL
)
1821 if ((target_sect
->flags
& SEC_RELOC
) == 0
1822 || target_sect
->reloc_count
== 0)
1823 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1827 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1828 amt
= sizeof (*hdr2
);
1829 hdr2
= bfd_alloc (abfd
, amt
);
1832 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1835 elf_elfsections (abfd
)[shindex
] = hdr2
;
1836 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1837 target_sect
->flags
|= SEC_RELOC
;
1838 target_sect
->relocation
= NULL
;
1839 target_sect
->rel_filepos
= hdr
->sh_offset
;
1840 /* In the section to which the relocations apply, mark whether
1841 its relocations are of the REL or RELA variety. */
1842 if (hdr
->sh_size
!= 0)
1843 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1844 abfd
->flags
|= HAS_RELOC
;
1848 case SHT_GNU_verdef
:
1849 elf_dynverdef (abfd
) = shindex
;
1850 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1851 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1853 case SHT_GNU_versym
:
1854 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1856 elf_dynversym (abfd
) = shindex
;
1857 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1858 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1860 case SHT_GNU_verneed
:
1861 elf_dynverref (abfd
) = shindex
;
1862 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1863 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1869 /* We need a BFD section for objcopy and relocatable linking,
1870 and it's handy to have the signature available as the section
1872 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1874 name
= group_signature (abfd
, hdr
);
1877 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1879 if (hdr
->contents
!= NULL
)
1881 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1882 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1885 if (idx
->flags
& GRP_COMDAT
)
1886 hdr
->bfd_section
->flags
1887 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1889 /* We try to keep the same section order as it comes in. */
1891 while (--n_elt
!= 0)
1895 if (idx
->shdr
!= NULL
1896 && (s
= idx
->shdr
->bfd_section
) != NULL
1897 && elf_next_in_group (s
) != NULL
)
1899 elf_next_in_group (hdr
->bfd_section
) = s
;
1907 /* Possibly an attributes section. */
1908 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1909 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1911 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1913 _bfd_elf_parse_attributes (abfd
, hdr
);
1917 /* Check for any processor-specific section types. */
1918 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1921 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1923 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1924 /* FIXME: How to properly handle allocated section reserved
1925 for applications? */
1926 (*_bfd_error_handler
)
1927 (_("%B: don't know how to handle allocated, application "
1928 "specific section `%s' [0x%8x]"),
1929 abfd
, name
, hdr
->sh_type
);
1931 /* Allow sections reserved for applications. */
1932 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1935 else if (hdr
->sh_type
>= SHT_LOPROC
1936 && hdr
->sh_type
<= SHT_HIPROC
)
1937 /* FIXME: We should handle this section. */
1938 (*_bfd_error_handler
)
1939 (_("%B: don't know how to handle processor specific section "
1941 abfd
, name
, hdr
->sh_type
);
1942 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1944 /* Unrecognised OS-specific sections. */
1945 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1946 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1947 required to correctly process the section and the file should
1948 be rejected with an error message. */
1949 (*_bfd_error_handler
)
1950 (_("%B: don't know how to handle OS specific section "
1952 abfd
, name
, hdr
->sh_type
);
1954 /* Otherwise it should be processed. */
1955 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1958 /* FIXME: We should handle this section. */
1959 (*_bfd_error_handler
)
1960 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1961 abfd
, name
, hdr
->sh_type
);
1969 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1970 Return SEC for sections that have no elf section, and NULL on error. */
1973 bfd_section_from_r_symndx (bfd
*abfd
,
1974 struct sym_sec_cache
*cache
,
1976 unsigned long r_symndx
)
1978 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1981 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1983 Elf_Internal_Shdr
*symtab_hdr
;
1984 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1985 Elf_External_Sym_Shndx eshndx
;
1986 Elf_Internal_Sym isym
;
1988 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1989 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1990 &isym
, esym
, &eshndx
) == NULL
)
1993 if (cache
->abfd
!= abfd
)
1995 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1998 cache
->indx
[ent
] = r_symndx
;
1999 cache
->shndx
[ent
] = isym
.st_shndx
;
2002 s
= bfd_section_from_elf_index (abfd
, cache
->shndx
[ent
]);
2009 /* Given an ELF section number, retrieve the corresponding BFD
2013 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2015 if (index
>= elf_numsections (abfd
))
2017 return elf_elfsections (abfd
)[index
]->bfd_section
;
2020 static const struct bfd_elf_special_section special_sections_b
[] =
2022 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2023 { NULL
, 0, 0, 0, 0 }
2026 static const struct bfd_elf_special_section special_sections_c
[] =
2028 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2029 { NULL
, 0, 0, 0, 0 }
2032 static const struct bfd_elf_special_section special_sections_d
[] =
2034 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2035 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2036 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2037 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2038 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2039 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2040 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2041 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2042 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2043 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2044 { NULL
, 0, 0, 0, 0 }
2047 static const struct bfd_elf_special_section special_sections_f
[] =
2049 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2050 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2051 { NULL
, 0, 0, 0, 0 }
2054 static const struct bfd_elf_special_section special_sections_g
[] =
2056 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2057 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2058 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2059 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2060 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2061 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2062 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2063 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2064 { NULL
, 0, 0, 0, 0 }
2067 static const struct bfd_elf_special_section special_sections_h
[] =
2069 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2070 { NULL
, 0, 0, 0, 0 }
2073 static const struct bfd_elf_special_section special_sections_i
[] =
2075 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2076 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2077 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2078 { NULL
, 0, 0, 0, 0 }
2081 static const struct bfd_elf_special_section special_sections_l
[] =
2083 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2084 { NULL
, 0, 0, 0, 0 }
2087 static const struct bfd_elf_special_section special_sections_n
[] =
2089 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2090 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2091 { NULL
, 0, 0, 0, 0 }
2094 static const struct bfd_elf_special_section special_sections_p
[] =
2096 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2097 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2098 { NULL
, 0, 0, 0, 0 }
2101 static const struct bfd_elf_special_section special_sections_r
[] =
2103 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2104 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2105 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2106 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2107 { NULL
, 0, 0, 0, 0 }
2110 static const struct bfd_elf_special_section special_sections_s
[] =
2112 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2113 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2114 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2115 /* See struct bfd_elf_special_section declaration for the semantics of
2116 this special case where .prefix_length != strlen (.prefix). */
2117 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2118 { NULL
, 0, 0, 0, 0 }
2121 static const struct bfd_elf_special_section special_sections_t
[] =
2123 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2124 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2125 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2126 { NULL
, 0, 0, 0, 0 }
2129 static const struct bfd_elf_special_section special_sections_z
[] =
2131 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2132 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2133 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2134 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2135 { NULL
, 0, 0, 0, 0 }
2138 static const struct bfd_elf_special_section
*special_sections
[] =
2140 special_sections_b
, /* 'b' */
2141 special_sections_c
, /* 'c' */
2142 special_sections_d
, /* 'd' */
2144 special_sections_f
, /* 'f' */
2145 special_sections_g
, /* 'g' */
2146 special_sections_h
, /* 'h' */
2147 special_sections_i
, /* 'i' */
2150 special_sections_l
, /* 'l' */
2152 special_sections_n
, /* 'n' */
2154 special_sections_p
, /* 'p' */
2156 special_sections_r
, /* 'r' */
2157 special_sections_s
, /* 's' */
2158 special_sections_t
, /* 't' */
2164 special_sections_z
/* 'z' */
2167 const struct bfd_elf_special_section
*
2168 _bfd_elf_get_special_section (const char *name
,
2169 const struct bfd_elf_special_section
*spec
,
2175 len
= strlen (name
);
2177 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2180 int prefix_len
= spec
[i
].prefix_length
;
2182 if (len
< prefix_len
)
2184 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2187 suffix_len
= spec
[i
].suffix_length
;
2188 if (suffix_len
<= 0)
2190 if (name
[prefix_len
] != 0)
2192 if (suffix_len
== 0)
2194 if (name
[prefix_len
] != '.'
2195 && (suffix_len
== -2
2196 || (rela
&& spec
[i
].type
== SHT_REL
)))
2202 if (len
< prefix_len
+ suffix_len
)
2204 if (memcmp (name
+ len
- suffix_len
,
2205 spec
[i
].prefix
+ prefix_len
,
2215 const struct bfd_elf_special_section
*
2216 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2219 const struct bfd_elf_special_section
*spec
;
2220 const struct elf_backend_data
*bed
;
2222 /* See if this is one of the special sections. */
2223 if (sec
->name
== NULL
)
2226 bed
= get_elf_backend_data (abfd
);
2227 spec
= bed
->special_sections
;
2230 spec
= _bfd_elf_get_special_section (sec
->name
,
2231 bed
->special_sections
,
2237 if (sec
->name
[0] != '.')
2240 i
= sec
->name
[1] - 'b';
2241 if (i
< 0 || i
> 'z' - 'b')
2244 spec
= special_sections
[i
];
2249 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2253 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2255 struct bfd_elf_section_data
*sdata
;
2256 const struct elf_backend_data
*bed
;
2257 const struct bfd_elf_special_section
*ssect
;
2259 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2262 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2265 sec
->used_by_bfd
= sdata
;
2268 /* Indicate whether or not this section should use RELA relocations. */
2269 bed
= get_elf_backend_data (abfd
);
2270 sec
->use_rela_p
= bed
->default_use_rela_p
;
2272 /* When we read a file, we don't need to set ELF section type and
2273 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2274 anyway. We will set ELF section type and flags for all linker
2275 created sections. If user specifies BFD section flags, we will
2276 set ELF section type and flags based on BFD section flags in
2277 elf_fake_sections. */
2278 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2279 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2281 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2284 elf_section_type (sec
) = ssect
->type
;
2285 elf_section_flags (sec
) = ssect
->attr
;
2289 return _bfd_generic_new_section_hook (abfd
, sec
);
2292 /* Create a new bfd section from an ELF program header.
2294 Since program segments have no names, we generate a synthetic name
2295 of the form segment<NUM>, where NUM is generally the index in the
2296 program header table. For segments that are split (see below) we
2297 generate the names segment<NUM>a and segment<NUM>b.
2299 Note that some program segments may have a file size that is different than
2300 (less than) the memory size. All this means is that at execution the
2301 system must allocate the amount of memory specified by the memory size,
2302 but only initialize it with the first "file size" bytes read from the
2303 file. This would occur for example, with program segments consisting
2304 of combined data+bss.
2306 To handle the above situation, this routine generates TWO bfd sections
2307 for the single program segment. The first has the length specified by
2308 the file size of the segment, and the second has the length specified
2309 by the difference between the two sizes. In effect, the segment is split
2310 into its initialized and uninitialized parts.
2315 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2316 Elf_Internal_Phdr
*hdr
,
2318 const char *typename
)
2326 split
= ((hdr
->p_memsz
> 0)
2327 && (hdr
->p_filesz
> 0)
2328 && (hdr
->p_memsz
> hdr
->p_filesz
));
2330 if (hdr
->p_filesz
> 0)
2332 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2333 len
= strlen (namebuf
) + 1;
2334 name
= bfd_alloc (abfd
, len
);
2337 memcpy (name
, namebuf
, len
);
2338 newsect
= bfd_make_section (abfd
, name
);
2339 if (newsect
== NULL
)
2341 newsect
->vma
= hdr
->p_vaddr
;
2342 newsect
->lma
= hdr
->p_paddr
;
2343 newsect
->size
= hdr
->p_filesz
;
2344 newsect
->filepos
= hdr
->p_offset
;
2345 newsect
->flags
|= SEC_HAS_CONTENTS
;
2346 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2347 if (hdr
->p_type
== PT_LOAD
)
2349 newsect
->flags
|= SEC_ALLOC
;
2350 newsect
->flags
|= SEC_LOAD
;
2351 if (hdr
->p_flags
& PF_X
)
2353 /* FIXME: all we known is that it has execute PERMISSION,
2355 newsect
->flags
|= SEC_CODE
;
2358 if (!(hdr
->p_flags
& PF_W
))
2360 newsect
->flags
|= SEC_READONLY
;
2364 if (hdr
->p_memsz
> hdr
->p_filesz
)
2368 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "b" : "");
2369 len
= strlen (namebuf
) + 1;
2370 name
= bfd_alloc (abfd
, len
);
2373 memcpy (name
, namebuf
, len
);
2374 newsect
= bfd_make_section (abfd
, name
);
2375 if (newsect
== NULL
)
2377 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2378 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2379 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2380 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2381 align
= newsect
->vma
& -newsect
->vma
;
2382 if (align
== 0 || align
> hdr
->p_align
)
2383 align
= hdr
->p_align
;
2384 newsect
->alignment_power
= bfd_log2 (align
);
2385 if (hdr
->p_type
== PT_LOAD
)
2387 /* Hack for gdb. Segments that have not been modified do
2388 not have their contents written to a core file, on the
2389 assumption that a debugger can find the contents in the
2390 executable. We flag this case by setting the fake
2391 section size to zero. Note that "real" bss sections will
2392 always have their contents dumped to the core file. */
2393 if (bfd_get_format (abfd
) == bfd_core
)
2395 newsect
->flags
|= SEC_ALLOC
;
2396 if (hdr
->p_flags
& PF_X
)
2397 newsect
->flags
|= SEC_CODE
;
2399 if (!(hdr
->p_flags
& PF_W
))
2400 newsect
->flags
|= SEC_READONLY
;
2407 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2409 const struct elf_backend_data
*bed
;
2411 switch (hdr
->p_type
)
2414 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2417 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2420 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2423 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2426 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2428 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2433 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2436 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2438 case PT_GNU_EH_FRAME
:
2439 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2443 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2446 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2449 /* Check for any processor-specific program segment types. */
2450 bed
= get_elf_backend_data (abfd
);
2451 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2455 /* Initialize REL_HDR, the section-header for new section, containing
2456 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2457 relocations; otherwise, we use REL relocations. */
2460 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2461 Elf_Internal_Shdr
*rel_hdr
,
2463 bfd_boolean use_rela_p
)
2466 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2467 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2469 name
= bfd_alloc (abfd
, amt
);
2472 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2474 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2476 if (rel_hdr
->sh_name
== (unsigned int) -1)
2478 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2479 rel_hdr
->sh_entsize
= (use_rela_p
2480 ? bed
->s
->sizeof_rela
2481 : bed
->s
->sizeof_rel
);
2482 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2483 rel_hdr
->sh_flags
= 0;
2484 rel_hdr
->sh_addr
= 0;
2485 rel_hdr
->sh_size
= 0;
2486 rel_hdr
->sh_offset
= 0;
2491 /* Set up an ELF internal section header for a section. */
2494 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2496 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2497 bfd_boolean
*failedptr
= failedptrarg
;
2498 Elf_Internal_Shdr
*this_hdr
;
2499 unsigned int sh_type
;
2503 /* We already failed; just get out of the bfd_map_over_sections
2508 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2510 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2511 asect
->name
, FALSE
);
2512 if (this_hdr
->sh_name
== (unsigned int) -1)
2518 /* Don't clear sh_flags. Assembler may set additional bits. */
2520 if ((asect
->flags
& SEC_ALLOC
) != 0
2521 || asect
->user_set_vma
)
2522 this_hdr
->sh_addr
= asect
->vma
;
2524 this_hdr
->sh_addr
= 0;
2526 this_hdr
->sh_offset
= 0;
2527 this_hdr
->sh_size
= asect
->size
;
2528 this_hdr
->sh_link
= 0;
2529 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2530 /* The sh_entsize and sh_info fields may have been set already by
2531 copy_private_section_data. */
2533 this_hdr
->bfd_section
= asect
;
2534 this_hdr
->contents
= NULL
;
2536 /* If the section type is unspecified, we set it based on
2538 if ((asect
->flags
& SEC_GROUP
) != 0)
2539 sh_type
= SHT_GROUP
;
2540 else if ((asect
->flags
& SEC_ALLOC
) != 0
2541 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2542 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2543 sh_type
= SHT_NOBITS
;
2545 sh_type
= SHT_PROGBITS
;
2547 if (this_hdr
->sh_type
== SHT_NULL
)
2548 this_hdr
->sh_type
= sh_type
;
2549 else if (this_hdr
->sh_type
== SHT_NOBITS
2550 && sh_type
== SHT_PROGBITS
2551 && (asect
->flags
& SEC_ALLOC
) != 0)
2553 /* Warn if we are changing a NOBITS section to PROGBITS, but
2554 allow the link to proceed. This can happen when users link
2555 non-bss input sections to bss output sections, or emit data
2556 to a bss output section via a linker script. */
2557 (*_bfd_error_handler
)
2558 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2559 this_hdr
->sh_type
= sh_type
;
2562 switch (this_hdr
->sh_type
)
2568 case SHT_INIT_ARRAY
:
2569 case SHT_FINI_ARRAY
:
2570 case SHT_PREINIT_ARRAY
:
2577 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2581 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2585 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2589 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2590 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2594 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2595 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2598 case SHT_GNU_versym
:
2599 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2602 case SHT_GNU_verdef
:
2603 this_hdr
->sh_entsize
= 0;
2604 /* objcopy or strip will copy over sh_info, but may not set
2605 cverdefs. The linker will set cverdefs, but sh_info will be
2607 if (this_hdr
->sh_info
== 0)
2608 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2610 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2611 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2614 case SHT_GNU_verneed
:
2615 this_hdr
->sh_entsize
= 0;
2616 /* objcopy or strip will copy over sh_info, but may not set
2617 cverrefs. The linker will set cverrefs, but sh_info will be
2619 if (this_hdr
->sh_info
== 0)
2620 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2622 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2623 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2627 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2631 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2635 if ((asect
->flags
& SEC_ALLOC
) != 0)
2636 this_hdr
->sh_flags
|= SHF_ALLOC
;
2637 if ((asect
->flags
& SEC_READONLY
) == 0)
2638 this_hdr
->sh_flags
|= SHF_WRITE
;
2639 if ((asect
->flags
& SEC_CODE
) != 0)
2640 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2641 if ((asect
->flags
& SEC_MERGE
) != 0)
2643 this_hdr
->sh_flags
|= SHF_MERGE
;
2644 this_hdr
->sh_entsize
= asect
->entsize
;
2645 if ((asect
->flags
& SEC_STRINGS
) != 0)
2646 this_hdr
->sh_flags
|= SHF_STRINGS
;
2648 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2649 this_hdr
->sh_flags
|= SHF_GROUP
;
2650 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2652 this_hdr
->sh_flags
|= SHF_TLS
;
2653 if (asect
->size
== 0
2654 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2656 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2658 this_hdr
->sh_size
= 0;
2661 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2662 if (this_hdr
->sh_size
!= 0)
2663 this_hdr
->sh_type
= SHT_NOBITS
;
2668 /* Check for processor-specific section types. */
2669 sh_type
= this_hdr
->sh_type
;
2670 if (bed
->elf_backend_fake_sections
2671 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2674 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2676 /* Don't change the header type from NOBITS if we are being
2677 called for objcopy --only-keep-debug. */
2678 this_hdr
->sh_type
= sh_type
;
2681 /* If the section has relocs, set up a section header for the
2682 SHT_REL[A] section. If two relocation sections are required for
2683 this section, it is up to the processor-specific back-end to
2684 create the other. */
2685 if ((asect
->flags
& SEC_RELOC
) != 0
2686 && !_bfd_elf_init_reloc_shdr (abfd
,
2687 &elf_section_data (asect
)->rel_hdr
,
2693 /* Fill in the contents of a SHT_GROUP section. */
2696 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2698 bfd_boolean
*failedptr
= failedptrarg
;
2699 unsigned long symindx
;
2700 asection
*elt
, *first
;
2704 /* Ignore linker created group section. See elfNN_ia64_object_p in
2706 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2711 if (elf_group_id (sec
) != NULL
)
2712 symindx
= elf_group_id (sec
)->udata
.i
;
2716 /* If called from the assembler, swap_out_syms will have set up
2717 elf_section_syms; If called for "ld -r", use target_index. */
2718 if (elf_section_syms (abfd
) != NULL
)
2719 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2721 symindx
= sec
->target_index
;
2723 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2725 /* The contents won't be allocated for "ld -r" or objcopy. */
2727 if (sec
->contents
== NULL
)
2730 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2732 /* Arrange for the section to be written out. */
2733 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2734 if (sec
->contents
== NULL
)
2741 loc
= sec
->contents
+ sec
->size
;
2743 /* Get the pointer to the first section in the group that gas
2744 squirreled away here. objcopy arranges for this to be set to the
2745 start of the input section group. */
2746 first
= elt
= elf_next_in_group (sec
);
2748 /* First element is a flag word. Rest of section is elf section
2749 indices for all the sections of the group. Write them backwards
2750 just to keep the group in the same order as given in .section
2751 directives, not that it matters. */
2760 s
= s
->output_section
;
2763 idx
= elf_section_data (s
)->this_idx
;
2764 H_PUT_32 (abfd
, idx
, loc
);
2765 elt
= elf_next_in_group (elt
);
2770 if ((loc
-= 4) != sec
->contents
)
2773 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2776 /* Assign all ELF section numbers. The dummy first section is handled here
2777 too. The link/info pointers for the standard section types are filled
2778 in here too, while we're at it. */
2781 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2783 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2785 unsigned int section_number
, secn
;
2786 Elf_Internal_Shdr
**i_shdrp
;
2787 struct bfd_elf_section_data
*d
;
2791 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2793 /* SHT_GROUP sections are in relocatable files only. */
2794 if (link_info
== NULL
|| link_info
->relocatable
)
2796 /* Put SHT_GROUP sections first. */
2797 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2799 d
= elf_section_data (sec
);
2801 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2803 if (sec
->flags
& SEC_LINKER_CREATED
)
2805 /* Remove the linker created SHT_GROUP sections. */
2806 bfd_section_list_remove (abfd
, sec
);
2807 abfd
->section_count
--;
2810 d
->this_idx
= section_number
++;
2815 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2817 d
= elf_section_data (sec
);
2819 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2820 d
->this_idx
= section_number
++;
2821 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2822 if ((sec
->flags
& SEC_RELOC
) == 0)
2826 d
->rel_idx
= section_number
++;
2827 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2832 d
->rel_idx2
= section_number
++;
2833 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2839 t
->shstrtab_section
= section_number
++;
2840 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2841 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2843 if (bfd_get_symcount (abfd
) > 0)
2845 t
->symtab_section
= section_number
++;
2846 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2847 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
2849 t
->symtab_shndx_section
= section_number
++;
2850 t
->symtab_shndx_hdr
.sh_name
2851 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2852 ".symtab_shndx", FALSE
);
2853 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2856 t
->strtab_section
= section_number
++;
2857 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2860 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2861 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2863 elf_numsections (abfd
) = section_number
;
2864 elf_elfheader (abfd
)->e_shnum
= section_number
;
2866 /* Set up the list of section header pointers, in agreement with the
2868 i_shdrp
= bfd_zalloc2 (abfd
, section_number
, sizeof (Elf_Internal_Shdr
*));
2869 if (i_shdrp
== NULL
)
2872 i_shdrp
[0] = bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2873 if (i_shdrp
[0] == NULL
)
2875 bfd_release (abfd
, i_shdrp
);
2879 elf_elfsections (abfd
) = i_shdrp
;
2881 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2882 if (bfd_get_symcount (abfd
) > 0)
2884 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2885 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
2887 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2888 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2890 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2891 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2894 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2896 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2900 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2901 if (d
->rel_idx
!= 0)
2902 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2903 if (d
->rel_idx2
!= 0)
2904 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2906 /* Fill in the sh_link and sh_info fields while we're at it. */
2908 /* sh_link of a reloc section is the section index of the symbol
2909 table. sh_info is the section index of the section to which
2910 the relocation entries apply. */
2911 if (d
->rel_idx
!= 0)
2913 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2914 d
->rel_hdr
.sh_info
= d
->this_idx
;
2916 if (d
->rel_idx2
!= 0)
2918 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2919 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2922 /* We need to set up sh_link for SHF_LINK_ORDER. */
2923 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2925 s
= elf_linked_to_section (sec
);
2928 /* elf_linked_to_section points to the input section. */
2929 if (link_info
!= NULL
)
2931 /* Check discarded linkonce section. */
2932 if (elf_discarded_section (s
))
2935 (*_bfd_error_handler
)
2936 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2937 abfd
, d
->this_hdr
.bfd_section
,
2939 /* Point to the kept section if it has the same
2940 size as the discarded one. */
2941 kept
= _bfd_elf_check_kept_section (s
, link_info
);
2944 bfd_set_error (bfd_error_bad_value
);
2950 s
= s
->output_section
;
2951 BFD_ASSERT (s
!= NULL
);
2955 /* Handle objcopy. */
2956 if (s
->output_section
== NULL
)
2958 (*_bfd_error_handler
)
2959 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2960 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
2961 bfd_set_error (bfd_error_bad_value
);
2964 s
= s
->output_section
;
2966 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2971 The Intel C compiler generates SHT_IA_64_UNWIND with
2972 SHF_LINK_ORDER. But it doesn't set the sh_link or
2973 sh_info fields. Hence we could get the situation
2975 const struct elf_backend_data
*bed
2976 = get_elf_backend_data (abfd
);
2977 if (bed
->link_order_error_handler
)
2978 bed
->link_order_error_handler
2979 (_("%B: warning: sh_link not set for section `%A'"),
2984 switch (d
->this_hdr
.sh_type
)
2988 /* A reloc section which we are treating as a normal BFD
2989 section. sh_link is the section index of the symbol
2990 table. sh_info is the section index of the section to
2991 which the relocation entries apply. We assume that an
2992 allocated reloc section uses the dynamic symbol table.
2993 FIXME: How can we be sure? */
2994 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2996 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2998 /* We look up the section the relocs apply to by name. */
3000 if (d
->this_hdr
.sh_type
== SHT_REL
)
3004 s
= bfd_get_section_by_name (abfd
, name
);
3006 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3010 /* We assume that a section named .stab*str is a stabs
3011 string section. We look for a section with the same name
3012 but without the trailing ``str'', and set its sh_link
3013 field to point to this section. */
3014 if (CONST_STRNEQ (sec
->name
, ".stab")
3015 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3020 len
= strlen (sec
->name
);
3021 alc
= bfd_malloc (len
- 2);
3024 memcpy (alc
, sec
->name
, len
- 3);
3025 alc
[len
- 3] = '\0';
3026 s
= bfd_get_section_by_name (abfd
, alc
);
3030 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3032 /* This is a .stab section. */
3033 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3034 elf_section_data (s
)->this_hdr
.sh_entsize
3035 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3042 case SHT_GNU_verneed
:
3043 case SHT_GNU_verdef
:
3044 /* sh_link is the section header index of the string table
3045 used for the dynamic entries, or the symbol table, or the
3047 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3049 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3052 case SHT_GNU_LIBLIST
:
3053 /* sh_link is the section header index of the prelink library
3054 list used for the dynamic entries, or the symbol table, or
3055 the version strings. */
3056 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3057 ? ".dynstr" : ".gnu.libstr");
3059 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3064 case SHT_GNU_versym
:
3065 /* sh_link is the section header index of the symbol table
3066 this hash table or version table is for. */
3067 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3069 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3073 d
->this_hdr
.sh_link
= t
->symtab_section
;
3077 for (secn
= 1; secn
< section_number
; ++secn
)
3078 if (i_shdrp
[secn
] == NULL
)
3079 i_shdrp
[secn
] = i_shdrp
[0];
3081 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3082 i_shdrp
[secn
]->sh_name
);
3086 /* Map symbol from it's internal number to the external number, moving
3087 all local symbols to be at the head of the list. */
3090 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3092 /* If the backend has a special mapping, use it. */
3093 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3094 if (bed
->elf_backend_sym_is_global
)
3095 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3097 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3098 || bfd_is_und_section (bfd_get_section (sym
))
3099 || bfd_is_com_section (bfd_get_section (sym
)));
3102 /* Don't output section symbols for sections that are not going to be
3106 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3108 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3109 && !(sym
->section
->owner
== abfd
3110 || (sym
->section
->output_section
->owner
== abfd
3111 && sym
->section
->output_offset
== 0)));
3115 elf_map_symbols (bfd
*abfd
)
3117 unsigned int symcount
= bfd_get_symcount (abfd
);
3118 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3119 asymbol
**sect_syms
;
3120 unsigned int num_locals
= 0;
3121 unsigned int num_globals
= 0;
3122 unsigned int num_locals2
= 0;
3123 unsigned int num_globals2
= 0;
3130 fprintf (stderr
, "elf_map_symbols\n");
3134 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3136 if (max_index
< asect
->index
)
3137 max_index
= asect
->index
;
3141 sect_syms
= bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3142 if (sect_syms
== NULL
)
3144 elf_section_syms (abfd
) = sect_syms
;
3145 elf_num_section_syms (abfd
) = max_index
;
3147 /* Init sect_syms entries for any section symbols we have already
3148 decided to output. */
3149 for (idx
= 0; idx
< symcount
; idx
++)
3151 asymbol
*sym
= syms
[idx
];
3153 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3155 && !ignore_section_sym (abfd
, sym
))
3157 asection
*sec
= sym
->section
;
3159 if (sec
->owner
!= abfd
)
3160 sec
= sec
->output_section
;
3162 sect_syms
[sec
->index
] = syms
[idx
];
3166 /* Classify all of the symbols. */
3167 for (idx
= 0; idx
< symcount
; idx
++)
3169 if (ignore_section_sym (abfd
, syms
[idx
]))
3171 if (!sym_is_global (abfd
, syms
[idx
]))
3177 /* We will be adding a section symbol for each normal BFD section. Most
3178 sections will already have a section symbol in outsymbols, but
3179 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3180 at least in that case. */
3181 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3183 if (sect_syms
[asect
->index
] == NULL
)
3185 if (!sym_is_global (abfd
, asect
->symbol
))
3192 /* Now sort the symbols so the local symbols are first. */
3193 new_syms
= bfd_alloc2 (abfd
, num_locals
+ num_globals
, sizeof (asymbol
*));
3195 if (new_syms
== NULL
)
3198 for (idx
= 0; idx
< symcount
; idx
++)
3200 asymbol
*sym
= syms
[idx
];
3203 if (ignore_section_sym (abfd
, sym
))
3205 if (!sym_is_global (abfd
, sym
))
3208 i
= num_locals
+ num_globals2
++;
3210 sym
->udata
.i
= i
+ 1;
3212 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3214 if (sect_syms
[asect
->index
] == NULL
)
3216 asymbol
*sym
= asect
->symbol
;
3219 sect_syms
[asect
->index
] = sym
;
3220 if (!sym_is_global (abfd
, sym
))
3223 i
= num_locals
+ num_globals2
++;
3225 sym
->udata
.i
= i
+ 1;
3229 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3231 elf_num_locals (abfd
) = num_locals
;
3232 elf_num_globals (abfd
) = num_globals
;
3236 /* Align to the maximum file alignment that could be required for any
3237 ELF data structure. */
3239 static inline file_ptr
3240 align_file_position (file_ptr off
, int align
)
3242 return (off
+ align
- 1) & ~(align
- 1);
3245 /* Assign a file position to a section, optionally aligning to the
3246 required section alignment. */
3249 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3253 if (align
&& i_shdrp
->sh_addralign
> 1)
3254 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3255 i_shdrp
->sh_offset
= offset
;
3256 if (i_shdrp
->bfd_section
!= NULL
)
3257 i_shdrp
->bfd_section
->filepos
= offset
;
3258 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3259 offset
+= i_shdrp
->sh_size
;
3263 /* Compute the file positions we are going to put the sections at, and
3264 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3265 is not NULL, this is being called by the ELF backend linker. */
3268 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3269 struct bfd_link_info
*link_info
)
3271 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3273 struct bfd_strtab_hash
*strtab
= NULL
;
3274 Elf_Internal_Shdr
*shstrtab_hdr
;
3276 if (abfd
->output_has_begun
)
3279 /* Do any elf backend specific processing first. */
3280 if (bed
->elf_backend_begin_write_processing
)
3281 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3283 if (! prep_headers (abfd
))
3286 /* Post process the headers if necessary. */
3287 if (bed
->elf_backend_post_process_headers
)
3288 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3291 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3295 if (!assign_section_numbers (abfd
, link_info
))
3298 /* The backend linker builds symbol table information itself. */
3299 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3301 /* Non-zero if doing a relocatable link. */
3302 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3304 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3308 if (link_info
== NULL
)
3310 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3315 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3316 /* sh_name was set in prep_headers. */
3317 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3318 shstrtab_hdr
->sh_flags
= 0;
3319 shstrtab_hdr
->sh_addr
= 0;
3320 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3321 shstrtab_hdr
->sh_entsize
= 0;
3322 shstrtab_hdr
->sh_link
= 0;
3323 shstrtab_hdr
->sh_info
= 0;
3324 /* sh_offset is set in assign_file_positions_except_relocs. */
3325 shstrtab_hdr
->sh_addralign
= 1;
3327 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3330 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3333 Elf_Internal_Shdr
*hdr
;
3335 off
= elf_tdata (abfd
)->next_file_pos
;
3337 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3338 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3340 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3341 if (hdr
->sh_size
!= 0)
3342 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3344 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3345 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3347 elf_tdata (abfd
)->next_file_pos
= off
;
3349 /* Now that we know where the .strtab section goes, write it
3351 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3352 || ! _bfd_stringtab_emit (abfd
, strtab
))
3354 _bfd_stringtab_free (strtab
);
3357 abfd
->output_has_begun
= TRUE
;
3362 /* Make an initial estimate of the size of the program header. If we
3363 get the number wrong here, we'll redo section placement. */
3365 static bfd_size_type
3366 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3370 const struct elf_backend_data
*bed
;
3372 /* Assume we will need exactly two PT_LOAD segments: one for text
3373 and one for data. */
3376 s
= bfd_get_section_by_name (abfd
, ".interp");
3377 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3379 /* If we have a loadable interpreter section, we need a
3380 PT_INTERP segment. In this case, assume we also need a
3381 PT_PHDR segment, although that may not be true for all
3386 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3388 /* We need a PT_DYNAMIC segment. */
3394 /* We need a PT_GNU_RELRO segment. */
3398 if (elf_tdata (abfd
)->eh_frame_hdr
)
3400 /* We need a PT_GNU_EH_FRAME segment. */
3404 if (elf_tdata (abfd
)->stack_flags
)
3406 /* We need a PT_GNU_STACK segment. */
3410 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3412 if ((s
->flags
& SEC_LOAD
) != 0
3413 && CONST_STRNEQ (s
->name
, ".note"))
3415 /* We need a PT_NOTE segment. */
3417 /* Try to create just one PT_NOTE segment
3418 for all adjacent loadable .note* sections.
3419 gABI requires that within a PT_NOTE segment
3420 (and also inside of each SHT_NOTE section)
3421 each note is padded to a multiple of 4 size,
3422 so we check whether the sections are correctly
3424 if (s
->alignment_power
== 2)
3425 while (s
->next
!= NULL
3426 && s
->next
->alignment_power
== 2
3427 && (s
->next
->flags
& SEC_LOAD
) != 0
3428 && CONST_STRNEQ (s
->next
->name
, ".note"))
3433 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3435 if (s
->flags
& SEC_THREAD_LOCAL
)
3437 /* We need a PT_TLS segment. */
3443 /* Let the backend count up any program headers it might need. */
3444 bed
= get_elf_backend_data (abfd
);
3445 if (bed
->elf_backend_additional_program_headers
)
3449 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3455 return segs
* bed
->s
->sizeof_phdr
;
3458 /* Find the segment that contains the output_section of section. */
3461 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3463 struct elf_segment_map
*m
;
3464 Elf_Internal_Phdr
*p
;
3466 for (m
= elf_tdata (abfd
)->segment_map
,
3467 p
= elf_tdata (abfd
)->phdr
;
3473 for (i
= m
->count
- 1; i
>= 0; i
--)
3474 if (m
->sections
[i
] == section
)
3481 /* Create a mapping from a set of sections to a program segment. */
3483 static struct elf_segment_map
*
3484 make_mapping (bfd
*abfd
,
3485 asection
**sections
,
3490 struct elf_segment_map
*m
;
3495 amt
= sizeof (struct elf_segment_map
);
3496 amt
+= (to
- from
- 1) * sizeof (asection
*);
3497 m
= bfd_zalloc (abfd
, amt
);
3501 m
->p_type
= PT_LOAD
;
3502 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3503 m
->sections
[i
- from
] = *hdrpp
;
3504 m
->count
= to
- from
;
3506 if (from
== 0 && phdr
)
3508 /* Include the headers in the first PT_LOAD segment. */
3509 m
->includes_filehdr
= 1;
3510 m
->includes_phdrs
= 1;
3516 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3519 struct elf_segment_map
*
3520 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3522 struct elf_segment_map
*m
;
3524 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3528 m
->p_type
= PT_DYNAMIC
;
3530 m
->sections
[0] = dynsec
;
3535 /* Possibly add or remove segments from the segment map. */
3538 elf_modify_segment_map (bfd
*abfd
,
3539 struct bfd_link_info
*info
,
3540 bfd_boolean remove_empty_load
)
3542 struct elf_segment_map
**m
;
3543 const struct elf_backend_data
*bed
;
3545 /* The placement algorithm assumes that non allocated sections are
3546 not in PT_LOAD segments. We ensure this here by removing such
3547 sections from the segment map. We also remove excluded
3548 sections. Finally, any PT_LOAD segment without sections is
3550 m
= &elf_tdata (abfd
)->segment_map
;
3553 unsigned int i
, new_count
;
3555 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3557 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3558 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3559 || (*m
)->p_type
!= PT_LOAD
))
3561 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3565 (*m
)->count
= new_count
;
3567 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3573 bed
= get_elf_backend_data (abfd
);
3574 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3576 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3583 /* Set up a mapping from BFD sections to program segments. */
3586 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3589 struct elf_segment_map
*m
;
3590 asection
**sections
= NULL
;
3591 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3592 bfd_boolean no_user_phdrs
;
3594 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3595 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3599 struct elf_segment_map
*mfirst
;
3600 struct elf_segment_map
**pm
;
3603 unsigned int phdr_index
;
3604 bfd_vma maxpagesize
;
3606 bfd_boolean phdr_in_segment
= TRUE
;
3607 bfd_boolean writable
;
3609 asection
*first_tls
= NULL
;
3610 asection
*dynsec
, *eh_frame_hdr
;
3613 /* Select the allocated sections, and sort them. */
3615 sections
= bfd_malloc2 (bfd_count_sections (abfd
), sizeof (asection
*));
3616 if (sections
== NULL
)
3620 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3622 if ((s
->flags
& SEC_ALLOC
) != 0)
3628 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3631 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3633 /* Build the mapping. */
3638 /* If we have a .interp section, then create a PT_PHDR segment for
3639 the program headers and a PT_INTERP segment for the .interp
3641 s
= bfd_get_section_by_name (abfd
, ".interp");
3642 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3644 amt
= sizeof (struct elf_segment_map
);
3645 m
= bfd_zalloc (abfd
, amt
);
3649 m
->p_type
= PT_PHDR
;
3650 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3651 m
->p_flags
= PF_R
| PF_X
;
3652 m
->p_flags_valid
= 1;
3653 m
->includes_phdrs
= 1;
3658 amt
= sizeof (struct elf_segment_map
);
3659 m
= bfd_zalloc (abfd
, amt
);
3663 m
->p_type
= PT_INTERP
;
3671 /* Look through the sections. We put sections in the same program
3672 segment when the start of the second section can be placed within
3673 a few bytes of the end of the first section. */
3677 maxpagesize
= bed
->maxpagesize
;
3679 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3681 && (dynsec
->flags
& SEC_LOAD
) == 0)
3684 /* Deal with -Ttext or something similar such that the first section
3685 is not adjacent to the program headers. This is an
3686 approximation, since at this point we don't know exactly how many
3687 program headers we will need. */
3690 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3692 if (phdr_size
== (bfd_size_type
) -1)
3693 phdr_size
= get_program_header_size (abfd
, info
);
3694 if ((abfd
->flags
& D_PAGED
) == 0
3695 || sections
[0]->lma
< phdr_size
3696 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3697 phdr_in_segment
= FALSE
;
3700 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3703 bfd_boolean new_segment
;
3707 /* See if this section and the last one will fit in the same
3710 if (last_hdr
== NULL
)
3712 /* If we don't have a segment yet, then we don't need a new
3713 one (we build the last one after this loop). */
3714 new_segment
= FALSE
;
3716 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3718 /* If this section has a different relation between the
3719 virtual address and the load address, then we need a new
3723 /* In the next test we have to be careful when last_hdr->lma is close
3724 to the end of the address space. If the aligned address wraps
3725 around to the start of the address space, then there are no more
3726 pages left in memory and it is OK to assume that the current
3727 section can be included in the current segment. */
3728 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3730 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3733 /* If putting this section in this segment would force us to
3734 skip a page in the segment, then we need a new segment. */
3737 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3738 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3740 /* We don't want to put a loadable section after a
3741 nonloadable section in the same segment.
3742 Consider .tbss sections as loadable for this purpose. */
3745 else if ((abfd
->flags
& D_PAGED
) == 0)
3747 /* If the file is not demand paged, which means that we
3748 don't require the sections to be correctly aligned in the
3749 file, then there is no other reason for a new segment. */
3750 new_segment
= FALSE
;
3753 && (hdr
->flags
& SEC_READONLY
) == 0
3754 && (((last_hdr
->lma
+ last_size
- 1)
3755 & ~(maxpagesize
- 1))
3756 != (hdr
->lma
& ~(maxpagesize
- 1))))
3758 /* We don't want to put a writable section in a read only
3759 segment, unless they are on the same page in memory
3760 anyhow. We already know that the last section does not
3761 bring us past the current section on the page, so the
3762 only case in which the new section is not on the same
3763 page as the previous section is when the previous section
3764 ends precisely on a page boundary. */
3769 /* Otherwise, we can use the same segment. */
3770 new_segment
= FALSE
;
3773 /* Allow interested parties a chance to override our decision. */
3774 if (last_hdr
&& info
->callbacks
->override_segment_assignment
)
3775 new_segment
= info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
, last_hdr
, new_segment
);
3779 if ((hdr
->flags
& SEC_READONLY
) == 0)
3782 /* .tbss sections effectively have zero size. */
3783 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3784 != SEC_THREAD_LOCAL
)
3785 last_size
= hdr
->size
;
3791 /* We need a new program segment. We must create a new program
3792 header holding all the sections from phdr_index until hdr. */
3794 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3801 if ((hdr
->flags
& SEC_READONLY
) == 0)
3807 /* .tbss sections effectively have zero size. */
3808 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3809 last_size
= hdr
->size
;
3813 phdr_in_segment
= FALSE
;
3816 /* Create a final PT_LOAD program segment. */
3817 if (last_hdr
!= NULL
)
3819 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3827 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3830 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3837 /* For each batch of consecutive loadable .note sections,
3838 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3839 because if we link together nonloadable .note sections and
3840 loadable .note sections, we will generate two .note sections
3841 in the output file. FIXME: Using names for section types is
3843 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3845 if ((s
->flags
& SEC_LOAD
) != 0
3846 && CONST_STRNEQ (s
->name
, ".note"))
3850 amt
= sizeof (struct elf_segment_map
);
3851 if (s
->alignment_power
== 2)
3852 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3854 if (s2
->next
->alignment_power
== 2
3855 && (s2
->next
->flags
& SEC_LOAD
) != 0
3856 && CONST_STRNEQ (s2
->next
->name
, ".note")
3857 && align_power (s2
->vma
+ s2
->size
, 2)
3863 amt
+= (count
- 1) * sizeof (asection
*);
3864 m
= bfd_zalloc (abfd
, amt
);
3868 m
->p_type
= PT_NOTE
;
3872 m
->sections
[m
->count
- count
--] = s
;
3873 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3876 m
->sections
[m
->count
- 1] = s
;
3877 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3881 if (s
->flags
& SEC_THREAD_LOCAL
)
3889 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3894 amt
= sizeof (struct elf_segment_map
);
3895 amt
+= (tls_count
- 1) * sizeof (asection
*);
3896 m
= bfd_zalloc (abfd
, amt
);
3901 m
->count
= tls_count
;
3902 /* Mandated PF_R. */
3904 m
->p_flags_valid
= 1;
3905 for (i
= 0; i
< tls_count
; ++i
)
3907 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3908 m
->sections
[i
] = first_tls
;
3909 first_tls
= first_tls
->next
;
3916 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3918 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3919 if (eh_frame_hdr
!= NULL
3920 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3922 amt
= sizeof (struct elf_segment_map
);
3923 m
= bfd_zalloc (abfd
, amt
);
3927 m
->p_type
= PT_GNU_EH_FRAME
;
3929 m
->sections
[0] = eh_frame_hdr
->output_section
;
3935 if (elf_tdata (abfd
)->stack_flags
)
3937 amt
= sizeof (struct elf_segment_map
);
3938 m
= bfd_zalloc (abfd
, amt
);
3942 m
->p_type
= PT_GNU_STACK
;
3943 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3944 m
->p_flags_valid
= 1;
3952 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3954 if (m
->p_type
== PT_LOAD
)
3956 asection
*last
= m
->sections
[m
->count
- 1];
3957 bfd_vma vaddr
= m
->sections
[0]->vma
;
3958 bfd_vma filesz
= last
->vma
- vaddr
+ last
->size
;
3960 if (vaddr
< info
->relro_end
3961 && vaddr
>= info
->relro_start
3962 && (vaddr
+ filesz
) >= info
->relro_end
)
3967 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3970 amt
= sizeof (struct elf_segment_map
);
3971 m
= bfd_zalloc (abfd
, amt
);
3975 m
->p_type
= PT_GNU_RELRO
;
3977 m
->p_flags_valid
= 1;
3985 elf_tdata (abfd
)->segment_map
= mfirst
;
3988 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
3991 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3993 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
3998 if (sections
!= NULL
)
4003 /* Sort sections by address. */
4006 elf_sort_sections (const void *arg1
, const void *arg2
)
4008 const asection
*sec1
= *(const asection
**) arg1
;
4009 const asection
*sec2
= *(const asection
**) arg2
;
4010 bfd_size_type size1
, size2
;
4012 /* Sort by LMA first, since this is the address used to
4013 place the section into a segment. */
4014 if (sec1
->lma
< sec2
->lma
)
4016 else if (sec1
->lma
> sec2
->lma
)
4019 /* Then sort by VMA. Normally the LMA and the VMA will be
4020 the same, and this will do nothing. */
4021 if (sec1
->vma
< sec2
->vma
)
4023 else if (sec1
->vma
> sec2
->vma
)
4026 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4028 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4034 /* If the indicies are the same, do not return 0
4035 here, but continue to try the next comparison. */
4036 if (sec1
->target_index
- sec2
->target_index
!= 0)
4037 return sec1
->target_index
- sec2
->target_index
;
4042 else if (TOEND (sec2
))
4047 /* Sort by size, to put zero sized sections
4048 before others at the same address. */
4050 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4051 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4058 return sec1
->target_index
- sec2
->target_index
;
4061 /* Ian Lance Taylor writes:
4063 We shouldn't be using % with a negative signed number. That's just
4064 not good. We have to make sure either that the number is not
4065 negative, or that the number has an unsigned type. When the types
4066 are all the same size they wind up as unsigned. When file_ptr is a
4067 larger signed type, the arithmetic winds up as signed long long,
4070 What we're trying to say here is something like ``increase OFF by
4071 the least amount that will cause it to be equal to the VMA modulo
4073 /* In other words, something like:
4075 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4076 off_offset = off % bed->maxpagesize;
4077 if (vma_offset < off_offset)
4078 adjustment = vma_offset + bed->maxpagesize - off_offset;
4080 adjustment = vma_offset - off_offset;
4082 which can can be collapsed into the expression below. */
4085 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4087 return ((vma
- off
) % maxpagesize
);
4091 print_segment_map (const struct elf_segment_map
*m
)
4094 const char *pt
= get_segment_type (m
->p_type
);
4099 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4100 sprintf (buf
, "LOPROC+%7.7x",
4101 (unsigned int) (m
->p_type
- PT_LOPROC
));
4102 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4103 sprintf (buf
, "LOOS+%7.7x",
4104 (unsigned int) (m
->p_type
- PT_LOOS
));
4106 snprintf (buf
, sizeof (buf
), "%8.8x",
4107 (unsigned int) m
->p_type
);
4110 fprintf (stderr
, "%s:", pt
);
4111 for (j
= 0; j
< m
->count
; j
++)
4112 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4116 /* Assign file positions to the sections based on the mapping from
4117 sections to segments. This function also sets up some fields in
4121 assign_file_positions_for_load_sections (bfd
*abfd
,
4122 struct bfd_link_info
*link_info
)
4124 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4125 struct elf_segment_map
*m
;
4126 Elf_Internal_Phdr
*phdrs
;
4127 Elf_Internal_Phdr
*p
;
4129 bfd_size_type maxpagesize
;
4133 if (link_info
== NULL
4134 && !elf_modify_segment_map (abfd
, link_info
, FALSE
))
4138 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4141 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4142 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4143 elf_elfheader (abfd
)->e_phnum
= alloc
;
4145 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4146 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4148 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4149 >= alloc
* bed
->s
->sizeof_phdr
);
4153 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4157 phdrs
= bfd_alloc2 (abfd
, alloc
, sizeof (Elf_Internal_Phdr
));
4158 elf_tdata (abfd
)->phdr
= phdrs
;
4163 if ((abfd
->flags
& D_PAGED
) != 0)
4164 maxpagesize
= bed
->maxpagesize
;
4166 off
= bed
->s
->sizeof_ehdr
;
4167 off
+= alloc
* bed
->s
->sizeof_phdr
;
4169 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4171 m
= m
->next
, p
++, j
++)
4175 bfd_boolean no_contents
;
4177 /* If elf_segment_map is not from map_sections_to_segments, the
4178 sections may not be correctly ordered. NOTE: sorting should
4179 not be done to the PT_NOTE section of a corefile, which may
4180 contain several pseudo-sections artificially created by bfd.
4181 Sorting these pseudo-sections breaks things badly. */
4183 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4184 && m
->p_type
== PT_NOTE
))
4185 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4188 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4189 number of sections with contents contributing to both p_filesz
4190 and p_memsz, followed by a number of sections with no contents
4191 that just contribute to p_memsz. In this loop, OFF tracks next
4192 available file offset for PT_LOAD and PT_NOTE segments. */
4193 p
->p_type
= m
->p_type
;
4194 p
->p_flags
= m
->p_flags
;
4199 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4201 if (m
->p_paddr_valid
)
4202 p
->p_paddr
= m
->p_paddr
;
4203 else if (m
->count
== 0)
4206 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4208 if (p
->p_type
== PT_LOAD
4209 && (abfd
->flags
& D_PAGED
) != 0)
4211 /* p_align in demand paged PT_LOAD segments effectively stores
4212 the maximum page size. When copying an executable with
4213 objcopy, we set m->p_align from the input file. Use this
4214 value for maxpagesize rather than bed->maxpagesize, which
4215 may be different. Note that we use maxpagesize for PT_TLS
4216 segment alignment later in this function, so we are relying
4217 on at least one PT_LOAD segment appearing before a PT_TLS
4219 if (m
->p_align_valid
)
4220 maxpagesize
= m
->p_align
;
4222 p
->p_align
= maxpagesize
;
4224 else if (m
->p_align_valid
)
4225 p
->p_align
= m
->p_align
;
4226 else if (m
->count
== 0)
4227 p
->p_align
= 1 << bed
->s
->log_file_align
;
4231 no_contents
= FALSE
;
4233 if (p
->p_type
== PT_LOAD
4236 bfd_size_type align
;
4237 unsigned int align_power
= 0;
4239 if (m
->p_align_valid
)
4243 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4245 unsigned int secalign
;
4247 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4248 if (secalign
> align_power
)
4249 align_power
= secalign
;
4251 align
= (bfd_size_type
) 1 << align_power
;
4252 if (align
< maxpagesize
)
4253 align
= maxpagesize
;
4256 for (i
= 0; i
< m
->count
; i
++)
4257 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4258 /* If we aren't making room for this section, then
4259 it must be SHT_NOBITS regardless of what we've
4260 set via struct bfd_elf_special_section. */
4261 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4263 /* Find out whether this segment contains any loadable
4264 sections. If the first section isn't loadable, the same
4265 holds for any other sections. */
4267 while (elf_section_type (m
->sections
[i
]) == SHT_NOBITS
)
4269 /* If a segment starts with .tbss, we need to look
4270 at the next section to decide whether the segment
4271 has any loadable sections. */
4272 if ((elf_section_flags (m
->sections
[i
]) & SHF_TLS
) == 0
4280 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4284 /* We shouldn't need to align the segment on disk since
4285 the segment doesn't need file space, but the gABI
4286 arguably requires the alignment and glibc ld.so
4287 checks it. So to comply with the alignment
4288 requirement but not waste file space, we adjust
4289 p_offset for just this segment. (OFF_ADJUST is
4290 subtracted from OFF later.) This may put p_offset
4291 past the end of file, but that shouldn't matter. */
4296 /* Make sure the .dynamic section is the first section in the
4297 PT_DYNAMIC segment. */
4298 else if (p
->p_type
== PT_DYNAMIC
4300 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4303 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4305 bfd_set_error (bfd_error_bad_value
);
4308 /* Set the note section type to SHT_NOTE. */
4309 else if (p
->p_type
== PT_NOTE
)
4310 for (i
= 0; i
< m
->count
; i
++)
4311 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4317 if (m
->includes_filehdr
)
4319 if (!m
->p_flags_valid
)
4321 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4322 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4325 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4327 if (p
->p_vaddr
< (bfd_vma
) off
)
4329 (*_bfd_error_handler
)
4330 (_("%B: Not enough room for program headers, try linking with -N"),
4332 bfd_set_error (bfd_error_bad_value
);
4337 if (!m
->p_paddr_valid
)
4342 if (m
->includes_phdrs
)
4344 if (!m
->p_flags_valid
)
4347 if (!m
->includes_filehdr
)
4349 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4353 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4354 p
->p_vaddr
-= off
- p
->p_offset
;
4355 if (!m
->p_paddr_valid
)
4356 p
->p_paddr
-= off
- p
->p_offset
;
4360 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4361 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4364 if (p
->p_type
== PT_LOAD
4365 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4367 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4373 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4375 p
->p_filesz
+= adjust
;
4376 p
->p_memsz
+= adjust
;
4380 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4381 maps. Set filepos for sections in PT_LOAD segments, and in
4382 core files, for sections in PT_NOTE segments.
4383 assign_file_positions_for_non_load_sections will set filepos
4384 for other sections and update p_filesz for other segments. */
4385 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4388 bfd_size_type align
;
4389 Elf_Internal_Shdr
*this_hdr
;
4392 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4393 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4395 if ((p
->p_type
== PT_LOAD
4396 || p
->p_type
== PT_TLS
)
4397 && (this_hdr
->sh_type
!= SHT_NOBITS
4398 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4399 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4400 || p
->p_type
== PT_TLS
))))
4402 bfd_signed_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
4406 (*_bfd_error_handler
)
4407 (_("%B: section %A vma 0x%lx overlaps previous sections"),
4408 abfd
, sec
, (unsigned long) sec
->vma
);
4411 p
->p_memsz
+= adjust
;
4413 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4416 p
->p_filesz
+= adjust
;
4420 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4422 /* The section at i == 0 is the one that actually contains
4426 this_hdr
->sh_offset
= sec
->filepos
= off
;
4427 off
+= this_hdr
->sh_size
;
4428 p
->p_filesz
= this_hdr
->sh_size
;
4434 /* The rest are fake sections that shouldn't be written. */
4443 if (p
->p_type
== PT_LOAD
)
4445 this_hdr
->sh_offset
= sec
->filepos
= off
;
4446 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4447 off
+= this_hdr
->sh_size
;
4450 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4452 p
->p_filesz
+= this_hdr
->sh_size
;
4453 /* A load section without SHF_ALLOC is something like
4454 a note section in a PT_NOTE segment. These take
4455 file space but are not loaded into memory. */
4456 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4457 p
->p_memsz
+= this_hdr
->sh_size
;
4459 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4461 if (p
->p_type
== PT_TLS
)
4462 p
->p_memsz
+= this_hdr
->sh_size
;
4464 /* .tbss is special. It doesn't contribute to p_memsz of
4466 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4467 p
->p_memsz
+= this_hdr
->sh_size
;
4470 if (align
> p
->p_align
4471 && !m
->p_align_valid
4472 && (p
->p_type
!= PT_LOAD
4473 || (abfd
->flags
& D_PAGED
) == 0))
4477 if (!m
->p_flags_valid
)
4480 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4482 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4488 /* Check that all sections are in a PT_LOAD segment.
4489 Don't check funky gdb generated core files. */
4490 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4491 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4493 Elf_Internal_Shdr
*this_hdr
;
4497 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4498 if (this_hdr
->sh_size
!= 0
4499 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, p
))
4501 (*_bfd_error_handler
)
4502 (_("%B: section `%A' can't be allocated in segment %d"),
4504 print_segment_map (m
);
4505 bfd_set_error (bfd_error_bad_value
);
4511 elf_tdata (abfd
)->next_file_pos
= off
;
4515 /* Assign file positions for the other sections. */
4518 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4519 struct bfd_link_info
*link_info
)
4521 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4522 Elf_Internal_Shdr
**i_shdrpp
;
4523 Elf_Internal_Shdr
**hdrpp
;
4524 Elf_Internal_Phdr
*phdrs
;
4525 Elf_Internal_Phdr
*p
;
4526 struct elf_segment_map
*m
;
4527 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4528 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4530 unsigned int num_sec
;
4534 i_shdrpp
= elf_elfsections (abfd
);
4535 num_sec
= elf_numsections (abfd
);
4536 off
= elf_tdata (abfd
)->next_file_pos
;
4537 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4539 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4540 Elf_Internal_Shdr
*hdr
;
4543 if (hdr
->bfd_section
!= NULL
4544 && (hdr
->bfd_section
->filepos
!= 0
4545 || (hdr
->sh_type
== SHT_NOBITS
4546 && hdr
->contents
== NULL
)))
4547 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4548 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4550 if (hdr
->sh_size
!= 0)
4551 ((*_bfd_error_handler
)
4552 (_("%B: warning: allocated section `%s' not in segment"),
4554 (hdr
->bfd_section
== NULL
4556 : hdr
->bfd_section
->name
)));
4557 /* We don't need to page align empty sections. */
4558 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4559 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4562 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4564 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4567 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4568 && hdr
->bfd_section
== NULL
)
4569 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4570 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4571 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4572 hdr
->sh_offset
= -1;
4574 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4577 /* Now that we have set the section file positions, we can set up
4578 the file positions for the non PT_LOAD segments. */
4582 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4584 phdrs
= elf_tdata (abfd
)->phdr
;
4585 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4590 if (p
->p_type
!= PT_LOAD
)
4593 if (m
->includes_filehdr
)
4595 filehdr_vaddr
= p
->p_vaddr
;
4596 filehdr_paddr
= p
->p_paddr
;
4598 if (m
->includes_phdrs
)
4600 phdrs_vaddr
= p
->p_vaddr
;
4601 phdrs_paddr
= p
->p_paddr
;
4602 if (m
->includes_filehdr
)
4604 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4605 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4610 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4616 if (p
->p_type
!= PT_LOAD
4617 && (p
->p_type
!= PT_NOTE
4618 || bfd_get_format (abfd
) != bfd_core
))
4620 Elf_Internal_Shdr
*hdr
;
4623 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4625 sect
= m
->sections
[m
->count
- 1];
4626 hdr
= &elf_section_data (sect
)->this_hdr
;
4627 p
->p_filesz
= sect
->filepos
- m
->sections
[0]->filepos
;
4628 if (hdr
->sh_type
!= SHT_NOBITS
)
4629 p
->p_filesz
+= hdr
->sh_size
;
4631 if (p
->p_type
== PT_GNU_RELRO
)
4633 /* When we get here, we are copying executable
4634 or shared library. But we need to use the same
4636 Elf_Internal_Phdr
*lp
;
4638 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4640 if (lp
->p_type
== PT_LOAD
4641 && lp
->p_paddr
== p
->p_paddr
)
4645 if (lp
< phdrs
+ count
)
4647 /* We should use p_size if it is valid since it
4648 may contain the first few bytes of the next
4649 SEC_ALLOC section. */
4650 if (m
->p_size_valid
)
4651 p
->p_filesz
= m
->p_size
;
4654 p
->p_vaddr
= lp
->p_vaddr
;
4655 p
->p_offset
= lp
->p_offset
;
4656 p
->p_memsz
= p
->p_filesz
;
4663 p
->p_offset
= m
->sections
[0]->filepos
;
4668 if (m
->includes_filehdr
)
4670 p
->p_vaddr
= filehdr_vaddr
;
4671 if (! m
->p_paddr_valid
)
4672 p
->p_paddr
= filehdr_paddr
;
4674 else if (m
->includes_phdrs
)
4676 p
->p_vaddr
= phdrs_vaddr
;
4677 if (! m
->p_paddr_valid
)
4678 p
->p_paddr
= phdrs_paddr
;
4680 else if (p
->p_type
== PT_GNU_RELRO
)
4682 Elf_Internal_Phdr
*lp
;
4684 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4686 if (lp
->p_type
== PT_LOAD
4687 && lp
->p_vaddr
<= link_info
->relro_end
4688 && lp
->p_vaddr
>= link_info
->relro_start
4689 && (lp
->p_vaddr
+ lp
->p_filesz
4690 >= link_info
->relro_end
))
4694 if (lp
< phdrs
+ count
4695 && link_info
->relro_end
> lp
->p_vaddr
)
4697 p
->p_vaddr
= lp
->p_vaddr
;
4698 p
->p_paddr
= lp
->p_paddr
;
4699 p
->p_offset
= lp
->p_offset
;
4700 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4701 p
->p_memsz
= p
->p_filesz
;
4703 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4707 memset (p
, 0, sizeof *p
);
4708 p
->p_type
= PT_NULL
;
4714 elf_tdata (abfd
)->next_file_pos
= off
;
4719 /* Work out the file positions of all the sections. This is called by
4720 _bfd_elf_compute_section_file_positions. All the section sizes and
4721 VMAs must be known before this is called.
4723 Reloc sections come in two flavours: Those processed specially as
4724 "side-channel" data attached to a section to which they apply, and
4725 those that bfd doesn't process as relocations. The latter sort are
4726 stored in a normal bfd section by bfd_section_from_shdr. We don't
4727 consider the former sort here, unless they form part of the loadable
4728 image. Reloc sections not assigned here will be handled later by
4729 assign_file_positions_for_relocs.
4731 We also don't set the positions of the .symtab and .strtab here. */
4734 assign_file_positions_except_relocs (bfd
*abfd
,
4735 struct bfd_link_info
*link_info
)
4737 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4738 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4740 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4742 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4743 && bfd_get_format (abfd
) != bfd_core
)
4745 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4746 unsigned int num_sec
= elf_numsections (abfd
);
4747 Elf_Internal_Shdr
**hdrpp
;
4750 /* Start after the ELF header. */
4751 off
= i_ehdrp
->e_ehsize
;
4753 /* We are not creating an executable, which means that we are
4754 not creating a program header, and that the actual order of
4755 the sections in the file is unimportant. */
4756 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4758 Elf_Internal_Shdr
*hdr
;
4761 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4762 && hdr
->bfd_section
== NULL
)
4763 || i
== tdata
->symtab_section
4764 || i
== tdata
->symtab_shndx_section
4765 || i
== tdata
->strtab_section
)
4767 hdr
->sh_offset
= -1;
4770 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4777 /* Assign file positions for the loaded sections based on the
4778 assignment of sections to segments. */
4779 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4782 /* And for non-load sections. */
4783 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4786 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4788 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4792 /* Write out the program headers. */
4793 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4794 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4795 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4798 off
= tdata
->next_file_pos
;
4801 /* Place the section headers. */
4802 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4803 i_ehdrp
->e_shoff
= off
;
4804 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4806 tdata
->next_file_pos
= off
;
4812 prep_headers (bfd
*abfd
)
4814 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4815 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4816 struct elf_strtab_hash
*shstrtab
;
4817 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4819 i_ehdrp
= elf_elfheader (abfd
);
4821 shstrtab
= _bfd_elf_strtab_init ();
4822 if (shstrtab
== NULL
)
4825 elf_shstrtab (abfd
) = shstrtab
;
4827 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4828 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4829 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4830 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4832 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4833 i_ehdrp
->e_ident
[EI_DATA
] =
4834 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4835 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4837 if ((abfd
->flags
& DYNAMIC
) != 0)
4838 i_ehdrp
->e_type
= ET_DYN
;
4839 else if ((abfd
->flags
& EXEC_P
) != 0)
4840 i_ehdrp
->e_type
= ET_EXEC
;
4841 else if (bfd_get_format (abfd
) == bfd_core
)
4842 i_ehdrp
->e_type
= ET_CORE
;
4844 i_ehdrp
->e_type
= ET_REL
;
4846 switch (bfd_get_arch (abfd
))
4848 case bfd_arch_unknown
:
4849 i_ehdrp
->e_machine
= EM_NONE
;
4852 /* There used to be a long list of cases here, each one setting
4853 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4854 in the corresponding bfd definition. To avoid duplication,
4855 the switch was removed. Machines that need special handling
4856 can generally do it in elf_backend_final_write_processing(),
4857 unless they need the information earlier than the final write.
4858 Such need can generally be supplied by replacing the tests for
4859 e_machine with the conditions used to determine it. */
4861 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4864 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4865 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4867 /* No program header, for now. */
4868 i_ehdrp
->e_phoff
= 0;
4869 i_ehdrp
->e_phentsize
= 0;
4870 i_ehdrp
->e_phnum
= 0;
4872 /* Each bfd section is section header entry. */
4873 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4874 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4876 /* If we're building an executable, we'll need a program header table. */
4877 if (abfd
->flags
& EXEC_P
)
4878 /* It all happens later. */
4882 i_ehdrp
->e_phentsize
= 0;
4884 i_ehdrp
->e_phoff
= 0;
4887 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4888 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4889 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4890 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4891 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4892 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4893 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4894 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4895 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4901 /* Assign file positions for all the reloc sections which are not part
4902 of the loadable file image. */
4905 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4908 unsigned int i
, num_sec
;
4909 Elf_Internal_Shdr
**shdrpp
;
4911 off
= elf_tdata (abfd
)->next_file_pos
;
4913 num_sec
= elf_numsections (abfd
);
4914 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4916 Elf_Internal_Shdr
*shdrp
;
4919 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4920 && shdrp
->sh_offset
== -1)
4921 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4924 elf_tdata (abfd
)->next_file_pos
= off
;
4928 _bfd_elf_write_object_contents (bfd
*abfd
)
4930 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4931 Elf_Internal_Ehdr
*i_ehdrp
;
4932 Elf_Internal_Shdr
**i_shdrp
;
4934 unsigned int count
, num_sec
;
4936 if (! abfd
->output_has_begun
4937 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4940 i_shdrp
= elf_elfsections (abfd
);
4941 i_ehdrp
= elf_elfheader (abfd
);
4944 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4948 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4950 /* After writing the headers, we need to write the sections too... */
4951 num_sec
= elf_numsections (abfd
);
4952 for (count
= 1; count
< num_sec
; count
++)
4954 if (bed
->elf_backend_section_processing
)
4955 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4956 if (i_shdrp
[count
]->contents
)
4958 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4960 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4961 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4966 /* Write out the section header names. */
4967 if (elf_shstrtab (abfd
) != NULL
4968 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4969 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
4972 if (bed
->elf_backend_final_write_processing
)
4973 (*bed
->elf_backend_final_write_processing
) (abfd
,
4974 elf_tdata (abfd
)->linker
);
4976 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
4979 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
4980 if (elf_tdata (abfd
)->after_write_object_contents
)
4981 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
4987 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4989 /* Hopefully this can be done just like an object file. */
4990 return _bfd_elf_write_object_contents (abfd
);
4993 /* Given a section, search the header to find them. */
4996 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4998 const struct elf_backend_data
*bed
;
5001 if (elf_section_data (asect
) != NULL
5002 && elf_section_data (asect
)->this_idx
!= 0)
5003 return elf_section_data (asect
)->this_idx
;
5005 if (bfd_is_abs_section (asect
))
5007 else if (bfd_is_com_section (asect
))
5009 else if (bfd_is_und_section (asect
))
5014 bed
= get_elf_backend_data (abfd
);
5015 if (bed
->elf_backend_section_from_bfd_section
)
5019 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5023 if (index
== SHN_BAD
)
5024 bfd_set_error (bfd_error_nonrepresentable_section
);
5029 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5033 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5035 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5037 flagword flags
= asym_ptr
->flags
;
5039 /* When gas creates relocations against local labels, it creates its
5040 own symbol for the section, but does put the symbol into the
5041 symbol chain, so udata is 0. When the linker is generating
5042 relocatable output, this section symbol may be for one of the
5043 input sections rather than the output section. */
5044 if (asym_ptr
->udata
.i
== 0
5045 && (flags
& BSF_SECTION_SYM
)
5046 && asym_ptr
->section
)
5051 sec
= asym_ptr
->section
;
5052 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5053 sec
= sec
->output_section
;
5054 if (sec
->owner
== abfd
5055 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5056 && elf_section_syms (abfd
)[indx
] != NULL
)
5057 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5060 idx
= asym_ptr
->udata
.i
;
5064 /* This case can occur when using --strip-symbol on a symbol
5065 which is used in a relocation entry. */
5066 (*_bfd_error_handler
)
5067 (_("%B: symbol `%s' required but not present"),
5068 abfd
, bfd_asymbol_name (asym_ptr
));
5069 bfd_set_error (bfd_error_no_symbols
);
5076 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5077 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5078 elf_symbol_flags (flags
));
5086 /* Rewrite program header information. */
5089 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5091 Elf_Internal_Ehdr
*iehdr
;
5092 struct elf_segment_map
*map
;
5093 struct elf_segment_map
*map_first
;
5094 struct elf_segment_map
**pointer_to_map
;
5095 Elf_Internal_Phdr
*segment
;
5098 unsigned int num_segments
;
5099 bfd_boolean phdr_included
= FALSE
;
5100 bfd_boolean p_paddr_valid
;
5101 bfd_vma maxpagesize
;
5102 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5103 unsigned int phdr_adjust_num
= 0;
5104 const struct elf_backend_data
*bed
;
5106 bed
= get_elf_backend_data (ibfd
);
5107 iehdr
= elf_elfheader (ibfd
);
5110 pointer_to_map
= &map_first
;
5112 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5113 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5115 /* Returns the end address of the segment + 1. */
5116 #define SEGMENT_END(segment, start) \
5117 (start + (segment->p_memsz > segment->p_filesz \
5118 ? segment->p_memsz : segment->p_filesz))
5120 #define SECTION_SIZE(section, segment) \
5121 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5122 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5123 ? section->size : 0)
5125 /* Returns TRUE if the given section is contained within
5126 the given segment. VMA addresses are compared. */
5127 #define IS_CONTAINED_BY_VMA(section, segment) \
5128 (section->vma >= segment->p_vaddr \
5129 && (section->vma + SECTION_SIZE (section, segment) \
5130 <= (SEGMENT_END (segment, segment->p_vaddr))))
5132 /* Returns TRUE if the given section is contained within
5133 the given segment. LMA addresses are compared. */
5134 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5135 (section->lma >= base \
5136 && (section->lma + SECTION_SIZE (section, segment) \
5137 <= SEGMENT_END (segment, base)))
5139 /* Handle PT_NOTE segment. */
5140 #define IS_NOTE(p, s) \
5141 (p->p_type == PT_NOTE \
5142 && elf_section_type (s) == SHT_NOTE \
5143 && (bfd_vma) s->filepos >= p->p_offset \
5144 && ((bfd_vma) s->filepos + s->size \
5145 <= p->p_offset + p->p_filesz))
5147 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5149 #define IS_COREFILE_NOTE(p, s) \
5151 && bfd_get_format (ibfd) == bfd_core \
5155 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5156 linker, which generates a PT_INTERP section with p_vaddr and
5157 p_memsz set to 0. */
5158 #define IS_SOLARIS_PT_INTERP(p, s) \
5160 && p->p_paddr == 0 \
5161 && p->p_memsz == 0 \
5162 && p->p_filesz > 0 \
5163 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5165 && (bfd_vma) s->filepos >= p->p_offset \
5166 && ((bfd_vma) s->filepos + s->size \
5167 <= p->p_offset + p->p_filesz))
5169 /* Decide if the given section should be included in the given segment.
5170 A section will be included if:
5171 1. It is within the address space of the segment -- we use the LMA
5172 if that is set for the segment and the VMA otherwise,
5173 2. It is an allocated section or a NOTE section in a PT_NOTE
5175 3. There is an output section associated with it,
5176 4. The section has not already been allocated to a previous segment.
5177 5. PT_GNU_STACK segments do not include any sections.
5178 6. PT_TLS segment includes only SHF_TLS sections.
5179 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5180 8. PT_DYNAMIC should not contain empty sections at the beginning
5181 (with the possible exception of .dynamic). */
5182 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5183 ((((segment->p_paddr \
5184 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5185 : IS_CONTAINED_BY_VMA (section, segment)) \
5186 && (section->flags & SEC_ALLOC) != 0) \
5187 || IS_NOTE (segment, section)) \
5188 && segment->p_type != PT_GNU_STACK \
5189 && (segment->p_type != PT_TLS \
5190 || (section->flags & SEC_THREAD_LOCAL)) \
5191 && (segment->p_type == PT_LOAD \
5192 || segment->p_type == PT_TLS \
5193 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5194 && (segment->p_type != PT_DYNAMIC \
5195 || SECTION_SIZE (section, segment) > 0 \
5196 || (segment->p_paddr \
5197 ? segment->p_paddr != section->lma \
5198 : segment->p_vaddr != section->vma) \
5199 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5201 && !section->segment_mark)
5203 /* If the output section of a section in the input segment is NULL,
5204 it is removed from the corresponding output segment. */
5205 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5206 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5207 && section->output_section != NULL)
5209 /* Returns TRUE iff seg1 starts after the end of seg2. */
5210 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5211 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5213 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5214 their VMA address ranges and their LMA address ranges overlap.
5215 It is possible to have overlapping VMA ranges without overlapping LMA
5216 ranges. RedBoot images for example can have both .data and .bss mapped
5217 to the same VMA range, but with the .data section mapped to a different
5219 #define SEGMENT_OVERLAPS(seg1, seg2) \
5220 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5221 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5222 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5223 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5225 /* Initialise the segment mark field. */
5226 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5227 section
->segment_mark
= FALSE
;
5229 /* The Solaris linker creates program headers in which all the
5230 p_paddr fields are zero. When we try to objcopy or strip such a
5231 file, we get confused. Check for this case, and if we find it
5232 don't set the p_paddr_valid fields. */
5233 p_paddr_valid
= FALSE
;
5234 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5237 if (segment
->p_paddr
!= 0)
5239 p_paddr_valid
= TRUE
;
5243 /* Scan through the segments specified in the program header
5244 of the input BFD. For this first scan we look for overlaps
5245 in the loadable segments. These can be created by weird
5246 parameters to objcopy. Also, fix some solaris weirdness. */
5247 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5252 Elf_Internal_Phdr
*segment2
;
5254 if (segment
->p_type
== PT_INTERP
)
5255 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5256 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5258 /* Mininal change so that the normal section to segment
5259 assignment code will work. */
5260 segment
->p_vaddr
= section
->vma
;
5264 if (segment
->p_type
!= PT_LOAD
)
5266 /* Remove PT_GNU_RELRO segment. */
5267 if (segment
->p_type
== PT_GNU_RELRO
)
5268 segment
->p_type
= PT_NULL
;
5272 /* Determine if this segment overlaps any previous segments. */
5273 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5275 bfd_signed_vma extra_length
;
5277 if (segment2
->p_type
!= PT_LOAD
5278 || !SEGMENT_OVERLAPS (segment
, segment2
))
5281 /* Merge the two segments together. */
5282 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5284 /* Extend SEGMENT2 to include SEGMENT and then delete
5286 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5287 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5289 if (extra_length
> 0)
5291 segment2
->p_memsz
+= extra_length
;
5292 segment2
->p_filesz
+= extra_length
;
5295 segment
->p_type
= PT_NULL
;
5297 /* Since we have deleted P we must restart the outer loop. */
5299 segment
= elf_tdata (ibfd
)->phdr
;
5304 /* Extend SEGMENT to include SEGMENT2 and then delete
5306 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5307 - SEGMENT_END (segment
, segment
->p_vaddr
));
5309 if (extra_length
> 0)
5311 segment
->p_memsz
+= extra_length
;
5312 segment
->p_filesz
+= extra_length
;
5315 segment2
->p_type
= PT_NULL
;
5320 /* The second scan attempts to assign sections to segments. */
5321 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5325 unsigned int section_count
;
5326 asection
**sections
;
5327 asection
*output_section
;
5329 bfd_vma matching_lma
;
5330 bfd_vma suggested_lma
;
5333 asection
*first_section
;
5334 bfd_boolean first_matching_lma
;
5335 bfd_boolean first_suggested_lma
;
5337 if (segment
->p_type
== PT_NULL
)
5340 first_section
= NULL
;
5341 /* Compute how many sections might be placed into this segment. */
5342 for (section
= ibfd
->sections
, section_count
= 0;
5344 section
= section
->next
)
5346 /* Find the first section in the input segment, which may be
5347 removed from the corresponding output segment. */
5348 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5350 if (first_section
== NULL
)
5351 first_section
= section
;
5352 if (section
->output_section
!= NULL
)
5357 /* Allocate a segment map big enough to contain
5358 all of the sections we have selected. */
5359 amt
= sizeof (struct elf_segment_map
);
5360 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5361 map
= bfd_zalloc (obfd
, amt
);
5365 /* Initialise the fields of the segment map. Default to
5366 using the physical address of the segment in the input BFD. */
5368 map
->p_type
= segment
->p_type
;
5369 map
->p_flags
= segment
->p_flags
;
5370 map
->p_flags_valid
= 1;
5372 /* If the first section in the input segment is removed, there is
5373 no need to preserve segment physical address in the corresponding
5375 if (!first_section
|| first_section
->output_section
!= NULL
)
5377 map
->p_paddr
= segment
->p_paddr
;
5378 map
->p_paddr_valid
= p_paddr_valid
;
5381 /* Determine if this segment contains the ELF file header
5382 and if it contains the program headers themselves. */
5383 map
->includes_filehdr
= (segment
->p_offset
== 0
5384 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5385 map
->includes_phdrs
= 0;
5387 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5389 map
->includes_phdrs
=
5390 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5391 && (segment
->p_offset
+ segment
->p_filesz
5392 >= ((bfd_vma
) iehdr
->e_phoff
5393 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5395 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5396 phdr_included
= TRUE
;
5399 if (section_count
== 0)
5401 /* Special segments, such as the PT_PHDR segment, may contain
5402 no sections, but ordinary, loadable segments should contain
5403 something. They are allowed by the ELF spec however, so only
5404 a warning is produced. */
5405 if (segment
->p_type
== PT_LOAD
)
5406 (*_bfd_error_handler
) (_("%B: warning: Empty loadable segment"
5407 " detected, is this intentional ?\n"),
5411 *pointer_to_map
= map
;
5412 pointer_to_map
= &map
->next
;
5417 /* Now scan the sections in the input BFD again and attempt
5418 to add their corresponding output sections to the segment map.
5419 The problem here is how to handle an output section which has
5420 been moved (ie had its LMA changed). There are four possibilities:
5422 1. None of the sections have been moved.
5423 In this case we can continue to use the segment LMA from the
5426 2. All of the sections have been moved by the same amount.
5427 In this case we can change the segment's LMA to match the LMA
5428 of the first section.
5430 3. Some of the sections have been moved, others have not.
5431 In this case those sections which have not been moved can be
5432 placed in the current segment which will have to have its size,
5433 and possibly its LMA changed, and a new segment or segments will
5434 have to be created to contain the other sections.
5436 4. The sections have been moved, but not by the same amount.
5437 In this case we can change the segment's LMA to match the LMA
5438 of the first section and we will have to create a new segment
5439 or segments to contain the other sections.
5441 In order to save time, we allocate an array to hold the section
5442 pointers that we are interested in. As these sections get assigned
5443 to a segment, they are removed from this array. */
5445 sections
= bfd_malloc2 (section_count
, sizeof (asection
*));
5446 if (sections
== NULL
)
5449 /* Step One: Scan for segment vs section LMA conflicts.
5450 Also add the sections to the section array allocated above.
5451 Also add the sections to the current segment. In the common
5452 case, where the sections have not been moved, this means that
5453 we have completely filled the segment, and there is nothing
5458 first_matching_lma
= TRUE
;
5459 first_suggested_lma
= TRUE
;
5461 for (section
= ibfd
->sections
;
5463 section
= section
->next
)
5464 if (section
== first_section
)
5467 for (j
= 0; section
!= NULL
; section
= section
->next
)
5469 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5471 output_section
= section
->output_section
;
5473 sections
[j
++] = section
;
5475 /* The Solaris native linker always sets p_paddr to 0.
5476 We try to catch that case here, and set it to the
5477 correct value. Note - some backends require that
5478 p_paddr be left as zero. */
5480 && segment
->p_vaddr
!= 0
5481 && !bed
->want_p_paddr_set_to_zero
5483 && output_section
->lma
!= 0
5484 && output_section
->vma
== (segment
->p_vaddr
5485 + (map
->includes_filehdr
5488 + (map
->includes_phdrs
5490 * iehdr
->e_phentsize
)
5492 map
->p_paddr
= segment
->p_vaddr
;
5494 /* Match up the physical address of the segment with the
5495 LMA address of the output section. */
5496 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5497 || IS_COREFILE_NOTE (segment
, section
)
5498 || (bed
->want_p_paddr_set_to_zero
5499 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
5501 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
5503 matching_lma
= output_section
->lma
;
5504 first_matching_lma
= FALSE
;
5507 /* We assume that if the section fits within the segment
5508 then it does not overlap any other section within that
5510 map
->sections
[isec
++] = output_section
;
5512 else if (first_suggested_lma
)
5514 suggested_lma
= output_section
->lma
;
5515 first_suggested_lma
= FALSE
;
5518 if (j
== section_count
)
5523 BFD_ASSERT (j
== section_count
);
5525 /* Step Two: Adjust the physical address of the current segment,
5527 if (isec
== section_count
)
5529 /* All of the sections fitted within the segment as currently
5530 specified. This is the default case. Add the segment to
5531 the list of built segments and carry on to process the next
5532 program header in the input BFD. */
5533 map
->count
= section_count
;
5534 *pointer_to_map
= map
;
5535 pointer_to_map
= &map
->next
;
5538 && !bed
->want_p_paddr_set_to_zero
5539 && matching_lma
!= map
->p_paddr
5540 && !map
->includes_filehdr
5541 && !map
->includes_phdrs
)
5542 /* There is some padding before the first section in the
5543 segment. So, we must account for that in the output
5545 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5552 if (!first_matching_lma
)
5554 /* At least one section fits inside the current segment.
5555 Keep it, but modify its physical address to match the
5556 LMA of the first section that fitted. */
5557 map
->p_paddr
= matching_lma
;
5561 /* None of the sections fitted inside the current segment.
5562 Change the current segment's physical address to match
5563 the LMA of the first section. */
5564 map
->p_paddr
= suggested_lma
;
5567 /* Offset the segment physical address from the lma
5568 to allow for space taken up by elf headers. */
5569 if (map
->includes_filehdr
)
5570 map
->p_paddr
-= iehdr
->e_ehsize
;
5572 if (map
->includes_phdrs
)
5574 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5576 /* iehdr->e_phnum is just an estimate of the number
5577 of program headers that we will need. Make a note
5578 here of the number we used and the segment we chose
5579 to hold these headers, so that we can adjust the
5580 offset when we know the correct value. */
5581 phdr_adjust_num
= iehdr
->e_phnum
;
5582 phdr_adjust_seg
= map
;
5586 /* Step Three: Loop over the sections again, this time assigning
5587 those that fit to the current segment and removing them from the
5588 sections array; but making sure not to leave large gaps. Once all
5589 possible sections have been assigned to the current segment it is
5590 added to the list of built segments and if sections still remain
5591 to be assigned, a new segment is constructed before repeating
5598 first_suggested_lma
= TRUE
;
5600 /* Fill the current segment with sections that fit. */
5601 for (j
= 0; j
< section_count
; j
++)
5603 section
= sections
[j
];
5605 if (section
== NULL
)
5608 output_section
= section
->output_section
;
5610 BFD_ASSERT (output_section
!= NULL
);
5612 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5613 || IS_COREFILE_NOTE (segment
, section
))
5615 if (map
->count
== 0)
5617 /* If the first section in a segment does not start at
5618 the beginning of the segment, then something is
5620 if (output_section
->lma
5622 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5623 + (map
->includes_phdrs
5624 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5632 prev_sec
= map
->sections
[map
->count
- 1];
5634 /* If the gap between the end of the previous section
5635 and the start of this section is more than
5636 maxpagesize then we need to start a new segment. */
5637 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5639 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5640 || (prev_sec
->lma
+ prev_sec
->size
5641 > output_section
->lma
))
5643 if (first_suggested_lma
)
5645 suggested_lma
= output_section
->lma
;
5646 first_suggested_lma
= FALSE
;
5653 map
->sections
[map
->count
++] = output_section
;
5656 section
->segment_mark
= TRUE
;
5658 else if (first_suggested_lma
)
5660 suggested_lma
= output_section
->lma
;
5661 first_suggested_lma
= FALSE
;
5665 BFD_ASSERT (map
->count
> 0);
5667 /* Add the current segment to the list of built segments. */
5668 *pointer_to_map
= map
;
5669 pointer_to_map
= &map
->next
;
5671 if (isec
< section_count
)
5673 /* We still have not allocated all of the sections to
5674 segments. Create a new segment here, initialise it
5675 and carry on looping. */
5676 amt
= sizeof (struct elf_segment_map
);
5677 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5678 map
= bfd_alloc (obfd
, amt
);
5685 /* Initialise the fields of the segment map. Set the physical
5686 physical address to the LMA of the first section that has
5687 not yet been assigned. */
5689 map
->p_type
= segment
->p_type
;
5690 map
->p_flags
= segment
->p_flags
;
5691 map
->p_flags_valid
= 1;
5692 map
->p_paddr
= suggested_lma
;
5693 map
->p_paddr_valid
= p_paddr_valid
;
5694 map
->includes_filehdr
= 0;
5695 map
->includes_phdrs
= 0;
5698 while (isec
< section_count
);
5703 elf_tdata (obfd
)->segment_map
= map_first
;
5705 /* If we had to estimate the number of program headers that were
5706 going to be needed, then check our estimate now and adjust
5707 the offset if necessary. */
5708 if (phdr_adjust_seg
!= NULL
)
5712 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5715 if (count
> phdr_adjust_num
)
5716 phdr_adjust_seg
->p_paddr
5717 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5722 #undef IS_CONTAINED_BY_VMA
5723 #undef IS_CONTAINED_BY_LMA
5725 #undef IS_COREFILE_NOTE
5726 #undef IS_SOLARIS_PT_INTERP
5727 #undef IS_SECTION_IN_INPUT_SEGMENT
5728 #undef INCLUDE_SECTION_IN_SEGMENT
5729 #undef SEGMENT_AFTER_SEGMENT
5730 #undef SEGMENT_OVERLAPS
5734 /* Copy ELF program header information. */
5737 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5739 Elf_Internal_Ehdr
*iehdr
;
5740 struct elf_segment_map
*map
;
5741 struct elf_segment_map
*map_first
;
5742 struct elf_segment_map
**pointer_to_map
;
5743 Elf_Internal_Phdr
*segment
;
5745 unsigned int num_segments
;
5746 bfd_boolean phdr_included
= FALSE
;
5747 bfd_boolean p_paddr_valid
;
5749 iehdr
= elf_elfheader (ibfd
);
5752 pointer_to_map
= &map_first
;
5754 /* If all the segment p_paddr fields are zero, don't set
5755 map->p_paddr_valid. */
5756 p_paddr_valid
= FALSE
;
5757 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5758 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5761 if (segment
->p_paddr
!= 0)
5763 p_paddr_valid
= TRUE
;
5767 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5772 unsigned int section_count
;
5774 Elf_Internal_Shdr
*this_hdr
;
5775 asection
*first_section
= NULL
;
5776 asection
*lowest_section
= NULL
;
5778 /* Compute how many sections are in this segment. */
5779 for (section
= ibfd
->sections
, section_count
= 0;
5781 section
= section
->next
)
5783 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5784 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5787 first_section
= lowest_section
= section
;
5788 if (section
->lma
< lowest_section
->lma
)
5789 lowest_section
= section
;
5794 /* Allocate a segment map big enough to contain
5795 all of the sections we have selected. */
5796 amt
= sizeof (struct elf_segment_map
);
5797 if (section_count
!= 0)
5798 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5799 map
= bfd_zalloc (obfd
, amt
);
5803 /* Initialize the fields of the output segment map with the
5806 map
->p_type
= segment
->p_type
;
5807 map
->p_flags
= segment
->p_flags
;
5808 map
->p_flags_valid
= 1;
5809 map
->p_paddr
= segment
->p_paddr
;
5810 map
->p_paddr_valid
= p_paddr_valid
;
5811 map
->p_align
= segment
->p_align
;
5812 map
->p_align_valid
= 1;
5813 map
->p_vaddr_offset
= 0;
5815 if (map
->p_type
== PT_GNU_RELRO
5816 && segment
->p_filesz
== segment
->p_memsz
)
5818 /* The PT_GNU_RELRO segment may contain the first a few
5819 bytes in the .got.plt section even if the whole .got.plt
5820 section isn't in the PT_GNU_RELRO segment. We won't
5821 change the size of the PT_GNU_RELRO segment. */
5822 map
->p_size
= segment
->p_filesz
;
5823 map
->p_size_valid
= 1;
5826 /* Determine if this segment contains the ELF file header
5827 and if it contains the program headers themselves. */
5828 map
->includes_filehdr
= (segment
->p_offset
== 0
5829 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5831 map
->includes_phdrs
= 0;
5832 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5834 map
->includes_phdrs
=
5835 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5836 && (segment
->p_offset
+ segment
->p_filesz
5837 >= ((bfd_vma
) iehdr
->e_phoff
5838 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5840 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5841 phdr_included
= TRUE
;
5844 if (!map
->includes_phdrs
5845 && !map
->includes_filehdr
5846 && map
->p_paddr_valid
)
5847 /* There is some other padding before the first section. */
5848 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
5849 - segment
->p_paddr
);
5851 if (section_count
!= 0)
5853 unsigned int isec
= 0;
5855 for (section
= first_section
;
5857 section
= section
->next
)
5859 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5860 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5862 map
->sections
[isec
++] = section
->output_section
;
5863 if (isec
== section_count
)
5869 map
->count
= section_count
;
5870 *pointer_to_map
= map
;
5871 pointer_to_map
= &map
->next
;
5874 elf_tdata (obfd
)->segment_map
= map_first
;
5878 /* Copy private BFD data. This copies or rewrites ELF program header
5882 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5884 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5885 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5888 if (elf_tdata (ibfd
)->phdr
== NULL
)
5891 if (ibfd
->xvec
== obfd
->xvec
)
5893 /* Check to see if any sections in the input BFD
5894 covered by ELF program header have changed. */
5895 Elf_Internal_Phdr
*segment
;
5896 asection
*section
, *osec
;
5897 unsigned int i
, num_segments
;
5898 Elf_Internal_Shdr
*this_hdr
;
5899 const struct elf_backend_data
*bed
;
5901 bed
= get_elf_backend_data (ibfd
);
5903 /* Regenerate the segment map if p_paddr is set to 0. */
5904 if (bed
->want_p_paddr_set_to_zero
)
5907 /* Initialize the segment mark field. */
5908 for (section
= obfd
->sections
; section
!= NULL
;
5909 section
= section
->next
)
5910 section
->segment_mark
= FALSE
;
5912 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5913 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5917 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5918 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5919 which severly confuses things, so always regenerate the segment
5920 map in this case. */
5921 if (segment
->p_paddr
== 0
5922 && segment
->p_memsz
== 0
5923 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
5926 for (section
= ibfd
->sections
;
5927 section
!= NULL
; section
= section
->next
)
5929 /* We mark the output section so that we know it comes
5930 from the input BFD. */
5931 osec
= section
->output_section
;
5933 osec
->segment_mark
= TRUE
;
5935 /* Check if this section is covered by the segment. */
5936 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5937 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5939 /* FIXME: Check if its output section is changed or
5940 removed. What else do we need to check? */
5942 || section
->flags
!= osec
->flags
5943 || section
->lma
!= osec
->lma
5944 || section
->vma
!= osec
->vma
5945 || section
->size
!= osec
->size
5946 || section
->rawsize
!= osec
->rawsize
5947 || section
->alignment_power
!= osec
->alignment_power
)
5953 /* Check to see if any output section do not come from the
5955 for (section
= obfd
->sections
; section
!= NULL
;
5956 section
= section
->next
)
5958 if (section
->segment_mark
== FALSE
)
5961 section
->segment_mark
= FALSE
;
5964 return copy_elf_program_header (ibfd
, obfd
);
5968 return rewrite_elf_program_header (ibfd
, obfd
);
5971 /* Initialize private output section information from input section. */
5974 _bfd_elf_init_private_section_data (bfd
*ibfd
,
5978 struct bfd_link_info
*link_info
)
5981 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5982 bfd_boolean need_group
= link_info
== NULL
|| link_info
->relocatable
;
5984 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5985 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5988 /* Don't copy the output ELF section type from input if the
5989 output BFD section flags have been set to something different.
5990 elf_fake_sections will set ELF section type based on BFD
5992 if (elf_section_type (osec
) == SHT_NULL
5993 && (osec
->flags
== isec
->flags
|| !osec
->flags
))
5994 elf_section_type (osec
) = elf_section_type (isec
);
5996 /* FIXME: Is this correct for all OS/PROC specific flags? */
5997 elf_section_flags (osec
) |= (elf_section_flags (isec
)
5998 & (SHF_MASKOS
| SHF_MASKPROC
));
6000 /* Set things up for objcopy and relocatable link. The output
6001 SHT_GROUP section will have its elf_next_in_group pointing back
6002 to the input group members. Ignore linker created group section.
6003 See elfNN_ia64_object_p in elfxx-ia64.c. */
6006 if (elf_sec_group (isec
) == NULL
6007 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6009 if (elf_section_flags (isec
) & SHF_GROUP
)
6010 elf_section_flags (osec
) |= SHF_GROUP
;
6011 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6012 elf_group_name (osec
) = elf_group_name (isec
);
6016 ihdr
= &elf_section_data (isec
)->this_hdr
;
6018 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6019 don't use the output section of the linked-to section since it
6020 may be NULL at this point. */
6021 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6023 ohdr
= &elf_section_data (osec
)->this_hdr
;
6024 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6025 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6028 osec
->use_rela_p
= isec
->use_rela_p
;
6033 /* Copy private section information. This copies over the entsize
6034 field, and sometimes the info field. */
6037 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6042 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6044 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6045 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6048 ihdr
= &elf_section_data (isec
)->this_hdr
;
6049 ohdr
= &elf_section_data (osec
)->this_hdr
;
6051 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6053 if (ihdr
->sh_type
== SHT_SYMTAB
6054 || ihdr
->sh_type
== SHT_DYNSYM
6055 || ihdr
->sh_type
== SHT_GNU_verneed
6056 || ihdr
->sh_type
== SHT_GNU_verdef
)
6057 ohdr
->sh_info
= ihdr
->sh_info
;
6059 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6063 /* Copy private header information. */
6066 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6070 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6071 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6074 /* Copy over private BFD data if it has not already been copied.
6075 This must be done here, rather than in the copy_private_bfd_data
6076 entry point, because the latter is called after the section
6077 contents have been set, which means that the program headers have
6078 already been worked out. */
6079 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6081 if (! copy_private_bfd_data (ibfd
, obfd
))
6085 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6086 but this might be wrong if we deleted the group section. */
6087 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6088 if (elf_section_type (isec
) == SHT_GROUP
6089 && isec
->output_section
== NULL
)
6091 asection
*first
= elf_next_in_group (isec
);
6092 asection
*s
= first
;
6095 if (s
->output_section
!= NULL
)
6097 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6098 elf_group_name (s
->output_section
) = NULL
;
6100 s
= elf_next_in_group (s
);
6109 /* Copy private symbol information. If this symbol is in a section
6110 which we did not map into a BFD section, try to map the section
6111 index correctly. We use special macro definitions for the mapped
6112 section indices; these definitions are interpreted by the
6113 swap_out_syms function. */
6115 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6116 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6117 #define MAP_STRTAB (SHN_HIOS + 3)
6118 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6119 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6122 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6127 elf_symbol_type
*isym
, *osym
;
6129 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6130 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6133 isym
= elf_symbol_from (ibfd
, isymarg
);
6134 osym
= elf_symbol_from (obfd
, osymarg
);
6137 && isym
->internal_elf_sym
.st_shndx
!= 0
6139 && bfd_is_abs_section (isym
->symbol
.section
))
6143 shndx
= isym
->internal_elf_sym
.st_shndx
;
6144 if (shndx
== elf_onesymtab (ibfd
))
6145 shndx
= MAP_ONESYMTAB
;
6146 else if (shndx
== elf_dynsymtab (ibfd
))
6147 shndx
= MAP_DYNSYMTAB
;
6148 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6150 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6151 shndx
= MAP_SHSTRTAB
;
6152 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6153 shndx
= MAP_SYM_SHNDX
;
6154 osym
->internal_elf_sym
.st_shndx
= shndx
;
6160 /* Swap out the symbols. */
6163 swap_out_syms (bfd
*abfd
,
6164 struct bfd_strtab_hash
**sttp
,
6167 const struct elf_backend_data
*bed
;
6170 struct bfd_strtab_hash
*stt
;
6171 Elf_Internal_Shdr
*symtab_hdr
;
6172 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6173 Elf_Internal_Shdr
*symstrtab_hdr
;
6174 bfd_byte
*outbound_syms
;
6175 bfd_byte
*outbound_shndx
;
6178 bfd_boolean name_local_sections
;
6180 if (!elf_map_symbols (abfd
))
6183 /* Dump out the symtabs. */
6184 stt
= _bfd_elf_stringtab_init ();
6188 bed
= get_elf_backend_data (abfd
);
6189 symcount
= bfd_get_symcount (abfd
);
6190 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6191 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6192 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6193 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6194 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6195 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6197 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6198 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6200 outbound_syms
= bfd_alloc2 (abfd
, 1 + symcount
, bed
->s
->sizeof_sym
);
6201 if (outbound_syms
== NULL
)
6203 _bfd_stringtab_free (stt
);
6206 symtab_hdr
->contents
= outbound_syms
;
6208 outbound_shndx
= NULL
;
6209 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6210 if (symtab_shndx_hdr
->sh_name
!= 0)
6212 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6213 outbound_shndx
= bfd_zalloc2 (abfd
, 1 + symcount
,
6214 sizeof (Elf_External_Sym_Shndx
));
6215 if (outbound_shndx
== NULL
)
6217 _bfd_stringtab_free (stt
);
6221 symtab_shndx_hdr
->contents
= outbound_shndx
;
6222 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6223 symtab_shndx_hdr
->sh_size
= amt
;
6224 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6225 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6228 /* Now generate the data (for "contents"). */
6230 /* Fill in zeroth symbol and swap it out. */
6231 Elf_Internal_Sym sym
;
6237 sym
.st_shndx
= SHN_UNDEF
;
6238 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6239 outbound_syms
+= bed
->s
->sizeof_sym
;
6240 if (outbound_shndx
!= NULL
)
6241 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6245 = (bed
->elf_backend_name_local_section_symbols
6246 && bed
->elf_backend_name_local_section_symbols (abfd
));
6248 syms
= bfd_get_outsymbols (abfd
);
6249 for (idx
= 0; idx
< symcount
; idx
++)
6251 Elf_Internal_Sym sym
;
6252 bfd_vma value
= syms
[idx
]->value
;
6253 elf_symbol_type
*type_ptr
;
6254 flagword flags
= syms
[idx
]->flags
;
6257 if (!name_local_sections
6258 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6260 /* Local section symbols have no name. */
6265 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6268 if (sym
.st_name
== (unsigned long) -1)
6270 _bfd_stringtab_free (stt
);
6275 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6277 if ((flags
& BSF_SECTION_SYM
) == 0
6278 && bfd_is_com_section (syms
[idx
]->section
))
6280 /* ELF common symbols put the alignment into the `value' field,
6281 and the size into the `size' field. This is backwards from
6282 how BFD handles it, so reverse it here. */
6283 sym
.st_size
= value
;
6284 if (type_ptr
== NULL
6285 || type_ptr
->internal_elf_sym
.st_value
== 0)
6286 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6288 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6289 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6290 (abfd
, syms
[idx
]->section
);
6294 asection
*sec
= syms
[idx
]->section
;
6297 if (sec
->output_section
)
6299 value
+= sec
->output_offset
;
6300 sec
= sec
->output_section
;
6303 /* Don't add in the section vma for relocatable output. */
6304 if (! relocatable_p
)
6306 sym
.st_value
= value
;
6307 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6309 if (bfd_is_abs_section (sec
)
6311 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6313 /* This symbol is in a real ELF section which we did
6314 not create as a BFD section. Undo the mapping done
6315 by copy_private_symbol_data. */
6316 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6320 shndx
= elf_onesymtab (abfd
);
6323 shndx
= elf_dynsymtab (abfd
);
6326 shndx
= elf_tdata (abfd
)->strtab_section
;
6329 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6332 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6340 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6342 if (shndx
== SHN_BAD
)
6346 /* Writing this would be a hell of a lot easier if
6347 we had some decent documentation on bfd, and
6348 knew what to expect of the library, and what to
6349 demand of applications. For example, it
6350 appears that `objcopy' might not set the
6351 section of a symbol to be a section that is
6352 actually in the output file. */
6353 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6356 _bfd_error_handler (_("\
6357 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6358 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6360 bfd_set_error (bfd_error_invalid_operation
);
6361 _bfd_stringtab_free (stt
);
6365 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6366 BFD_ASSERT (shndx
!= SHN_BAD
);
6370 sym
.st_shndx
= shndx
;
6373 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6375 else if ((flags
& BSF_FUNCTION
) != 0)
6377 else if ((flags
& BSF_OBJECT
) != 0)
6379 else if ((flags
& BSF_RELC
) != 0)
6381 else if ((flags
& BSF_SRELC
) != 0)
6386 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6389 /* Processor-specific types. */
6390 if (type_ptr
!= NULL
6391 && bed
->elf_backend_get_symbol_type
)
6392 type
= ((*bed
->elf_backend_get_symbol_type
)
6393 (&type_ptr
->internal_elf_sym
, type
));
6395 if (flags
& BSF_SECTION_SYM
)
6397 if (flags
& BSF_GLOBAL
)
6398 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6400 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6402 else if (bfd_is_com_section (syms
[idx
]->section
))
6404 #ifdef USE_STT_COMMON
6405 if (type
== STT_OBJECT
)
6406 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
6409 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6412 else if (bfd_is_und_section (syms
[idx
]->section
))
6413 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6417 else if (flags
& BSF_FILE
)
6418 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6421 int bind
= STB_LOCAL
;
6423 if (flags
& BSF_LOCAL
)
6425 else if (flags
& BSF_WEAK
)
6427 else if (flags
& BSF_GLOBAL
)
6430 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6433 if (type_ptr
!= NULL
)
6434 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6438 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6439 outbound_syms
+= bed
->s
->sizeof_sym
;
6440 if (outbound_shndx
!= NULL
)
6441 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6445 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6446 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6448 symstrtab_hdr
->sh_flags
= 0;
6449 symstrtab_hdr
->sh_addr
= 0;
6450 symstrtab_hdr
->sh_entsize
= 0;
6451 symstrtab_hdr
->sh_link
= 0;
6452 symstrtab_hdr
->sh_info
= 0;
6453 symstrtab_hdr
->sh_addralign
= 1;
6458 /* Return the number of bytes required to hold the symtab vector.
6460 Note that we base it on the count plus 1, since we will null terminate
6461 the vector allocated based on this size. However, the ELF symbol table
6462 always has a dummy entry as symbol #0, so it ends up even. */
6465 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6469 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6471 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6472 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6474 symtab_size
-= sizeof (asymbol
*);
6480 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6484 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6486 if (elf_dynsymtab (abfd
) == 0)
6488 bfd_set_error (bfd_error_invalid_operation
);
6492 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6493 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6495 symtab_size
-= sizeof (asymbol
*);
6501 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6504 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6507 /* Canonicalize the relocs. */
6510 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6517 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6519 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6522 tblptr
= section
->relocation
;
6523 for (i
= 0; i
< section
->reloc_count
; i
++)
6524 *relptr
++ = tblptr
++;
6528 return section
->reloc_count
;
6532 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6534 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6535 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6538 bfd_get_symcount (abfd
) = symcount
;
6543 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6544 asymbol
**allocation
)
6546 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6547 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6550 bfd_get_dynamic_symcount (abfd
) = symcount
;
6554 /* Return the size required for the dynamic reloc entries. Any loadable
6555 section that was actually installed in the BFD, and has type SHT_REL
6556 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6557 dynamic reloc section. */
6560 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6565 if (elf_dynsymtab (abfd
) == 0)
6567 bfd_set_error (bfd_error_invalid_operation
);
6571 ret
= sizeof (arelent
*);
6572 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6573 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6574 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6575 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6576 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6577 * sizeof (arelent
*));
6582 /* Canonicalize the dynamic relocation entries. Note that we return the
6583 dynamic relocations as a single block, although they are actually
6584 associated with particular sections; the interface, which was
6585 designed for SunOS style shared libraries, expects that there is only
6586 one set of dynamic relocs. Any loadable section that was actually
6587 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6588 dynamic symbol table, is considered to be a dynamic reloc section. */
6591 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6595 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6599 if (elf_dynsymtab (abfd
) == 0)
6601 bfd_set_error (bfd_error_invalid_operation
);
6605 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6607 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6609 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6610 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6611 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6616 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6618 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6620 for (i
= 0; i
< count
; i
++)
6631 /* Read in the version information. */
6634 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6636 bfd_byte
*contents
= NULL
;
6637 unsigned int freeidx
= 0;
6639 if (elf_dynverref (abfd
) != 0)
6641 Elf_Internal_Shdr
*hdr
;
6642 Elf_External_Verneed
*everneed
;
6643 Elf_Internal_Verneed
*iverneed
;
6645 bfd_byte
*contents_end
;
6647 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6649 elf_tdata (abfd
)->verref
= bfd_zalloc2 (abfd
, hdr
->sh_info
,
6650 sizeof (Elf_Internal_Verneed
));
6651 if (elf_tdata (abfd
)->verref
== NULL
)
6654 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6656 contents
= bfd_malloc (hdr
->sh_size
);
6657 if (contents
== NULL
)
6659 error_return_verref
:
6660 elf_tdata (abfd
)->verref
= NULL
;
6661 elf_tdata (abfd
)->cverrefs
= 0;
6664 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6665 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6666 goto error_return_verref
;
6668 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6669 goto error_return_verref
;
6671 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6672 == sizeof (Elf_External_Vernaux
));
6673 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6674 everneed
= (Elf_External_Verneed
*) contents
;
6675 iverneed
= elf_tdata (abfd
)->verref
;
6676 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6678 Elf_External_Vernaux
*evernaux
;
6679 Elf_Internal_Vernaux
*ivernaux
;
6682 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6684 iverneed
->vn_bfd
= abfd
;
6686 iverneed
->vn_filename
=
6687 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6689 if (iverneed
->vn_filename
== NULL
)
6690 goto error_return_verref
;
6692 if (iverneed
->vn_cnt
== 0)
6693 iverneed
->vn_auxptr
= NULL
;
6696 iverneed
->vn_auxptr
= bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6697 sizeof (Elf_Internal_Vernaux
));
6698 if (iverneed
->vn_auxptr
== NULL
)
6699 goto error_return_verref
;
6702 if (iverneed
->vn_aux
6703 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6704 goto error_return_verref
;
6706 evernaux
= ((Elf_External_Vernaux
*)
6707 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6708 ivernaux
= iverneed
->vn_auxptr
;
6709 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6711 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6713 ivernaux
->vna_nodename
=
6714 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6715 ivernaux
->vna_name
);
6716 if (ivernaux
->vna_nodename
== NULL
)
6717 goto error_return_verref
;
6719 if (j
+ 1 < iverneed
->vn_cnt
)
6720 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6722 ivernaux
->vna_nextptr
= NULL
;
6724 if (ivernaux
->vna_next
6725 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6726 goto error_return_verref
;
6728 evernaux
= ((Elf_External_Vernaux
*)
6729 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6731 if (ivernaux
->vna_other
> freeidx
)
6732 freeidx
= ivernaux
->vna_other
;
6735 if (i
+ 1 < hdr
->sh_info
)
6736 iverneed
->vn_nextref
= iverneed
+ 1;
6738 iverneed
->vn_nextref
= NULL
;
6740 if (iverneed
->vn_next
6741 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6742 goto error_return_verref
;
6744 everneed
= ((Elf_External_Verneed
*)
6745 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6752 if (elf_dynverdef (abfd
) != 0)
6754 Elf_Internal_Shdr
*hdr
;
6755 Elf_External_Verdef
*everdef
;
6756 Elf_Internal_Verdef
*iverdef
;
6757 Elf_Internal_Verdef
*iverdefarr
;
6758 Elf_Internal_Verdef iverdefmem
;
6760 unsigned int maxidx
;
6761 bfd_byte
*contents_end_def
, *contents_end_aux
;
6763 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6765 contents
= bfd_malloc (hdr
->sh_size
);
6766 if (contents
== NULL
)
6768 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6769 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6772 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6775 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6776 >= sizeof (Elf_External_Verdaux
));
6777 contents_end_def
= contents
+ hdr
->sh_size
6778 - sizeof (Elf_External_Verdef
);
6779 contents_end_aux
= contents
+ hdr
->sh_size
6780 - sizeof (Elf_External_Verdaux
);
6782 /* We know the number of entries in the section but not the maximum
6783 index. Therefore we have to run through all entries and find
6785 everdef
= (Elf_External_Verdef
*) contents
;
6787 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6789 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6791 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6792 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6794 if (iverdefmem
.vd_next
6795 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6798 everdef
= ((Elf_External_Verdef
*)
6799 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6802 if (default_imported_symver
)
6804 if (freeidx
> maxidx
)
6809 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, maxidx
,
6810 sizeof (Elf_Internal_Verdef
));
6811 if (elf_tdata (abfd
)->verdef
== NULL
)
6814 elf_tdata (abfd
)->cverdefs
= maxidx
;
6816 everdef
= (Elf_External_Verdef
*) contents
;
6817 iverdefarr
= elf_tdata (abfd
)->verdef
;
6818 for (i
= 0; i
< hdr
->sh_info
; i
++)
6820 Elf_External_Verdaux
*everdaux
;
6821 Elf_Internal_Verdaux
*iverdaux
;
6824 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6826 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6828 error_return_verdef
:
6829 elf_tdata (abfd
)->verdef
= NULL
;
6830 elf_tdata (abfd
)->cverdefs
= 0;
6834 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6835 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6837 iverdef
->vd_bfd
= abfd
;
6839 if (iverdef
->vd_cnt
== 0)
6840 iverdef
->vd_auxptr
= NULL
;
6843 iverdef
->vd_auxptr
= bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6844 sizeof (Elf_Internal_Verdaux
));
6845 if (iverdef
->vd_auxptr
== NULL
)
6846 goto error_return_verdef
;
6850 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6851 goto error_return_verdef
;
6853 everdaux
= ((Elf_External_Verdaux
*)
6854 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6855 iverdaux
= iverdef
->vd_auxptr
;
6856 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6858 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6860 iverdaux
->vda_nodename
=
6861 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6862 iverdaux
->vda_name
);
6863 if (iverdaux
->vda_nodename
== NULL
)
6864 goto error_return_verdef
;
6866 if (j
+ 1 < iverdef
->vd_cnt
)
6867 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6869 iverdaux
->vda_nextptr
= NULL
;
6871 if (iverdaux
->vda_next
6872 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
6873 goto error_return_verdef
;
6875 everdaux
= ((Elf_External_Verdaux
*)
6876 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6879 if (iverdef
->vd_cnt
)
6880 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6882 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
6883 iverdef
->vd_nextdef
= iverdef
+ 1;
6885 iverdef
->vd_nextdef
= NULL
;
6887 everdef
= ((Elf_External_Verdef
*)
6888 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6894 else if (default_imported_symver
)
6901 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, freeidx
,
6902 sizeof (Elf_Internal_Verdef
));
6903 if (elf_tdata (abfd
)->verdef
== NULL
)
6906 elf_tdata (abfd
)->cverdefs
= freeidx
;
6909 /* Create a default version based on the soname. */
6910 if (default_imported_symver
)
6912 Elf_Internal_Verdef
*iverdef
;
6913 Elf_Internal_Verdaux
*iverdaux
;
6915 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6917 iverdef
->vd_version
= VER_DEF_CURRENT
;
6918 iverdef
->vd_flags
= 0;
6919 iverdef
->vd_ndx
= freeidx
;
6920 iverdef
->vd_cnt
= 1;
6922 iverdef
->vd_bfd
= abfd
;
6924 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6925 if (iverdef
->vd_nodename
== NULL
)
6926 goto error_return_verdef
;
6927 iverdef
->vd_nextdef
= NULL
;
6928 iverdef
->vd_auxptr
= bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
6929 if (iverdef
->vd_auxptr
== NULL
)
6930 goto error_return_verdef
;
6932 iverdaux
= iverdef
->vd_auxptr
;
6933 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
6934 iverdaux
->vda_nextptr
= NULL
;
6940 if (contents
!= NULL
)
6946 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6948 elf_symbol_type
*newsym
;
6949 bfd_size_type amt
= sizeof (elf_symbol_type
);
6951 newsym
= bfd_zalloc (abfd
, amt
);
6956 newsym
->symbol
.the_bfd
= abfd
;
6957 return &newsym
->symbol
;
6962 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6966 bfd_symbol_info (symbol
, ret
);
6969 /* Return whether a symbol name implies a local symbol. Most targets
6970 use this function for the is_local_label_name entry point, but some
6974 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6977 /* Normal local symbols start with ``.L''. */
6978 if (name
[0] == '.' && name
[1] == 'L')
6981 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6982 DWARF debugging symbols starting with ``..''. */
6983 if (name
[0] == '.' && name
[1] == '.')
6986 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6987 emitting DWARF debugging output. I suspect this is actually a
6988 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6989 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6990 underscore to be emitted on some ELF targets). For ease of use,
6991 we treat such symbols as local. */
6992 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6999 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7000 asymbol
*symbol ATTRIBUTE_UNUSED
)
7007 _bfd_elf_set_arch_mach (bfd
*abfd
,
7008 enum bfd_architecture arch
,
7009 unsigned long machine
)
7011 /* If this isn't the right architecture for this backend, and this
7012 isn't the generic backend, fail. */
7013 if (arch
!= get_elf_backend_data (abfd
)->arch
7014 && arch
!= bfd_arch_unknown
7015 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7018 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7021 /* Find the function to a particular section and offset,
7022 for error reporting. */
7025 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
7029 const char **filename_ptr
,
7030 const char **functionname_ptr
)
7032 const char *filename
;
7033 asymbol
*func
, *file
;
7036 /* ??? Given multiple file symbols, it is impossible to reliably
7037 choose the right file name for global symbols. File symbols are
7038 local symbols, and thus all file symbols must sort before any
7039 global symbols. The ELF spec may be interpreted to say that a
7040 file symbol must sort before other local symbols, but currently
7041 ld -r doesn't do this. So, for ld -r output, it is possible to
7042 make a better choice of file name for local symbols by ignoring
7043 file symbols appearing after a given local symbol. */
7044 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7050 state
= nothing_seen
;
7052 for (p
= symbols
; *p
!= NULL
; p
++)
7056 q
= (elf_symbol_type
*) *p
;
7058 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
7064 if (state
== symbol_seen
)
7065 state
= file_after_symbol_seen
;
7069 if (bfd_get_section (&q
->symbol
) == section
7070 && q
->symbol
.value
>= low_func
7071 && q
->symbol
.value
<= offset
)
7073 func
= (asymbol
*) q
;
7074 low_func
= q
->symbol
.value
;
7077 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7078 || state
!= file_after_symbol_seen
))
7079 filename
= bfd_asymbol_name (file
);
7083 if (state
== nothing_seen
)
7084 state
= symbol_seen
;
7091 *filename_ptr
= filename
;
7092 if (functionname_ptr
)
7093 *functionname_ptr
= bfd_asymbol_name (func
);
7098 /* Find the nearest line to a particular section and offset,
7099 for error reporting. */
7102 _bfd_elf_find_nearest_line (bfd
*abfd
,
7106 const char **filename_ptr
,
7107 const char **functionname_ptr
,
7108 unsigned int *line_ptr
)
7112 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7113 filename_ptr
, functionname_ptr
,
7116 if (!*functionname_ptr
)
7117 elf_find_function (abfd
, section
, symbols
, offset
,
7118 *filename_ptr
? NULL
: filename_ptr
,
7124 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7125 filename_ptr
, functionname_ptr
,
7127 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7129 if (!*functionname_ptr
)
7130 elf_find_function (abfd
, section
, symbols
, offset
,
7131 *filename_ptr
? NULL
: filename_ptr
,
7137 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7138 &found
, filename_ptr
,
7139 functionname_ptr
, line_ptr
,
7140 &elf_tdata (abfd
)->line_info
))
7142 if (found
&& (*functionname_ptr
|| *line_ptr
))
7145 if (symbols
== NULL
)
7148 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7149 filename_ptr
, functionname_ptr
))
7156 /* Find the line for a symbol. */
7159 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7160 const char **filename_ptr
, unsigned int *line_ptr
)
7162 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7163 filename_ptr
, line_ptr
, 0,
7164 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7167 /* After a call to bfd_find_nearest_line, successive calls to
7168 bfd_find_inliner_info can be used to get source information about
7169 each level of function inlining that terminated at the address
7170 passed to bfd_find_nearest_line. Currently this is only supported
7171 for DWARF2 with appropriate DWARF3 extensions. */
7174 _bfd_elf_find_inliner_info (bfd
*abfd
,
7175 const char **filename_ptr
,
7176 const char **functionname_ptr
,
7177 unsigned int *line_ptr
)
7180 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7181 functionname_ptr
, line_ptr
,
7182 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7187 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7189 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7190 int ret
= bed
->s
->sizeof_ehdr
;
7192 if (!info
->relocatable
)
7194 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7196 if (phdr_size
== (bfd_size_type
) -1)
7198 struct elf_segment_map
*m
;
7201 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7202 phdr_size
+= bed
->s
->sizeof_phdr
;
7205 phdr_size
= get_program_header_size (abfd
, info
);
7208 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7216 _bfd_elf_set_section_contents (bfd
*abfd
,
7218 const void *location
,
7220 bfd_size_type count
)
7222 Elf_Internal_Shdr
*hdr
;
7225 if (! abfd
->output_has_begun
7226 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7229 hdr
= &elf_section_data (section
)->this_hdr
;
7230 pos
= hdr
->sh_offset
+ offset
;
7231 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7232 || bfd_bwrite (location
, count
, abfd
) != count
)
7239 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7240 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7241 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7246 /* Try to convert a non-ELF reloc into an ELF one. */
7249 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7251 /* Check whether we really have an ELF howto. */
7253 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7255 bfd_reloc_code_real_type code
;
7256 reloc_howto_type
*howto
;
7258 /* Alien reloc: Try to determine its type to replace it with an
7259 equivalent ELF reloc. */
7261 if (areloc
->howto
->pc_relative
)
7263 switch (areloc
->howto
->bitsize
)
7266 code
= BFD_RELOC_8_PCREL
;
7269 code
= BFD_RELOC_12_PCREL
;
7272 code
= BFD_RELOC_16_PCREL
;
7275 code
= BFD_RELOC_24_PCREL
;
7278 code
= BFD_RELOC_32_PCREL
;
7281 code
= BFD_RELOC_64_PCREL
;
7287 howto
= bfd_reloc_type_lookup (abfd
, code
);
7289 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7291 if (howto
->pcrel_offset
)
7292 areloc
->addend
+= areloc
->address
;
7294 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7299 switch (areloc
->howto
->bitsize
)
7305 code
= BFD_RELOC_14
;
7308 code
= BFD_RELOC_16
;
7311 code
= BFD_RELOC_26
;
7314 code
= BFD_RELOC_32
;
7317 code
= BFD_RELOC_64
;
7323 howto
= bfd_reloc_type_lookup (abfd
, code
);
7327 areloc
->howto
= howto
;
7335 (*_bfd_error_handler
)
7336 (_("%B: unsupported relocation type %s"),
7337 abfd
, areloc
->howto
->name
);
7338 bfd_set_error (bfd_error_bad_value
);
7343 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7345 if (bfd_get_format (abfd
) == bfd_object
)
7347 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7348 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7349 _bfd_dwarf2_cleanup_debug_info (abfd
);
7352 return _bfd_generic_close_and_cleanup (abfd
);
7355 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7356 in the relocation's offset. Thus we cannot allow any sort of sanity
7357 range-checking to interfere. There is nothing else to do in processing
7360 bfd_reloc_status_type
7361 _bfd_elf_rel_vtable_reloc_fn
7362 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7363 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7364 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7365 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7367 return bfd_reloc_ok
;
7370 /* Elf core file support. Much of this only works on native
7371 toolchains, since we rely on knowing the
7372 machine-dependent procfs structure in order to pick
7373 out details about the corefile. */
7375 #ifdef HAVE_SYS_PROCFS_H
7376 # include <sys/procfs.h>
7379 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7382 elfcore_make_pid (bfd
*abfd
)
7384 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7385 + (elf_tdata (abfd
)->core_pid
));
7388 /* If there isn't a section called NAME, make one, using
7389 data from SECT. Note, this function will generate a
7390 reference to NAME, so you shouldn't deallocate or
7394 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7398 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7401 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7405 sect2
->size
= sect
->size
;
7406 sect2
->filepos
= sect
->filepos
;
7407 sect2
->alignment_power
= sect
->alignment_power
;
7411 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7412 actually creates up to two pseudosections:
7413 - For the single-threaded case, a section named NAME, unless
7414 such a section already exists.
7415 - For the multi-threaded case, a section named "NAME/PID", where
7416 PID is elfcore_make_pid (abfd).
7417 Both pseudosections have identical contents. */
7419 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7425 char *threaded_name
;
7429 /* Build the section name. */
7431 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7432 len
= strlen (buf
) + 1;
7433 threaded_name
= bfd_alloc (abfd
, len
);
7434 if (threaded_name
== NULL
)
7436 memcpy (threaded_name
, buf
, len
);
7438 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7443 sect
->filepos
= filepos
;
7444 sect
->alignment_power
= 2;
7446 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7449 /* prstatus_t exists on:
7451 linux 2.[01] + glibc
7455 #if defined (HAVE_PRSTATUS_T)
7458 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7463 if (note
->descsz
== sizeof (prstatus_t
))
7467 size
= sizeof (prstat
.pr_reg
);
7468 offset
= offsetof (prstatus_t
, pr_reg
);
7469 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7471 /* Do not overwrite the core signal if it
7472 has already been set by another thread. */
7473 if (elf_tdata (abfd
)->core_signal
== 0)
7474 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7475 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7477 /* pr_who exists on:
7480 pr_who doesn't exist on:
7483 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7484 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7487 #if defined (HAVE_PRSTATUS32_T)
7488 else if (note
->descsz
== sizeof (prstatus32_t
))
7490 /* 64-bit host, 32-bit corefile */
7491 prstatus32_t prstat
;
7493 size
= sizeof (prstat
.pr_reg
);
7494 offset
= offsetof (prstatus32_t
, pr_reg
);
7495 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7497 /* Do not overwrite the core signal if it
7498 has already been set by another thread. */
7499 if (elf_tdata (abfd
)->core_signal
== 0)
7500 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7501 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7503 /* pr_who exists on:
7506 pr_who doesn't exist on:
7509 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7510 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7513 #endif /* HAVE_PRSTATUS32_T */
7516 /* Fail - we don't know how to handle any other
7517 note size (ie. data object type). */
7521 /* Make a ".reg/999" section and a ".reg" section. */
7522 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7523 size
, note
->descpos
+ offset
);
7525 #endif /* defined (HAVE_PRSTATUS_T) */
7527 /* Create a pseudosection containing the exact contents of NOTE. */
7529 elfcore_make_note_pseudosection (bfd
*abfd
,
7531 Elf_Internal_Note
*note
)
7533 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7534 note
->descsz
, note
->descpos
);
7537 /* There isn't a consistent prfpregset_t across platforms,
7538 but it doesn't matter, because we don't have to pick this
7539 data structure apart. */
7542 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7544 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7547 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7548 type of NT_PRXFPREG. Just include the whole note's contents
7552 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7554 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7558 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
7560 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
7564 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
7566 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
7569 #if defined (HAVE_PRPSINFO_T)
7570 typedef prpsinfo_t elfcore_psinfo_t
;
7571 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7572 typedef prpsinfo32_t elfcore_psinfo32_t
;
7576 #if defined (HAVE_PSINFO_T)
7577 typedef psinfo_t elfcore_psinfo_t
;
7578 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7579 typedef psinfo32_t elfcore_psinfo32_t
;
7583 /* return a malloc'ed copy of a string at START which is at
7584 most MAX bytes long, possibly without a terminating '\0'.
7585 the copy will always have a terminating '\0'. */
7588 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7591 char *end
= memchr (start
, '\0', max
);
7599 dups
= bfd_alloc (abfd
, len
+ 1);
7603 memcpy (dups
, start
, len
);
7609 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7611 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7613 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7615 elfcore_psinfo_t psinfo
;
7617 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7619 elf_tdata (abfd
)->core_program
7620 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7621 sizeof (psinfo
.pr_fname
));
7623 elf_tdata (abfd
)->core_command
7624 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7625 sizeof (psinfo
.pr_psargs
));
7627 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7628 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7630 /* 64-bit host, 32-bit corefile */
7631 elfcore_psinfo32_t psinfo
;
7633 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7635 elf_tdata (abfd
)->core_program
7636 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7637 sizeof (psinfo
.pr_fname
));
7639 elf_tdata (abfd
)->core_command
7640 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7641 sizeof (psinfo
.pr_psargs
));
7647 /* Fail - we don't know how to handle any other
7648 note size (ie. data object type). */
7652 /* Note that for some reason, a spurious space is tacked
7653 onto the end of the args in some (at least one anyway)
7654 implementations, so strip it off if it exists. */
7657 char *command
= elf_tdata (abfd
)->core_command
;
7658 int n
= strlen (command
);
7660 if (0 < n
&& command
[n
- 1] == ' ')
7661 command
[n
- 1] = '\0';
7666 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7668 #if defined (HAVE_PSTATUS_T)
7670 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7672 if (note
->descsz
== sizeof (pstatus_t
)
7673 #if defined (HAVE_PXSTATUS_T)
7674 || note
->descsz
== sizeof (pxstatus_t
)
7680 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7682 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7684 #if defined (HAVE_PSTATUS32_T)
7685 else if (note
->descsz
== sizeof (pstatus32_t
))
7687 /* 64-bit host, 32-bit corefile */
7690 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7692 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7695 /* Could grab some more details from the "representative"
7696 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7697 NT_LWPSTATUS note, presumably. */
7701 #endif /* defined (HAVE_PSTATUS_T) */
7703 #if defined (HAVE_LWPSTATUS_T)
7705 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7707 lwpstatus_t lwpstat
;
7713 if (note
->descsz
!= sizeof (lwpstat
)
7714 #if defined (HAVE_LWPXSTATUS_T)
7715 && note
->descsz
!= sizeof (lwpxstatus_t
)
7720 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7722 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7723 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7725 /* Make a ".reg/999" section. */
7727 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7728 len
= strlen (buf
) + 1;
7729 name
= bfd_alloc (abfd
, len
);
7732 memcpy (name
, buf
, len
);
7734 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7738 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7739 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7740 sect
->filepos
= note
->descpos
7741 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7744 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7745 sect
->size
= sizeof (lwpstat
.pr_reg
);
7746 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7749 sect
->alignment_power
= 2;
7751 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7754 /* Make a ".reg2/999" section */
7756 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7757 len
= strlen (buf
) + 1;
7758 name
= bfd_alloc (abfd
, len
);
7761 memcpy (name
, buf
, len
);
7763 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7767 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7768 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7769 sect
->filepos
= note
->descpos
7770 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7773 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7774 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7775 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7778 sect
->alignment_power
= 2;
7780 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7782 #endif /* defined (HAVE_LWPSTATUS_T) */
7785 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7792 int is_active_thread
;
7795 if (note
->descsz
< 728)
7798 if (! CONST_STRNEQ (note
->namedata
, "win32"))
7801 type
= bfd_get_32 (abfd
, note
->descdata
);
7805 case 1 /* NOTE_INFO_PROCESS */:
7806 /* FIXME: need to add ->core_command. */
7807 /* process_info.pid */
7808 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7809 /* process_info.signal */
7810 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
7813 case 2 /* NOTE_INFO_THREAD */:
7814 /* Make a ".reg/999" section. */
7815 /* thread_info.tid */
7816 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
7818 len
= strlen (buf
) + 1;
7819 name
= bfd_alloc (abfd
, len
);
7823 memcpy (name
, buf
, len
);
7825 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7829 /* sizeof (thread_info.thread_context) */
7831 /* offsetof (thread_info.thread_context) */
7832 sect
->filepos
= note
->descpos
+ 12;
7833 sect
->alignment_power
= 2;
7835 /* thread_info.is_active_thread */
7836 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7838 if (is_active_thread
)
7839 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7843 case 3 /* NOTE_INFO_MODULE */:
7844 /* Make a ".module/xxxxxxxx" section. */
7845 /* module_info.base_address */
7846 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
7847 sprintf (buf
, ".module/%08lx", (long) base_addr
);
7849 len
= strlen (buf
) + 1;
7850 name
= bfd_alloc (abfd
, len
);
7854 memcpy (name
, buf
, len
);
7856 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7861 sect
->size
= note
->descsz
;
7862 sect
->filepos
= note
->descpos
;
7863 sect
->alignment_power
= 2;
7874 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7876 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7884 if (bed
->elf_backend_grok_prstatus
)
7885 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7887 #if defined (HAVE_PRSTATUS_T)
7888 return elfcore_grok_prstatus (abfd
, note
);
7893 #if defined (HAVE_PSTATUS_T)
7895 return elfcore_grok_pstatus (abfd
, note
);
7898 #if defined (HAVE_LWPSTATUS_T)
7900 return elfcore_grok_lwpstatus (abfd
, note
);
7903 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7904 return elfcore_grok_prfpreg (abfd
, note
);
7906 case NT_WIN32PSTATUS
:
7907 return elfcore_grok_win32pstatus (abfd
, note
);
7909 case NT_PRXFPREG
: /* Linux SSE extension */
7910 if (note
->namesz
== 6
7911 && strcmp (note
->namedata
, "LINUX") == 0)
7912 return elfcore_grok_prxfpreg (abfd
, note
);
7917 if (note
->namesz
== 6
7918 && strcmp (note
->namedata
, "LINUX") == 0)
7919 return elfcore_grok_ppc_vmx (abfd
, note
);
7924 if (note
->namesz
== 6
7925 && strcmp (note
->namedata
, "LINUX") == 0)
7926 return elfcore_grok_ppc_vsx (abfd
, note
);
7932 if (bed
->elf_backend_grok_psinfo
)
7933 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7935 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7936 return elfcore_grok_psinfo (abfd
, note
);
7943 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
7948 sect
->size
= note
->descsz
;
7949 sect
->filepos
= note
->descpos
;
7950 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7958 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
7960 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
7961 elf_tdata (abfd
)->build_id
= bfd_alloc (abfd
, note
->descsz
);
7962 if (elf_tdata (abfd
)->build_id
== NULL
)
7965 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
7971 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7978 case NT_GNU_BUILD_ID
:
7979 return elfobj_grok_gnu_build_id (abfd
, note
);
7984 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
7988 cp
= strchr (note
->namedata
, '@');
7991 *lwpidp
= atoi(cp
+ 1);
7998 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8000 /* Signal number at offset 0x08. */
8001 elf_tdata (abfd
)->core_signal
8002 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8004 /* Process ID at offset 0x50. */
8005 elf_tdata (abfd
)->core_pid
8006 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8008 /* Command name at 0x7c (max 32 bytes, including nul). */
8009 elf_tdata (abfd
)->core_command
8010 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8012 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8017 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8021 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8022 elf_tdata (abfd
)->core_lwpid
= lwp
;
8024 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
8026 /* NetBSD-specific core "procinfo". Note that we expect to
8027 find this note before any of the others, which is fine,
8028 since the kernel writes this note out first when it
8029 creates a core file. */
8031 return elfcore_grok_netbsd_procinfo (abfd
, note
);
8034 /* As of Jan 2002 there are no other machine-independent notes
8035 defined for NetBSD core files. If the note type is less
8036 than the start of the machine-dependent note types, we don't
8039 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8043 switch (bfd_get_arch (abfd
))
8045 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8046 PT_GETFPREGS == mach+2. */
8048 case bfd_arch_alpha
:
8049 case bfd_arch_sparc
:
8052 case NT_NETBSDCORE_FIRSTMACH
+0:
8053 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8055 case NT_NETBSDCORE_FIRSTMACH
+2:
8056 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8062 /* On all other arch's, PT_GETREGS == mach+1 and
8063 PT_GETFPREGS == mach+3. */
8068 case NT_NETBSDCORE_FIRSTMACH
+1:
8069 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8071 case NT_NETBSDCORE_FIRSTMACH
+3:
8072 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8082 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8084 void *ddata
= note
->descdata
;
8091 /* nto_procfs_status 'pid' field is at offset 0. */
8092 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8094 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8095 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8097 /* nto_procfs_status 'flags' field is at offset 8. */
8098 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8100 /* nto_procfs_status 'what' field is at offset 14. */
8101 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8103 elf_tdata (abfd
)->core_signal
= sig
;
8104 elf_tdata (abfd
)->core_lwpid
= *tid
;
8107 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8108 do not come from signals so we make sure we set the current
8109 thread just in case. */
8110 if (flags
& 0x00000080)
8111 elf_tdata (abfd
)->core_lwpid
= *tid
;
8113 /* Make a ".qnx_core_status/%d" section. */
8114 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8116 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8121 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8125 sect
->size
= note
->descsz
;
8126 sect
->filepos
= note
->descpos
;
8127 sect
->alignment_power
= 2;
8129 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8133 elfcore_grok_nto_regs (bfd
*abfd
,
8134 Elf_Internal_Note
*note
,
8142 /* Make a "(base)/%d" section. */
8143 sprintf (buf
, "%s/%ld", base
, tid
);
8145 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8150 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8154 sect
->size
= note
->descsz
;
8155 sect
->filepos
= note
->descpos
;
8156 sect
->alignment_power
= 2;
8158 /* This is the current thread. */
8159 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8160 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8165 #define BFD_QNT_CORE_INFO 7
8166 #define BFD_QNT_CORE_STATUS 8
8167 #define BFD_QNT_CORE_GREG 9
8168 #define BFD_QNT_CORE_FPREG 10
8171 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8173 /* Every GREG section has a STATUS section before it. Store the
8174 tid from the previous call to pass down to the next gregs
8176 static long tid
= 1;
8180 case BFD_QNT_CORE_INFO
:
8181 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8182 case BFD_QNT_CORE_STATUS
:
8183 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8184 case BFD_QNT_CORE_GREG
:
8185 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8186 case BFD_QNT_CORE_FPREG
:
8187 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8194 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8200 /* Use note name as section name. */
8202 name
= bfd_alloc (abfd
, len
);
8205 memcpy (name
, note
->namedata
, len
);
8206 name
[len
- 1] = '\0';
8208 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8212 sect
->size
= note
->descsz
;
8213 sect
->filepos
= note
->descpos
;
8214 sect
->alignment_power
= 1;
8219 /* Function: elfcore_write_note
8222 buffer to hold note, and current size of buffer
8226 size of data for note
8228 Writes note to end of buffer. ELF64 notes are written exactly as
8229 for ELF32, despite the current (as of 2006) ELF gabi specifying
8230 that they ought to have 8-byte namesz and descsz field, and have
8231 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8234 Pointer to realloc'd buffer, *BUFSIZ updated. */
8237 elfcore_write_note (bfd
*abfd
,
8245 Elf_External_Note
*xnp
;
8252 namesz
= strlen (name
) + 1;
8254 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8256 buf
= realloc (buf
, *bufsiz
+ newspace
);
8259 dest
= buf
+ *bufsiz
;
8260 *bufsiz
+= newspace
;
8261 xnp
= (Elf_External_Note
*) dest
;
8262 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8263 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8264 H_PUT_32 (abfd
, type
, xnp
->type
);
8268 memcpy (dest
, name
, namesz
);
8276 memcpy (dest
, input
, size
);
8286 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8288 elfcore_write_prpsinfo (bfd
*abfd
,
8294 const char *note_name
= "CORE";
8295 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8297 if (bed
->elf_backend_write_core_note
!= NULL
)
8300 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8301 NT_PRPSINFO
, fname
, psargs
);
8306 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8307 if (bed
->s
->elfclass
== ELFCLASS32
)
8309 #if defined (HAVE_PSINFO32_T)
8311 int note_type
= NT_PSINFO
;
8314 int note_type
= NT_PRPSINFO
;
8317 memset (&data
, 0, sizeof (data
));
8318 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8319 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8320 return elfcore_write_note (abfd
, buf
, bufsiz
,
8321 note_name
, note_type
, &data
, sizeof (data
));
8326 #if defined (HAVE_PSINFO_T)
8328 int note_type
= NT_PSINFO
;
8331 int note_type
= NT_PRPSINFO
;
8334 memset (&data
, 0, sizeof (data
));
8335 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8336 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8337 return elfcore_write_note (abfd
, buf
, bufsiz
,
8338 note_name
, note_type
, &data
, sizeof (data
));
8341 #endif /* PSINFO_T or PRPSINFO_T */
8343 #if defined (HAVE_PRSTATUS_T)
8345 elfcore_write_prstatus (bfd
*abfd
,
8352 const char *note_name
= "CORE";
8353 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8355 if (bed
->elf_backend_write_core_note
!= NULL
)
8358 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8360 pid
, cursig
, gregs
);
8365 #if defined (HAVE_PRSTATUS32_T)
8366 if (bed
->s
->elfclass
== ELFCLASS32
)
8368 prstatus32_t prstat
;
8370 memset (&prstat
, 0, sizeof (prstat
));
8371 prstat
.pr_pid
= pid
;
8372 prstat
.pr_cursig
= cursig
;
8373 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8374 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8375 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8382 memset (&prstat
, 0, sizeof (prstat
));
8383 prstat
.pr_pid
= pid
;
8384 prstat
.pr_cursig
= cursig
;
8385 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8386 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8387 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8390 #endif /* HAVE_PRSTATUS_T */
8392 #if defined (HAVE_LWPSTATUS_T)
8394 elfcore_write_lwpstatus (bfd
*abfd
,
8401 lwpstatus_t lwpstat
;
8402 const char *note_name
= "CORE";
8404 memset (&lwpstat
, 0, sizeof (lwpstat
));
8405 lwpstat
.pr_lwpid
= pid
>> 16;
8406 lwpstat
.pr_cursig
= cursig
;
8407 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8408 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8409 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8411 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8412 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8414 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8415 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8418 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8419 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8421 #endif /* HAVE_LWPSTATUS_T */
8423 #if defined (HAVE_PSTATUS_T)
8425 elfcore_write_pstatus (bfd
*abfd
,
8429 int cursig ATTRIBUTE_UNUSED
,
8430 const void *gregs ATTRIBUTE_UNUSED
)
8432 const char *note_name
= "CORE";
8433 #if defined (HAVE_PSTATUS32_T)
8434 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8436 if (bed
->s
->elfclass
== ELFCLASS32
)
8440 memset (&pstat
, 0, sizeof (pstat
));
8441 pstat
.pr_pid
= pid
& 0xffff;
8442 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8443 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8451 memset (&pstat
, 0, sizeof (pstat
));
8452 pstat
.pr_pid
= pid
& 0xffff;
8453 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8454 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8458 #endif /* HAVE_PSTATUS_T */
8461 elfcore_write_prfpreg (bfd
*abfd
,
8467 const char *note_name
= "CORE";
8468 return elfcore_write_note (abfd
, buf
, bufsiz
,
8469 note_name
, NT_FPREGSET
, fpregs
, size
);
8473 elfcore_write_prxfpreg (bfd
*abfd
,
8476 const void *xfpregs
,
8479 char *note_name
= "LINUX";
8480 return elfcore_write_note (abfd
, buf
, bufsiz
,
8481 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8485 elfcore_write_ppc_vmx (bfd
*abfd
,
8488 const void *ppc_vmx
,
8491 char *note_name
= "LINUX";
8492 return elfcore_write_note (abfd
, buf
, bufsiz
,
8493 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
8497 elfcore_write_ppc_vsx (bfd
*abfd
,
8500 const void *ppc_vsx
,
8503 char *note_name
= "LINUX";
8504 return elfcore_write_note (abfd
, buf
, bufsiz
,
8505 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
8509 elfcore_write_register_note (bfd
*abfd
,
8512 const char *section
,
8516 if (strcmp (section
, ".reg2") == 0)
8517 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
8518 if (strcmp (section
, ".reg-xfp") == 0)
8519 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
8520 if (strcmp (section
, ".reg-ppc-vmx") == 0)
8521 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
8522 if (strcmp (section
, ".reg-ppc-vsx") == 0)
8523 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
8528 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
8533 while (p
< buf
+ size
)
8535 /* FIXME: bad alignment assumption. */
8536 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8537 Elf_Internal_Note in
;
8539 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8541 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8542 in
.namedata
= xnp
->name
;
8544 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8545 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8546 in
.descpos
= offset
+ (in
.descdata
- buf
);
8548 switch (bfd_get_format (abfd
))
8554 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8556 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8559 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8561 if (! elfcore_grok_nto_note (abfd
, &in
))
8564 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
8566 if (! elfcore_grok_spu_note (abfd
, &in
))
8571 if (! elfcore_grok_note (abfd
, &in
))
8577 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
8579 if (! elfobj_grok_gnu_note (abfd
, &in
))
8585 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
8592 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
8599 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
8602 buf
= bfd_malloc (size
);
8606 if (bfd_bread (buf
, size
, abfd
) != size
8607 || !elf_parse_notes (abfd
, buf
, size
, offset
))
8617 /* Providing external access to the ELF program header table. */
8619 /* Return an upper bound on the number of bytes required to store a
8620 copy of ABFD's program header table entries. Return -1 if an error
8621 occurs; bfd_get_error will return an appropriate code. */
8624 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
8626 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8628 bfd_set_error (bfd_error_wrong_format
);
8632 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
8635 /* Copy ABFD's program header table entries to *PHDRS. The entries
8636 will be stored as an array of Elf_Internal_Phdr structures, as
8637 defined in include/elf/internal.h. To find out how large the
8638 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8640 Return the number of program header table entries read, or -1 if an
8641 error occurs; bfd_get_error will return an appropriate code. */
8644 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
8648 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8650 bfd_set_error (bfd_error_wrong_format
);
8654 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
8655 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
8656 num_phdrs
* sizeof (Elf_Internal_Phdr
));
8661 enum elf_reloc_type_class
8662 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
8664 return reloc_class_normal
;
8667 /* For RELA architectures, return the relocation value for a
8668 relocation against a local symbol. */
8671 _bfd_elf_rela_local_sym (bfd
*abfd
,
8672 Elf_Internal_Sym
*sym
,
8674 Elf_Internal_Rela
*rel
)
8676 asection
*sec
= *psec
;
8679 relocation
= (sec
->output_section
->vma
8680 + sec
->output_offset
8682 if ((sec
->flags
& SEC_MERGE
)
8683 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8684 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8687 _bfd_merged_section_offset (abfd
, psec
,
8688 elf_section_data (sec
)->sec_info
,
8689 sym
->st_value
+ rel
->r_addend
);
8692 /* If we have changed the section, and our original section is
8693 marked with SEC_EXCLUDE, it means that the original
8694 SEC_MERGE section has been completely subsumed in some
8695 other SEC_MERGE section. In this case, we need to leave
8696 some info around for --emit-relocs. */
8697 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8698 sec
->kept_section
= *psec
;
8701 rel
->r_addend
-= relocation
;
8702 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8708 _bfd_elf_rel_local_sym (bfd
*abfd
,
8709 Elf_Internal_Sym
*sym
,
8713 asection
*sec
= *psec
;
8715 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8716 return sym
->st_value
+ addend
;
8718 return _bfd_merged_section_offset (abfd
, psec
,
8719 elf_section_data (sec
)->sec_info
,
8720 sym
->st_value
+ addend
);
8724 _bfd_elf_section_offset (bfd
*abfd
,
8725 struct bfd_link_info
*info
,
8729 switch (sec
->sec_info_type
)
8731 case ELF_INFO_TYPE_STABS
:
8732 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8734 case ELF_INFO_TYPE_EH_FRAME
:
8735 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8741 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8742 reconstruct an ELF file by reading the segments out of remote memory
8743 based on the ELF file header at EHDR_VMA and the ELF program headers it
8744 points to. If not null, *LOADBASEP is filled in with the difference
8745 between the VMAs from which the segments were read, and the VMAs the
8746 file headers (and hence BFD's idea of each section's VMA) put them at.
8748 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8749 remote memory at target address VMA into the local buffer at MYADDR; it
8750 should return zero on success or an `errno' code on failure. TEMPL must
8751 be a BFD for an ELF target with the word size and byte order found in
8752 the remote memory. */
8755 bfd_elf_bfd_from_remote_memory
8759 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8761 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8762 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8766 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8767 long symcount ATTRIBUTE_UNUSED
,
8768 asymbol
**syms ATTRIBUTE_UNUSED
,
8773 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8776 const char *relplt_name
;
8777 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8781 Elf_Internal_Shdr
*hdr
;
8787 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8790 if (dynsymcount
<= 0)
8793 if (!bed
->plt_sym_val
)
8796 relplt_name
= bed
->relplt_name
;
8797 if (relplt_name
== NULL
)
8798 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8799 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8803 hdr
= &elf_section_data (relplt
)->this_hdr
;
8804 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8805 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8808 plt
= bfd_get_section_by_name (abfd
, ".plt");
8812 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8813 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8816 count
= relplt
->size
/ hdr
->sh_entsize
;
8817 size
= count
* sizeof (asymbol
);
8818 p
= relplt
->relocation
;
8819 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
8820 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8822 s
= *ret
= bfd_malloc (size
);
8826 names
= (char *) (s
+ count
);
8827 p
= relplt
->relocation
;
8829 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
8834 addr
= bed
->plt_sym_val (i
, plt
, p
);
8835 if (addr
== (bfd_vma
) -1)
8838 *s
= **p
->sym_ptr_ptr
;
8839 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8840 we are defining a symbol, ensure one of them is set. */
8841 if ((s
->flags
& BSF_LOCAL
) == 0)
8842 s
->flags
|= BSF_GLOBAL
;
8843 s
->flags
|= BSF_SYNTHETIC
;
8845 s
->value
= addr
- plt
->vma
;
8848 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8849 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8851 memcpy (names
, "@plt", sizeof ("@plt"));
8852 names
+= sizeof ("@plt");
8859 /* It is only used by x86-64 so far. */
8860 asection _bfd_elf_large_com_section
8861 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
8862 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
8865 _bfd_elf_set_osabi (bfd
* abfd
,
8866 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
8868 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
8870 i_ehdrp
= elf_elfheader (abfd
);
8872 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
8876 /* Return TRUE for ELF symbol types that represent functions.
8877 This is the default version of this function, which is sufficient for
8878 most targets. It returns true if TYPE is STT_FUNC. */
8881 _bfd_elf_is_function_type (unsigned int type
)
8883 return (type
== STT_FUNC
);