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
!= NULL
)
1510 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
1512 if ((*d
->match
) (d
, h
->root
.root
.string
))
1517 if (t
->locals
!= NULL
)
1519 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
1521 if ((*d
->match
) (d
, h
->root
.root
.string
))
1530 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1541 /* Look through the symbols which are defined in other shared
1542 libraries and referenced here. Update the list of version
1543 dependencies. This will be put into the .gnu.version_r section.
1544 This function is called via elf_link_hash_traverse. */
1547 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1550 struct elf_find_verdep_info
*rinfo
= data
;
1551 Elf_Internal_Verneed
*t
;
1552 Elf_Internal_Vernaux
*a
;
1555 if (h
->root
.type
== bfd_link_hash_warning
)
1556 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1558 /* We only care about symbols defined in shared objects with version
1560 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1561 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1563 || h
->verinfo
.verdef
== NULL
)
1566 /* See if we already know about this version. */
1567 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1569 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1572 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1573 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1579 /* This is a new version. Add it to tree we are building. */
1584 t
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1587 rinfo
->failed
= TRUE
;
1591 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1592 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
1593 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
1597 a
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1599 /* Note that we are copying a string pointer here, and testing it
1600 above. If bfd_elf_string_from_elf_section is ever changed to
1601 discard the string data when low in memory, this will have to be
1603 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1605 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1606 a
->vna_nextptr
= t
->vn_auxptr
;
1608 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1611 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1618 /* Figure out appropriate versions for all the symbols. We may not
1619 have the version number script until we have read all of the input
1620 files, so until that point we don't know which symbols should be
1621 local. This function is called via elf_link_hash_traverse. */
1624 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1626 struct elf_assign_sym_version_info
*sinfo
;
1627 struct bfd_link_info
*info
;
1628 const struct elf_backend_data
*bed
;
1629 struct elf_info_failed eif
;
1636 if (h
->root
.type
== bfd_link_hash_warning
)
1637 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1639 /* Fix the symbol flags. */
1642 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1645 sinfo
->failed
= TRUE
;
1649 /* We only need version numbers for symbols defined in regular
1651 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1654 bed
= get_elf_backend_data (sinfo
->output_bfd
);
1655 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1656 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1658 struct bfd_elf_version_tree
*t
;
1663 /* There are two consecutive ELF_VER_CHR characters if this is
1664 not a hidden symbol. */
1666 if (*p
== ELF_VER_CHR
)
1672 /* If there is no version string, we can just return out. */
1676 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1680 /* Look for the version. If we find it, it is no longer weak. */
1681 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1683 if (strcmp (t
->name
, p
) == 0)
1687 struct bfd_elf_version_expr
*d
;
1689 len
= p
- h
->root
.root
.string
;
1690 alc
= bfd_malloc (len
);
1693 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1694 alc
[len
- 1] = '\0';
1695 if (alc
[len
- 2] == ELF_VER_CHR
)
1696 alc
[len
- 2] = '\0';
1698 h
->verinfo
.vertree
= t
;
1702 if (t
->globals
!= NULL
)
1704 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
1705 if ((*d
->match
) (d
, alc
))
1709 /* See if there is anything to force this symbol to
1711 if (d
== NULL
&& t
->locals
!= NULL
)
1713 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
1715 if ((*d
->match
) (d
, alc
))
1717 if (h
->dynindx
!= -1
1719 && ! info
->export_dynamic
)
1721 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1734 /* If we are building an application, we need to create a
1735 version node for this version. */
1736 if (t
== NULL
&& info
->executable
)
1738 struct bfd_elf_version_tree
**pp
;
1741 /* If we aren't going to export this symbol, we don't need
1742 to worry about it. */
1743 if (h
->dynindx
== -1)
1747 t
= bfd_alloc (sinfo
->output_bfd
, amt
);
1750 sinfo
->failed
= TRUE
;
1759 t
->name_indx
= (unsigned int) -1;
1763 /* Don't count anonymous version tag. */
1764 if (sinfo
->verdefs
!= NULL
&& sinfo
->verdefs
->vernum
== 0)
1766 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1768 t
->vernum
= version_index
;
1772 h
->verinfo
.vertree
= t
;
1776 /* We could not find the version for a symbol when
1777 generating a shared archive. Return an error. */
1778 (*_bfd_error_handler
)
1779 (_("%s: undefined versioned symbol name %s"),
1780 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
1781 bfd_set_error (bfd_error_bad_value
);
1782 sinfo
->failed
= TRUE
;
1787 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
1790 /* If we don't have a version for this symbol, see if we can find
1792 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
1794 struct bfd_elf_version_tree
*t
;
1795 struct bfd_elf_version_tree
*local_ver
;
1796 struct bfd_elf_version_expr
*d
;
1798 /* See if can find what version this symbol is in. If the
1799 symbol is supposed to be local, then don't actually register
1802 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1804 if (t
->globals
!= NULL
)
1806 bfd_boolean matched
;
1809 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
1811 if ((*d
->match
) (d
, h
->root
.root
.string
))
1817 /* There is a version without definition. Make
1818 the symbol the default definition for this
1820 h
->verinfo
.vertree
= t
;
1831 /* There is no undefined version for this symbol. Hide the
1833 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1836 if (t
->locals
!= NULL
)
1838 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
1840 /* If the match is "*", keep looking for a more
1841 explicit, perhaps even global, match. */
1842 if (d
->pattern
[0] == '*' && d
->pattern
[1] == '\0')
1844 else if ((*d
->match
) (d
, h
->root
.root
.string
))
1856 if (local_ver
!= NULL
)
1858 h
->verinfo
.vertree
= local_ver
;
1859 if (h
->dynindx
!= -1
1861 && ! info
->export_dynamic
)
1863 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1871 /* Read and swap the relocs from the section indicated by SHDR. This
1872 may be either a REL or a RELA section. The relocations are
1873 translated into RELA relocations and stored in INTERNAL_RELOCS,
1874 which should have already been allocated to contain enough space.
1875 The EXTERNAL_RELOCS are a buffer where the external form of the
1876 relocations should be stored.
1878 Returns FALSE if something goes wrong. */
1881 elf_link_read_relocs_from_section (bfd
*abfd
,
1883 Elf_Internal_Shdr
*shdr
,
1884 void *external_relocs
,
1885 Elf_Internal_Rela
*internal_relocs
)
1887 const struct elf_backend_data
*bed
;
1888 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
1889 const bfd_byte
*erela
;
1890 const bfd_byte
*erelaend
;
1891 Elf_Internal_Rela
*irela
;
1892 Elf_Internal_Shdr
*symtab_hdr
;
1895 /* If there aren't any relocations, that's OK. */
1899 /* Position ourselves at the start of the section. */
1900 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
1903 /* Read the relocations. */
1904 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
1907 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1908 nsyms
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
1910 bed
= get_elf_backend_data (abfd
);
1912 /* Convert the external relocations to the internal format. */
1913 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
1914 swap_in
= bed
->s
->swap_reloc_in
;
1915 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
1916 swap_in
= bed
->s
->swap_reloca_in
;
1919 bfd_set_error (bfd_error_wrong_format
);
1923 erela
= external_relocs
;
1924 erelaend
= erela
+ NUM_SHDR_ENTRIES (shdr
) * shdr
->sh_entsize
;
1925 irela
= internal_relocs
;
1926 while (erela
< erelaend
)
1930 (*swap_in
) (abfd
, erela
, irela
);
1931 r_symndx
= ELF32_R_SYM (irela
->r_info
);
1932 if (bed
->s
->arch_size
== 64)
1934 if ((size_t) r_symndx
>= nsyms
)
1936 (*_bfd_error_handler
)
1937 (_("%s: bad reloc symbol index (0x%lx >= 0x%lx) for offset 0x%lx in section `%s'"),
1938 bfd_archive_filename (abfd
), (unsigned long) r_symndx
,
1939 (unsigned long) nsyms
, irela
->r_offset
, sec
->name
);
1940 bfd_set_error (bfd_error_bad_value
);
1943 irela
+= bed
->s
->int_rels_per_ext_rel
;
1944 erela
+= shdr
->sh_entsize
;
1950 /* Read and swap the relocs for a section O. They may have been
1951 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
1952 not NULL, they are used as buffers to read into. They are known to
1953 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
1954 the return value is allocated using either malloc or bfd_alloc,
1955 according to the KEEP_MEMORY argument. If O has two relocation
1956 sections (both REL and RELA relocations), then the REL_HDR
1957 relocations will appear first in INTERNAL_RELOCS, followed by the
1958 REL_HDR2 relocations. */
1961 _bfd_elf_link_read_relocs (bfd
*abfd
,
1963 void *external_relocs
,
1964 Elf_Internal_Rela
*internal_relocs
,
1965 bfd_boolean keep_memory
)
1967 Elf_Internal_Shdr
*rel_hdr
;
1968 void *alloc1
= NULL
;
1969 Elf_Internal_Rela
*alloc2
= NULL
;
1970 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1972 if (elf_section_data (o
)->relocs
!= NULL
)
1973 return elf_section_data (o
)->relocs
;
1975 if (o
->reloc_count
== 0)
1978 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1980 if (internal_relocs
== NULL
)
1984 size
= o
->reloc_count
;
1985 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
1987 internal_relocs
= bfd_alloc (abfd
, size
);
1989 internal_relocs
= alloc2
= bfd_malloc (size
);
1990 if (internal_relocs
== NULL
)
1994 if (external_relocs
== NULL
)
1996 bfd_size_type size
= rel_hdr
->sh_size
;
1998 if (elf_section_data (o
)->rel_hdr2
)
1999 size
+= elf_section_data (o
)->rel_hdr2
->sh_size
;
2000 alloc1
= bfd_malloc (size
);
2003 external_relocs
= alloc1
;
2006 if (!elf_link_read_relocs_from_section (abfd
, o
, rel_hdr
,
2010 if (!elf_link_read_relocs_from_section
2012 elf_section_data (o
)->rel_hdr2
,
2013 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
2014 internal_relocs
+ (NUM_SHDR_ENTRIES (rel_hdr
)
2015 * bed
->s
->int_rels_per_ext_rel
)))
2018 /* Cache the results for next time, if we can. */
2020 elf_section_data (o
)->relocs
= internal_relocs
;
2025 /* Don't free alloc2, since if it was allocated we are passing it
2026 back (under the name of internal_relocs). */
2028 return internal_relocs
;
2038 /* Compute the size of, and allocate space for, REL_HDR which is the
2039 section header for a section containing relocations for O. */
2042 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2043 Elf_Internal_Shdr
*rel_hdr
,
2046 bfd_size_type reloc_count
;
2047 bfd_size_type num_rel_hashes
;
2049 /* Figure out how many relocations there will be. */
2050 if (rel_hdr
== &elf_section_data (o
)->rel_hdr
)
2051 reloc_count
= elf_section_data (o
)->rel_count
;
2053 reloc_count
= elf_section_data (o
)->rel_count2
;
2055 num_rel_hashes
= o
->reloc_count
;
2056 if (num_rel_hashes
< reloc_count
)
2057 num_rel_hashes
= reloc_count
;
2059 /* That allows us to calculate the size of the section. */
2060 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reloc_count
;
2062 /* The contents field must last into write_object_contents, so we
2063 allocate it with bfd_alloc rather than malloc. Also since we
2064 cannot be sure that the contents will actually be filled in,
2065 we zero the allocated space. */
2066 rel_hdr
->contents
= bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2067 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2070 /* We only allocate one set of hash entries, so we only do it the
2071 first time we are called. */
2072 if (elf_section_data (o
)->rel_hashes
== NULL
2075 struct elf_link_hash_entry
**p
;
2077 p
= bfd_zmalloc (num_rel_hashes
* sizeof (struct elf_link_hash_entry
*));
2081 elf_section_data (o
)->rel_hashes
= p
;
2087 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2088 originated from the section given by INPUT_REL_HDR) to the
2092 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2093 asection
*input_section
,
2094 Elf_Internal_Shdr
*input_rel_hdr
,
2095 Elf_Internal_Rela
*internal_relocs
)
2097 Elf_Internal_Rela
*irela
;
2098 Elf_Internal_Rela
*irelaend
;
2100 Elf_Internal_Shdr
*output_rel_hdr
;
2101 asection
*output_section
;
2102 unsigned int *rel_countp
= NULL
;
2103 const struct elf_backend_data
*bed
;
2104 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2106 output_section
= input_section
->output_section
;
2107 output_rel_hdr
= NULL
;
2109 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
2110 == input_rel_hdr
->sh_entsize
)
2112 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
2113 rel_countp
= &elf_section_data (output_section
)->rel_count
;
2115 else if (elf_section_data (output_section
)->rel_hdr2
2116 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
2117 == input_rel_hdr
->sh_entsize
))
2119 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
2120 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
2124 (*_bfd_error_handler
)
2125 (_("%s: relocation size mismatch in %s section %s"),
2126 bfd_get_filename (output_bfd
),
2127 bfd_archive_filename (input_section
->owner
),
2128 input_section
->name
);
2129 bfd_set_error (bfd_error_wrong_object_format
);
2133 bed
= get_elf_backend_data (output_bfd
);
2134 if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2135 swap_out
= bed
->s
->swap_reloc_out
;
2136 else if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2137 swap_out
= bed
->s
->swap_reloca_out
;
2141 erel
= output_rel_hdr
->contents
;
2142 erel
+= *rel_countp
* input_rel_hdr
->sh_entsize
;
2143 irela
= internal_relocs
;
2144 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2145 * bed
->s
->int_rels_per_ext_rel
);
2146 while (irela
< irelaend
)
2148 (*swap_out
) (output_bfd
, irela
, erel
);
2149 irela
+= bed
->s
->int_rels_per_ext_rel
;
2150 erel
+= input_rel_hdr
->sh_entsize
;
2153 /* Bump the counter, so that we know where to add the next set of
2155 *rel_countp
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2160 /* Fix up the flags for a symbol. This handles various cases which
2161 can only be fixed after all the input files are seen. This is
2162 currently called by both adjust_dynamic_symbol and
2163 assign_sym_version, which is unnecessary but perhaps more robust in
2164 the face of future changes. */
2167 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2168 struct elf_info_failed
*eif
)
2170 /* If this symbol was mentioned in a non-ELF file, try to set
2171 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2172 permit a non-ELF file to correctly refer to a symbol defined in
2173 an ELF dynamic object. */
2174 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
2176 while (h
->root
.type
== bfd_link_hash_indirect
)
2177 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2179 if (h
->root
.type
!= bfd_link_hash_defined
2180 && h
->root
.type
!= bfd_link_hash_defweak
)
2181 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2182 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2185 if (h
->root
.u
.def
.section
->owner
!= NULL
2186 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2187 == bfd_target_elf_flavour
))
2188 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
2189 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
2191 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2194 if (h
->dynindx
== -1
2195 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2196 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
2198 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2207 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
2208 was first seen in a non-ELF file. Fortunately, if the symbol
2209 was first seen in an ELF file, we're probably OK unless the
2210 symbol was defined in a non-ELF file. Catch that case here.
2211 FIXME: We're still in trouble if the symbol was first seen in
2212 a dynamic object, and then later in a non-ELF regular object. */
2213 if ((h
->root
.type
== bfd_link_hash_defined
2214 || h
->root
.type
== bfd_link_hash_defweak
)
2215 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2216 && (h
->root
.u
.def
.section
->owner
!= NULL
2217 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2218 != bfd_target_elf_flavour
)
2219 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2220 && (h
->elf_link_hash_flags
2221 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
2222 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2225 /* If this is a final link, and the symbol was defined as a common
2226 symbol in a regular object file, and there was no definition in
2227 any dynamic object, then the linker will have allocated space for
2228 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
2229 flag will not have been set. */
2230 if (h
->root
.type
== bfd_link_hash_defined
2231 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2232 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
2233 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2234 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2235 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2237 /* If -Bsymbolic was used (which means to bind references to global
2238 symbols to the definition within the shared object), and this
2239 symbol was defined in a regular object, then it actually doesn't
2240 need a PLT entry. Likewise, if the symbol has non-default
2241 visibility. If the symbol has hidden or internal visibility, we
2242 will force it local. */
2243 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
2244 && eif
->info
->shared
2245 && is_elf_hash_table (eif
->info
)
2246 && (eif
->info
->symbolic
2247 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2248 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2250 const struct elf_backend_data
*bed
;
2251 bfd_boolean force_local
;
2253 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2255 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2256 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2257 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2260 /* If a weak undefined symbol has non-default visibility, we also
2261 hide it from the dynamic linker. */
2262 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2263 && h
->root
.type
== bfd_link_hash_undefweak
)
2265 const struct elf_backend_data
*bed
;
2266 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2267 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2270 /* If this is a weak defined symbol in a dynamic object, and we know
2271 the real definition in the dynamic object, copy interesting flags
2272 over to the real definition. */
2273 if (h
->weakdef
!= NULL
)
2275 struct elf_link_hash_entry
*weakdef
;
2277 weakdef
= h
->weakdef
;
2278 if (h
->root
.type
== bfd_link_hash_indirect
)
2279 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2281 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2282 || h
->root
.type
== bfd_link_hash_defweak
);
2283 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2284 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2285 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
2287 /* If the real definition is defined by a regular object file,
2288 don't do anything special. See the longer description in
2289 _bfd_elf_adjust_dynamic_symbol, below. */
2290 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2294 const struct elf_backend_data
*bed
;
2296 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2297 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, weakdef
, h
);
2304 /* Make the backend pick a good value for a dynamic symbol. This is
2305 called via elf_link_hash_traverse, and also calls itself
2309 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2311 struct elf_info_failed
*eif
= data
;
2313 const struct elf_backend_data
*bed
;
2315 if (! is_elf_hash_table (eif
->info
))
2318 if (h
->root
.type
== bfd_link_hash_warning
)
2320 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2321 h
->got
= elf_hash_table (eif
->info
)->init_offset
;
2323 /* When warning symbols are created, they **replace** the "real"
2324 entry in the hash table, thus we never get to see the real
2325 symbol in a hash traversal. So look at it now. */
2326 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2329 /* Ignore indirect symbols. These are added by the versioning code. */
2330 if (h
->root
.type
== bfd_link_hash_indirect
)
2333 /* Fix the symbol flags. */
2334 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2337 /* If this symbol does not require a PLT entry, and it is not
2338 defined by a dynamic object, or is not referenced by a regular
2339 object, ignore it. We do have to handle a weak defined symbol,
2340 even if no regular object refers to it, if we decided to add it
2341 to the dynamic symbol table. FIXME: Do we normally need to worry
2342 about symbols which are defined by one dynamic object and
2343 referenced by another one? */
2344 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
2345 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2346 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2347 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
2348 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
2350 h
->plt
= elf_hash_table (eif
->info
)->init_offset
;
2354 /* If we've already adjusted this symbol, don't do it again. This
2355 can happen via a recursive call. */
2356 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
2359 /* Don't look at this symbol again. Note that we must set this
2360 after checking the above conditions, because we may look at a
2361 symbol once, decide not to do anything, and then get called
2362 recursively later after REF_REGULAR is set below. */
2363 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
2365 /* If this is a weak definition, and we know a real definition, and
2366 the real symbol is not itself defined by a regular object file,
2367 then get a good value for the real definition. We handle the
2368 real symbol first, for the convenience of the backend routine.
2370 Note that there is a confusing case here. If the real definition
2371 is defined by a regular object file, we don't get the real symbol
2372 from the dynamic object, but we do get the weak symbol. If the
2373 processor backend uses a COPY reloc, then if some routine in the
2374 dynamic object changes the real symbol, we will not see that
2375 change in the corresponding weak symbol. This is the way other
2376 ELF linkers work as well, and seems to be a result of the shared
2379 I will clarify this issue. Most SVR4 shared libraries define the
2380 variable _timezone and define timezone as a weak synonym. The
2381 tzset call changes _timezone. If you write
2382 extern int timezone;
2384 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2385 you might expect that, since timezone is a synonym for _timezone,
2386 the same number will print both times. However, if the processor
2387 backend uses a COPY reloc, then actually timezone will be copied
2388 into your process image, and, since you define _timezone
2389 yourself, _timezone will not. Thus timezone and _timezone will
2390 wind up at different memory locations. The tzset call will set
2391 _timezone, leaving timezone unchanged. */
2393 if (h
->weakdef
!= NULL
)
2395 /* If we get to this point, we know there is an implicit
2396 reference by a regular object file via the weak symbol H.
2397 FIXME: Is this really true? What if the traversal finds
2398 H->WEAKDEF before it finds H? */
2399 h
->weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2401 if (! _bfd_elf_adjust_dynamic_symbol (h
->weakdef
, eif
))
2405 /* If a symbol has no type and no size and does not require a PLT
2406 entry, then we are probably about to do the wrong thing here: we
2407 are probably going to create a COPY reloc for an empty object.
2408 This case can arise when a shared object is built with assembly
2409 code, and the assembly code fails to set the symbol type. */
2411 && h
->type
== STT_NOTYPE
2412 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
2413 (*_bfd_error_handler
)
2414 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2415 h
->root
.root
.string
);
2417 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2418 bed
= get_elf_backend_data (dynobj
);
2419 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2428 /* Adjust all external symbols pointing into SEC_MERGE sections
2429 to reflect the object merging within the sections. */
2432 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2436 if (h
->root
.type
== bfd_link_hash_warning
)
2437 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2439 if ((h
->root
.type
== bfd_link_hash_defined
2440 || h
->root
.type
== bfd_link_hash_defweak
)
2441 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2442 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2444 bfd
*output_bfd
= data
;
2446 h
->root
.u
.def
.value
=
2447 _bfd_merged_section_offset (output_bfd
,
2448 &h
->root
.u
.def
.section
,
2449 elf_section_data (sec
)->sec_info
,
2450 h
->root
.u
.def
.value
, 0);
2456 /* Returns false if the symbol referred to by H should be considered
2457 to resolve local to the current module, and true if it should be
2458 considered to bind dynamically. */
2461 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2462 struct bfd_link_info
*info
,
2463 bfd_boolean ignore_protected
)
2465 bfd_boolean binding_stays_local_p
;
2470 while (h
->root
.type
== bfd_link_hash_indirect
2471 || h
->root
.type
== bfd_link_hash_warning
)
2472 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2474 /* If it was forced local, then clearly it's not dynamic. */
2475 if (h
->dynindx
== -1)
2477 if (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)
2480 /* Identify the cases where name binding rules say that a
2481 visible symbol resolves locally. */
2482 binding_stays_local_p
= info
->executable
|| info
->symbolic
;
2484 switch (ELF_ST_VISIBILITY (h
->other
))
2491 /* Proper resolution for function pointer equality may require
2492 that these symbols perhaps be resolved dynamically, even though
2493 we should be resolving them to the current module. */
2494 if (!ignore_protected
)
2495 binding_stays_local_p
= TRUE
;
2502 /* If it isn't defined locally, then clearly it's dynamic. */
2503 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2506 /* Otherwise, the symbol is dynamic if binding rules don't tell
2507 us that it remains local. */
2508 return !binding_stays_local_p
;
2511 /* Return true if the symbol referred to by H should be considered
2512 to resolve local to the current module, and false otherwise. Differs
2513 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2514 undefined symbols and weak symbols. */
2517 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2518 struct bfd_link_info
*info
,
2519 bfd_boolean local_protected
)
2521 /* If it's a local sym, of course we resolve locally. */
2525 /* If we don't have a definition in a regular file, then we can't
2526 resolve locally. The sym is either undefined or dynamic. */
2527 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2530 /* Forced local symbols resolve locally. */
2531 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2534 /* As do non-dynamic symbols. */
2535 if (h
->dynindx
== -1)
2538 /* At this point, we know the symbol is defined and dynamic. In an
2539 executable it must resolve locally, likewise when building symbolic
2540 shared libraries. */
2541 if (info
->executable
|| info
->symbolic
)
2544 /* Now deal with defined dynamic symbols in shared libraries. Ones
2545 with default visibility might not resolve locally. */
2546 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2549 /* However, STV_HIDDEN or STV_INTERNAL ones must be local. */
2550 if (ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
)
2553 /* Function pointer equality tests may require that STV_PROTECTED
2554 symbols be treated as dynamic symbols, even when we know that the
2555 dynamic linker will resolve them locally. */
2556 return local_protected
;