1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
33 struct elf_link_hash_entry
*h
;
34 struct bfd_link_hash_entry
*bh
;
35 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
38 /* This function may be called more than once. */
39 s
= bfd_get_section_by_name (abfd
, ".got");
40 if (s
!= NULL
&& (s
->flags
& SEC_LINKER_CREATED
) != 0)
43 switch (bed
->s
->arch_size
)
54 bfd_set_error (bfd_error_bad_value
);
58 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
59 | SEC_LINKER_CREATED
);
61 s
= bfd_make_section (abfd
, ".got");
63 || !bfd_set_section_flags (abfd
, s
, flags
)
64 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
67 if (bed
->want_got_plt
)
69 s
= bfd_make_section (abfd
, ".got.plt");
71 || !bfd_set_section_flags (abfd
, s
, flags
)
72 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
76 if (bed
->want_got_sym
)
78 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
79 (or .got.plt) section. We don't do this in the linker script
80 because we don't want to define the symbol if we are not creating
81 a global offset table. */
83 if (!(_bfd_generic_link_add_one_symbol
84 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
85 bed
->got_symbol_offset
, NULL
, FALSE
, bed
->collect
, &bh
)))
87 h
= (struct elf_link_hash_entry
*) bh
;
88 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
91 if (! info
->executable
92 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
95 elf_hash_table (info
)->hgot
= h
;
98 /* The first bit of the global offset table is the header. */
99 s
->_raw_size
+= bed
->got_header_size
+ bed
->got_symbol_offset
;
104 /* Create some sections which will be filled in with dynamic linking
105 information. ABFD is an input file which requires dynamic sections
106 to be created. The dynamic sections take up virtual memory space
107 when the final executable is run, so we need to create them before
108 addresses are assigned to the output sections. We work out the
109 actual contents and size of these sections later. */
112 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
115 register asection
*s
;
116 struct elf_link_hash_entry
*h
;
117 struct bfd_link_hash_entry
*bh
;
118 const struct elf_backend_data
*bed
;
120 if (! is_elf_hash_table (info
->hash
))
123 if (elf_hash_table (info
)->dynamic_sections_created
)
126 /* Make sure that all dynamic sections use the same input BFD. */
127 if (elf_hash_table (info
)->dynobj
== NULL
)
128 elf_hash_table (info
)->dynobj
= abfd
;
130 abfd
= elf_hash_table (info
)->dynobj
;
132 /* Note that we set the SEC_IN_MEMORY flag for all of these
134 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
135 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
137 /* A dynamically linked executable has a .interp section, but a
138 shared library does not. */
139 if (info
->executable
)
141 s
= bfd_make_section (abfd
, ".interp");
143 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
147 if (! info
->traditional_format
)
149 s
= bfd_make_section (abfd
, ".eh_frame_hdr");
151 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
152 || ! bfd_set_section_alignment (abfd
, s
, 2))
154 elf_hash_table (info
)->eh_info
.hdr_sec
= s
;
157 bed
= get_elf_backend_data (abfd
);
159 /* Create sections to hold version informations. These are removed
160 if they are not needed. */
161 s
= bfd_make_section (abfd
, ".gnu.version_d");
163 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
164 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
167 s
= bfd_make_section (abfd
, ".gnu.version");
169 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
170 || ! bfd_set_section_alignment (abfd
, s
, 1))
173 s
= bfd_make_section (abfd
, ".gnu.version_r");
175 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
176 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
179 s
= bfd_make_section (abfd
, ".dynsym");
181 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
182 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
185 s
= bfd_make_section (abfd
, ".dynstr");
187 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
190 /* Create a strtab to hold the dynamic symbol names. */
191 if (elf_hash_table (info
)->dynstr
== NULL
)
193 elf_hash_table (info
)->dynstr
= _bfd_elf_strtab_init ();
194 if (elf_hash_table (info
)->dynstr
== NULL
)
198 s
= bfd_make_section (abfd
, ".dynamic");
200 || ! bfd_set_section_flags (abfd
, s
, flags
)
201 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
204 /* The special symbol _DYNAMIC is always set to the start of the
205 .dynamic section. This call occurs before we have processed the
206 symbols for any dynamic object, so we don't have to worry about
207 overriding a dynamic definition. We could set _DYNAMIC in a
208 linker script, but we only want to define it if we are, in fact,
209 creating a .dynamic section. We don't want to define it if there
210 is no .dynamic section, since on some ELF platforms the start up
211 code examines it to decide how to initialize the process. */
213 if (! (_bfd_generic_link_add_one_symbol
214 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
215 get_elf_backend_data (abfd
)->collect
, &bh
)))
217 h
= (struct elf_link_hash_entry
*) bh
;
218 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
219 h
->type
= STT_OBJECT
;
221 if (! info
->executable
222 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
225 s
= bfd_make_section (abfd
, ".hash");
227 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
228 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
230 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
232 /* Let the backend create the rest of the sections. This lets the
233 backend set the right flags. The backend will normally create
234 the .got and .plt sections. */
235 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
238 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
243 /* Create dynamic sections when linking against a dynamic object. */
246 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
248 flagword flags
, pltflags
;
250 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
252 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
253 .rel[a].bss sections. */
255 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
256 | SEC_LINKER_CREATED
);
259 pltflags
|= SEC_CODE
;
260 if (bed
->plt_not_loaded
)
261 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
262 if (bed
->plt_readonly
)
263 pltflags
|= SEC_READONLY
;
265 s
= bfd_make_section (abfd
, ".plt");
267 || ! bfd_set_section_flags (abfd
, s
, pltflags
)
268 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
271 if (bed
->want_plt_sym
)
273 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
275 struct elf_link_hash_entry
*h
;
276 struct bfd_link_hash_entry
*bh
= NULL
;
278 if (! (_bfd_generic_link_add_one_symbol
279 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
280 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
282 h
= (struct elf_link_hash_entry
*) bh
;
283 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
284 h
->type
= STT_OBJECT
;
286 if (! info
->executable
287 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
291 s
= bfd_make_section (abfd
,
292 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt");
294 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
295 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
298 if (! _bfd_elf_create_got_section (abfd
, info
))
301 if (bed
->want_dynbss
)
303 /* The .dynbss section is a place to put symbols which are defined
304 by dynamic objects, are referenced by regular objects, and are
305 not functions. We must allocate space for them in the process
306 image and use a R_*_COPY reloc to tell the dynamic linker to
307 initialize them at run time. The linker script puts the .dynbss
308 section into the .bss section of the final image. */
309 s
= bfd_make_section (abfd
, ".dynbss");
311 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
| SEC_LINKER_CREATED
))
314 /* The .rel[a].bss section holds copy relocs. This section is not
315 normally needed. We need to create it here, though, so that the
316 linker will map it to an output section. We can't just create it
317 only if we need it, because we will not know whether we need it
318 until we have seen all the input files, and the first time the
319 main linker code calls BFD after examining all the input files
320 (size_dynamic_sections) the input sections have already been
321 mapped to the output sections. If the section turns out not to
322 be needed, we can discard it later. We will never need this
323 section when generating a shared object, since they do not use
327 s
= bfd_make_section (abfd
,
328 (bed
->default_use_rela_p
329 ? ".rela.bss" : ".rel.bss"));
331 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
332 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
340 /* Record a new dynamic symbol. We record the dynamic symbols as we
341 read the input files, since we need to have a list of all of them
342 before we can determine the final sizes of the output sections.
343 Note that we may actually call this function even though we are not
344 going to output any dynamic symbols; in some cases we know that a
345 symbol should be in the dynamic symbol table, but only if there is
349 _bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
350 struct elf_link_hash_entry
*h
)
352 if (h
->dynindx
== -1)
354 struct elf_strtab_hash
*dynstr
;
359 /* XXX: The ABI draft says the linker must turn hidden and
360 internal symbols into STB_LOCAL symbols when producing the
361 DSO. However, if ld.so honors st_other in the dynamic table,
362 this would not be necessary. */
363 switch (ELF_ST_VISIBILITY (h
->other
))
367 if (h
->root
.type
!= bfd_link_hash_undefined
368 && h
->root
.type
!= bfd_link_hash_undefweak
)
370 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
378 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
379 ++elf_hash_table (info
)->dynsymcount
;
381 dynstr
= elf_hash_table (info
)->dynstr
;
384 /* Create a strtab to hold the dynamic symbol names. */
385 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
390 /* We don't put any version information in the dynamic string
392 name
= h
->root
.root
.string
;
393 p
= strchr (name
, ELF_VER_CHR
);
395 /* We know that the p points into writable memory. In fact,
396 there are only a few symbols that have read-only names, being
397 those like _GLOBAL_OFFSET_TABLE_ that are created specially
398 by the backends. Most symbols will have names pointing into
399 an ELF string table read from a file, or to objalloc memory. */
402 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
407 if (indx
== (bfd_size_type
) -1)
409 h
->dynstr_index
= indx
;
415 /* Record an assignment to a symbol made by a linker script. We need
416 this in case some dynamic object refers to this symbol. */
419 bfd_elf_record_link_assignment (bfd
*output_bfd ATTRIBUTE_UNUSED
,
420 struct bfd_link_info
*info
,
424 struct elf_link_hash_entry
*h
;
426 if (!is_elf_hash_table (info
->hash
))
429 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, TRUE
, FALSE
);
433 /* Since we're defining the symbol, don't let it seem to have not
434 been defined. record_dynamic_symbol and size_dynamic_sections
435 may depend on this. */
436 if (h
->root
.type
== bfd_link_hash_undefweak
437 || h
->root
.type
== bfd_link_hash_undefined
)
438 h
->root
.type
= bfd_link_hash_new
;
440 if (h
->root
.type
== bfd_link_hash_new
)
441 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
443 /* If this symbol is being provided by the linker script, and it is
444 currently defined by a dynamic object, but not by a regular
445 object, then mark it as undefined so that the generic linker will
446 force the correct value. */
448 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
449 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
450 h
->root
.type
= bfd_link_hash_undefined
;
452 /* If this symbol is not being provided by the linker script, and it is
453 currently defined by a dynamic object, but not by a regular object,
454 then clear out any version information because the symbol will not be
455 associated with the dynamic object any more. */
457 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
458 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
459 h
->verinfo
.verdef
= NULL
;
461 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
463 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
464 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
468 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
471 /* If this is a weak defined symbol, and we know a corresponding
472 real symbol from the same dynamic object, make sure the real
473 symbol is also made into a dynamic symbol. */
474 if (h
->weakdef
!= NULL
475 && h
->weakdef
->dynindx
== -1)
477 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
485 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
486 success, and 2 on a failure caused by attempting to record a symbol
487 in a discarded section, eg. a discarded link-once section symbol. */
490 elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
495 struct elf_link_local_dynamic_entry
*entry
;
496 struct elf_link_hash_table
*eht
;
497 struct elf_strtab_hash
*dynstr
;
498 unsigned long dynstr_index
;
500 Elf_External_Sym_Shndx eshndx
;
501 char esym
[sizeof (Elf64_External_Sym
)];
503 if (! is_elf_hash_table (info
->hash
))
506 /* See if the entry exists already. */
507 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
508 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
511 amt
= sizeof (*entry
);
512 entry
= bfd_alloc (input_bfd
, amt
);
516 /* Go find the symbol, so that we can find it's name. */
517 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
518 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
520 bfd_release (input_bfd
, entry
);
524 if (entry
->isym
.st_shndx
!= SHN_UNDEF
525 && (entry
->isym
.st_shndx
< SHN_LORESERVE
526 || entry
->isym
.st_shndx
> SHN_HIRESERVE
))
530 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
531 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
533 /* We can still bfd_release here as nothing has done another
534 bfd_alloc. We can't do this later in this function. */
535 bfd_release (input_bfd
, entry
);
540 name
= (bfd_elf_string_from_elf_section
541 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
542 entry
->isym
.st_name
));
544 dynstr
= elf_hash_table (info
)->dynstr
;
547 /* Create a strtab to hold the dynamic symbol names. */
548 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
553 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
554 if (dynstr_index
== (unsigned long) -1)
556 entry
->isym
.st_name
= dynstr_index
;
558 eht
= elf_hash_table (info
);
560 entry
->next
= eht
->dynlocal
;
561 eht
->dynlocal
= entry
;
562 entry
->input_bfd
= input_bfd
;
563 entry
->input_indx
= input_indx
;
566 /* Whatever binding the symbol had before, it's now local. */
568 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
570 /* The dynindx will be set at the end of size_dynamic_sections. */
575 /* Return the dynindex of a local dynamic symbol. */
578 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
582 struct elf_link_local_dynamic_entry
*e
;
584 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
585 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
590 /* This function is used to renumber the dynamic symbols, if some of
591 them are removed because they are marked as local. This is called
592 via elf_link_hash_traverse. */
595 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
598 size_t *count
= data
;
600 if (h
->root
.type
== bfd_link_hash_warning
)
601 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
603 if (h
->dynindx
!= -1)
604 h
->dynindx
= ++(*count
);
609 /* Assign dynsym indices. In a shared library we generate a section
610 symbol for each output section, which come first. Next come all of
611 the back-end allocated local dynamic syms, followed by the rest of
612 the global symbols. */
615 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
617 unsigned long dynsymcount
= 0;
622 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
623 if ((p
->flags
& SEC_EXCLUDE
) == 0)
624 elf_section_data (p
)->dynindx
= ++dynsymcount
;
627 if (elf_hash_table (info
)->dynlocal
)
629 struct elf_link_local_dynamic_entry
*p
;
630 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
631 p
->dynindx
= ++dynsymcount
;
634 elf_link_hash_traverse (elf_hash_table (info
),
635 elf_link_renumber_hash_table_dynsyms
,
638 /* There is an unused NULL entry at the head of the table which
639 we must account for in our count. Unless there weren't any
640 symbols, which means we'll have no table at all. */
641 if (dynsymcount
!= 0)
644 return elf_hash_table (info
)->dynsymcount
= dynsymcount
;
647 /* This function is called when we want to define a new symbol. It
648 handles the various cases which arise when we find a definition in
649 a dynamic object, or when there is already a definition in a
650 dynamic object. The new symbol is described by NAME, SYM, PSEC,
651 and PVALUE. We set SYM_HASH to the hash table entry. We set
652 OVERRIDE if the old symbol is overriding a new definition. We set
653 TYPE_CHANGE_OK if it is OK for the type to change. We set
654 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
655 change, we mean that we shouldn't warn if the type or size does
656 change. DT_NEEDED indicates if it comes from a DT_NEEDED entry of
660 _bfd_elf_merge_symbol (bfd
*abfd
,
661 struct bfd_link_info
*info
,
663 Elf_Internal_Sym
*sym
,
666 struct elf_link_hash_entry
**sym_hash
,
668 bfd_boolean
*override
,
669 bfd_boolean
*type_change_ok
,
670 bfd_boolean
*size_change_ok
,
671 bfd_boolean dt_needed
)
674 struct elf_link_hash_entry
*h
;
675 struct elf_link_hash_entry
*flip
;
678 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
679 bfd_boolean newweak
, oldweak
;
685 bind
= ELF_ST_BIND (sym
->st_info
);
687 if (! bfd_is_und_section (sec
))
688 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
690 h
= ((struct elf_link_hash_entry
*)
691 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
696 /* This code is for coping with dynamic objects, and is only useful
697 if we are doing an ELF link. */
698 if (info
->hash
->creator
!= abfd
->xvec
)
701 /* For merging, we only care about real symbols. */
703 while (h
->root
.type
== bfd_link_hash_indirect
704 || h
->root
.type
== bfd_link_hash_warning
)
705 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
707 /* If we just created the symbol, mark it as being an ELF symbol.
708 Other than that, there is nothing to do--there is no merge issue
709 with a newly defined symbol--so we just return. */
711 if (h
->root
.type
== bfd_link_hash_new
)
713 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
717 /* OLDBFD is a BFD associated with the existing symbol. */
719 switch (h
->root
.type
)
725 case bfd_link_hash_undefined
:
726 case bfd_link_hash_undefweak
:
727 oldbfd
= h
->root
.u
.undef
.abfd
;
730 case bfd_link_hash_defined
:
731 case bfd_link_hash_defweak
:
732 oldbfd
= h
->root
.u
.def
.section
->owner
;
735 case bfd_link_hash_common
:
736 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
740 /* In cases involving weak versioned symbols, we may wind up trying
741 to merge a symbol with itself. Catch that here, to avoid the
742 confusion that results if we try to override a symbol with
743 itself. The additional tests catch cases like
744 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
745 dynamic object, which we do want to handle here. */
747 && ((abfd
->flags
& DYNAMIC
) == 0
748 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0))
751 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
752 respectively, is from a dynamic object. */
754 if ((abfd
->flags
& DYNAMIC
) != 0)
760 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
765 /* This code handles the special SHN_MIPS_{TEXT,DATA} section
766 indices used by MIPS ELF. */
767 switch (h
->root
.type
)
773 case bfd_link_hash_defined
:
774 case bfd_link_hash_defweak
:
775 hsec
= h
->root
.u
.def
.section
;
778 case bfd_link_hash_common
:
779 hsec
= h
->root
.u
.c
.p
->section
;
786 olddyn
= (hsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
789 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
790 respectively, appear to be a definition rather than reference. */
792 if (bfd_is_und_section (sec
) || bfd_is_com_section (sec
))
797 if (h
->root
.type
== bfd_link_hash_undefined
798 || h
->root
.type
== bfd_link_hash_undefweak
799 || h
->root
.type
== bfd_link_hash_common
)
804 /* We need to remember if a symbol has a definition in a dynamic
805 object or is weak in all dynamic objects. Internal and hidden
806 visibility will make it unavailable to dynamic objects. */
807 if (newdyn
&& (h
->elf_link_hash_flags
& ELF_LINK_DYNAMIC_DEF
) == 0)
809 if (!bfd_is_und_section (sec
))
810 h
->elf_link_hash_flags
|= ELF_LINK_DYNAMIC_DEF
;
813 /* Check if this symbol is weak in all dynamic objects. If it
814 is the first time we see it in a dynamic object, we mark
815 if it is weak. Otherwise, we clear it. */
816 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
818 if (bind
== STB_WEAK
)
819 h
->elf_link_hash_flags
|= ELF_LINK_DYNAMIC_WEAK
;
821 else if (bind
!= STB_WEAK
)
822 h
->elf_link_hash_flags
&= ~ELF_LINK_DYNAMIC_WEAK
;
826 /* If the old symbol has non-default visibility, we ignore the new
827 definition from a dynamic object. */
829 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
830 && !bfd_is_und_section (sec
))
833 /* Make sure this symbol is dynamic. */
834 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
835 /* A protected symbol has external availability. Make sure it is
838 FIXME: Should we check type and size for protected symbol? */
839 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
840 return _bfd_elf_link_record_dynamic_symbol (info
, h
);
845 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
846 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
848 /* If the new symbol with non-default visibility comes from a
849 relocatable file and the old definition comes from a dynamic
850 object, we remove the old definition. */
851 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
854 if ((h
->root
.und_next
|| info
->hash
->undefs_tail
== &h
->root
)
855 && bfd_is_und_section (sec
))
857 /* If the new symbol is undefined and the old symbol was
858 also undefined before, we need to make sure
859 _bfd_generic_link_add_one_symbol doesn't mess
860 up the linker hash table undefs list. Since the old
861 definition came from a dynamic object, it is still on the
863 h
->root
.type
= bfd_link_hash_undefined
;
864 /* FIXME: What if the new symbol is weak undefined? */
865 h
->root
.u
.undef
.abfd
= abfd
;
869 h
->root
.type
= bfd_link_hash_new
;
870 h
->root
.u
.undef
.abfd
= NULL
;
873 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
875 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_DEF_DYNAMIC
;
876 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_DYNAMIC
877 | ELF_LINK_DYNAMIC_DEF
);
879 /* FIXME: Should we check type and size for protected symbol? */
885 /* Differentiate strong and weak symbols. */
886 newweak
= bind
== STB_WEAK
;
887 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
888 || h
->root
.type
== bfd_link_hash_undefweak
);
890 /* It's OK to change the type if either the existing symbol or the
891 new symbol is weak. A type change is also OK if the old symbol
892 is undefined and the new symbol is defined. */
897 && h
->root
.type
== bfd_link_hash_undefined
))
898 *type_change_ok
= TRUE
;
900 /* It's OK to change the size if either the existing symbol or the
901 new symbol is weak, or if the old symbol is undefined. */
904 || h
->root
.type
== bfd_link_hash_undefined
)
905 *size_change_ok
= TRUE
;
907 /* If a new weak symbol comes from a regular file and the old symbol
908 comes from a dynamic library, we treat the new one as strong.
909 Similarly, an old weak symbol from a regular file is treated as
910 strong when the new symbol comes from a dynamic library. Further,
911 an old weak symbol from a dynamic library is treated as strong if
912 the new symbol is from a DT_NEEDED dynamic library. */
913 if (!newdyn
&& olddyn
)
915 if ((!olddyn
|| dt_needed
) && newdyn
)
918 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
919 symbol, respectively, appears to be a common symbol in a dynamic
920 object. If a symbol appears in an uninitialized section, and is
921 not weak, and is not a function, then it may be a common symbol
922 which was resolved when the dynamic object was created. We want
923 to treat such symbols specially, because they raise special
924 considerations when setting the symbol size: if the symbol
925 appears as a common symbol in a regular object, and the size in
926 the regular object is larger, we must make sure that we use the
927 larger size. This problematic case can always be avoided in C,
928 but it must be handled correctly when using Fortran shared
931 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
932 likewise for OLDDYNCOMMON and OLDDEF.
934 Note that this test is just a heuristic, and that it is quite
935 possible to have an uninitialized symbol in a shared object which
936 is really a definition, rather than a common symbol. This could
937 lead to some minor confusion when the symbol really is a common
938 symbol in some regular object. However, I think it will be
944 && (sec
->flags
& SEC_ALLOC
) != 0
945 && (sec
->flags
& SEC_LOAD
) == 0
947 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
950 newdyncommon
= FALSE
;
954 && h
->root
.type
== bfd_link_hash_defined
955 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
956 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
957 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
959 && h
->type
!= STT_FUNC
)
962 olddyncommon
= FALSE
;
964 /* If both the old and the new symbols look like common symbols in a
965 dynamic object, set the size of the symbol to the larger of the
970 && sym
->st_size
!= h
->size
)
972 /* Since we think we have two common symbols, issue a multiple
973 common warning if desired. Note that we only warn if the
974 size is different. If the size is the same, we simply let
975 the old symbol override the new one as normally happens with
976 symbols defined in dynamic objects. */
978 if (! ((*info
->callbacks
->multiple_common
)
979 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
980 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
983 if (sym
->st_size
> h
->size
)
984 h
->size
= sym
->st_size
;
986 *size_change_ok
= TRUE
;
989 /* If we are looking at a dynamic object, and we have found a
990 definition, we need to see if the symbol was already defined by
991 some other object. If so, we want to use the existing
992 definition, and we do not want to report a multiple symbol
993 definition error; we do this by clobbering *PSEC to be
996 We treat a common symbol as a definition if the symbol in the
997 shared library is a function, since common symbols always
998 represent variables; this can cause confusion in principle, but
999 any such confusion would seem to indicate an erroneous program or
1000 shared library. We also permit a common symbol in a regular
1001 object to override a weak symbol in a shared object. */
1006 || (h
->root
.type
== bfd_link_hash_common
1008 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)))
1009 && (!oldweak
|| newweak
))
1013 newdyncommon
= FALSE
;
1015 *psec
= sec
= bfd_und_section_ptr
;
1016 *size_change_ok
= TRUE
;
1018 /* If we get here when the old symbol is a common symbol, then
1019 we are explicitly letting it override a weak symbol or
1020 function in a dynamic object, and we don't want to warn about
1021 a type change. If the old symbol is a defined symbol, a type
1022 change warning may still be appropriate. */
1024 if (h
->root
.type
== bfd_link_hash_common
)
1025 *type_change_ok
= TRUE
;
1028 /* Handle the special case of an old common symbol merging with a
1029 new symbol which looks like a common symbol in a shared object.
1030 We change *PSEC and *PVALUE to make the new symbol look like a
1031 common symbol, and let _bfd_generic_link_add_one_symbol will do
1035 && h
->root
.type
== bfd_link_hash_common
)
1039 newdyncommon
= FALSE
;
1040 *pvalue
= sym
->st_size
;
1041 *psec
= sec
= bfd_com_section_ptr
;
1042 *size_change_ok
= TRUE
;
1045 /* If the old symbol is from a dynamic object, and the new symbol is
1046 a definition which is not from a dynamic object, then the new
1047 symbol overrides the old symbol. Symbols from regular files
1048 always take precedence over symbols from dynamic objects, even if
1049 they are defined after the dynamic object in the link.
1051 As above, we again permit a common symbol in a regular object to
1052 override a definition in a shared object if the shared object
1053 symbol is a function or is weak.
1055 As above, we permit a non-weak definition in a shared object to
1056 override a weak definition in a regular object. */
1061 || (bfd_is_com_section (sec
)
1063 || h
->type
== STT_FUNC
)))
1066 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1067 && (!newweak
|| oldweak
))
1069 /* Change the hash table entry to undefined, and let
1070 _bfd_generic_link_add_one_symbol do the right thing with the
1073 h
->root
.type
= bfd_link_hash_undefined
;
1074 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1075 *size_change_ok
= TRUE
;
1078 olddyncommon
= FALSE
;
1080 /* We again permit a type change when a common symbol may be
1081 overriding a function. */
1083 if (bfd_is_com_section (sec
))
1084 *type_change_ok
= TRUE
;
1086 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1089 /* This union may have been set to be non-NULL when this symbol
1090 was seen in a dynamic object. We must force the union to be
1091 NULL, so that it is correct for a regular symbol. */
1092 h
->verinfo
.vertree
= NULL
;
1095 /* Handle the special case of a new common symbol merging with an
1096 old symbol that looks like it might be a common symbol defined in
1097 a shared object. Note that we have already handled the case in
1098 which a new common symbol should simply override the definition
1099 in the shared library. */
1102 && bfd_is_com_section (sec
)
1105 /* It would be best if we could set the hash table entry to a
1106 common symbol, but we don't know what to use for the section
1107 or the alignment. */
1108 if (! ((*info
->callbacks
->multiple_common
)
1109 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
1110 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1113 /* If the presumed common symbol in the dynamic object is
1114 larger, pretend that the new symbol has its size. */
1116 if (h
->size
> *pvalue
)
1119 /* FIXME: We no longer know the alignment required by the symbol
1120 in the dynamic object, so we just wind up using the one from
1121 the regular object. */
1124 olddyncommon
= FALSE
;
1126 h
->root
.type
= bfd_link_hash_undefined
;
1127 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1129 *size_change_ok
= TRUE
;
1130 *type_change_ok
= TRUE
;
1132 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1135 h
->verinfo
.vertree
= NULL
;
1140 /* Handle the case where we had a versioned symbol in a dynamic
1141 library and now find a definition in a normal object. In this
1142 case, we make the versioned symbol point to the normal one. */
1143 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1144 flip
->root
.type
= h
->root
.type
;
1145 h
->root
.type
= bfd_link_hash_indirect
;
1146 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1147 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, flip
, h
);
1148 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1149 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1151 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_DEF_DYNAMIC
;
1152 flip
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1156 /* Handle the special case of a weak definition in one shared object
1157 followed by a non-weak definition in another. We are covering for
1158 a deficiency of _bfd_generic_link_add_one_symbol here. A new
1159 strong definition of an indirect symbol is treated as a multiple
1160 definition even when the indirect symbol points to a weak sym. */
1168 /* To make this work we have to frob the flags so that the rest
1169 of the code does not think we are using the old definition. */
1170 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1171 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_DEF_DYNAMIC
;
1173 /* If H is the target of an indirection, we want the caller to
1174 use H rather than the indirect symbol. Otherwise if we are
1175 defining a new indirect symbol we will wind up attaching it
1176 to the entry we are overriding. */
1183 /* This function is called to create an indirect symbol from the
1184 default for the symbol with the default version if needed. The
1185 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1186 set DYNSYM if the new indirect symbol is dynamic. DT_NEEDED
1187 indicates if it comes from a DT_NEEDED entry of a shared object. */
1190 _bfd_elf_add_default_symbol (bfd
*abfd
,
1191 struct bfd_link_info
*info
,
1192 struct elf_link_hash_entry
*h
,
1194 Elf_Internal_Sym
*sym
,
1197 bfd_boolean
*dynsym
,
1198 bfd_boolean override
,
1199 bfd_boolean dt_needed
)
1201 bfd_boolean type_change_ok
;
1202 bfd_boolean size_change_ok
;
1205 struct elf_link_hash_entry
*hi
;
1206 struct bfd_link_hash_entry
*bh
;
1207 const struct elf_backend_data
*bed
;
1208 bfd_boolean collect
;
1209 bfd_boolean dynamic
;
1211 size_t len
, shortlen
;
1214 /* If this symbol has a version, and it is the default version, we
1215 create an indirect symbol from the default name to the fully
1216 decorated name. This will cause external references which do not
1217 specify a version to be bound to this version of the symbol. */
1218 p
= strchr (name
, ELF_VER_CHR
);
1219 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1224 /* We are overridden by an old definition. We need to check if we
1225 need to create the indirect symbol from the default name. */
1226 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1228 BFD_ASSERT (hi
!= NULL
);
1231 while (hi
->root
.type
== bfd_link_hash_indirect
1232 || hi
->root
.type
== bfd_link_hash_warning
)
1234 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1240 bed
= get_elf_backend_data (abfd
);
1241 collect
= bed
->collect
;
1242 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1244 shortlen
= p
- name
;
1245 shortname
= bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1246 if (shortname
== NULL
)
1248 memcpy (shortname
, name
, shortlen
);
1249 shortname
[shortlen
] = '\0';
1251 /* We are going to create a new symbol. Merge it with any existing
1252 symbol with this name. For the purposes of the merge, act as
1253 though we were defining the symbol we just defined, although we
1254 actually going to define an indirect symbol. */
1255 type_change_ok
= FALSE
;
1256 size_change_ok
= FALSE
;
1258 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1259 &hi
, &skip
, &override
, &type_change_ok
,
1260 &size_change_ok
, dt_needed
))
1269 if (! (_bfd_generic_link_add_one_symbol
1270 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1271 0, name
, FALSE
, collect
, &bh
)))
1273 hi
= (struct elf_link_hash_entry
*) bh
;
1277 /* In this case the symbol named SHORTNAME is overriding the
1278 indirect symbol we want to add. We were planning on making
1279 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1280 is the name without a version. NAME is the fully versioned
1281 name, and it is the default version.
1283 Overriding means that we already saw a definition for the
1284 symbol SHORTNAME in a regular object, and it is overriding
1285 the symbol defined in the dynamic object.
1287 When this happens, we actually want to change NAME, the
1288 symbol we just added, to refer to SHORTNAME. This will cause
1289 references to NAME in the shared object to become references
1290 to SHORTNAME in the regular object. This is what we expect
1291 when we override a function in a shared object: that the
1292 references in the shared object will be mapped to the
1293 definition in the regular object. */
1295 while (hi
->root
.type
== bfd_link_hash_indirect
1296 || hi
->root
.type
== bfd_link_hash_warning
)
1297 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1299 h
->root
.type
= bfd_link_hash_indirect
;
1300 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1301 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1303 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEF_DYNAMIC
;
1304 hi
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1305 if (hi
->elf_link_hash_flags
1306 & (ELF_LINK_HASH_REF_REGULAR
1307 | ELF_LINK_HASH_DEF_REGULAR
))
1309 if (! _bfd_elf_link_record_dynamic_symbol (info
, hi
))
1314 /* Now set HI to H, so that the following code will set the
1315 other fields correctly. */
1319 /* If there is a duplicate definition somewhere, then HI may not
1320 point to an indirect symbol. We will have reported an error to
1321 the user in that case. */
1323 if (hi
->root
.type
== bfd_link_hash_indirect
)
1325 struct elf_link_hash_entry
*ht
;
1327 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1328 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, ht
, hi
);
1330 /* See if the new flags lead us to realize that the symbol must
1337 || ((hi
->elf_link_hash_flags
1338 & ELF_LINK_HASH_REF_DYNAMIC
) != 0))
1343 if ((hi
->elf_link_hash_flags
1344 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1350 /* We also need to define an indirection from the nondefault version
1354 len
= strlen (name
);
1355 shortname
= bfd_hash_allocate (&info
->hash
->table
, len
);
1356 if (shortname
== NULL
)
1358 memcpy (shortname
, name
, shortlen
);
1359 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1361 /* Once again, merge with any existing symbol. */
1362 type_change_ok
= FALSE
;
1363 size_change_ok
= FALSE
;
1365 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1366 &hi
, &skip
, &override
, &type_change_ok
,
1367 &size_change_ok
, dt_needed
))
1375 /* Here SHORTNAME is a versioned name, so we don't expect to see
1376 the type of override we do in the case above unless it is
1377 overridden by a versioned definition. */
1378 if (hi
->root
.type
!= bfd_link_hash_defined
1379 && hi
->root
.type
!= bfd_link_hash_defweak
)
1380 (*_bfd_error_handler
)
1381 (_("%s: warning: unexpected redefinition of indirect versioned symbol `%s'"),
1382 bfd_archive_filename (abfd
), shortname
);
1387 if (! (_bfd_generic_link_add_one_symbol
1388 (info
, abfd
, shortname
, BSF_INDIRECT
,
1389 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1391 hi
= (struct elf_link_hash_entry
*) bh
;
1393 /* If there is a duplicate definition somewhere, then HI may not
1394 point to an indirect symbol. We will have reported an error
1395 to the user in that case. */
1397 if (hi
->root
.type
== bfd_link_hash_indirect
)
1399 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, h
, hi
);
1401 /* See if the new flags lead us to realize that the symbol
1408 || ((hi
->elf_link_hash_flags
1409 & ELF_LINK_HASH_REF_DYNAMIC
) != 0))
1414 if ((hi
->elf_link_hash_flags
1415 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1425 /* This routine is used to export all defined symbols into the dynamic
1426 symbol table. It is called via elf_link_hash_traverse. */
1429 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1431 struct elf_info_failed
*eif
= data
;
1433 /* Ignore indirect symbols. These are added by the versioning code. */
1434 if (h
->root
.type
== bfd_link_hash_indirect
)
1437 if (h
->root
.type
== bfd_link_hash_warning
)
1438 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1440 if (h
->dynindx
== -1
1441 && (h
->elf_link_hash_flags
1442 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1444 struct bfd_elf_version_tree
*t
;
1445 struct bfd_elf_version_expr
*d
;
1447 for (t
= eif
->verdefs
; t
!= NULL
; t
= t
->next
)
1449 if (t
->globals
.list
!= NULL
)
1451 d
= (*t
->match
) (&t
->globals
, NULL
, h
->root
.root
.string
);
1456 if (t
->locals
.list
!= NULL
)
1458 d
= (*t
->match
) (&t
->locals
, NULL
, h
->root
.root
.string
);
1467 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1478 /* Look through the symbols which are defined in other shared
1479 libraries and referenced here. Update the list of version
1480 dependencies. This will be put into the .gnu.version_r section.
1481 This function is called via elf_link_hash_traverse. */
1484 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1487 struct elf_find_verdep_info
*rinfo
= data
;
1488 Elf_Internal_Verneed
*t
;
1489 Elf_Internal_Vernaux
*a
;
1492 if (h
->root
.type
== bfd_link_hash_warning
)
1493 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1495 /* We only care about symbols defined in shared objects with version
1497 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1498 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1500 || h
->verinfo
.verdef
== NULL
)
1503 /* See if we already know about this version. */
1504 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1506 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1509 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1510 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1516 /* This is a new version. Add it to tree we are building. */
1521 t
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1524 rinfo
->failed
= TRUE
;
1528 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1529 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
1530 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
1534 a
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1536 /* Note that we are copying a string pointer here, and testing it
1537 above. If bfd_elf_string_from_elf_section is ever changed to
1538 discard the string data when low in memory, this will have to be
1540 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1542 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1543 a
->vna_nextptr
= t
->vn_auxptr
;
1545 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1548 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1555 /* Figure out appropriate versions for all the symbols. We may not
1556 have the version number script until we have read all of the input
1557 files, so until that point we don't know which symbols should be
1558 local. This function is called via elf_link_hash_traverse. */
1561 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1563 struct elf_assign_sym_version_info
*sinfo
;
1564 struct bfd_link_info
*info
;
1565 const struct elf_backend_data
*bed
;
1566 struct elf_info_failed eif
;
1573 if (h
->root
.type
== bfd_link_hash_warning
)
1574 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1576 /* Fix the symbol flags. */
1579 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1582 sinfo
->failed
= TRUE
;
1586 /* We only need version numbers for symbols defined in regular
1588 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1591 bed
= get_elf_backend_data (sinfo
->output_bfd
);
1592 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1593 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1595 struct bfd_elf_version_tree
*t
;
1600 /* There are two consecutive ELF_VER_CHR characters if this is
1601 not a hidden symbol. */
1603 if (*p
== ELF_VER_CHR
)
1609 /* If there is no version string, we can just return out. */
1613 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1617 /* Look for the version. If we find it, it is no longer weak. */
1618 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1620 if (strcmp (t
->name
, p
) == 0)
1624 struct bfd_elf_version_expr
*d
;
1626 len
= p
- h
->root
.root
.string
;
1627 alc
= bfd_malloc (len
);
1630 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1631 alc
[len
- 1] = '\0';
1632 if (alc
[len
- 2] == ELF_VER_CHR
)
1633 alc
[len
- 2] = '\0';
1635 h
->verinfo
.vertree
= t
;
1639 if (t
->globals
.list
!= NULL
)
1640 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
1642 /* See if there is anything to force this symbol to
1644 if (d
== NULL
&& t
->locals
.list
!= NULL
)
1646 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
1650 && ! info
->export_dynamic
)
1651 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1659 /* If we are building an application, we need to create a
1660 version node for this version. */
1661 if (t
== NULL
&& info
->executable
)
1663 struct bfd_elf_version_tree
**pp
;
1666 /* If we aren't going to export this symbol, we don't need
1667 to worry about it. */
1668 if (h
->dynindx
== -1)
1672 t
= bfd_zalloc (sinfo
->output_bfd
, amt
);
1675 sinfo
->failed
= TRUE
;
1680 t
->name_indx
= (unsigned int) -1;
1684 /* Don't count anonymous version tag. */
1685 if (sinfo
->verdefs
!= NULL
&& sinfo
->verdefs
->vernum
== 0)
1687 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1689 t
->vernum
= version_index
;
1693 h
->verinfo
.vertree
= t
;
1697 /* We could not find the version for a symbol when
1698 generating a shared archive. Return an error. */
1699 (*_bfd_error_handler
)
1700 (_("%s: undefined versioned symbol name %s"),
1701 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
1702 bfd_set_error (bfd_error_bad_value
);
1703 sinfo
->failed
= TRUE
;
1708 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1711 /* If we don't have a version for this symbol, see if we can find
1713 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
1715 struct bfd_elf_version_tree
*t
;
1716 struct bfd_elf_version_tree
*local_ver
;
1717 struct bfd_elf_version_expr
*d
;
1719 /* See if can find what version this symbol is in. If the
1720 symbol is supposed to be local, then don't actually register
1723 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1725 if (t
->globals
.list
!= NULL
)
1727 bfd_boolean matched
;
1731 while ((d
= (*t
->match
) (&t
->globals
, d
,
1732 h
->root
.root
.string
)) != NULL
)
1737 /* There is a version without definition. Make
1738 the symbol the default definition for this
1740 h
->verinfo
.vertree
= t
;
1748 /* There is no undefined version for this symbol. Hide the
1750 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1753 if (t
->locals
.list
!= NULL
)
1756 while ((d
= (*t
->match
) (&t
->locals
, d
,
1757 h
->root
.root
.string
)) != NULL
)
1760 /* If the match is "*", keep looking for a more
1761 explicit, perhaps even global, match.
1762 XXX: Shouldn't this be !d->wildcard instead? */
1763 if (d
->pattern
[0] != '*' || d
->pattern
[1] != '\0')
1772 if (local_ver
!= NULL
)
1774 h
->verinfo
.vertree
= local_ver
;
1775 if (h
->dynindx
!= -1
1777 && ! info
->export_dynamic
)
1779 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1787 /* Read and swap the relocs from the section indicated by SHDR. This
1788 may be either a REL or a RELA section. The relocations are
1789 translated into RELA relocations and stored in INTERNAL_RELOCS,
1790 which should have already been allocated to contain enough space.
1791 The EXTERNAL_RELOCS are a buffer where the external form of the
1792 relocations should be stored.
1794 Returns FALSE if something goes wrong. */
1797 elf_link_read_relocs_from_section (bfd
*abfd
,
1799 Elf_Internal_Shdr
*shdr
,
1800 void *external_relocs
,
1801 Elf_Internal_Rela
*internal_relocs
)
1803 const struct elf_backend_data
*bed
;
1804 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
1805 const bfd_byte
*erela
;
1806 const bfd_byte
*erelaend
;
1807 Elf_Internal_Rela
*irela
;
1808 Elf_Internal_Shdr
*symtab_hdr
;
1811 /* Position ourselves at the start of the section. */
1812 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
1815 /* Read the relocations. */
1816 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
1819 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1820 nsyms
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
1822 bed
= get_elf_backend_data (abfd
);
1824 /* Convert the external relocations to the internal format. */
1825 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
1826 swap_in
= bed
->s
->swap_reloc_in
;
1827 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
1828 swap_in
= bed
->s
->swap_reloca_in
;
1831 bfd_set_error (bfd_error_wrong_format
);
1835 erela
= external_relocs
;
1836 erelaend
= erela
+ shdr
->sh_size
;
1837 irela
= internal_relocs
;
1838 while (erela
< erelaend
)
1842 (*swap_in
) (abfd
, erela
, irela
);
1843 r_symndx
= ELF32_R_SYM (irela
->r_info
);
1844 if (bed
->s
->arch_size
== 64)
1846 if ((size_t) r_symndx
>= nsyms
)
1848 (*_bfd_error_handler
)
1849 (_("%s: bad reloc symbol index (0x%lx >= 0x%lx) for offset 0x%lx in section `%s'"),
1850 bfd_archive_filename (abfd
), (unsigned long) r_symndx
,
1851 (unsigned long) nsyms
, irela
->r_offset
, sec
->name
);
1852 bfd_set_error (bfd_error_bad_value
);
1855 irela
+= bed
->s
->int_rels_per_ext_rel
;
1856 erela
+= shdr
->sh_entsize
;
1862 /* Read and swap the relocs for a section O. They may have been
1863 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
1864 not NULL, they are used as buffers to read into. They are known to
1865 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
1866 the return value is allocated using either malloc or bfd_alloc,
1867 according to the KEEP_MEMORY argument. If O has two relocation
1868 sections (both REL and RELA relocations), then the REL_HDR
1869 relocations will appear first in INTERNAL_RELOCS, followed by the
1870 REL_HDR2 relocations. */
1873 _bfd_elf_link_read_relocs (bfd
*abfd
,
1875 void *external_relocs
,
1876 Elf_Internal_Rela
*internal_relocs
,
1877 bfd_boolean keep_memory
)
1879 Elf_Internal_Shdr
*rel_hdr
;
1880 void *alloc1
= NULL
;
1881 Elf_Internal_Rela
*alloc2
= NULL
;
1882 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1884 if (elf_section_data (o
)->relocs
!= NULL
)
1885 return elf_section_data (o
)->relocs
;
1887 if (o
->reloc_count
== 0)
1890 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1892 if (internal_relocs
== NULL
)
1896 size
= o
->reloc_count
;
1897 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
1899 internal_relocs
= bfd_alloc (abfd
, size
);
1901 internal_relocs
= alloc2
= bfd_malloc (size
);
1902 if (internal_relocs
== NULL
)
1906 if (external_relocs
== NULL
)
1908 bfd_size_type size
= rel_hdr
->sh_size
;
1910 if (elf_section_data (o
)->rel_hdr2
)
1911 size
+= elf_section_data (o
)->rel_hdr2
->sh_size
;
1912 alloc1
= bfd_malloc (size
);
1915 external_relocs
= alloc1
;
1918 if (!elf_link_read_relocs_from_section (abfd
, o
, rel_hdr
,
1922 if (elf_section_data (o
)->rel_hdr2
1923 && (!elf_link_read_relocs_from_section
1925 elf_section_data (o
)->rel_hdr2
,
1926 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
1927 internal_relocs
+ (NUM_SHDR_ENTRIES (rel_hdr
)
1928 * bed
->s
->int_rels_per_ext_rel
))))
1931 /* Cache the results for next time, if we can. */
1933 elf_section_data (o
)->relocs
= internal_relocs
;
1938 /* Don't free alloc2, since if it was allocated we are passing it
1939 back (under the name of internal_relocs). */
1941 return internal_relocs
;
1951 /* Compute the size of, and allocate space for, REL_HDR which is the
1952 section header for a section containing relocations for O. */
1955 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
1956 Elf_Internal_Shdr
*rel_hdr
,
1959 bfd_size_type reloc_count
;
1960 bfd_size_type num_rel_hashes
;
1962 /* Figure out how many relocations there will be. */
1963 if (rel_hdr
== &elf_section_data (o
)->rel_hdr
)
1964 reloc_count
= elf_section_data (o
)->rel_count
;
1966 reloc_count
= elf_section_data (o
)->rel_count2
;
1968 num_rel_hashes
= o
->reloc_count
;
1969 if (num_rel_hashes
< reloc_count
)
1970 num_rel_hashes
= reloc_count
;
1972 /* That allows us to calculate the size of the section. */
1973 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reloc_count
;
1975 /* The contents field must last into write_object_contents, so we
1976 allocate it with bfd_alloc rather than malloc. Also since we
1977 cannot be sure that the contents will actually be filled in,
1978 we zero the allocated space. */
1979 rel_hdr
->contents
= bfd_zalloc (abfd
, rel_hdr
->sh_size
);
1980 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1983 /* We only allocate one set of hash entries, so we only do it the
1984 first time we are called. */
1985 if (elf_section_data (o
)->rel_hashes
== NULL
1988 struct elf_link_hash_entry
**p
;
1990 p
= bfd_zmalloc (num_rel_hashes
* sizeof (struct elf_link_hash_entry
*));
1994 elf_section_data (o
)->rel_hashes
= p
;
2000 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2001 originated from the section given by INPUT_REL_HDR) to the
2005 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2006 asection
*input_section
,
2007 Elf_Internal_Shdr
*input_rel_hdr
,
2008 Elf_Internal_Rela
*internal_relocs
)
2010 Elf_Internal_Rela
*irela
;
2011 Elf_Internal_Rela
*irelaend
;
2013 Elf_Internal_Shdr
*output_rel_hdr
;
2014 asection
*output_section
;
2015 unsigned int *rel_countp
= NULL
;
2016 const struct elf_backend_data
*bed
;
2017 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2019 output_section
= input_section
->output_section
;
2020 output_rel_hdr
= NULL
;
2022 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
2023 == input_rel_hdr
->sh_entsize
)
2025 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
2026 rel_countp
= &elf_section_data (output_section
)->rel_count
;
2028 else if (elf_section_data (output_section
)->rel_hdr2
2029 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
2030 == input_rel_hdr
->sh_entsize
))
2032 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
2033 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
2037 (*_bfd_error_handler
)
2038 (_("%s: relocation size mismatch in %s section %s"),
2039 bfd_get_filename (output_bfd
),
2040 bfd_archive_filename (input_section
->owner
),
2041 input_section
->name
);
2042 bfd_set_error (bfd_error_wrong_object_format
);
2046 bed
= get_elf_backend_data (output_bfd
);
2047 if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2048 swap_out
= bed
->s
->swap_reloc_out
;
2049 else if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2050 swap_out
= bed
->s
->swap_reloca_out
;
2054 erel
= output_rel_hdr
->contents
;
2055 erel
+= *rel_countp
* input_rel_hdr
->sh_entsize
;
2056 irela
= internal_relocs
;
2057 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2058 * bed
->s
->int_rels_per_ext_rel
);
2059 while (irela
< irelaend
)
2061 (*swap_out
) (output_bfd
, irela
, erel
);
2062 irela
+= bed
->s
->int_rels_per_ext_rel
;
2063 erel
+= input_rel_hdr
->sh_entsize
;
2066 /* Bump the counter, so that we know where to add the next set of
2068 *rel_countp
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2073 /* Fix up the flags for a symbol. This handles various cases which
2074 can only be fixed after all the input files are seen. This is
2075 currently called by both adjust_dynamic_symbol and
2076 assign_sym_version, which is unnecessary but perhaps more robust in
2077 the face of future changes. */
2080 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2081 struct elf_info_failed
*eif
)
2083 /* If this symbol was mentioned in a non-ELF file, try to set
2084 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2085 permit a non-ELF file to correctly refer to a symbol defined in
2086 an ELF dynamic object. */
2087 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
2089 while (h
->root
.type
== bfd_link_hash_indirect
)
2090 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2092 if (h
->root
.type
!= bfd_link_hash_defined
2093 && h
->root
.type
!= bfd_link_hash_defweak
)
2094 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2095 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2098 if (h
->root
.u
.def
.section
->owner
!= NULL
2099 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2100 == bfd_target_elf_flavour
))
2101 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2102 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2104 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2107 if (h
->dynindx
== -1
2108 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2109 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
2111 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2120 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
2121 was first seen in a non-ELF file. Fortunately, if the symbol
2122 was first seen in an ELF file, we're probably OK unless the
2123 symbol was defined in a non-ELF file. Catch that case here.
2124 FIXME: We're still in trouble if the symbol was first seen in
2125 a dynamic object, and then later in a non-ELF regular object. */
2126 if ((h
->root
.type
== bfd_link_hash_defined
2127 || h
->root
.type
== bfd_link_hash_defweak
)
2128 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2129 && (h
->root
.u
.def
.section
->owner
!= NULL
2130 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2131 != bfd_target_elf_flavour
)
2132 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2133 && (h
->elf_link_hash_flags
2134 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
2135 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2138 /* If this is a final link, and the symbol was defined as a common
2139 symbol in a regular object file, and there was no definition in
2140 any dynamic object, then the linker will have allocated space for
2141 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
2142 flag will not have been set. */
2143 if (h
->root
.type
== bfd_link_hash_defined
2144 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2145 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
2146 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2147 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2148 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2150 /* If -Bsymbolic was used (which means to bind references to global
2151 symbols to the definition within the shared object), and this
2152 symbol was defined in a regular object, then it actually doesn't
2153 need a PLT entry. Likewise, if the symbol has non-default
2154 visibility. If the symbol has hidden or internal visibility, we
2155 will force it local. */
2156 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
2157 && eif
->info
->shared
2158 && is_elf_hash_table (eif
->info
->hash
)
2159 && (eif
->info
->symbolic
2160 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2161 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2163 const struct elf_backend_data
*bed
;
2164 bfd_boolean force_local
;
2166 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2168 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2169 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2170 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2173 /* If a weak undefined symbol has non-default visibility, we also
2174 hide it from the dynamic linker. */
2175 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2176 && h
->root
.type
== bfd_link_hash_undefweak
)
2178 const struct elf_backend_data
*bed
;
2179 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2180 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2183 /* If this is a weak defined symbol in a dynamic object, and we know
2184 the real definition in the dynamic object, copy interesting flags
2185 over to the real definition. */
2186 if (h
->weakdef
!= NULL
)
2188 struct elf_link_hash_entry
*weakdef
;
2190 weakdef
= h
->weakdef
;
2191 if (h
->root
.type
== bfd_link_hash_indirect
)
2192 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2194 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2195 || h
->root
.type
== bfd_link_hash_defweak
);
2196 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2197 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2198 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
2200 /* If the real definition is defined by a regular object file,
2201 don't do anything special. See the longer description in
2202 _bfd_elf_adjust_dynamic_symbol, below. */
2203 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2207 const struct elf_backend_data
*bed
;
2209 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2210 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, weakdef
, h
);
2217 /* Make the backend pick a good value for a dynamic symbol. This is
2218 called via elf_link_hash_traverse, and also calls itself
2222 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2224 struct elf_info_failed
*eif
= data
;
2226 const struct elf_backend_data
*bed
;
2228 if (! is_elf_hash_table (eif
->info
->hash
))
2231 if (h
->root
.type
== bfd_link_hash_warning
)
2233 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2234 h
->got
= elf_hash_table (eif
->info
)->init_offset
;
2236 /* When warning symbols are created, they **replace** the "real"
2237 entry in the hash table, thus we never get to see the real
2238 symbol in a hash traversal. So look at it now. */
2239 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2242 /* Ignore indirect symbols. These are added by the versioning code. */
2243 if (h
->root
.type
== bfd_link_hash_indirect
)
2246 /* Fix the symbol flags. */
2247 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2250 /* If this symbol does not require a PLT entry, and it is not
2251 defined by a dynamic object, or is not referenced by a regular
2252 object, ignore it. We do have to handle a weak defined symbol,
2253 even if no regular object refers to it, if we decided to add it
2254 to the dynamic symbol table. FIXME: Do we normally need to worry
2255 about symbols which are defined by one dynamic object and
2256 referenced by another one? */
2257 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
2258 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2259 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2260 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
2261 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
2263 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2267 /* If we've already adjusted this symbol, don't do it again. This
2268 can happen via a recursive call. */
2269 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
2272 /* Don't look at this symbol again. Note that we must set this
2273 after checking the above conditions, because we may look at a
2274 symbol once, decide not to do anything, and then get called
2275 recursively later after REF_REGULAR is set below. */
2276 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
2278 /* If this is a weak definition, and we know a real definition, and
2279 the real symbol is not itself defined by a regular object file,
2280 then get a good value for the real definition. We handle the
2281 real symbol first, for the convenience of the backend routine.
2283 Note that there is a confusing case here. If the real definition
2284 is defined by a regular object file, we don't get the real symbol
2285 from the dynamic object, but we do get the weak symbol. If the
2286 processor backend uses a COPY reloc, then if some routine in the
2287 dynamic object changes the real symbol, we will not see that
2288 change in the corresponding weak symbol. This is the way other
2289 ELF linkers work as well, and seems to be a result of the shared
2292 I will clarify this issue. Most SVR4 shared libraries define the
2293 variable _timezone and define timezone as a weak synonym. The
2294 tzset call changes _timezone. If you write
2295 extern int timezone;
2297 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2298 you might expect that, since timezone is a synonym for _timezone,
2299 the same number will print both times. However, if the processor
2300 backend uses a COPY reloc, then actually timezone will be copied
2301 into your process image, and, since you define _timezone
2302 yourself, _timezone will not. Thus timezone and _timezone will
2303 wind up at different memory locations. The tzset call will set
2304 _timezone, leaving timezone unchanged. */
2306 if (h
->weakdef
!= NULL
)
2308 /* If we get to this point, we know there is an implicit
2309 reference by a regular object file via the weak symbol H.
2310 FIXME: Is this really true? What if the traversal finds
2311 H->WEAKDEF before it finds H? */
2312 h
->weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2314 if (! _bfd_elf_adjust_dynamic_symbol (h
->weakdef
, eif
))
2318 /* If a symbol has no type and no size and does not require a PLT
2319 entry, then we are probably about to do the wrong thing here: we
2320 are probably going to create a COPY reloc for an empty object.
2321 This case can arise when a shared object is built with assembly
2322 code, and the assembly code fails to set the symbol type. */
2324 && h
->type
== STT_NOTYPE
2325 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
2326 (*_bfd_error_handler
)
2327 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2328 h
->root
.root
.string
);
2330 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2331 bed
= get_elf_backend_data (dynobj
);
2332 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2341 /* Adjust all external symbols pointing into SEC_MERGE sections
2342 to reflect the object merging within the sections. */
2345 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2349 if (h
->root
.type
== bfd_link_hash_warning
)
2350 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2352 if ((h
->root
.type
== bfd_link_hash_defined
2353 || h
->root
.type
== bfd_link_hash_defweak
)
2354 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2355 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2357 bfd
*output_bfd
= data
;
2359 h
->root
.u
.def
.value
=
2360 _bfd_merged_section_offset (output_bfd
,
2361 &h
->root
.u
.def
.section
,
2362 elf_section_data (sec
)->sec_info
,
2363 h
->root
.u
.def
.value
, 0);
2369 /* Returns false if the symbol referred to by H should be considered
2370 to resolve local to the current module, and true if it should be
2371 considered to bind dynamically. */
2374 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2375 struct bfd_link_info
*info
,
2376 bfd_boolean ignore_protected
)
2378 bfd_boolean binding_stays_local_p
;
2383 while (h
->root
.type
== bfd_link_hash_indirect
2384 || h
->root
.type
== bfd_link_hash_warning
)
2385 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2387 /* If it was forced local, then clearly it's not dynamic. */
2388 if (h
->dynindx
== -1)
2390 if (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)
2393 /* Identify the cases where name binding rules say that a
2394 visible symbol resolves locally. */
2395 binding_stays_local_p
= info
->executable
|| info
->symbolic
;
2397 switch (ELF_ST_VISIBILITY (h
->other
))
2404 /* Proper resolution for function pointer equality may require
2405 that these symbols perhaps be resolved dynamically, even though
2406 we should be resolving them to the current module. */
2407 if (!ignore_protected
)
2408 binding_stays_local_p
= TRUE
;
2415 /* If it isn't defined locally, then clearly it's dynamic. */
2416 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2419 /* Otherwise, the symbol is dynamic if binding rules don't tell
2420 us that it remains local. */
2421 return !binding_stays_local_p
;
2424 /* Return true if the symbol referred to by H should be considered
2425 to resolve local to the current module, and false otherwise. Differs
2426 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2427 undefined symbols and weak symbols. */
2430 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2431 struct bfd_link_info
*info
,
2432 bfd_boolean local_protected
)
2434 /* If it's a local sym, of course we resolve locally. */
2438 /* If we don't have a definition in a regular file, then we can't
2439 resolve locally. The sym is either undefined or dynamic. */
2440 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2443 /* Forced local symbols resolve locally. */
2444 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2447 /* As do non-dynamic symbols. */
2448 if (h
->dynindx
== -1)
2451 /* At this point, we know the symbol is defined and dynamic. In an
2452 executable it must resolve locally, likewise when building symbolic
2453 shared libraries. */
2454 if (info
->executable
|| info
->symbolic
)
2457 /* Now deal with defined dynamic symbols in shared libraries. Ones
2458 with default visibility might not resolve locally. */
2459 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2462 /* However, STV_HIDDEN or STV_INTERNAL ones must be local. */
2463 if (ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
)
2466 /* Function pointer equality tests may require that STV_PROTECTED
2467 symbols be treated as dynamic symbols, even when we know that the
2468 dynamic linker will resolve them locally. */
2469 return local_protected
;
2472 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2473 aligned. Returns the first TLS output section. */
2475 struct bfd_section
*
2476 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2478 struct bfd_section
*sec
, *tls
;
2479 unsigned int align
= 0;
2481 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2482 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2486 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2487 if (sec
->alignment_power
> align
)
2488 align
= sec
->alignment_power
;
2490 elf_hash_table (info
)->tls_sec
= tls
;
2492 /* Ensure the alignment of the first section is the largest alignment,
2493 so that the tls segment starts aligned. */
2495 tls
->alignment_power
= align
;
2500 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2502 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2503 Elf_Internal_Sym
*sym
)
2505 /* Local symbols do not count, but target specific ones might. */
2506 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2507 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2510 /* Function symbols do not count. */
2511 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)
2514 /* If the section is undefined, then so is the symbol. */
2515 if (sym
->st_shndx
== SHN_UNDEF
)
2518 /* If the symbol is defined in the common section, then
2519 it is a common definition and so does not count. */
2520 if (sym
->st_shndx
== SHN_COMMON
)
2523 /* If the symbol is in a target specific section then we
2524 must rely upon the backend to tell us what it is. */
2525 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2526 /* FIXME - this function is not coded yet:
2528 return _bfd_is_global_symbol_definition (abfd, sym);
2530 Instead for now assume that the definition is not global,
2531 Even if this is wrong, at least the linker will behave
2532 in the same way that it used to do. */
2538 /* Search the symbol table of the archive element of the archive ABFD
2539 whose archive map contains a mention of SYMDEF, and determine if
2540 the symbol is defined in this element. */
2542 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2544 Elf_Internal_Shdr
* hdr
;
2545 bfd_size_type symcount
;
2546 bfd_size_type extsymcount
;
2547 bfd_size_type extsymoff
;
2548 Elf_Internal_Sym
*isymbuf
;
2549 Elf_Internal_Sym
*isym
;
2550 Elf_Internal_Sym
*isymend
;
2553 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2557 if (! bfd_check_format (abfd
, bfd_object
))
2560 /* If we have already included the element containing this symbol in the
2561 link then we do not need to include it again. Just claim that any symbol
2562 it contains is not a definition, so that our caller will not decide to
2563 (re)include this element. */
2564 if (abfd
->archive_pass
)
2567 /* Select the appropriate symbol table. */
2568 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2569 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2571 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2573 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2575 /* The sh_info field of the symtab header tells us where the
2576 external symbols start. We don't care about the local symbols. */
2577 if (elf_bad_symtab (abfd
))
2579 extsymcount
= symcount
;
2584 extsymcount
= symcount
- hdr
->sh_info
;
2585 extsymoff
= hdr
->sh_info
;
2588 if (extsymcount
== 0)
2591 /* Read in the symbol table. */
2592 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
2594 if (isymbuf
== NULL
)
2597 /* Scan the symbol table looking for SYMDEF. */
2599 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
2603 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2608 if (strcmp (name
, symdef
->name
) == 0)
2610 result
= is_global_data_symbol_definition (abfd
, isym
);
2620 /* Add symbols from an ELF archive file to the linker hash table. We
2621 don't use _bfd_generic_link_add_archive_symbols because of a
2622 problem which arises on UnixWare. The UnixWare libc.so is an
2623 archive which includes an entry libc.so.1 which defines a bunch of
2624 symbols. The libc.so archive also includes a number of other
2625 object files, which also define symbols, some of which are the same
2626 as those defined in libc.so.1. Correct linking requires that we
2627 consider each object file in turn, and include it if it defines any
2628 symbols we need. _bfd_generic_link_add_archive_symbols does not do
2629 this; it looks through the list of undefined symbols, and includes
2630 any object file which defines them. When this algorithm is used on
2631 UnixWare, it winds up pulling in libc.so.1 early and defining a
2632 bunch of symbols. This means that some of the other objects in the
2633 archive are not included in the link, which is incorrect since they
2634 precede libc.so.1 in the archive.
2636 Fortunately, ELF archive handling is simpler than that done by
2637 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
2638 oddities. In ELF, if we find a symbol in the archive map, and the
2639 symbol is currently undefined, we know that we must pull in that
2642 Unfortunately, we do have to make multiple passes over the symbol
2643 table until nothing further is resolved. */
2646 _bfd_elf_link_add_archive_symbols (bfd
*abfd
,
2647 struct bfd_link_info
*info
)
2650 bfd_boolean
*defined
= NULL
;
2651 bfd_boolean
*included
= NULL
;
2656 if (! bfd_has_map (abfd
))
2658 /* An empty archive is a special case. */
2659 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
2661 bfd_set_error (bfd_error_no_armap
);
2665 /* Keep track of all symbols we know to be already defined, and all
2666 files we know to be already included. This is to speed up the
2667 second and subsequent passes. */
2668 c
= bfd_ardata (abfd
)->symdef_count
;
2672 amt
*= sizeof (bfd_boolean
);
2673 defined
= bfd_zmalloc (amt
);
2674 included
= bfd_zmalloc (amt
);
2675 if (defined
== NULL
|| included
== NULL
)
2678 symdefs
= bfd_ardata (abfd
)->symdefs
;
2691 symdefend
= symdef
+ c
;
2692 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
2694 struct elf_link_hash_entry
*h
;
2696 struct bfd_link_hash_entry
*undefs_tail
;
2699 if (defined
[i
] || included
[i
])
2701 if (symdef
->file_offset
== last
)
2707 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
2708 FALSE
, FALSE
, FALSE
);
2715 /* If this is a default version (the name contains @@),
2716 look up the symbol again with only one `@' as well
2717 as without the version. The effect is that references
2718 to the symbol with and without the version will be
2719 matched by the default symbol in the archive. */
2721 p
= strchr (symdef
->name
, ELF_VER_CHR
);
2722 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
2725 /* First check with only one `@'. */
2726 len
= strlen (symdef
->name
);
2727 copy
= bfd_alloc (abfd
, len
);
2730 first
= p
- symdef
->name
+ 1;
2731 memcpy (copy
, symdef
->name
, first
);
2732 memcpy (copy
+ first
, symdef
->name
+ first
+ 1, len
- first
);
2734 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
2735 FALSE
, FALSE
, FALSE
);
2739 /* We also need to check references to the symbol
2740 without the version. */
2742 copy
[first
- 1] = '\0';
2743 h
= elf_link_hash_lookup (elf_hash_table (info
),
2744 copy
, FALSE
, FALSE
, FALSE
);
2747 bfd_release (abfd
, copy
);
2753 if (h
->root
.type
== bfd_link_hash_common
)
2755 /* We currently have a common symbol. The archive map contains
2756 a reference to this symbol, so we may want to include it. We
2757 only want to include it however, if this archive element
2758 contains a definition of the symbol, not just another common
2761 Unfortunately some archivers (including GNU ar) will put
2762 declarations of common symbols into their archive maps, as
2763 well as real definitions, so we cannot just go by the archive
2764 map alone. Instead we must read in the element's symbol
2765 table and check that to see what kind of symbol definition
2767 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
2770 else if (h
->root
.type
!= bfd_link_hash_undefined
)
2772 if (h
->root
.type
!= bfd_link_hash_undefweak
)
2777 /* We need to include this archive member. */
2778 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2779 if (element
== NULL
)
2782 if (! bfd_check_format (element
, bfd_object
))
2785 /* Doublecheck that we have not included this object
2786 already--it should be impossible, but there may be
2787 something wrong with the archive. */
2788 if (element
->archive_pass
!= 0)
2790 bfd_set_error (bfd_error_bad_value
);
2793 element
->archive_pass
= 1;
2795 undefs_tail
= info
->hash
->undefs_tail
;
2797 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
2800 if (! bfd_link_add_symbols (element
, info
))
2803 /* If there are any new undefined symbols, we need to make
2804 another pass through the archive in order to see whether
2805 they can be defined. FIXME: This isn't perfect, because
2806 common symbols wind up on undefs_tail and because an
2807 undefined symbol which is defined later on in this pass
2808 does not require another pass. This isn't a bug, but it
2809 does make the code less efficient than it could be. */
2810 if (undefs_tail
!= info
->hash
->undefs_tail
)
2813 /* Look backward to mark all symbols from this object file
2814 which we have already seen in this pass. */
2818 included
[mark
] = TRUE
;
2823 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
2825 /* We mark subsequent symbols from this object file as we go
2826 on through the loop. */
2827 last
= symdef
->file_offset
;
2838 if (defined
!= NULL
)
2840 if (included
!= NULL
)