1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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
))
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
148 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
150 s
= bfd_make_section (abfd
, ".eh_frame_hdr");
152 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
153 || ! bfd_set_section_alignment (abfd
, s
, 2))
155 elf_hash_table (info
)->eh_info
.hdr_sec
= s
;
158 bed
= get_elf_backend_data (abfd
);
160 /* Create sections to hold version informations. These are removed
161 if they are not needed. */
162 s
= bfd_make_section (abfd
, ".gnu.version_d");
164 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
165 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
168 s
= bfd_make_section (abfd
, ".gnu.version");
170 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
171 || ! bfd_set_section_alignment (abfd
, s
, 1))
174 s
= bfd_make_section (abfd
, ".gnu.version_r");
176 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
177 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
180 s
= bfd_make_section (abfd
, ".dynsym");
182 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
183 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
186 s
= bfd_make_section (abfd
, ".dynstr");
188 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
191 /* Create a strtab to hold the dynamic symbol names. */
192 if (elf_hash_table (info
)->dynstr
== NULL
)
194 elf_hash_table (info
)->dynstr
= _bfd_elf_strtab_init ();
195 if (elf_hash_table (info
)->dynstr
== NULL
)
199 s
= bfd_make_section (abfd
, ".dynamic");
201 || ! bfd_set_section_flags (abfd
, s
, flags
)
202 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
205 /* The special symbol _DYNAMIC is always set to the start of the
206 .dynamic section. This call occurs before we have processed the
207 symbols for any dynamic object, so we don't have to worry about
208 overriding a dynamic definition. We could set _DYNAMIC in a
209 linker script, but we only want to define it if we are, in fact,
210 creating a .dynamic section. We don't want to define it if there
211 is no .dynamic section, since on some ELF platforms the start up
212 code examines it to decide how to initialize the process. */
214 if (! (_bfd_generic_link_add_one_symbol
215 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
216 get_elf_backend_data (abfd
)->collect
, &bh
)))
218 h
= (struct elf_link_hash_entry
*) bh
;
219 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
220 h
->type
= STT_OBJECT
;
222 if (! info
->executable
223 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
226 s
= bfd_make_section (abfd
, ".hash");
228 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
229 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
231 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
233 /* Let the backend create the rest of the sections. This lets the
234 backend set the right flags. The backend will normally create
235 the .got and .plt sections. */
236 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
239 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
244 /* Create dynamic sections when linking against a dynamic object. */
247 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
249 flagword flags
, pltflags
;
251 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
253 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
254 .rel[a].bss sections. */
256 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
257 | SEC_LINKER_CREATED
);
260 pltflags
|= SEC_CODE
;
261 if (bed
->plt_not_loaded
)
262 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
263 if (bed
->plt_readonly
)
264 pltflags
|= SEC_READONLY
;
266 s
= bfd_make_section (abfd
, ".plt");
268 || ! bfd_set_section_flags (abfd
, s
, pltflags
)
269 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
272 if (bed
->want_plt_sym
)
274 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
276 struct elf_link_hash_entry
*h
;
277 struct bfd_link_hash_entry
*bh
= NULL
;
279 if (! (_bfd_generic_link_add_one_symbol
280 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
281 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
283 h
= (struct elf_link_hash_entry
*) bh
;
284 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
285 h
->type
= STT_OBJECT
;
287 if (! info
->executable
288 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
292 s
= bfd_make_section (abfd
,
293 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt");
295 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
296 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
299 if (! _bfd_elf_create_got_section (abfd
, info
))
302 if (bed
->want_dynbss
)
304 /* The .dynbss section is a place to put symbols which are defined
305 by dynamic objects, are referenced by regular objects, and are
306 not functions. We must allocate space for them in the process
307 image and use a R_*_COPY reloc to tell the dynamic linker to
308 initialize them at run time. The linker script puts the .dynbss
309 section into the .bss section of the final image. */
310 s
= bfd_make_section (abfd
, ".dynbss");
312 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
| SEC_LINKER_CREATED
))
315 /* The .rel[a].bss section holds copy relocs. This section is not
316 normally needed. We need to create it here, though, so that the
317 linker will map it to an output section. We can't just create it
318 only if we need it, because we will not know whether we need it
319 until we have seen all the input files, and the first time the
320 main linker code calls BFD after examining all the input files
321 (size_dynamic_sections) the input sections have already been
322 mapped to the output sections. If the section turns out not to
323 be needed, we can discard it later. We will never need this
324 section when generating a shared object, since they do not use
328 s
= bfd_make_section (abfd
,
329 (bed
->default_use_rela_p
330 ? ".rela.bss" : ".rel.bss"));
332 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
333 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
341 /* Record a new dynamic symbol. We record the dynamic symbols as we
342 read the input files, since we need to have a list of all of them
343 before we can determine the final sizes of the output sections.
344 Note that we may actually call this function even though we are not
345 going to output any dynamic symbols; in some cases we know that a
346 symbol should be in the dynamic symbol table, but only if there is
350 _bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
351 struct elf_link_hash_entry
*h
)
353 if (h
->dynindx
== -1)
355 struct elf_strtab_hash
*dynstr
;
361 /* XXX: The ABI draft says the linker must turn hidden and
362 internal symbols into STB_LOCAL symbols when producing the
363 DSO. However, if ld.so honors st_other in the dynamic table,
364 this would not be necessary. */
365 switch (ELF_ST_VISIBILITY (h
->other
))
369 if (h
->root
.type
!= bfd_link_hash_undefined
370 && h
->root
.type
!= bfd_link_hash_undefweak
)
372 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
380 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
381 ++elf_hash_table (info
)->dynsymcount
;
383 dynstr
= elf_hash_table (info
)->dynstr
;
386 /* Create a strtab to hold the dynamic symbol names. */
387 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
392 /* We don't put any version information in the dynamic string
394 name
= h
->root
.root
.string
;
395 p
= strchr (name
, ELF_VER_CHR
);
403 size_t len
= p
- name
+ 1;
405 alc
= bfd_malloc (len
);
408 memcpy (alc
, name
, len
- 1);
414 indx
= _bfd_elf_strtab_add (dynstr
, name
, copy
);
419 if (indx
== (bfd_size_type
) -1)
421 h
->dynstr_index
= indx
;
427 /* Record an assignment to a symbol made by a linker script. We need
428 this in case some dynamic object refers to this symbol. */
431 bfd_elf_record_link_assignment (bfd
*output_bfd ATTRIBUTE_UNUSED
,
432 struct bfd_link_info
*info
,
436 struct elf_link_hash_entry
*h
;
438 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
441 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, TRUE
, FALSE
);
445 if (h
->root
.type
== bfd_link_hash_new
)
446 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
448 /* If this symbol is being provided by the linker script, and it is
449 currently defined by a dynamic object, but not by a regular
450 object, then mark it as undefined so that the generic linker will
451 force the correct value. */
453 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
454 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
455 h
->root
.type
= bfd_link_hash_undefined
;
457 /* If this symbol is not being provided by the linker script, and it is
458 currently defined by a dynamic object, but not by a regular object,
459 then clear out any version information because the symbol will not be
460 associated with the dynamic object any more. */
462 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
463 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
464 h
->verinfo
.verdef
= NULL
;
466 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
468 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
469 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
473 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
476 /* If this is a weak defined symbol, and we know a corresponding
477 real symbol from the same dynamic object, make sure the real
478 symbol is also made into a dynamic symbol. */
479 if (h
->weakdef
!= NULL
480 && h
->weakdef
->dynindx
== -1)
482 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
490 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
491 success, and 2 on a failure caused by attempting to record a symbol
492 in a discarded section, eg. a discarded link-once section symbol. */
495 elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
500 struct elf_link_local_dynamic_entry
*entry
;
501 struct elf_link_hash_table
*eht
;
502 struct elf_strtab_hash
*dynstr
;
503 unsigned long dynstr_index
;
505 Elf_External_Sym_Shndx eshndx
;
506 char esym
[sizeof (Elf64_External_Sym
)];
508 if (! is_elf_hash_table (info
))
511 /* See if the entry exists already. */
512 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
513 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
516 amt
= sizeof (*entry
);
517 entry
= bfd_alloc (input_bfd
, amt
);
521 /* Go find the symbol, so that we can find it's name. */
522 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
523 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
525 bfd_release (input_bfd
, entry
);
529 if (entry
->isym
.st_shndx
!= SHN_UNDEF
530 && (entry
->isym
.st_shndx
< SHN_LORESERVE
531 || entry
->isym
.st_shndx
> SHN_HIRESERVE
))
535 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
536 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
538 /* We can still bfd_release here as nothing has done another
539 bfd_alloc. We can't do this later in this function. */
540 bfd_release (input_bfd
, entry
);
545 name
= (bfd_elf_string_from_elf_section
546 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
547 entry
->isym
.st_name
));
549 dynstr
= elf_hash_table (info
)->dynstr
;
552 /* Create a strtab to hold the dynamic symbol names. */
553 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
558 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
559 if (dynstr_index
== (unsigned long) -1)
561 entry
->isym
.st_name
= dynstr_index
;
563 eht
= elf_hash_table (info
);
565 entry
->next
= eht
->dynlocal
;
566 eht
->dynlocal
= entry
;
567 entry
->input_bfd
= input_bfd
;
568 entry
->input_indx
= input_indx
;
571 /* Whatever binding the symbol had before, it's now local. */
573 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
575 /* The dynindx will be set at the end of size_dynamic_sections. */
580 /* Return the dynindex of a local dynamic symbol. */
583 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
587 struct elf_link_local_dynamic_entry
*e
;
589 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
590 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
595 /* This function is used to renumber the dynamic symbols, if some of
596 them are removed because they are marked as local. This is called
597 via elf_link_hash_traverse. */
600 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
603 size_t *count
= data
;
605 if (h
->root
.type
== bfd_link_hash_warning
)
606 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
608 if (h
->dynindx
!= -1)
609 h
->dynindx
= ++(*count
);
614 /* Assign dynsym indices. In a shared library we generate a section
615 symbol for each output section, which come first. Next come all of
616 the back-end allocated local dynamic syms, followed by the rest of
617 the global symbols. */
620 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
622 unsigned long dynsymcount
= 0;
627 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
628 if ((p
->flags
& SEC_EXCLUDE
) == 0)
629 elf_section_data (p
)->dynindx
= ++dynsymcount
;
632 if (elf_hash_table (info
)->dynlocal
)
634 struct elf_link_local_dynamic_entry
*p
;
635 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
636 p
->dynindx
= ++dynsymcount
;
639 elf_link_hash_traverse (elf_hash_table (info
),
640 elf_link_renumber_hash_table_dynsyms
,
643 /* There is an unused NULL entry at the head of the table which
644 we must account for in our count. Unless there weren't any
645 symbols, which means we'll have no table at all. */
646 if (dynsymcount
!= 0)
649 return elf_hash_table (info
)->dynsymcount
= dynsymcount
;
652 /* This function is called when we want to define a new symbol. It
653 handles the various cases which arise when we find a definition in
654 a dynamic object, or when there is already a definition in a
655 dynamic object. The new symbol is described by NAME, SYM, PSEC,
656 and PVALUE. We set SYM_HASH to the hash table entry. We set
657 OVERRIDE if the old symbol is overriding a new definition. We set
658 TYPE_CHANGE_OK if it is OK for the type to change. We set
659 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
660 change, we mean that we shouldn't warn if the type or size does
661 change. DT_NEEDED indicates if it comes from a DT_NEEDED entry of
665 _bfd_elf_merge_symbol (bfd
*abfd
,
666 struct bfd_link_info
*info
,
668 Elf_Internal_Sym
*sym
,
671 struct elf_link_hash_entry
**sym_hash
,
673 bfd_boolean
*override
,
674 bfd_boolean
*type_change_ok
,
675 bfd_boolean
*size_change_ok
,
676 bfd_boolean dt_needed
)
679 struct elf_link_hash_entry
*h
;
680 struct elf_link_hash_entry
*flip
;
683 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
684 bfd_boolean newweakdef
, oldweakdef
, newweakundef
, oldweakundef
;
690 bind
= ELF_ST_BIND (sym
->st_info
);
692 if (! bfd_is_und_section (sec
))
693 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
695 h
= ((struct elf_link_hash_entry
*)
696 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
701 /* This code is for coping with dynamic objects, and is only useful
702 if we are doing an ELF link. */
703 if (info
->hash
->creator
!= abfd
->xvec
)
706 /* For merging, we only care about real symbols. */
708 while (h
->root
.type
== bfd_link_hash_indirect
709 || h
->root
.type
== bfd_link_hash_warning
)
710 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
712 /* If we just created the symbol, mark it as being an ELF symbol.
713 Other than that, there is nothing to do--there is no merge issue
714 with a newly defined symbol--so we just return. */
716 if (h
->root
.type
== bfd_link_hash_new
)
718 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
722 /* OLDBFD is a BFD associated with the existing symbol. */
724 switch (h
->root
.type
)
730 case bfd_link_hash_undefined
:
731 case bfd_link_hash_undefweak
:
732 oldbfd
= h
->root
.u
.undef
.abfd
;
735 case bfd_link_hash_defined
:
736 case bfd_link_hash_defweak
:
737 oldbfd
= h
->root
.u
.def
.section
->owner
;
740 case bfd_link_hash_common
:
741 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
745 /* In cases involving weak versioned symbols, we may wind up trying
746 to merge a symbol with itself. Catch that here, to avoid the
747 confusion that results if we try to override a symbol with
748 itself. The additional tests catch cases like
749 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
750 dynamic object, which we do want to handle here. */
752 && ((abfd
->flags
& DYNAMIC
) == 0
753 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0))
756 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
757 respectively, is from a dynamic object. */
759 if ((abfd
->flags
& DYNAMIC
) != 0)
765 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
770 /* This code handles the special SHN_MIPS_{TEXT,DATA} section
771 indices used by MIPS ELF. */
772 switch (h
->root
.type
)
778 case bfd_link_hash_defined
:
779 case bfd_link_hash_defweak
:
780 hsec
= h
->root
.u
.def
.section
;
783 case bfd_link_hash_common
:
784 hsec
= h
->root
.u
.c
.p
->section
;
791 olddyn
= (hsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
794 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
795 respectively, appear to be a definition rather than reference. */
797 if (bfd_is_und_section (sec
) || bfd_is_com_section (sec
))
802 if (h
->root
.type
== bfd_link_hash_undefined
803 || h
->root
.type
== bfd_link_hash_undefweak
804 || h
->root
.type
== bfd_link_hash_common
)
809 /* We need to rememeber if a symbol has a definition in a dynamic
810 object or is weak in all dynamic objects. Internal and hidden
811 visibility will make it unavailable to dynamic objects. */
812 if (newdyn
&& (h
->elf_link_hash_flags
& ELF_LINK_DYNAMIC_DEF
) == 0)
814 if (!bfd_is_und_section (sec
))
815 h
->elf_link_hash_flags
|= ELF_LINK_DYNAMIC_DEF
;
818 /* Check if this symbol is weak in all dynamic objects. If it
819 is the first time we see it in a dynamic object, we mark
820 if it is weak. Otherwise, we clear it. */
821 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
823 if (bind
== STB_WEAK
)
824 h
->elf_link_hash_flags
|= ELF_LINK_DYNAMIC_WEAK
;
826 else if (bind
!= STB_WEAK
)
827 h
->elf_link_hash_flags
&= ~ELF_LINK_DYNAMIC_WEAK
;
831 /* If the old symbol has non-default visibility, we ignore the new
832 definition from a dynamic object. */
834 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
835 && !bfd_is_und_section (sec
))
838 /* Make sure this symbol is dynamic. */
839 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
840 /* A protected symbol has external availability. Make sure it is
843 FIXME: Should we check type and size for protected symbol? */
844 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
845 return _bfd_elf_link_record_dynamic_symbol (info
, h
);
850 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
851 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
853 /* If the new symbol with non-default visibility comes from a
854 relocatable file and the old definition comes from a dynamic
855 object, we remove the old definition. */
856 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
858 h
->root
.type
= bfd_link_hash_new
;
859 h
->root
.u
.undef
.abfd
= NULL
;
860 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
862 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_DEF_DYNAMIC
;
863 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_DYNAMIC
864 | ELF_LINK_DYNAMIC_DEF
);
866 /* FIXME: Should we check type and size for protected symbol? */
872 /* We need to treat weak definiton right, depending on if there is a
873 definition from a dynamic object. */
874 if (bind
== STB_WEAK
)
879 newweakundef
= FALSE
;
888 newweakdef
= newweakundef
= FALSE
;
890 /* If the new weak definition comes from a relocatable file and the
891 old symbol comes from a dynamic object, we treat the new one as
893 if (newweakdef
&& !newdyn
&& olddyn
)
896 if (h
->root
.type
== bfd_link_hash_defweak
)
899 oldweakundef
= FALSE
;
901 else if (h
->root
.type
== bfd_link_hash_undefweak
)
907 oldweakdef
= oldweakundef
= FALSE
;
909 /* If the old weak definition comes from a relocatable file and the
910 new symbol comes from a dynamic object, we treat the old one as
912 if (oldweakdef
&& !olddyn
&& newdyn
)
915 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
916 symbol, respectively, appears to be a common symbol in a dynamic
917 object. If a symbol appears in an uninitialized section, and is
918 not weak, and is not a function, then it may be a common symbol
919 which was resolved when the dynamic object was created. We want
920 to treat such symbols specially, because they raise special
921 considerations when setting the symbol size: if the symbol
922 appears as a common symbol in a regular object, and the size in
923 the regular object is larger, we must make sure that we use the
924 larger size. This problematic case can always be avoided in C,
925 but it must be handled correctly when using Fortran shared
928 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
929 likewise for OLDDYNCOMMON and OLDDEF.
931 Note that this test is just a heuristic, and that it is quite
932 possible to have an uninitialized symbol in a shared object which
933 is really a definition, rather than a common symbol. This could
934 lead to some minor confusion when the symbol really is a common
935 symbol in some regular object. However, I think it will be
940 && (sec
->flags
& SEC_ALLOC
) != 0
941 && (sec
->flags
& SEC_LOAD
) == 0
945 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
948 newdyncommon
= FALSE
;
952 && h
->root
.type
== bfd_link_hash_defined
953 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
954 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
955 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
957 && h
->type
!= STT_FUNC
)
960 olddyncommon
= FALSE
;
962 /* It's OK to change the type if either the existing symbol or the
963 new symbol is weak unless it comes from a DT_NEEDED entry of
964 a shared object, in which case, the DT_NEEDED entry may not be
965 required at the run time. The type change is also OK if the
966 old symbol is undefined and the new symbol is defined. */
968 if ((! dt_needed
&& oldweakdef
)
973 && (h
->root
.type
== bfd_link_hash_undefined
974 || h
->root
.type
== bfd_link_hash_undefweak
)))
975 *type_change_ok
= TRUE
;
977 /* It's OK to change the size if either the existing symbol or the
978 new symbol is weak, or if the old symbol is undefined. */
981 || h
->root
.type
== bfd_link_hash_undefined
)
982 *size_change_ok
= TRUE
;
984 /* If both the old and the new symbols look like common symbols in a
985 dynamic object, set the size of the symbol to the larger of the
990 && sym
->st_size
!= h
->size
)
992 /* Since we think we have two common symbols, issue a multiple
993 common warning if desired. Note that we only warn if the
994 size is different. If the size is the same, we simply let
995 the old symbol override the new one as normally happens with
996 symbols defined in dynamic objects. */
998 if (! ((*info
->callbacks
->multiple_common
)
999 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
1000 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1003 if (sym
->st_size
> h
->size
)
1004 h
->size
= sym
->st_size
;
1006 *size_change_ok
= TRUE
;
1009 /* If we are looking at a dynamic object, and we have found a
1010 definition, we need to see if the symbol was already defined by
1011 some other object. If so, we want to use the existing
1012 definition, and we do not want to report a multiple symbol
1013 definition error; we do this by clobbering *PSEC to be
1014 bfd_und_section_ptr.
1016 We treat a common symbol as a definition if the symbol in the
1017 shared library is a function, since common symbols always
1018 represent variables; this can cause confusion in principle, but
1019 any such confusion would seem to indicate an erroneous program or
1020 shared library. We also permit a common symbol in a regular
1021 object to override a weak symbol in a shared object.
1023 We prefer a non-weak definition in a shared library to a weak
1024 definition in the executable unless it comes from a DT_NEEDED
1025 entry of a shared object, in which case, the DT_NEEDED entry
1026 may not be required at the run time. */
1031 || (h
->root
.type
== bfd_link_hash_common
1034 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)))
1042 newdyncommon
= FALSE
;
1044 *psec
= sec
= bfd_und_section_ptr
;
1045 *size_change_ok
= TRUE
;
1047 /* If we get here when the old symbol is a common symbol, then
1048 we are explicitly letting it override a weak symbol or
1049 function in a dynamic object, and we don't want to warn about
1050 a type change. If the old symbol is a defined symbol, a type
1051 change warning may still be appropriate. */
1053 if (h
->root
.type
== bfd_link_hash_common
)
1054 *type_change_ok
= TRUE
;
1057 /* Handle the special case of an old common symbol merging with a
1058 new symbol which looks like a common symbol in a shared object.
1059 We change *PSEC and *PVALUE to make the new symbol look like a
1060 common symbol, and let _bfd_generic_link_add_one_symbol will do
1064 && h
->root
.type
== bfd_link_hash_common
)
1068 newdyncommon
= FALSE
;
1069 *pvalue
= sym
->st_size
;
1070 *psec
= sec
= bfd_com_section_ptr
;
1071 *size_change_ok
= TRUE
;
1074 /* If the old symbol is from a dynamic object, and the new symbol is
1075 a definition which is not from a dynamic object, then the new
1076 symbol overrides the old symbol. Symbols from regular files
1077 always take precedence over symbols from dynamic objects, even if
1078 they are defined after the dynamic object in the link.
1080 As above, we again permit a common symbol in a regular object to
1081 override a definition in a shared object if the shared object
1082 symbol is a function or is weak.
1084 As above, we permit a non-weak definition in a shared object to
1085 override a weak definition in a regular object. */
1090 || (bfd_is_com_section (sec
)
1091 && (oldweakdef
|| h
->type
== STT_FUNC
)))
1094 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1095 && ((!newweakdef
&& !newweakundef
) || oldweakdef
))
1097 /* Change the hash table entry to undefined, and let
1098 _bfd_generic_link_add_one_symbol do the right thing with the
1101 h
->root
.type
= bfd_link_hash_undefined
;
1102 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1103 *size_change_ok
= TRUE
;
1106 olddyncommon
= FALSE
;
1108 /* We again permit a type change when a common symbol may be
1109 overriding a function. */
1111 if (bfd_is_com_section (sec
))
1112 *type_change_ok
= TRUE
;
1114 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1117 /* This union may have been set to be non-NULL when this symbol
1118 was seen in a dynamic object. We must force the union to be
1119 NULL, so that it is correct for a regular symbol. */
1120 h
->verinfo
.vertree
= NULL
;
1123 /* Handle the special case of a new common symbol merging with an
1124 old symbol that looks like it might be a common symbol defined in
1125 a shared object. Note that we have already handled the case in
1126 which a new common symbol should simply override the definition
1127 in the shared library. */
1130 && bfd_is_com_section (sec
)
1133 /* It would be best if we could set the hash table entry to a
1134 common symbol, but we don't know what to use for the section
1135 or the alignment. */
1136 if (! ((*info
->callbacks
->multiple_common
)
1137 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
1138 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1141 /* If the predumed common symbol in the dynamic object is
1142 larger, pretend that the new symbol has its size. */
1144 if (h
->size
> *pvalue
)
1147 /* FIXME: We no longer know the alignment required by the symbol
1148 in the dynamic object, so we just wind up using the one from
1149 the regular object. */
1152 olddyncommon
= FALSE
;
1154 h
->root
.type
= bfd_link_hash_undefined
;
1155 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1157 *size_change_ok
= TRUE
;
1158 *type_change_ok
= TRUE
;
1160 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1163 h
->verinfo
.vertree
= NULL
;
1168 /* Handle the case where we had a versioned symbol in a dynamic
1169 library and now find a definition in a normal object. In this
1170 case, we make the versioned symbol point to the normal one. */
1171 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1172 flip
->root
.type
= h
->root
.type
;
1173 h
->root
.type
= bfd_link_hash_indirect
;
1174 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1175 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, flip
, h
);
1176 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1177 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1179 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_DEF_DYNAMIC
;
1180 flip
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1184 /* Handle the special case of a weak definition in a regular object
1185 followed by a non-weak definition in a shared object. In this
1186 case, we prefer the definition in the shared object unless it
1187 comes from a DT_NEEDED entry of a shared object, in which case,
1188 the DT_NEEDED entry may not be required at the run time. */
1197 /* To make this work we have to frob the flags so that the rest
1198 of the code does not think we are using the regular
1200 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1201 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1202 else if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
1203 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1204 h
->elf_link_hash_flags
&= ~ (ELF_LINK_HASH_DEF_REGULAR
1205 | ELF_LINK_HASH_DEF_DYNAMIC
);
1207 /* If H is the target of an indirection, we want the caller to
1208 use H rather than the indirect symbol. Otherwise if we are
1209 defining a new indirect symbol we will wind up attaching it
1210 to the entry we are overriding. */
1214 /* Handle the special case of a non-weak definition in a shared
1215 object followed by a weak definition in a regular object. In
1216 this case we prefer the definition in the shared object. To make
1217 this work we have to tell the caller to not treat the new symbol
1224 && (newweakdef
|| newweakundef
))
1230 /* This function is called to create an indirect symbol from the
1231 default for the symbol with the default version if needed. The
1232 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1233 set DYNSYM if the new indirect symbol is dynamic. DT_NEEDED
1234 indicates if it comes from a DT_NEEDED entry of a shared object. */
1237 _bfd_elf_add_default_symbol (bfd
*abfd
,
1238 struct bfd_link_info
*info
,
1239 struct elf_link_hash_entry
*h
,
1241 Elf_Internal_Sym
*sym
,
1244 bfd_boolean
*dynsym
,
1245 bfd_boolean override
,
1246 bfd_boolean dt_needed
)
1248 bfd_boolean type_change_ok
;
1249 bfd_boolean size_change_ok
;
1252 struct elf_link_hash_entry
*hi
;
1253 struct bfd_link_hash_entry
*bh
;
1254 const struct elf_backend_data
*bed
;
1255 bfd_boolean collect
;
1256 bfd_boolean dynamic
;
1258 size_t len
, shortlen
;
1261 /* If this symbol has a version, and it is the default version, we
1262 create an indirect symbol from the default name to the fully
1263 decorated name. This will cause external references which do not
1264 specify a version to be bound to this version of the symbol. */
1265 p
= strchr (name
, ELF_VER_CHR
);
1266 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1271 /* We are overridden by an old defition. We need to check if we
1272 need to create the indirect symbol from the default name. */
1273 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1275 BFD_ASSERT (hi
!= NULL
);
1278 while (hi
->root
.type
== bfd_link_hash_indirect
1279 || hi
->root
.type
== bfd_link_hash_warning
)
1281 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1287 bed
= get_elf_backend_data (abfd
);
1288 collect
= bed
->collect
;
1289 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1291 shortlen
= p
- name
;
1292 shortname
= bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1293 if (shortname
== NULL
)
1295 memcpy (shortname
, name
, shortlen
);
1296 shortname
[shortlen
] = '\0';
1298 /* We are going to create a new symbol. Merge it with any existing
1299 symbol with this name. For the purposes of the merge, act as
1300 though we were defining the symbol we just defined, although we
1301 actually going to define an indirect symbol. */
1302 type_change_ok
= FALSE
;
1303 size_change_ok
= FALSE
;
1305 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1306 &hi
, &skip
, &override
, &type_change_ok
,
1307 &size_change_ok
, dt_needed
))
1316 if (! (_bfd_generic_link_add_one_symbol
1317 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1318 0, name
, FALSE
, collect
, &bh
)))
1320 hi
= (struct elf_link_hash_entry
*) bh
;
1324 /* In this case the symbol named SHORTNAME is overriding the
1325 indirect symbol we want to add. We were planning on making
1326 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1327 is the name without a version. NAME is the fully versioned
1328 name, and it is the default version.
1330 Overriding means that we already saw a definition for the
1331 symbol SHORTNAME in a regular object, and it is overriding
1332 the symbol defined in the dynamic object.
1334 When this happens, we actually want to change NAME, the
1335 symbol we just added, to refer to SHORTNAME. This will cause
1336 references to NAME in the shared object to become references
1337 to SHORTNAME in the regular object. This is what we expect
1338 when we override a function in a shared object: that the
1339 references in the shared object will be mapped to the
1340 definition in the regular object. */
1342 while (hi
->root
.type
== bfd_link_hash_indirect
1343 || hi
->root
.type
== bfd_link_hash_warning
)
1344 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1346 h
->root
.type
= bfd_link_hash_indirect
;
1347 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1348 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1350 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEF_DYNAMIC
;
1351 hi
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1352 if (hi
->elf_link_hash_flags
1353 & (ELF_LINK_HASH_REF_REGULAR
1354 | ELF_LINK_HASH_DEF_REGULAR
))
1356 if (! _bfd_elf_link_record_dynamic_symbol (info
, hi
))
1361 /* Now set HI to H, so that the following code will set the
1362 other fields correctly. */
1366 /* If there is a duplicate definition somewhere, then HI may not
1367 point to an indirect symbol. We will have reported an error to
1368 the user in that case. */
1370 if (hi
->root
.type
== bfd_link_hash_indirect
)
1372 struct elf_link_hash_entry
*ht
;
1374 /* If the symbol became indirect, then we assume that we have
1375 not seen a definition before. */
1376 BFD_ASSERT ((hi
->elf_link_hash_flags
1377 & (ELF_LINK_HASH_DEF_DYNAMIC
1378 | ELF_LINK_HASH_DEF_REGULAR
)) == 0);
1380 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1381 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, ht
, hi
);
1383 /* See if the new flags lead us to realize that the symbol must
1390 || ((hi
->elf_link_hash_flags
1391 & ELF_LINK_HASH_REF_DYNAMIC
) != 0))
1396 if ((hi
->elf_link_hash_flags
1397 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1403 /* We also need to define an indirection from the nondefault version
1407 len
= strlen (name
);
1408 shortname
= bfd_hash_allocate (&info
->hash
->table
, len
);
1409 if (shortname
== NULL
)
1411 memcpy (shortname
, name
, shortlen
);
1412 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1414 /* Once again, merge with any existing symbol. */
1415 type_change_ok
= FALSE
;
1416 size_change_ok
= FALSE
;
1418 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1419 &hi
, &skip
, &override
, &type_change_ok
,
1420 &size_change_ok
, dt_needed
))
1428 /* Here SHORTNAME is a versioned name, so we don't expect to see
1429 the type of override we do in the case above unless it is
1430 overridden by a versioned definiton. */
1431 if (hi
->root
.type
!= bfd_link_hash_defined
1432 && hi
->root
.type
!= bfd_link_hash_defweak
)
1433 (*_bfd_error_handler
)
1434 (_("%s: warning: unexpected redefinition of indirect versioned symbol `%s'"),
1435 bfd_archive_filename (abfd
), shortname
);
1440 if (! (_bfd_generic_link_add_one_symbol
1441 (info
, abfd
, shortname
, BSF_INDIRECT
,
1442 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1444 hi
= (struct elf_link_hash_entry
*) bh
;
1446 /* If there is a duplicate definition somewhere, then HI may not
1447 point to an indirect symbol. We will have reported an error
1448 to the user in that case. */
1450 if (hi
->root
.type
== bfd_link_hash_indirect
)
1452 /* If the symbol became indirect, then we assume that we have
1453 not seen a definition before. */
1454 BFD_ASSERT ((hi
->elf_link_hash_flags
1455 & (ELF_LINK_HASH_DEF_DYNAMIC
1456 | ELF_LINK_HASH_DEF_REGULAR
)) == 0);
1458 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, h
, hi
);
1460 /* See if the new flags lead us to realize that the symbol
1467 || ((hi
->elf_link_hash_flags
1468 & ELF_LINK_HASH_REF_DYNAMIC
) != 0))
1473 if ((hi
->elf_link_hash_flags
1474 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1484 /* This routine is used to export all defined symbols into the dynamic
1485 symbol table. It is called via elf_link_hash_traverse. */
1488 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1490 struct elf_info_failed
*eif
= data
;
1492 /* Ignore indirect symbols. These are added by the versioning code. */
1493 if (h
->root
.type
== bfd_link_hash_indirect
)
1496 if (h
->root
.type
== bfd_link_hash_warning
)
1497 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1499 if (h
->dynindx
== -1
1500 && (h
->elf_link_hash_flags
1501 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1503 struct bfd_elf_version_tree
*t
;
1504 struct bfd_elf_version_expr
*d
;
1506 for (t
= eif
->verdefs
; t
!= NULL
; t
= t
->next
)
1508 if (t
->globals
.list
!= NULL
)
1510 d
= (*t
->match
) (&t
->globals
, NULL
, h
->root
.root
.string
);
1515 if (t
->locals
.list
!= NULL
)
1517 d
= (*t
->match
) (&t
->locals
, NULL
, h
->root
.root
.string
);
1526 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1537 /* Look through the symbols which are defined in other shared
1538 libraries and referenced here. Update the list of version
1539 dependencies. This will be put into the .gnu.version_r section.
1540 This function is called via elf_link_hash_traverse. */
1543 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1546 struct elf_find_verdep_info
*rinfo
= data
;
1547 Elf_Internal_Verneed
*t
;
1548 Elf_Internal_Vernaux
*a
;
1551 if (h
->root
.type
== bfd_link_hash_warning
)
1552 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1554 /* We only care about symbols defined in shared objects with version
1556 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1557 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1559 || h
->verinfo
.verdef
== NULL
)
1562 /* See if we already know about this version. */
1563 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1565 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1568 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1569 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1575 /* This is a new version. Add it to tree we are building. */
1580 t
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1583 rinfo
->failed
= TRUE
;
1587 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1588 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
1589 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
1593 a
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1595 /* Note that we are copying a string pointer here, and testing it
1596 above. If bfd_elf_string_from_elf_section is ever changed to
1597 discard the string data when low in memory, this will have to be
1599 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1601 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1602 a
->vna_nextptr
= t
->vn_auxptr
;
1604 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1607 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1614 /* Figure out appropriate versions for all the symbols. We may not
1615 have the version number script until we have read all of the input
1616 files, so until that point we don't know which symbols should be
1617 local. This function is called via elf_link_hash_traverse. */
1620 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1622 struct elf_assign_sym_version_info
*sinfo
;
1623 struct bfd_link_info
*info
;
1624 const struct elf_backend_data
*bed
;
1625 struct elf_info_failed eif
;
1632 if (h
->root
.type
== bfd_link_hash_warning
)
1633 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1635 /* Fix the symbol flags. */
1638 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1641 sinfo
->failed
= TRUE
;
1645 /* We only need version numbers for symbols defined in regular
1647 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1650 bed
= get_elf_backend_data (sinfo
->output_bfd
);
1651 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1652 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1654 struct bfd_elf_version_tree
*t
;
1659 /* There are two consecutive ELF_VER_CHR characters if this is
1660 not a hidden symbol. */
1662 if (*p
== ELF_VER_CHR
)
1668 /* If there is no version string, we can just return out. */
1672 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1676 /* Look for the version. If we find it, it is no longer weak. */
1677 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1679 if (strcmp (t
->name
, p
) == 0)
1683 struct bfd_elf_version_expr
*d
;
1685 len
= p
- h
->root
.root
.string
;
1686 alc
= bfd_malloc (len
);
1689 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1690 alc
[len
- 1] = '\0';
1691 if (alc
[len
- 2] == ELF_VER_CHR
)
1692 alc
[len
- 2] = '\0';
1694 h
->verinfo
.vertree
= t
;
1698 if (t
->globals
.list
!= NULL
)
1699 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
1701 /* See if there is anything to force this symbol to
1703 if (d
== NULL
&& t
->locals
.list
!= NULL
)
1705 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
1709 && ! info
->export_dynamic
)
1710 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1718 /* If we are building an application, we need to create a
1719 version node for this version. */
1720 if (t
== NULL
&& info
->executable
)
1722 struct bfd_elf_version_tree
**pp
;
1725 /* If we aren't going to export this symbol, we don't need
1726 to worry about it. */
1727 if (h
->dynindx
== -1)
1731 t
= bfd_zalloc (sinfo
->output_bfd
, amt
);
1734 sinfo
->failed
= TRUE
;
1739 t
->name_indx
= (unsigned int) -1;
1743 /* Don't count anonymous version tag. */
1744 if (sinfo
->verdefs
!= NULL
&& sinfo
->verdefs
->vernum
== 0)
1746 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1748 t
->vernum
= version_index
;
1752 h
->verinfo
.vertree
= t
;
1756 /* We could not find the version for a symbol when
1757 generating a shared archive. Return an error. */
1758 (*_bfd_error_handler
)
1759 (_("%s: undefined versioned symbol name %s"),
1760 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
1761 bfd_set_error (bfd_error_bad_value
);
1762 sinfo
->failed
= TRUE
;
1767 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1770 /* If we don't have a version for this symbol, see if we can find
1772 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
1774 struct bfd_elf_version_tree
*t
;
1775 struct bfd_elf_version_tree
*local_ver
;
1776 struct bfd_elf_version_expr
*d
;
1778 /* See if can find what version this symbol is in. If the
1779 symbol is supposed to be local, then don't actually register
1782 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1784 if (t
->globals
.list
!= NULL
)
1786 bfd_boolean matched
;
1790 while ((d
= (*t
->match
) (&t
->globals
, d
,
1791 h
->root
.root
.string
)) != NULL
)
1796 /* There is a version without definition. Make
1797 the symbol the default definition for this
1799 h
->verinfo
.vertree
= t
;
1807 /* There is no undefined version for this symbol. Hide the
1809 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1812 if (t
->locals
.list
!= NULL
)
1815 while ((d
= (*t
->match
) (&t
->locals
, d
,
1816 h
->root
.root
.string
)) != NULL
)
1819 /* If the match is "*", keep looking for a more
1820 explicit, perhaps even global, match.
1821 XXX: Shouldn't this be !d->wildcard instead? */
1822 if (d
->pattern
[0] != '*' || d
->pattern
[1] != '\0')
1831 if (local_ver
!= NULL
)
1833 h
->verinfo
.vertree
= local_ver
;
1834 if (h
->dynindx
!= -1
1836 && ! info
->export_dynamic
)
1838 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1846 /* Read and swap the relocs from the section indicated by SHDR. This
1847 may be either a REL or a RELA section. The relocations are
1848 translated into RELA relocations and stored in INTERNAL_RELOCS,
1849 which should have already been allocated to contain enough space.
1850 The EXTERNAL_RELOCS are a buffer where the external form of the
1851 relocations should be stored.
1853 Returns FALSE if something goes wrong. */
1856 elf_link_read_relocs_from_section (bfd
*abfd
,
1858 Elf_Internal_Shdr
*shdr
,
1859 void *external_relocs
,
1860 Elf_Internal_Rela
*internal_relocs
)
1862 const struct elf_backend_data
*bed
;
1863 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
1864 const bfd_byte
*erela
;
1865 const bfd_byte
*erelaend
;
1866 Elf_Internal_Rela
*irela
;
1867 Elf_Internal_Shdr
*symtab_hdr
;
1870 /* If there aren't any relocations, that's OK. */
1874 /* Position ourselves at the start of the section. */
1875 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
1878 /* Read the relocations. */
1879 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
1882 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1883 nsyms
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
1885 bed
= get_elf_backend_data (abfd
);
1887 /* Convert the external relocations to the internal format. */
1888 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
1889 swap_in
= bed
->s
->swap_reloc_in
;
1890 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
1891 swap_in
= bed
->s
->swap_reloca_in
;
1894 bfd_set_error (bfd_error_wrong_format
);
1898 erela
= external_relocs
;
1899 erelaend
= erela
+ NUM_SHDR_ENTRIES (shdr
) * shdr
->sh_entsize
;
1900 irela
= internal_relocs
;
1901 while (erela
< erelaend
)
1905 (*swap_in
) (abfd
, erela
, irela
);
1906 r_symndx
= ELF32_R_SYM (irela
->r_info
);
1907 if (bed
->s
->arch_size
== 64)
1909 if ((size_t) r_symndx
>= nsyms
)
1911 (*_bfd_error_handler
)
1912 (_("%s: bad reloc symbol index (0x%lx >= 0x%lx) for offset 0x%lx in section `%s'"),
1913 bfd_archive_filename (abfd
), (unsigned long) r_symndx
,
1914 (unsigned long) nsyms
, irela
->r_offset
, sec
->name
);
1915 bfd_set_error (bfd_error_bad_value
);
1918 irela
+= bed
->s
->int_rels_per_ext_rel
;
1919 erela
+= shdr
->sh_entsize
;
1925 /* Read and swap the relocs for a section O. They may have been
1926 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
1927 not NULL, they are used as buffers to read into. They are known to
1928 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
1929 the return value is allocated using either malloc or bfd_alloc,
1930 according to the KEEP_MEMORY argument. If O has two relocation
1931 sections (both REL and RELA relocations), then the REL_HDR
1932 relocations will appear first in INTERNAL_RELOCS, followed by the
1933 REL_HDR2 relocations. */
1936 _bfd_elf_link_read_relocs (bfd
*abfd
,
1938 void *external_relocs
,
1939 Elf_Internal_Rela
*internal_relocs
,
1940 bfd_boolean keep_memory
)
1942 Elf_Internal_Shdr
*rel_hdr
;
1943 void *alloc1
= NULL
;
1944 Elf_Internal_Rela
*alloc2
= NULL
;
1945 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1947 if (elf_section_data (o
)->relocs
!= NULL
)
1948 return elf_section_data (o
)->relocs
;
1950 if (o
->reloc_count
== 0)
1953 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1955 if (internal_relocs
== NULL
)
1959 size
= o
->reloc_count
;
1960 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
1962 internal_relocs
= bfd_alloc (abfd
, size
);
1964 internal_relocs
= alloc2
= bfd_malloc (size
);
1965 if (internal_relocs
== NULL
)
1969 if (external_relocs
== NULL
)
1971 bfd_size_type size
= rel_hdr
->sh_size
;
1973 if (elf_section_data (o
)->rel_hdr2
)
1974 size
+= elf_section_data (o
)->rel_hdr2
->sh_size
;
1975 alloc1
= bfd_malloc (size
);
1978 external_relocs
= alloc1
;
1981 if (!elf_link_read_relocs_from_section (abfd
, o
, rel_hdr
,
1985 if (!elf_link_read_relocs_from_section
1987 elf_section_data (o
)->rel_hdr2
,
1988 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
1989 internal_relocs
+ (NUM_SHDR_ENTRIES (rel_hdr
)
1990 * bed
->s
->int_rels_per_ext_rel
)))
1993 /* Cache the results for next time, if we can. */
1995 elf_section_data (o
)->relocs
= internal_relocs
;
2000 /* Don't free alloc2, since if it was allocated we are passing it
2001 back (under the name of internal_relocs). */
2003 return internal_relocs
;
2013 /* Compute the size of, and allocate space for, REL_HDR which is the
2014 section header for a section containing relocations for O. */
2017 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2018 Elf_Internal_Shdr
*rel_hdr
,
2021 bfd_size_type reloc_count
;
2022 bfd_size_type num_rel_hashes
;
2024 /* Figure out how many relocations there will be. */
2025 if (rel_hdr
== &elf_section_data (o
)->rel_hdr
)
2026 reloc_count
= elf_section_data (o
)->rel_count
;
2028 reloc_count
= elf_section_data (o
)->rel_count2
;
2030 num_rel_hashes
= o
->reloc_count
;
2031 if (num_rel_hashes
< reloc_count
)
2032 num_rel_hashes
= reloc_count
;
2034 /* That allows us to calculate the size of the section. */
2035 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reloc_count
;
2037 /* The contents field must last into write_object_contents, so we
2038 allocate it with bfd_alloc rather than malloc. Also since we
2039 cannot be sure that the contents will actually be filled in,
2040 we zero the allocated space. */
2041 rel_hdr
->contents
= bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2042 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2045 /* We only allocate one set of hash entries, so we only do it the
2046 first time we are called. */
2047 if (elf_section_data (o
)->rel_hashes
== NULL
2050 struct elf_link_hash_entry
**p
;
2052 p
= bfd_zmalloc (num_rel_hashes
* sizeof (struct elf_link_hash_entry
*));
2056 elf_section_data (o
)->rel_hashes
= p
;
2062 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2063 originated from the section given by INPUT_REL_HDR) to the
2067 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2068 asection
*input_section
,
2069 Elf_Internal_Shdr
*input_rel_hdr
,
2070 Elf_Internal_Rela
*internal_relocs
)
2072 Elf_Internal_Rela
*irela
;
2073 Elf_Internal_Rela
*irelaend
;
2075 Elf_Internal_Shdr
*output_rel_hdr
;
2076 asection
*output_section
;
2077 unsigned int *rel_countp
= NULL
;
2078 const struct elf_backend_data
*bed
;
2079 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2081 output_section
= input_section
->output_section
;
2082 output_rel_hdr
= NULL
;
2084 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
2085 == input_rel_hdr
->sh_entsize
)
2087 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
2088 rel_countp
= &elf_section_data (output_section
)->rel_count
;
2090 else if (elf_section_data (output_section
)->rel_hdr2
2091 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
2092 == input_rel_hdr
->sh_entsize
))
2094 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
2095 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
2099 (*_bfd_error_handler
)
2100 (_("%s: relocation size mismatch in %s section %s"),
2101 bfd_get_filename (output_bfd
),
2102 bfd_archive_filename (input_section
->owner
),
2103 input_section
->name
);
2104 bfd_set_error (bfd_error_wrong_object_format
);
2108 bed
= get_elf_backend_data (output_bfd
);
2109 if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2110 swap_out
= bed
->s
->swap_reloc_out
;
2111 else if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2112 swap_out
= bed
->s
->swap_reloca_out
;
2116 erel
= output_rel_hdr
->contents
;
2117 erel
+= *rel_countp
* input_rel_hdr
->sh_entsize
;
2118 irela
= internal_relocs
;
2119 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2120 * bed
->s
->int_rels_per_ext_rel
);
2121 while (irela
< irelaend
)
2123 (*swap_out
) (output_bfd
, irela
, erel
);
2124 irela
+= bed
->s
->int_rels_per_ext_rel
;
2125 erel
+= input_rel_hdr
->sh_entsize
;
2128 /* Bump the counter, so that we know where to add the next set of
2130 *rel_countp
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2135 /* Fix up the flags for a symbol. This handles various cases which
2136 can only be fixed after all the input files are seen. This is
2137 currently called by both adjust_dynamic_symbol and
2138 assign_sym_version, which is unnecessary but perhaps more robust in
2139 the face of future changes. */
2142 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2143 struct elf_info_failed
*eif
)
2145 /* If this symbol was mentioned in a non-ELF file, try to set
2146 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2147 permit a non-ELF file to correctly refer to a symbol defined in
2148 an ELF dynamic object. */
2149 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
2151 while (h
->root
.type
== bfd_link_hash_indirect
)
2152 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2154 if (h
->root
.type
!= bfd_link_hash_defined
2155 && h
->root
.type
!= bfd_link_hash_defweak
)
2156 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2157 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2160 if (h
->root
.u
.def
.section
->owner
!= NULL
2161 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2162 == bfd_target_elf_flavour
))
2163 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2164 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2166 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2169 if (h
->dynindx
== -1
2170 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2171 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
2173 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2182 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
2183 was first seen in a non-ELF file. Fortunately, if the symbol
2184 was first seen in an ELF file, we're probably OK unless the
2185 symbol was defined in a non-ELF file. Catch that case here.
2186 FIXME: We're still in trouble if the symbol was first seen in
2187 a dynamic object, and then later in a non-ELF regular object. */
2188 if ((h
->root
.type
== bfd_link_hash_defined
2189 || h
->root
.type
== bfd_link_hash_defweak
)
2190 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2191 && (h
->root
.u
.def
.section
->owner
!= NULL
2192 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2193 != bfd_target_elf_flavour
)
2194 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2195 && (h
->elf_link_hash_flags
2196 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
2197 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2200 /* If this is a final link, and the symbol was defined as a common
2201 symbol in a regular object file, and there was no definition in
2202 any dynamic object, then the linker will have allocated space for
2203 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
2204 flag will not have been set. */
2205 if (h
->root
.type
== bfd_link_hash_defined
2206 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2207 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
2208 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2209 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2210 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2212 /* If -Bsymbolic was used (which means to bind references to global
2213 symbols to the definition within the shared object), and this
2214 symbol was defined in a regular object, then it actually doesn't
2215 need a PLT entry. Likewise, if the symbol has non-default
2216 visibility. If the symbol has hidden or internal visibility, we
2217 will force it local. */
2218 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
2219 && eif
->info
->shared
2220 && is_elf_hash_table (eif
->info
)
2221 && (eif
->info
->symbolic
2222 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2223 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2225 const struct elf_backend_data
*bed
;
2226 bfd_boolean force_local
;
2228 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2230 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2231 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2232 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2235 /* If a weak undefined symbol has non-default visibility, we also
2236 hide it from the dynamic linker. */
2237 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2238 && h
->root
.type
== bfd_link_hash_undefweak
)
2240 const struct elf_backend_data
*bed
;
2241 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2242 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2245 /* If this is a weak defined symbol in a dynamic object, and we know
2246 the real definition in the dynamic object, copy interesting flags
2247 over to the real definition. */
2248 if (h
->weakdef
!= NULL
)
2250 struct elf_link_hash_entry
*weakdef
;
2252 weakdef
= h
->weakdef
;
2253 if (h
->root
.type
== bfd_link_hash_indirect
)
2254 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2256 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2257 || h
->root
.type
== bfd_link_hash_defweak
);
2258 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2259 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2260 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
2262 /* If the real definition is defined by a regular object file,
2263 don't do anything special. See the longer description in
2264 _bfd_elf_adjust_dynamic_symbol, below. */
2265 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2269 const struct elf_backend_data
*bed
;
2271 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2272 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, weakdef
, h
);
2279 /* Make the backend pick a good value for a dynamic symbol. This is
2280 called via elf_link_hash_traverse, and also calls itself
2284 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2286 struct elf_info_failed
*eif
= data
;
2288 const struct elf_backend_data
*bed
;
2290 if (! is_elf_hash_table (eif
->info
))
2293 if (h
->root
.type
== bfd_link_hash_warning
)
2295 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2296 h
->got
= elf_hash_table (eif
->info
)->init_offset
;
2298 /* When warning symbols are created, they **replace** the "real"
2299 entry in the hash table, thus we never get to see the real
2300 symbol in a hash traversal. So look at it now. */
2301 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2304 /* Ignore indirect symbols. These are added by the versioning code. */
2305 if (h
->root
.type
== bfd_link_hash_indirect
)
2308 /* Fix the symbol flags. */
2309 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2312 /* If this symbol does not require a PLT entry, and it is not
2313 defined by a dynamic object, or is not referenced by a regular
2314 object, ignore it. We do have to handle a weak defined symbol,
2315 even if no regular object refers to it, if we decided to add it
2316 to the dynamic symbol table. FIXME: Do we normally need to worry
2317 about symbols which are defined by one dynamic object and
2318 referenced by another one? */
2319 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
2320 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2321 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2322 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
2323 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
2325 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2329 /* If we've already adjusted this symbol, don't do it again. This
2330 can happen via a recursive call. */
2331 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
2334 /* Don't look at this symbol again. Note that we must set this
2335 after checking the above conditions, because we may look at a
2336 symbol once, decide not to do anything, and then get called
2337 recursively later after REF_REGULAR is set below. */
2338 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
2340 /* If this is a weak definition, and we know a real definition, and
2341 the real symbol is not itself defined by a regular object file,
2342 then get a good value for the real definition. We handle the
2343 real symbol first, for the convenience of the backend routine.
2345 Note that there is a confusing case here. If the real definition
2346 is defined by a regular object file, we don't get the real symbol
2347 from the dynamic object, but we do get the weak symbol. If the
2348 processor backend uses a COPY reloc, then if some routine in the
2349 dynamic object changes the real symbol, we will not see that
2350 change in the corresponding weak symbol. This is the way other
2351 ELF linkers work as well, and seems to be a result of the shared
2354 I will clarify this issue. Most SVR4 shared libraries define the
2355 variable _timezone and define timezone as a weak synonym. The
2356 tzset call changes _timezone. If you write
2357 extern int timezone;
2359 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2360 you might expect that, since timezone is a synonym for _timezone,
2361 the same number will print both times. However, if the processor
2362 backend uses a COPY reloc, then actually timezone will be copied
2363 into your process image, and, since you define _timezone
2364 yourself, _timezone will not. Thus timezone and _timezone will
2365 wind up at different memory locations. The tzset call will set
2366 _timezone, leaving timezone unchanged. */
2368 if (h
->weakdef
!= NULL
)
2370 /* If we get to this point, we know there is an implicit
2371 reference by a regular object file via the weak symbol H.
2372 FIXME: Is this really true? What if the traversal finds
2373 H->WEAKDEF before it finds H? */
2374 h
->weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2376 if (! _bfd_elf_adjust_dynamic_symbol (h
->weakdef
, eif
))
2380 /* If a symbol has no type and no size and does not require a PLT
2381 entry, then we are probably about to do the wrong thing here: we
2382 are probably going to create a COPY reloc for an empty object.
2383 This case can arise when a shared object is built with assembly
2384 code, and the assembly code fails to set the symbol type. */
2386 && h
->type
== STT_NOTYPE
2387 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
2388 (*_bfd_error_handler
)
2389 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2390 h
->root
.root
.string
);
2392 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2393 bed
= get_elf_backend_data (dynobj
);
2394 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2403 /* Adjust all external symbols pointing into SEC_MERGE sections
2404 to reflect the object merging within the sections. */
2407 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2411 if (h
->root
.type
== bfd_link_hash_warning
)
2412 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2414 if ((h
->root
.type
== bfd_link_hash_defined
2415 || h
->root
.type
== bfd_link_hash_defweak
)
2416 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2417 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2419 bfd
*output_bfd
= data
;
2421 h
->root
.u
.def
.value
=
2422 _bfd_merged_section_offset (output_bfd
,
2423 &h
->root
.u
.def
.section
,
2424 elf_section_data (sec
)->sec_info
,
2425 h
->root
.u
.def
.value
, 0);
2431 /* Returns false if the symbol referred to by H should be considered
2432 to resolve local to the current module, and true if it should be
2433 considered to bind dynamically. */
2436 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2437 struct bfd_link_info
*info
,
2438 bfd_boolean ignore_protected
)
2440 bfd_boolean binding_stays_local_p
;
2445 while (h
->root
.type
== bfd_link_hash_indirect
2446 || h
->root
.type
== bfd_link_hash_warning
)
2447 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2449 /* If it was forced local, then clearly it's not dynamic. */
2450 if (h
->dynindx
== -1)
2452 if (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)
2455 /* Identify the cases where name binding rules say that a
2456 visible symbol resolves locally. */
2457 binding_stays_local_p
= info
->executable
|| info
->symbolic
;
2459 switch (ELF_ST_VISIBILITY (h
->other
))
2466 /* Proper resolution for function pointer equality may require
2467 that these symbols perhaps be resolved dynamically, even though
2468 we should be resolving them to the current module. */
2469 if (!ignore_protected
)
2470 binding_stays_local_p
= TRUE
;
2477 /* If it isn't defined locally, then clearly it's dynamic. */
2478 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2481 /* Otherwise, the symbol is dynamic if binding rules don't tell
2482 us that it remains local. */
2483 return !binding_stays_local_p
;
2486 /* Return true if the symbol referred to by H should be considered
2487 to resolve local to the current module, and false otherwise. Differs
2488 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2489 undefined symbols and weak symbols. */
2492 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2493 struct bfd_link_info
*info
,
2494 bfd_boolean local_protected
)
2496 /* If it's a local sym, of course we resolve locally. */
2500 /* If we don't have a definition in a regular file, then we can't
2501 resolve locally. The sym is either undefined or dynamic. */
2502 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2505 /* Forced local symbols resolve locally. */
2506 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2509 /* As do non-dynamic symbols. */
2510 if (h
->dynindx
== -1)
2513 /* At this point, we know the symbol is defined and dynamic. In an
2514 executable it must resolve locally, likewise when building symbolic
2515 shared libraries. */
2516 if (info
->executable
|| info
->symbolic
)
2519 /* Now deal with defined dynamic symbols in shared libraries. Ones
2520 with default visibility might not resolve locally. */
2521 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2524 /* However, STV_HIDDEN or STV_INTERNAL ones must be local. */
2525 if (ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
)
2528 /* Function pointer equality tests may require that STV_PROTECTED
2529 symbols be treated as dynamic symbols, even when we know that the
2530 dynamic linker will resolve them locally. */
2531 return local_protected
;