2009-06-17 Michael Eager <eager@eagercon.com>
[deliverable/binutils-gdb.git] / bfd / elflink.c
CommitLineData
252b5132 1/* ELF linking support for BFD.
64d03ab5 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
9dbe8890
L
3 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
252b5132 5
8fdd7217 6 This file is part of BFD, the Binary File Descriptor library.
252b5132 7
8fdd7217
NC
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
cd123cb7 10 the Free Software Foundation; either version 3 of the License, or
8fdd7217 11 (at your option) any later version.
252b5132 12
8fdd7217
NC
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
252b5132 17
8fdd7217
NC
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
cd123cb7
NC
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
252b5132 22
252b5132 23#include "sysdep.h"
3db64b00 24#include "bfd.h"
252b5132
RH
25#include "bfdlink.h"
26#include "libbfd.h"
27#define ARCH_SIZE 0
28#include "elf-bfd.h"
4ad4eba5 29#include "safe-ctype.h"
ccf2f652 30#include "libiberty.h"
66eb6687 31#include "objalloc.h"
252b5132 32
28caa186
AM
33/* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
35
36struct elf_info_failed
37{
38 struct bfd_link_info *info;
39 struct bfd_elf_version_tree *verdefs;
40 bfd_boolean failed;
41};
42
43/* This structure is used to pass information to
44 _bfd_elf_link_find_version_dependencies. */
45
46struct elf_find_verdep_info
47{
48 /* General link information. */
49 struct bfd_link_info *info;
50 /* The number of dependencies. */
51 unsigned int vers;
52 /* Whether we had a failure. */
53 bfd_boolean failed;
54};
55
56static bfd_boolean _bfd_elf_fix_symbol_flags
57 (struct elf_link_hash_entry *, struct elf_info_failed *);
58
d98685ac
AM
59/* Define a symbol in a dynamic linkage section. */
60
61struct elf_link_hash_entry *
62_bfd_elf_define_linkage_sym (bfd *abfd,
63 struct bfd_link_info *info,
64 asection *sec,
65 const char *name)
66{
67 struct elf_link_hash_entry *h;
68 struct bfd_link_hash_entry *bh;
ccabcbe5 69 const struct elf_backend_data *bed;
d98685ac
AM
70
71 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
72 if (h != NULL)
73 {
74 /* Zap symbol defined in an as-needed lib that wasn't linked.
75 This is a symptom of a larger problem: Absolute symbols
76 defined in shared libraries can't be overridden, because we
77 lose the link to the bfd which is via the symbol section. */
78 h->root.type = bfd_link_hash_new;
79 }
80
81 bh = &h->root;
82 if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
83 sec, 0, NULL, FALSE,
84 get_elf_backend_data (abfd)->collect,
85 &bh))
86 return NULL;
87 h = (struct elf_link_hash_entry *) bh;
88 h->def_regular = 1;
89 h->type = STT_OBJECT;
90 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
91
ccabcbe5
AM
92 bed = get_elf_backend_data (abfd);
93 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
d98685ac
AM
94 return h;
95}
96
b34976b6 97bfd_boolean
268b6b39 98_bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
252b5132
RH
99{
100 flagword flags;
aad5d350 101 asection *s;
252b5132 102 struct elf_link_hash_entry *h;
9c5bfbb7 103 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6de2ae4a 104 struct elf_link_hash_table *htab = elf_hash_table (info);
252b5132
RH
105
106 /* This function may be called more than once. */
aad5d350
AM
107 s = bfd_get_section_by_name (abfd, ".got");
108 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
b34976b6 109 return TRUE;
252b5132 110
e5a52504 111 flags = bed->dynamic_sec_flags;
252b5132 112
3496cb2a 113 s = bfd_make_section_with_flags (abfd, ".got", flags);
252b5132 114 if (s == NULL
6de2ae4a 115 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
b34976b6 116 return FALSE;
6de2ae4a
L
117 htab->sgot = s;
118
119 s = bfd_make_section_with_flags (abfd,
120 (bed->rela_plts_and_copies_p
121 ? ".rela.got" : ".rel.got"),
122 (bed->dynamic_sec_flags
123 | SEC_READONLY));
124 if (s == NULL
125 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
126 return FALSE;
127 htab->srelgot = s;
252b5132
RH
128
129 if (bed->want_got_plt)
130 {
3496cb2a 131 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
252b5132 132 if (s == NULL
6de2ae4a
L
133 || !bfd_set_section_alignment (abfd, s,
134 bed->s->log_file_align))
b34976b6 135 return FALSE;
6de2ae4a 136 htab->sgotplt = s;
252b5132
RH
137 }
138
2517a57f
AM
139 if (bed->want_got_sym)
140 {
141 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
142 (or .got.plt) section. We don't do this in the linker script
143 because we don't want to define the symbol if we are not creating
144 a global offset table. */
6de2ae4a
L
145 h = _bfd_elf_define_linkage_sym (abfd, info, s,
146 "_GLOBAL_OFFSET_TABLE_");
2517a57f 147 elf_hash_table (info)->hgot = h;
d98685ac
AM
148 if (h == NULL)
149 return FALSE;
2517a57f 150 }
252b5132
RH
151
152 /* The first bit of the global offset table is the header. */
3b36f7e6 153 s->size += bed->got_header_size;
252b5132 154
b34976b6 155 return TRUE;
252b5132
RH
156}
157\f
7e9f0867
AM
158/* Create a strtab to hold the dynamic symbol names. */
159static bfd_boolean
160_bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
161{
162 struct elf_link_hash_table *hash_table;
163
164 hash_table = elf_hash_table (info);
165 if (hash_table->dynobj == NULL)
166 hash_table->dynobj = abfd;
167
168 if (hash_table->dynstr == NULL)
169 {
170 hash_table->dynstr = _bfd_elf_strtab_init ();
171 if (hash_table->dynstr == NULL)
172 return FALSE;
173 }
174 return TRUE;
175}
176
45d6a902
AM
177/* Create some sections which will be filled in with dynamic linking
178 information. ABFD is an input file which requires dynamic sections
179 to be created. The dynamic sections take up virtual memory space
180 when the final executable is run, so we need to create them before
181 addresses are assigned to the output sections. We work out the
182 actual contents and size of these sections later. */
252b5132 183
b34976b6 184bfd_boolean
268b6b39 185_bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
252b5132 186{
45d6a902
AM
187 flagword flags;
188 register asection *s;
9c5bfbb7 189 const struct elf_backend_data *bed;
252b5132 190
0eddce27 191 if (! is_elf_hash_table (info->hash))
45d6a902
AM
192 return FALSE;
193
194 if (elf_hash_table (info)->dynamic_sections_created)
195 return TRUE;
196
7e9f0867
AM
197 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
198 return FALSE;
45d6a902 199
7e9f0867 200 abfd = elf_hash_table (info)->dynobj;
e5a52504
MM
201 bed = get_elf_backend_data (abfd);
202
203 flags = bed->dynamic_sec_flags;
45d6a902
AM
204
205 /* A dynamically linked executable has a .interp section, but a
206 shared library does not. */
36af4a4e 207 if (info->executable)
252b5132 208 {
3496cb2a
L
209 s = bfd_make_section_with_flags (abfd, ".interp",
210 flags | SEC_READONLY);
211 if (s == NULL)
45d6a902
AM
212 return FALSE;
213 }
bb0deeff 214
45d6a902
AM
215 /* Create sections to hold version informations. These are removed
216 if they are not needed. */
3496cb2a
L
217 s = bfd_make_section_with_flags (abfd, ".gnu.version_d",
218 flags | SEC_READONLY);
45d6a902 219 if (s == NULL
45d6a902
AM
220 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
221 return FALSE;
222
3496cb2a
L
223 s = bfd_make_section_with_flags (abfd, ".gnu.version",
224 flags | SEC_READONLY);
45d6a902 225 if (s == NULL
45d6a902
AM
226 || ! bfd_set_section_alignment (abfd, s, 1))
227 return FALSE;
228
3496cb2a
L
229 s = bfd_make_section_with_flags (abfd, ".gnu.version_r",
230 flags | SEC_READONLY);
45d6a902 231 if (s == NULL
45d6a902
AM
232 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
233 return FALSE;
234
3496cb2a
L
235 s = bfd_make_section_with_flags (abfd, ".dynsym",
236 flags | SEC_READONLY);
45d6a902 237 if (s == NULL
45d6a902
AM
238 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
239 return FALSE;
240
3496cb2a
L
241 s = bfd_make_section_with_flags (abfd, ".dynstr",
242 flags | SEC_READONLY);
243 if (s == NULL)
45d6a902
AM
244 return FALSE;
245
3496cb2a 246 s = bfd_make_section_with_flags (abfd, ".dynamic", flags);
45d6a902 247 if (s == NULL
45d6a902
AM
248 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
249 return FALSE;
250
251 /* The special symbol _DYNAMIC is always set to the start of the
77cfaee6
AM
252 .dynamic section. We could set _DYNAMIC in a linker script, but we
253 only want to define it if we are, in fact, creating a .dynamic
254 section. We don't want to define it if there is no .dynamic
255 section, since on some ELF platforms the start up code examines it
256 to decide how to initialize the process. */
d98685ac 257 if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
45d6a902
AM
258 return FALSE;
259
fdc90cb4
JJ
260 if (info->emit_hash)
261 {
262 s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
263 if (s == NULL
264 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
265 return FALSE;
266 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
267 }
268
269 if (info->emit_gnu_hash)
270 {
271 s = bfd_make_section_with_flags (abfd, ".gnu.hash",
272 flags | SEC_READONLY);
273 if (s == NULL
274 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
275 return FALSE;
276 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
277 4 32-bit words followed by variable count of 64-bit words, then
278 variable count of 32-bit words. */
279 if (bed->s->arch_size == 64)
280 elf_section_data (s)->this_hdr.sh_entsize = 0;
281 else
282 elf_section_data (s)->this_hdr.sh_entsize = 4;
283 }
45d6a902
AM
284
285 /* Let the backend create the rest of the sections. This lets the
286 backend set the right flags. The backend will normally create
287 the .got and .plt sections. */
288 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
289 return FALSE;
290
291 elf_hash_table (info)->dynamic_sections_created = TRUE;
292
293 return TRUE;
294}
295
296/* Create dynamic sections when linking against a dynamic object. */
297
298bfd_boolean
268b6b39 299_bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
45d6a902
AM
300{
301 flagword flags, pltflags;
7325306f 302 struct elf_link_hash_entry *h;
45d6a902 303 asection *s;
9c5bfbb7 304 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6de2ae4a 305 struct elf_link_hash_table *htab = elf_hash_table (info);
45d6a902 306
252b5132
RH
307 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
308 .rel[a].bss sections. */
e5a52504 309 flags = bed->dynamic_sec_flags;
252b5132
RH
310
311 pltflags = flags;
252b5132 312 if (bed->plt_not_loaded)
6df4d94c
MM
313 /* We do not clear SEC_ALLOC here because we still want the OS to
314 allocate space for the section; it's just that there's nothing
315 to read in from the object file. */
5d1634d7 316 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
6df4d94c
MM
317 else
318 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
252b5132
RH
319 if (bed->plt_readonly)
320 pltflags |= SEC_READONLY;
321
3496cb2a 322 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
252b5132 323 if (s == NULL
252b5132 324 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
b34976b6 325 return FALSE;
6de2ae4a 326 htab->splt = s;
252b5132 327
d98685ac
AM
328 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
329 .plt section. */
7325306f
RS
330 if (bed->want_plt_sym)
331 {
332 h = _bfd_elf_define_linkage_sym (abfd, info, s,
333 "_PROCEDURE_LINKAGE_TABLE_");
334 elf_hash_table (info)->hplt = h;
335 if (h == NULL)
336 return FALSE;
337 }
252b5132 338
3496cb2a 339 s = bfd_make_section_with_flags (abfd,
d35fd659 340 (bed->rela_plts_and_copies_p
3496cb2a
L
341 ? ".rela.plt" : ".rel.plt"),
342 flags | SEC_READONLY);
252b5132 343 if (s == NULL
45d6a902 344 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
b34976b6 345 return FALSE;
6de2ae4a 346 htab->srelplt = s;
252b5132
RH
347
348 if (! _bfd_elf_create_got_section (abfd, info))
b34976b6 349 return FALSE;
252b5132 350
3018b441
RH
351 if (bed->want_dynbss)
352 {
353 /* The .dynbss section is a place to put symbols which are defined
354 by dynamic objects, are referenced by regular objects, and are
355 not functions. We must allocate space for them in the process
356 image and use a R_*_COPY reloc to tell the dynamic linker to
357 initialize them at run time. The linker script puts the .dynbss
358 section into the .bss section of the final image. */
3496cb2a
L
359 s = bfd_make_section_with_flags (abfd, ".dynbss",
360 (SEC_ALLOC
361 | SEC_LINKER_CREATED));
362 if (s == NULL)
b34976b6 363 return FALSE;
252b5132 364
3018b441 365 /* The .rel[a].bss section holds copy relocs. This section is not
77cfaee6
AM
366 normally needed. We need to create it here, though, so that the
367 linker will map it to an output section. We can't just create it
368 only if we need it, because we will not know whether we need it
369 until we have seen all the input files, and the first time the
370 main linker code calls BFD after examining all the input files
371 (size_dynamic_sections) the input sections have already been
372 mapped to the output sections. If the section turns out not to
373 be needed, we can discard it later. We will never need this
374 section when generating a shared object, since they do not use
375 copy relocs. */
3018b441
RH
376 if (! info->shared)
377 {
3496cb2a 378 s = bfd_make_section_with_flags (abfd,
d35fd659 379 (bed->rela_plts_and_copies_p
3496cb2a
L
380 ? ".rela.bss" : ".rel.bss"),
381 flags | SEC_READONLY);
3018b441 382 if (s == NULL
45d6a902 383 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
b34976b6 384 return FALSE;
3018b441 385 }
252b5132
RH
386 }
387
b34976b6 388 return TRUE;
252b5132
RH
389}
390\f
252b5132
RH
391/* Record a new dynamic symbol. We record the dynamic symbols as we
392 read the input files, since we need to have a list of all of them
393 before we can determine the final sizes of the output sections.
394 Note that we may actually call this function even though we are not
395 going to output any dynamic symbols; in some cases we know that a
396 symbol should be in the dynamic symbol table, but only if there is
397 one. */
398
b34976b6 399bfd_boolean
c152c796
AM
400bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
401 struct elf_link_hash_entry *h)
252b5132
RH
402{
403 if (h->dynindx == -1)
404 {
2b0f7ef9 405 struct elf_strtab_hash *dynstr;
68b6ddd0 406 char *p;
252b5132 407 const char *name;
252b5132
RH
408 bfd_size_type indx;
409
7a13edea
NC
410 /* XXX: The ABI draft says the linker must turn hidden and
411 internal symbols into STB_LOCAL symbols when producing the
412 DSO. However, if ld.so honors st_other in the dynamic table,
413 this would not be necessary. */
414 switch (ELF_ST_VISIBILITY (h->other))
415 {
416 case STV_INTERNAL:
417 case STV_HIDDEN:
9d6eee78
L
418 if (h->root.type != bfd_link_hash_undefined
419 && h->root.type != bfd_link_hash_undefweak)
38048eb9 420 {
f5385ebf 421 h->forced_local = 1;
67687978
PB
422 if (!elf_hash_table (info)->is_relocatable_executable)
423 return TRUE;
7a13edea 424 }
0444bdd4 425
7a13edea
NC
426 default:
427 break;
428 }
429
252b5132
RH
430 h->dynindx = elf_hash_table (info)->dynsymcount;
431 ++elf_hash_table (info)->dynsymcount;
432
433 dynstr = elf_hash_table (info)->dynstr;
434 if (dynstr == NULL)
435 {
436 /* Create a strtab to hold the dynamic symbol names. */
2b0f7ef9 437 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
252b5132 438 if (dynstr == NULL)
b34976b6 439 return FALSE;
252b5132
RH
440 }
441
442 /* We don't put any version information in the dynamic string
aad5d350 443 table. */
252b5132
RH
444 name = h->root.root.string;
445 p = strchr (name, ELF_VER_CHR);
68b6ddd0
AM
446 if (p != NULL)
447 /* We know that the p points into writable memory. In fact,
448 there are only a few symbols that have read-only names, being
449 those like _GLOBAL_OFFSET_TABLE_ that are created specially
450 by the backends. Most symbols will have names pointing into
451 an ELF string table read from a file, or to objalloc memory. */
452 *p = 0;
453
454 indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
455
456 if (p != NULL)
457 *p = ELF_VER_CHR;
252b5132
RH
458
459 if (indx == (bfd_size_type) -1)
b34976b6 460 return FALSE;
252b5132
RH
461 h->dynstr_index = indx;
462 }
463
b34976b6 464 return TRUE;
252b5132 465}
45d6a902 466\f
55255dae
L
467/* Mark a symbol dynamic. */
468
28caa186 469static void
55255dae 470bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
40b36307
L
471 struct elf_link_hash_entry *h,
472 Elf_Internal_Sym *sym)
55255dae 473{
40b36307 474 struct bfd_elf_dynamic_list *d = info->dynamic_list;
55255dae 475
40b36307
L
476 /* It may be called more than once on the same H. */
477 if(h->dynamic || info->relocatable)
55255dae
L
478 return;
479
40b36307
L
480 if ((info->dynamic_data
481 && (h->type == STT_OBJECT
482 || (sym != NULL
483 && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
a0c8462f 484 || (d != NULL
40b36307
L
485 && h->root.type == bfd_link_hash_new
486 && (*d->match) (&d->head, NULL, h->root.root.string)))
55255dae
L
487 h->dynamic = 1;
488}
489
45d6a902
AM
490/* Record an assignment to a symbol made by a linker script. We need
491 this in case some dynamic object refers to this symbol. */
492
493bfd_boolean
fe21a8fc
L
494bfd_elf_record_link_assignment (bfd *output_bfd,
495 struct bfd_link_info *info,
268b6b39 496 const char *name,
fe21a8fc
L
497 bfd_boolean provide,
498 bfd_boolean hidden)
45d6a902 499{
00cbee0a 500 struct elf_link_hash_entry *h, *hv;
4ea42fb7 501 struct elf_link_hash_table *htab;
00cbee0a 502 const struct elf_backend_data *bed;
45d6a902 503
0eddce27 504 if (!is_elf_hash_table (info->hash))
45d6a902
AM
505 return TRUE;
506
4ea42fb7
AM
507 htab = elf_hash_table (info);
508 h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
45d6a902 509 if (h == NULL)
4ea42fb7 510 return provide;
45d6a902 511
00cbee0a 512 switch (h->root.type)
77cfaee6 513 {
00cbee0a
L
514 case bfd_link_hash_defined:
515 case bfd_link_hash_defweak:
516 case bfd_link_hash_common:
517 break;
518 case bfd_link_hash_undefweak:
519 case bfd_link_hash_undefined:
520 /* Since we're defining the symbol, don't let it seem to have not
521 been defined. record_dynamic_symbol and size_dynamic_sections
522 may depend on this. */
4ea42fb7 523 h->root.type = bfd_link_hash_new;
77cfaee6
AM
524 if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
525 bfd_link_repair_undef_list (&htab->root);
00cbee0a
L
526 break;
527 case bfd_link_hash_new:
40b36307 528 bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
55255dae 529 h->non_elf = 0;
00cbee0a
L
530 break;
531 case bfd_link_hash_indirect:
532 /* We had a versioned symbol in a dynamic library. We make the
a0c8462f 533 the versioned symbol point to this one. */
00cbee0a
L
534 bed = get_elf_backend_data (output_bfd);
535 hv = h;
536 while (hv->root.type == bfd_link_hash_indirect
537 || hv->root.type == bfd_link_hash_warning)
538 hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
539 /* We don't need to update h->root.u since linker will set them
540 later. */
541 h->root.type = bfd_link_hash_undefined;
542 hv->root.type = bfd_link_hash_indirect;
543 hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
544 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
545 break;
546 case bfd_link_hash_warning:
547 abort ();
548 break;
55255dae 549 }
45d6a902
AM
550
551 /* If this symbol is being provided by the linker script, and it is
552 currently defined by a dynamic object, but not by a regular
553 object, then mark it as undefined so that the generic linker will
554 force the correct value. */
555 if (provide
f5385ebf
AM
556 && h->def_dynamic
557 && !h->def_regular)
45d6a902
AM
558 h->root.type = bfd_link_hash_undefined;
559
560 /* If this symbol is not being provided by the linker script, and it is
561 currently defined by a dynamic object, but not by a regular object,
562 then clear out any version information because the symbol will not be
563 associated with the dynamic object any more. */
564 if (!provide
f5385ebf
AM
565 && h->def_dynamic
566 && !h->def_regular)
45d6a902
AM
567 h->verinfo.verdef = NULL;
568
f5385ebf 569 h->def_regular = 1;
45d6a902 570
fe21a8fc
L
571 if (provide && hidden)
572 {
573 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
574
575 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
576 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
577 }
578
6fa3860b
PB
579 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
580 and executables. */
581 if (!info->relocatable
582 && h->dynindx != -1
583 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
584 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
585 h->forced_local = 1;
586
f5385ebf
AM
587 if ((h->def_dynamic
588 || h->ref_dynamic
67687978
PB
589 || info->shared
590 || (info->executable && elf_hash_table (info)->is_relocatable_executable))
45d6a902
AM
591 && h->dynindx == -1)
592 {
c152c796 593 if (! bfd_elf_link_record_dynamic_symbol (info, h))
45d6a902
AM
594 return FALSE;
595
596 /* If this is a weak defined symbol, and we know a corresponding
597 real symbol from the same dynamic object, make sure the real
598 symbol is also made into a dynamic symbol. */
f6e332e6
AM
599 if (h->u.weakdef != NULL
600 && h->u.weakdef->dynindx == -1)
45d6a902 601 {
f6e332e6 602 if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
45d6a902
AM
603 return FALSE;
604 }
605 }
606
607 return TRUE;
608}
42751cf3 609
8c58d23b
AM
610/* Record a new local dynamic symbol. Returns 0 on failure, 1 on
611 success, and 2 on a failure caused by attempting to record a symbol
612 in a discarded section, eg. a discarded link-once section symbol. */
613
614int
c152c796
AM
615bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
616 bfd *input_bfd,
617 long input_indx)
8c58d23b
AM
618{
619 bfd_size_type amt;
620 struct elf_link_local_dynamic_entry *entry;
621 struct elf_link_hash_table *eht;
622 struct elf_strtab_hash *dynstr;
623 unsigned long dynstr_index;
624 char *name;
625 Elf_External_Sym_Shndx eshndx;
626 char esym[sizeof (Elf64_External_Sym)];
627
0eddce27 628 if (! is_elf_hash_table (info->hash))
8c58d23b
AM
629 return 0;
630
631 /* See if the entry exists already. */
632 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
633 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
634 return 1;
635
636 amt = sizeof (*entry);
268b6b39 637 entry = bfd_alloc (input_bfd, amt);
8c58d23b
AM
638 if (entry == NULL)
639 return 0;
640
641 /* Go find the symbol, so that we can find it's name. */
642 if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
268b6b39 643 1, input_indx, &entry->isym, esym, &eshndx))
8c58d23b
AM
644 {
645 bfd_release (input_bfd, entry);
646 return 0;
647 }
648
649 if (entry->isym.st_shndx != SHN_UNDEF
4fbb74a6 650 && entry->isym.st_shndx < SHN_LORESERVE)
8c58d23b
AM
651 {
652 asection *s;
653
654 s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
655 if (s == NULL || bfd_is_abs_section (s->output_section))
656 {
657 /* We can still bfd_release here as nothing has done another
658 bfd_alloc. We can't do this later in this function. */
659 bfd_release (input_bfd, entry);
660 return 2;
661 }
662 }
663
664 name = (bfd_elf_string_from_elf_section
665 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
666 entry->isym.st_name));
667
668 dynstr = elf_hash_table (info)->dynstr;
669 if (dynstr == NULL)
670 {
671 /* Create a strtab to hold the dynamic symbol names. */
672 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
673 if (dynstr == NULL)
674 return 0;
675 }
676
b34976b6 677 dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
8c58d23b
AM
678 if (dynstr_index == (unsigned long) -1)
679 return 0;
680 entry->isym.st_name = dynstr_index;
681
682 eht = elf_hash_table (info);
683
684 entry->next = eht->dynlocal;
685 eht->dynlocal = entry;
686 entry->input_bfd = input_bfd;
687 entry->input_indx = input_indx;
688 eht->dynsymcount++;
689
690 /* Whatever binding the symbol had before, it's now local. */
691 entry->isym.st_info
692 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
693
694 /* The dynindx will be set at the end of size_dynamic_sections. */
695
696 return 1;
697}
698
30b30c21 699/* Return the dynindex of a local dynamic symbol. */
42751cf3 700
30b30c21 701long
268b6b39
AM
702_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
703 bfd *input_bfd,
704 long input_indx)
30b30c21
RH
705{
706 struct elf_link_local_dynamic_entry *e;
707
708 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
709 if (e->input_bfd == input_bfd && e->input_indx == input_indx)
710 return e->dynindx;
711 return -1;
712}
713
714/* This function is used to renumber the dynamic symbols, if some of
715 them are removed because they are marked as local. This is called
716 via elf_link_hash_traverse. */
717
b34976b6 718static bfd_boolean
268b6b39
AM
719elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
720 void *data)
42751cf3 721{
268b6b39 722 size_t *count = data;
30b30c21 723
e92d460e
AM
724 if (h->root.type == bfd_link_hash_warning)
725 h = (struct elf_link_hash_entry *) h->root.u.i.link;
726
6fa3860b
PB
727 if (h->forced_local)
728 return TRUE;
729
730 if (h->dynindx != -1)
731 h->dynindx = ++(*count);
732
733 return TRUE;
734}
735
736
737/* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
738 STB_LOCAL binding. */
739
740static bfd_boolean
741elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
742 void *data)
743{
744 size_t *count = data;
745
746 if (h->root.type == bfd_link_hash_warning)
747 h = (struct elf_link_hash_entry *) h->root.u.i.link;
748
749 if (!h->forced_local)
750 return TRUE;
751
42751cf3 752 if (h->dynindx != -1)
30b30c21
RH
753 h->dynindx = ++(*count);
754
b34976b6 755 return TRUE;
42751cf3 756}
30b30c21 757
aee6f5b4
AO
758/* Return true if the dynamic symbol for a given section should be
759 omitted when creating a shared library. */
760bfd_boolean
761_bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
762 struct bfd_link_info *info,
763 asection *p)
764{
74541ad4
AM
765 struct elf_link_hash_table *htab;
766
aee6f5b4
AO
767 switch (elf_section_data (p)->this_hdr.sh_type)
768 {
769 case SHT_PROGBITS:
770 case SHT_NOBITS:
771 /* If sh_type is yet undecided, assume it could be
772 SHT_PROGBITS/SHT_NOBITS. */
773 case SHT_NULL:
74541ad4
AM
774 htab = elf_hash_table (info);
775 if (p == htab->tls_sec)
776 return FALSE;
777
778 if (htab->text_index_section != NULL)
779 return p != htab->text_index_section && p != htab->data_index_section;
780
aee6f5b4
AO
781 if (strcmp (p->name, ".got") == 0
782 || strcmp (p->name, ".got.plt") == 0
783 || strcmp (p->name, ".plt") == 0)
784 {
785 asection *ip;
aee6f5b4 786
74541ad4
AM
787 if (htab->dynobj != NULL
788 && (ip = bfd_get_section_by_name (htab->dynobj, p->name)) != NULL
aee6f5b4
AO
789 && (ip->flags & SEC_LINKER_CREATED)
790 && ip->output_section == p)
791 return TRUE;
792 }
793 return FALSE;
794
795 /* There shouldn't be section relative relocations
796 against any other section. */
797 default:
798 return TRUE;
799 }
800}
801
062e2358 802/* Assign dynsym indices. In a shared library we generate a section
6fa3860b
PB
803 symbol for each output section, which come first. Next come symbols
804 which have been forced to local binding. Then all of the back-end
805 allocated local dynamic syms, followed by the rest of the global
806 symbols. */
30b30c21 807
554220db
AM
808static unsigned long
809_bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
810 struct bfd_link_info *info,
811 unsigned long *section_sym_count)
30b30c21
RH
812{
813 unsigned long dynsymcount = 0;
814
67687978 815 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
30b30c21 816 {
aee6f5b4 817 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
30b30c21
RH
818 asection *p;
819 for (p = output_bfd->sections; p ; p = p->next)
8c37241b 820 if ((p->flags & SEC_EXCLUDE) == 0
aee6f5b4
AO
821 && (p->flags & SEC_ALLOC) != 0
822 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
823 elf_section_data (p)->dynindx = ++dynsymcount;
74541ad4
AM
824 else
825 elf_section_data (p)->dynindx = 0;
30b30c21 826 }
554220db 827 *section_sym_count = dynsymcount;
30b30c21 828
6fa3860b
PB
829 elf_link_hash_traverse (elf_hash_table (info),
830 elf_link_renumber_local_hash_table_dynsyms,
831 &dynsymcount);
832
30b30c21
RH
833 if (elf_hash_table (info)->dynlocal)
834 {
835 struct elf_link_local_dynamic_entry *p;
836 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
837 p->dynindx = ++dynsymcount;
838 }
839
840 elf_link_hash_traverse (elf_hash_table (info),
841 elf_link_renumber_hash_table_dynsyms,
842 &dynsymcount);
843
844 /* There is an unused NULL entry at the head of the table which
845 we must account for in our count. Unless there weren't any
846 symbols, which means we'll have no table at all. */
847 if (dynsymcount != 0)
848 ++dynsymcount;
849
ccabcbe5
AM
850 elf_hash_table (info)->dynsymcount = dynsymcount;
851 return dynsymcount;
30b30c21 852}
252b5132 853
54ac0771
L
854/* Merge st_other field. */
855
856static void
857elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
858 Elf_Internal_Sym *isym, bfd_boolean definition,
859 bfd_boolean dynamic)
860{
861 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
862
863 /* If st_other has a processor-specific meaning, specific
864 code might be needed here. We never merge the visibility
865 attribute with the one from a dynamic object. */
866 if (bed->elf_backend_merge_symbol_attribute)
867 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
868 dynamic);
869
870 /* If this symbol has default visibility and the user has requested
871 we not re-export it, then mark it as hidden. */
872 if (definition
873 && !dynamic
874 && (abfd->no_export
875 || (abfd->my_archive && abfd->my_archive->no_export))
876 && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
877 isym->st_other = (STV_HIDDEN
878 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
879
880 if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
881 {
882 unsigned char hvis, symvis, other, nvis;
883
884 /* Only merge the visibility. Leave the remainder of the
885 st_other field to elf_backend_merge_symbol_attribute. */
886 other = h->other & ~ELF_ST_VISIBILITY (-1);
887
888 /* Combine visibilities, using the most constraining one. */
889 hvis = ELF_ST_VISIBILITY (h->other);
890 symvis = ELF_ST_VISIBILITY (isym->st_other);
891 if (! hvis)
892 nvis = symvis;
893 else if (! symvis)
894 nvis = hvis;
895 else
896 nvis = hvis < symvis ? hvis : symvis;
897
898 h->other = other | nvis;
899 }
900}
901
45d6a902
AM
902/* This function is called when we want to define a new symbol. It
903 handles the various cases which arise when we find a definition in
904 a dynamic object, or when there is already a definition in a
905 dynamic object. The new symbol is described by NAME, SYM, PSEC,
906 and PVALUE. We set SYM_HASH to the hash table entry. We set
907 OVERRIDE if the old symbol is overriding a new definition. We set
908 TYPE_CHANGE_OK if it is OK for the type to change. We set
909 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
910 change, we mean that we shouldn't warn if the type or size does
af44c138
L
911 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
912 object is overridden by a regular object. */
45d6a902
AM
913
914bfd_boolean
268b6b39
AM
915_bfd_elf_merge_symbol (bfd *abfd,
916 struct bfd_link_info *info,
917 const char *name,
918 Elf_Internal_Sym *sym,
919 asection **psec,
920 bfd_vma *pvalue,
af44c138 921 unsigned int *pold_alignment,
268b6b39
AM
922 struct elf_link_hash_entry **sym_hash,
923 bfd_boolean *skip,
924 bfd_boolean *override,
925 bfd_boolean *type_change_ok,
0f8a2703 926 bfd_boolean *size_change_ok)
252b5132 927{
7479dfd4 928 asection *sec, *oldsec;
45d6a902
AM
929 struct elf_link_hash_entry *h;
930 struct elf_link_hash_entry *flip;
931 int bind;
932 bfd *oldbfd;
933 bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
0a36a439 934 bfd_boolean newweak, oldweak, newfunc, oldfunc;
a4d8e49b 935 const struct elf_backend_data *bed;
45d6a902
AM
936
937 *skip = FALSE;
938 *override = FALSE;
939
940 sec = *psec;
941 bind = ELF_ST_BIND (sym->st_info);
942
cd7be95b
KH
943 /* Silently discard TLS symbols from --just-syms. There's no way to
944 combine a static TLS block with a new TLS block for this executable. */
945 if (ELF_ST_TYPE (sym->st_info) == STT_TLS
946 && sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
947 {
948 *skip = TRUE;
949 return TRUE;
950 }
951
45d6a902
AM
952 if (! bfd_is_und_section (sec))
953 h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
954 else
955 h = ((struct elf_link_hash_entry *)
956 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
957 if (h == NULL)
958 return FALSE;
959 *sym_hash = h;
252b5132 960
88ba32a0
L
961 bed = get_elf_backend_data (abfd);
962
45d6a902
AM
963 /* This code is for coping with dynamic objects, and is only useful
964 if we are doing an ELF link. */
88ba32a0 965 if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
45d6a902 966 return TRUE;
252b5132 967
45d6a902
AM
968 /* For merging, we only care about real symbols. */
969
970 while (h->root.type == bfd_link_hash_indirect
971 || h->root.type == bfd_link_hash_warning)
972 h = (struct elf_link_hash_entry *) h->root.u.i.link;
973
40b36307
L
974 /* We have to check it for every instance since the first few may be
975 refereences and not all compilers emit symbol type for undefined
976 symbols. */
977 bfd_elf_link_mark_dynamic_symbol (info, h, sym);
978
45d6a902
AM
979 /* If we just created the symbol, mark it as being an ELF symbol.
980 Other than that, there is nothing to do--there is no merge issue
981 with a newly defined symbol--so we just return. */
982
983 if (h->root.type == bfd_link_hash_new)
252b5132 984 {
f5385ebf 985 h->non_elf = 0;
45d6a902
AM
986 return TRUE;
987 }
252b5132 988
7479dfd4
L
989 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
990 existing symbol. */
252b5132 991
45d6a902
AM
992 switch (h->root.type)
993 {
994 default:
995 oldbfd = NULL;
7479dfd4 996 oldsec = NULL;
45d6a902 997 break;
252b5132 998
45d6a902
AM
999 case bfd_link_hash_undefined:
1000 case bfd_link_hash_undefweak:
1001 oldbfd = h->root.u.undef.abfd;
7479dfd4 1002 oldsec = NULL;
45d6a902
AM
1003 break;
1004
1005 case bfd_link_hash_defined:
1006 case bfd_link_hash_defweak:
1007 oldbfd = h->root.u.def.section->owner;
7479dfd4 1008 oldsec = h->root.u.def.section;
45d6a902
AM
1009 break;
1010
1011 case bfd_link_hash_common:
1012 oldbfd = h->root.u.c.p->section->owner;
7479dfd4 1013 oldsec = h->root.u.c.p->section;
45d6a902
AM
1014 break;
1015 }
1016
1017 /* In cases involving weak versioned symbols, we may wind up trying
1018 to merge a symbol with itself. Catch that here, to avoid the
1019 confusion that results if we try to override a symbol with
1020 itself. The additional tests catch cases like
1021 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1022 dynamic object, which we do want to handle here. */
1023 if (abfd == oldbfd
1024 && ((abfd->flags & DYNAMIC) == 0
f5385ebf 1025 || !h->def_regular))
45d6a902
AM
1026 return TRUE;
1027
1028 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1029 respectively, is from a dynamic object. */
1030
707bba77 1031 newdyn = (abfd->flags & DYNAMIC) != 0;
45d6a902 1032
707bba77 1033 olddyn = FALSE;
45d6a902
AM
1034 if (oldbfd != NULL)
1035 olddyn = (oldbfd->flags & DYNAMIC) != 0;
707bba77 1036 else if (oldsec != NULL)
45d6a902 1037 {
707bba77 1038 /* This handles the special SHN_MIPS_{TEXT,DATA} section
45d6a902 1039 indices used by MIPS ELF. */
707bba77 1040 olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
45d6a902 1041 }
252b5132 1042
45d6a902
AM
1043 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1044 respectively, appear to be a definition rather than reference. */
1045
707bba77 1046 newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
45d6a902 1047
707bba77
AM
1048 olddef = (h->root.type != bfd_link_hash_undefined
1049 && h->root.type != bfd_link_hash_undefweak
1050 && h->root.type != bfd_link_hash_common);
45d6a902 1051
0a36a439
L
1052 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1053 respectively, appear to be a function. */
1054
1055 newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1056 && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1057
1058 oldfunc = (h->type != STT_NOTYPE
1059 && bed->is_function_type (h->type));
1060
580a2b6e
L
1061 /* When we try to create a default indirect symbol from the dynamic
1062 definition with the default version, we skip it if its type and
1063 the type of existing regular definition mismatch. We only do it
1064 if the existing regular definition won't be dynamic. */
1065 if (pold_alignment == NULL
1066 && !info->shared
1067 && !info->export_dynamic
1068 && !h->ref_dynamic
1069 && newdyn
1070 && newdef
1071 && !olddyn
1072 && (olddef || h->root.type == bfd_link_hash_common)
1073 && ELF_ST_TYPE (sym->st_info) != h->type
1074 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
fcb93ecf 1075 && h->type != STT_NOTYPE
0a36a439 1076 && !(newfunc && oldfunc))
580a2b6e
L
1077 {
1078 *skip = TRUE;
1079 return TRUE;
1080 }
1081
68f49ba3
L
1082 /* Check TLS symbol. We don't check undefined symbol introduced by
1083 "ld -u". */
7479dfd4 1084 if ((ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS)
68f49ba3
L
1085 && ELF_ST_TYPE (sym->st_info) != h->type
1086 && oldbfd != NULL)
7479dfd4
L
1087 {
1088 bfd *ntbfd, *tbfd;
1089 bfd_boolean ntdef, tdef;
1090 asection *ntsec, *tsec;
1091
1092 if (h->type == STT_TLS)
1093 {
3b36f7e6 1094 ntbfd = abfd;
7479dfd4
L
1095 ntsec = sec;
1096 ntdef = newdef;
1097 tbfd = oldbfd;
1098 tsec = oldsec;
1099 tdef = olddef;
1100 }
1101 else
1102 {
1103 ntbfd = oldbfd;
1104 ntsec = oldsec;
1105 ntdef = olddef;
1106 tbfd = abfd;
1107 tsec = sec;
1108 tdef = newdef;
1109 }
1110
1111 if (tdef && ntdef)
1112 (*_bfd_error_handler)
1113 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1114 tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1115 else if (!tdef && !ntdef)
1116 (*_bfd_error_handler)
1117 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1118 tbfd, ntbfd, h->root.root.string);
1119 else if (tdef)
1120 (*_bfd_error_handler)
1121 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1122 tbfd, tsec, ntbfd, h->root.root.string);
1123 else
1124 (*_bfd_error_handler)
1125 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1126 tbfd, ntbfd, ntsec, h->root.root.string);
1127
1128 bfd_set_error (bfd_error_bad_value);
1129 return FALSE;
1130 }
1131
4cc11e76 1132 /* We need to remember if a symbol has a definition in a dynamic
45d6a902
AM
1133 object or is weak in all dynamic objects. Internal and hidden
1134 visibility will make it unavailable to dynamic objects. */
f5385ebf 1135 if (newdyn && !h->dynamic_def)
45d6a902
AM
1136 {
1137 if (!bfd_is_und_section (sec))
f5385ebf 1138 h->dynamic_def = 1;
45d6a902 1139 else
252b5132 1140 {
45d6a902
AM
1141 /* Check if this symbol is weak in all dynamic objects. If it
1142 is the first time we see it in a dynamic object, we mark
1143 if it is weak. Otherwise, we clear it. */
f5385ebf 1144 if (!h->ref_dynamic)
79349b09 1145 {
45d6a902 1146 if (bind == STB_WEAK)
f5385ebf 1147 h->dynamic_weak = 1;
252b5132 1148 }
45d6a902 1149 else if (bind != STB_WEAK)
f5385ebf 1150 h->dynamic_weak = 0;
252b5132 1151 }
45d6a902 1152 }
252b5132 1153
45d6a902
AM
1154 /* If the old symbol has non-default visibility, we ignore the new
1155 definition from a dynamic object. */
1156 if (newdyn
9c7a29a3 1157 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
45d6a902
AM
1158 && !bfd_is_und_section (sec))
1159 {
1160 *skip = TRUE;
1161 /* Make sure this symbol is dynamic. */
f5385ebf 1162 h->ref_dynamic = 1;
45d6a902
AM
1163 /* A protected symbol has external availability. Make sure it is
1164 recorded as dynamic.
1165
1166 FIXME: Should we check type and size for protected symbol? */
1167 if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
c152c796 1168 return bfd_elf_link_record_dynamic_symbol (info, h);
45d6a902
AM
1169 else
1170 return TRUE;
1171 }
1172 else if (!newdyn
9c7a29a3 1173 && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
f5385ebf 1174 && h->def_dynamic)
45d6a902
AM
1175 {
1176 /* If the new symbol with non-default visibility comes from a
1177 relocatable file and the old definition comes from a dynamic
1178 object, we remove the old definition. */
1179 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
d2dee3b2
L
1180 {
1181 /* Handle the case where the old dynamic definition is
1182 default versioned. We need to copy the symbol info from
1183 the symbol with default version to the normal one if it
1184 was referenced before. */
1185 if (h->ref_regular)
1186 {
1187 const struct elf_backend_data *bed
1188 = get_elf_backend_data (abfd);
1189 struct elf_link_hash_entry *vh = *sym_hash;
1190 vh->root.type = h->root.type;
1191 h->root.type = bfd_link_hash_indirect;
1192 (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1193 /* Protected symbols will override the dynamic definition
1194 with default version. */
1195 if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
1196 {
1197 h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
1198 vh->dynamic_def = 1;
1199 vh->ref_dynamic = 1;
1200 }
1201 else
1202 {
1203 h->root.type = vh->root.type;
1204 vh->ref_dynamic = 0;
1205 /* We have to hide it here since it was made dynamic
1206 global with extra bits when the symbol info was
1207 copied from the old dynamic definition. */
1208 (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1209 }
1210 h = vh;
1211 }
1212 else
1213 h = *sym_hash;
1214 }
1de1a317 1215
f6e332e6 1216 if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1de1a317
L
1217 && bfd_is_und_section (sec))
1218 {
1219 /* If the new symbol is undefined and the old symbol was
1220 also undefined before, we need to make sure
1221 _bfd_generic_link_add_one_symbol doesn't mess
f6e332e6 1222 up the linker hash table undefs list. Since the old
1de1a317
L
1223 definition came from a dynamic object, it is still on the
1224 undefs list. */
1225 h->root.type = bfd_link_hash_undefined;
1de1a317
L
1226 h->root.u.undef.abfd = abfd;
1227 }
1228 else
1229 {
1230 h->root.type = bfd_link_hash_new;
1231 h->root.u.undef.abfd = NULL;
1232 }
1233
f5385ebf 1234 if (h->def_dynamic)
252b5132 1235 {
f5385ebf
AM
1236 h->def_dynamic = 0;
1237 h->ref_dynamic = 1;
1238 h->dynamic_def = 1;
45d6a902
AM
1239 }
1240 /* FIXME: Should we check type and size for protected symbol? */
1241 h->size = 0;
1242 h->type = 0;
1243 return TRUE;
1244 }
14a793b2 1245
79349b09
AM
1246 /* Differentiate strong and weak symbols. */
1247 newweak = bind == STB_WEAK;
1248 oldweak = (h->root.type == bfd_link_hash_defweak
1249 || h->root.type == bfd_link_hash_undefweak);
14a793b2 1250
15b43f48
AM
1251 /* If a new weak symbol definition comes from a regular file and the
1252 old symbol comes from a dynamic library, we treat the new one as
1253 strong. Similarly, an old weak symbol definition from a regular
1254 file is treated as strong when the new symbol comes from a dynamic
1255 library. Further, an old weak symbol from a dynamic library is
1256 treated as strong if the new symbol is from a dynamic library.
1257 This reflects the way glibc's ld.so works.
1258
1259 Do this before setting *type_change_ok or *size_change_ok so that
1260 we warn properly when dynamic library symbols are overridden. */
1261
1262 if (newdef && !newdyn && olddyn)
0f8a2703 1263 newweak = FALSE;
15b43f48 1264 if (olddef && newdyn)
0f8a2703
AM
1265 oldweak = FALSE;
1266
d334575b 1267 /* Allow changes between different types of function symbol. */
0a36a439 1268 if (newfunc && oldfunc)
fcb93ecf
PB
1269 *type_change_ok = TRUE;
1270
79349b09
AM
1271 /* It's OK to change the type if either the existing symbol or the
1272 new symbol is weak. A type change is also OK if the old symbol
1273 is undefined and the new symbol is defined. */
252b5132 1274
79349b09
AM
1275 if (oldweak
1276 || newweak
1277 || (newdef
1278 && h->root.type == bfd_link_hash_undefined))
1279 *type_change_ok = TRUE;
1280
1281 /* It's OK to change the size if either the existing symbol or the
1282 new symbol is weak, or if the old symbol is undefined. */
1283
1284 if (*type_change_ok
1285 || h->root.type == bfd_link_hash_undefined)
1286 *size_change_ok = TRUE;
45d6a902 1287
45d6a902
AM
1288 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1289 symbol, respectively, appears to be a common symbol in a dynamic
1290 object. If a symbol appears in an uninitialized section, and is
1291 not weak, and is not a function, then it may be a common symbol
1292 which was resolved when the dynamic object was created. We want
1293 to treat such symbols specially, because they raise special
1294 considerations when setting the symbol size: if the symbol
1295 appears as a common symbol in a regular object, and the size in
1296 the regular object is larger, we must make sure that we use the
1297 larger size. This problematic case can always be avoided in C,
1298 but it must be handled correctly when using Fortran shared
1299 libraries.
1300
1301 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1302 likewise for OLDDYNCOMMON and OLDDEF.
1303
1304 Note that this test is just a heuristic, and that it is quite
1305 possible to have an uninitialized symbol in a shared object which
1306 is really a definition, rather than a common symbol. This could
1307 lead to some minor confusion when the symbol really is a common
1308 symbol in some regular object. However, I think it will be
1309 harmless. */
1310
1311 if (newdyn
1312 && newdef
79349b09 1313 && !newweak
45d6a902
AM
1314 && (sec->flags & SEC_ALLOC) != 0
1315 && (sec->flags & SEC_LOAD) == 0
1316 && sym->st_size > 0
0a36a439 1317 && !newfunc)
45d6a902
AM
1318 newdyncommon = TRUE;
1319 else
1320 newdyncommon = FALSE;
1321
1322 if (olddyn
1323 && olddef
1324 && h->root.type == bfd_link_hash_defined
f5385ebf 1325 && h->def_dynamic
45d6a902
AM
1326 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1327 && (h->root.u.def.section->flags & SEC_LOAD) == 0
1328 && h->size > 0
0a36a439 1329 && !oldfunc)
45d6a902
AM
1330 olddyncommon = TRUE;
1331 else
1332 olddyncommon = FALSE;
1333
a4d8e49b
L
1334 /* We now know everything about the old and new symbols. We ask the
1335 backend to check if we can merge them. */
a4d8e49b
L
1336 if (bed->merge_symbol
1337 && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1338 pold_alignment, skip, override,
1339 type_change_ok, size_change_ok,
1340 &newdyn, &newdef, &newdyncommon, &newweak,
1341 abfd, &sec,
1342 &olddyn, &olddef, &olddyncommon, &oldweak,
1343 oldbfd, &oldsec))
1344 return FALSE;
1345
45d6a902
AM
1346 /* If both the old and the new symbols look like common symbols in a
1347 dynamic object, set the size of the symbol to the larger of the
1348 two. */
1349
1350 if (olddyncommon
1351 && newdyncommon
1352 && sym->st_size != h->size)
1353 {
1354 /* Since we think we have two common symbols, issue a multiple
1355 common warning if desired. Note that we only warn if the
1356 size is different. If the size is the same, we simply let
1357 the old symbol override the new one as normally happens with
1358 symbols defined in dynamic objects. */
1359
1360 if (! ((*info->callbacks->multiple_common)
1361 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1362 h->size, abfd, bfd_link_hash_common, sym->st_size)))
1363 return FALSE;
252b5132 1364
45d6a902
AM
1365 if (sym->st_size > h->size)
1366 h->size = sym->st_size;
252b5132 1367
45d6a902 1368 *size_change_ok = TRUE;
252b5132
RH
1369 }
1370
45d6a902
AM
1371 /* If we are looking at a dynamic object, and we have found a
1372 definition, we need to see if the symbol was already defined by
1373 some other object. If so, we want to use the existing
1374 definition, and we do not want to report a multiple symbol
1375 definition error; we do this by clobbering *PSEC to be
1376 bfd_und_section_ptr.
1377
1378 We treat a common symbol as a definition if the symbol in the
1379 shared library is a function, since common symbols always
1380 represent variables; this can cause confusion in principle, but
1381 any such confusion would seem to indicate an erroneous program or
1382 shared library. We also permit a common symbol in a regular
79349b09 1383 object to override a weak symbol in a shared object. */
45d6a902
AM
1384
1385 if (newdyn
1386 && newdef
77cfaee6 1387 && (olddef
45d6a902 1388 || (h->root.type == bfd_link_hash_common
0a36a439 1389 && (newweak || newfunc))))
45d6a902
AM
1390 {
1391 *override = TRUE;
1392 newdef = FALSE;
1393 newdyncommon = FALSE;
252b5132 1394
45d6a902
AM
1395 *psec = sec = bfd_und_section_ptr;
1396 *size_change_ok = TRUE;
252b5132 1397
45d6a902
AM
1398 /* If we get here when the old symbol is a common symbol, then
1399 we are explicitly letting it override a weak symbol or
1400 function in a dynamic object, and we don't want to warn about
1401 a type change. If the old symbol is a defined symbol, a type
1402 change warning may still be appropriate. */
252b5132 1403
45d6a902
AM
1404 if (h->root.type == bfd_link_hash_common)
1405 *type_change_ok = TRUE;
1406 }
1407
1408 /* Handle the special case of an old common symbol merging with a
1409 new symbol which looks like a common symbol in a shared object.
1410 We change *PSEC and *PVALUE to make the new symbol look like a
91134c82
L
1411 common symbol, and let _bfd_generic_link_add_one_symbol do the
1412 right thing. */
45d6a902
AM
1413
1414 if (newdyncommon
1415 && h->root.type == bfd_link_hash_common)
1416 {
1417 *override = TRUE;
1418 newdef = FALSE;
1419 newdyncommon = FALSE;
1420 *pvalue = sym->st_size;
a4d8e49b 1421 *psec = sec = bed->common_section (oldsec);
45d6a902
AM
1422 *size_change_ok = TRUE;
1423 }
1424
c5e2cead 1425 /* Skip weak definitions of symbols that are already defined. */
f41d945b 1426 if (newdef && olddef && newweak)
54ac0771
L
1427 {
1428 *skip = TRUE;
1429
1430 /* Merge st_other. If the symbol already has a dynamic index,
1431 but visibility says it should not be visible, turn it into a
1432 local symbol. */
1433 elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1434 if (h->dynindx != -1)
1435 switch (ELF_ST_VISIBILITY (h->other))
1436 {
1437 case STV_INTERNAL:
1438 case STV_HIDDEN:
1439 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1440 break;
1441 }
1442 }
c5e2cead 1443
45d6a902
AM
1444 /* If the old symbol is from a dynamic object, and the new symbol is
1445 a definition which is not from a dynamic object, then the new
1446 symbol overrides the old symbol. Symbols from regular files
1447 always take precedence over symbols from dynamic objects, even if
1448 they are defined after the dynamic object in the link.
1449
1450 As above, we again permit a common symbol in a regular object to
1451 override a definition in a shared object if the shared object
0f8a2703 1452 symbol is a function or is weak. */
45d6a902
AM
1453
1454 flip = NULL;
77cfaee6 1455 if (!newdyn
45d6a902
AM
1456 && (newdef
1457 || (bfd_is_com_section (sec)
0a36a439 1458 && (oldweak || oldfunc)))
45d6a902
AM
1459 && olddyn
1460 && olddef
f5385ebf 1461 && h->def_dynamic)
45d6a902
AM
1462 {
1463 /* Change the hash table entry to undefined, and let
1464 _bfd_generic_link_add_one_symbol do the right thing with the
1465 new definition. */
1466
1467 h->root.type = bfd_link_hash_undefined;
1468 h->root.u.undef.abfd = h->root.u.def.section->owner;
1469 *size_change_ok = TRUE;
1470
1471 olddef = FALSE;
1472 olddyncommon = FALSE;
1473
1474 /* We again permit a type change when a common symbol may be
1475 overriding a function. */
1476
1477 if (bfd_is_com_section (sec))
0a36a439
L
1478 {
1479 if (oldfunc)
1480 {
1481 /* If a common symbol overrides a function, make sure
1482 that it isn't defined dynamically nor has type
1483 function. */
1484 h->def_dynamic = 0;
1485 h->type = STT_NOTYPE;
1486 }
1487 *type_change_ok = TRUE;
1488 }
45d6a902
AM
1489
1490 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1491 flip = *sym_hash;
1492 else
1493 /* This union may have been set to be non-NULL when this symbol
1494 was seen in a dynamic object. We must force the union to be
1495 NULL, so that it is correct for a regular symbol. */
1496 h->verinfo.vertree = NULL;
1497 }
1498
1499 /* Handle the special case of a new common symbol merging with an
1500 old symbol that looks like it might be a common symbol defined in
1501 a shared object. Note that we have already handled the case in
1502 which a new common symbol should simply override the definition
1503 in the shared library. */
1504
1505 if (! newdyn
1506 && bfd_is_com_section (sec)
1507 && olddyncommon)
1508 {
1509 /* It would be best if we could set the hash table entry to a
1510 common symbol, but we don't know what to use for the section
1511 or the alignment. */
1512 if (! ((*info->callbacks->multiple_common)
1513 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1514 h->size, abfd, bfd_link_hash_common, sym->st_size)))
1515 return FALSE;
1516
4cc11e76 1517 /* If the presumed common symbol in the dynamic object is
45d6a902
AM
1518 larger, pretend that the new symbol has its size. */
1519
1520 if (h->size > *pvalue)
1521 *pvalue = h->size;
1522
af44c138
L
1523 /* We need to remember the alignment required by the symbol
1524 in the dynamic object. */
1525 BFD_ASSERT (pold_alignment);
1526 *pold_alignment = h->root.u.def.section->alignment_power;
45d6a902
AM
1527
1528 olddef = FALSE;
1529 olddyncommon = FALSE;
1530
1531 h->root.type = bfd_link_hash_undefined;
1532 h->root.u.undef.abfd = h->root.u.def.section->owner;
1533
1534 *size_change_ok = TRUE;
1535 *type_change_ok = TRUE;
1536
1537 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1538 flip = *sym_hash;
1539 else
1540 h->verinfo.vertree = NULL;
1541 }
1542
1543 if (flip != NULL)
1544 {
1545 /* Handle the case where we had a versioned symbol in a dynamic
1546 library and now find a definition in a normal object. In this
1547 case, we make the versioned symbol point to the normal one. */
9c5bfbb7 1548 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
45d6a902 1549 flip->root.type = h->root.type;
00cbee0a 1550 flip->root.u.undef.abfd = h->root.u.undef.abfd;
45d6a902
AM
1551 h->root.type = bfd_link_hash_indirect;
1552 h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
fcfa13d2 1553 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
f5385ebf 1554 if (h->def_dynamic)
45d6a902 1555 {
f5385ebf
AM
1556 h->def_dynamic = 0;
1557 flip->ref_dynamic = 1;
45d6a902
AM
1558 }
1559 }
1560
45d6a902
AM
1561 return TRUE;
1562}
1563
1564/* This function is called to create an indirect symbol from the
1565 default for the symbol with the default version if needed. The
1566 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
0f8a2703 1567 set DYNSYM if the new indirect symbol is dynamic. */
45d6a902 1568
28caa186 1569static bfd_boolean
268b6b39
AM
1570_bfd_elf_add_default_symbol (bfd *abfd,
1571 struct bfd_link_info *info,
1572 struct elf_link_hash_entry *h,
1573 const char *name,
1574 Elf_Internal_Sym *sym,
1575 asection **psec,
1576 bfd_vma *value,
1577 bfd_boolean *dynsym,
0f8a2703 1578 bfd_boolean override)
45d6a902
AM
1579{
1580 bfd_boolean type_change_ok;
1581 bfd_boolean size_change_ok;
1582 bfd_boolean skip;
1583 char *shortname;
1584 struct elf_link_hash_entry *hi;
1585 struct bfd_link_hash_entry *bh;
9c5bfbb7 1586 const struct elf_backend_data *bed;
45d6a902
AM
1587 bfd_boolean collect;
1588 bfd_boolean dynamic;
1589 char *p;
1590 size_t len, shortlen;
1591 asection *sec;
1592
1593 /* If this symbol has a version, and it is the default version, we
1594 create an indirect symbol from the default name to the fully
1595 decorated name. This will cause external references which do not
1596 specify a version to be bound to this version of the symbol. */
1597 p = strchr (name, ELF_VER_CHR);
1598 if (p == NULL || p[1] != ELF_VER_CHR)
1599 return TRUE;
1600
1601 if (override)
1602 {
4cc11e76 1603 /* We are overridden by an old definition. We need to check if we
45d6a902
AM
1604 need to create the indirect symbol from the default name. */
1605 hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
1606 FALSE, FALSE);
1607 BFD_ASSERT (hi != NULL);
1608 if (hi == h)
1609 return TRUE;
1610 while (hi->root.type == bfd_link_hash_indirect
1611 || hi->root.type == bfd_link_hash_warning)
1612 {
1613 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1614 if (hi == h)
1615 return TRUE;
1616 }
1617 }
1618
1619 bed = get_elf_backend_data (abfd);
1620 collect = bed->collect;
1621 dynamic = (abfd->flags & DYNAMIC) != 0;
1622
1623 shortlen = p - name;
1624 shortname = bfd_hash_allocate (&info->hash->table, shortlen + 1);
1625 if (shortname == NULL)
1626 return FALSE;
1627 memcpy (shortname, name, shortlen);
1628 shortname[shortlen] = '\0';
1629
1630 /* We are going to create a new symbol. Merge it with any existing
1631 symbol with this name. For the purposes of the merge, act as
1632 though we were defining the symbol we just defined, although we
1633 actually going to define an indirect symbol. */
1634 type_change_ok = FALSE;
1635 size_change_ok = FALSE;
1636 sec = *psec;
1637 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
af44c138
L
1638 NULL, &hi, &skip, &override,
1639 &type_change_ok, &size_change_ok))
45d6a902
AM
1640 return FALSE;
1641
1642 if (skip)
1643 goto nondefault;
1644
1645 if (! override)
1646 {
1647 bh = &hi->root;
1648 if (! (_bfd_generic_link_add_one_symbol
1649 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
268b6b39 1650 0, name, FALSE, collect, &bh)))
45d6a902
AM
1651 return FALSE;
1652 hi = (struct elf_link_hash_entry *) bh;
1653 }
1654 else
1655 {
1656 /* In this case the symbol named SHORTNAME is overriding the
1657 indirect symbol we want to add. We were planning on making
1658 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1659 is the name without a version. NAME is the fully versioned
1660 name, and it is the default version.
1661
1662 Overriding means that we already saw a definition for the
1663 symbol SHORTNAME in a regular object, and it is overriding
1664 the symbol defined in the dynamic object.
1665
1666 When this happens, we actually want to change NAME, the
1667 symbol we just added, to refer to SHORTNAME. This will cause
1668 references to NAME in the shared object to become references
1669 to SHORTNAME in the regular object. This is what we expect
1670 when we override a function in a shared object: that the
1671 references in the shared object will be mapped to the
1672 definition in the regular object. */
1673
1674 while (hi->root.type == bfd_link_hash_indirect
1675 || hi->root.type == bfd_link_hash_warning)
1676 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1677
1678 h->root.type = bfd_link_hash_indirect;
1679 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
f5385ebf 1680 if (h->def_dynamic)
45d6a902 1681 {
f5385ebf
AM
1682 h->def_dynamic = 0;
1683 hi->ref_dynamic = 1;
1684 if (hi->ref_regular
1685 || hi->def_regular)
45d6a902 1686 {
c152c796 1687 if (! bfd_elf_link_record_dynamic_symbol (info, hi))
45d6a902
AM
1688 return FALSE;
1689 }
1690 }
1691
1692 /* Now set HI to H, so that the following code will set the
1693 other fields correctly. */
1694 hi = h;
1695 }
1696
fab4a87f
L
1697 /* Check if HI is a warning symbol. */
1698 if (hi->root.type == bfd_link_hash_warning)
1699 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1700
45d6a902
AM
1701 /* If there is a duplicate definition somewhere, then HI may not
1702 point to an indirect symbol. We will have reported an error to
1703 the user in that case. */
1704
1705 if (hi->root.type == bfd_link_hash_indirect)
1706 {
1707 struct elf_link_hash_entry *ht;
1708
45d6a902 1709 ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
fcfa13d2 1710 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
45d6a902
AM
1711
1712 /* See if the new flags lead us to realize that the symbol must
1713 be dynamic. */
1714 if (! *dynsym)
1715 {
1716 if (! dynamic)
1717 {
1718 if (info->shared
f5385ebf 1719 || hi->ref_dynamic)
45d6a902
AM
1720 *dynsym = TRUE;
1721 }
1722 else
1723 {
f5385ebf 1724 if (hi->ref_regular)
45d6a902
AM
1725 *dynsym = TRUE;
1726 }
1727 }
1728 }
1729
1730 /* We also need to define an indirection from the nondefault version
1731 of the symbol. */
1732
1733nondefault:
1734 len = strlen (name);
1735 shortname = bfd_hash_allocate (&info->hash->table, len);
1736 if (shortname == NULL)
1737 return FALSE;
1738 memcpy (shortname, name, shortlen);
1739 memcpy (shortname + shortlen, p + 1, len - shortlen);
1740
1741 /* Once again, merge with any existing symbol. */
1742 type_change_ok = FALSE;
1743 size_change_ok = FALSE;
1744 sec = *psec;
1745 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
af44c138
L
1746 NULL, &hi, &skip, &override,
1747 &type_change_ok, &size_change_ok))
45d6a902
AM
1748 return FALSE;
1749
1750 if (skip)
1751 return TRUE;
1752
1753 if (override)
1754 {
1755 /* Here SHORTNAME is a versioned name, so we don't expect to see
1756 the type of override we do in the case above unless it is
4cc11e76 1757 overridden by a versioned definition. */
45d6a902
AM
1758 if (hi->root.type != bfd_link_hash_defined
1759 && hi->root.type != bfd_link_hash_defweak)
1760 (*_bfd_error_handler)
d003868e
AM
1761 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1762 abfd, shortname);
45d6a902
AM
1763 }
1764 else
1765 {
1766 bh = &hi->root;
1767 if (! (_bfd_generic_link_add_one_symbol
1768 (info, abfd, shortname, BSF_INDIRECT,
268b6b39 1769 bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
45d6a902
AM
1770 return FALSE;
1771 hi = (struct elf_link_hash_entry *) bh;
1772
1773 /* If there is a duplicate definition somewhere, then HI may not
1774 point to an indirect symbol. We will have reported an error
1775 to the user in that case. */
1776
1777 if (hi->root.type == bfd_link_hash_indirect)
1778 {
fcfa13d2 1779 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
45d6a902
AM
1780
1781 /* See if the new flags lead us to realize that the symbol
1782 must be dynamic. */
1783 if (! *dynsym)
1784 {
1785 if (! dynamic)
1786 {
1787 if (info->shared
f5385ebf 1788 || hi->ref_dynamic)
45d6a902
AM
1789 *dynsym = TRUE;
1790 }
1791 else
1792 {
f5385ebf 1793 if (hi->ref_regular)
45d6a902
AM
1794 *dynsym = TRUE;
1795 }
1796 }
1797 }
1798 }
1799
1800 return TRUE;
1801}
1802\f
1803/* This routine is used to export all defined symbols into the dynamic
1804 symbol table. It is called via elf_link_hash_traverse. */
1805
28caa186 1806static bfd_boolean
268b6b39 1807_bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
45d6a902 1808{
268b6b39 1809 struct elf_info_failed *eif = data;
45d6a902 1810
55255dae
L
1811 /* Ignore this if we won't export it. */
1812 if (!eif->info->export_dynamic && !h->dynamic)
1813 return TRUE;
1814
45d6a902
AM
1815 /* Ignore indirect symbols. These are added by the versioning code. */
1816 if (h->root.type == bfd_link_hash_indirect)
1817 return TRUE;
1818
1819 if (h->root.type == bfd_link_hash_warning)
1820 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1821
1822 if (h->dynindx == -1
f5385ebf
AM
1823 && (h->def_regular
1824 || h->ref_regular))
45d6a902 1825 {
1e8fa21e 1826 bfd_boolean hide;
45d6a902 1827
1e8fa21e 1828 if (eif->verdefs == NULL
09e2aba4 1829 || (bfd_find_version_for_sym (eif->verdefs, h->root.root.string, &hide)
1e8fa21e 1830 && !hide))
45d6a902 1831 {
c152c796 1832 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
45d6a902
AM
1833 {
1834 eif->failed = TRUE;
1835 return FALSE;
1836 }
1837 }
1838 }
1839
1840 return TRUE;
1841}
1842\f
1843/* Look through the symbols which are defined in other shared
1844 libraries and referenced here. Update the list of version
1845 dependencies. This will be put into the .gnu.version_r section.
1846 This function is called via elf_link_hash_traverse. */
1847
28caa186 1848static bfd_boolean
268b6b39
AM
1849_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1850 void *data)
45d6a902 1851{
268b6b39 1852 struct elf_find_verdep_info *rinfo = data;
45d6a902
AM
1853 Elf_Internal_Verneed *t;
1854 Elf_Internal_Vernaux *a;
1855 bfd_size_type amt;
1856
1857 if (h->root.type == bfd_link_hash_warning)
1858 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1859
1860 /* We only care about symbols defined in shared objects with version
1861 information. */
f5385ebf
AM
1862 if (!h->def_dynamic
1863 || h->def_regular
45d6a902
AM
1864 || h->dynindx == -1
1865 || h->verinfo.verdef == NULL)
1866 return TRUE;
1867
1868 /* See if we already know about this version. */
28caa186
AM
1869 for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1870 t != NULL;
1871 t = t->vn_nextref)
45d6a902
AM
1872 {
1873 if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1874 continue;
1875
1876 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1877 if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1878 return TRUE;
1879
1880 break;
1881 }
1882
1883 /* This is a new version. Add it to tree we are building. */
1884
1885 if (t == NULL)
1886 {
1887 amt = sizeof *t;
28caa186 1888 t = bfd_zalloc (rinfo->info->output_bfd, amt);
45d6a902
AM
1889 if (t == NULL)
1890 {
1891 rinfo->failed = TRUE;
1892 return FALSE;
1893 }
1894
1895 t->vn_bfd = h->verinfo.verdef->vd_bfd;
28caa186
AM
1896 t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1897 elf_tdata (rinfo->info->output_bfd)->verref = t;
45d6a902
AM
1898 }
1899
1900 amt = sizeof *a;
28caa186 1901 a = bfd_zalloc (rinfo->info->output_bfd, amt);
14b1c01e
AM
1902 if (a == NULL)
1903 {
1904 rinfo->failed = TRUE;
1905 return FALSE;
1906 }
45d6a902
AM
1907
1908 /* Note that we are copying a string pointer here, and testing it
1909 above. If bfd_elf_string_from_elf_section is ever changed to
1910 discard the string data when low in memory, this will have to be
1911 fixed. */
1912 a->vna_nodename = h->verinfo.verdef->vd_nodename;
1913
1914 a->vna_flags = h->verinfo.verdef->vd_flags;
1915 a->vna_nextptr = t->vn_auxptr;
1916
1917 h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1918 ++rinfo->vers;
1919
1920 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1921
1922 t->vn_auxptr = a;
1923
1924 return TRUE;
1925}
1926
1927/* Figure out appropriate versions for all the symbols. We may not
1928 have the version number script until we have read all of the input
1929 files, so until that point we don't know which symbols should be
1930 local. This function is called via elf_link_hash_traverse. */
1931
28caa186 1932static bfd_boolean
268b6b39 1933_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
45d6a902 1934{
28caa186 1935 struct elf_info_failed *sinfo;
45d6a902 1936 struct bfd_link_info *info;
9c5bfbb7 1937 const struct elf_backend_data *bed;
45d6a902
AM
1938 struct elf_info_failed eif;
1939 char *p;
1940 bfd_size_type amt;
1941
268b6b39 1942 sinfo = data;
45d6a902
AM
1943 info = sinfo->info;
1944
1945 if (h->root.type == bfd_link_hash_warning)
1946 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1947
1948 /* Fix the symbol flags. */
1949 eif.failed = FALSE;
1950 eif.info = info;
1951 if (! _bfd_elf_fix_symbol_flags (h, &eif))
1952 {
1953 if (eif.failed)
1954 sinfo->failed = TRUE;
1955 return FALSE;
1956 }
1957
1958 /* We only need version numbers for symbols defined in regular
1959 objects. */
f5385ebf 1960 if (!h->def_regular)
45d6a902
AM
1961 return TRUE;
1962
28caa186 1963 bed = get_elf_backend_data (info->output_bfd);
45d6a902
AM
1964 p = strchr (h->root.root.string, ELF_VER_CHR);
1965 if (p != NULL && h->verinfo.vertree == NULL)
1966 {
1967 struct bfd_elf_version_tree *t;
1968 bfd_boolean hidden;
1969
1970 hidden = TRUE;
1971
1972 /* There are two consecutive ELF_VER_CHR characters if this is
1973 not a hidden symbol. */
1974 ++p;
1975 if (*p == ELF_VER_CHR)
1976 {
1977 hidden = FALSE;
1978 ++p;
1979 }
1980
1981 /* If there is no version string, we can just return out. */
1982 if (*p == '\0')
1983 {
1984 if (hidden)
f5385ebf 1985 h->hidden = 1;
45d6a902
AM
1986 return TRUE;
1987 }
1988
1989 /* Look for the version. If we find it, it is no longer weak. */
1990 for (t = sinfo->verdefs; t != NULL; t = t->next)
1991 {
1992 if (strcmp (t->name, p) == 0)
1993 {
1994 size_t len;
1995 char *alc;
1996 struct bfd_elf_version_expr *d;
1997
1998 len = p - h->root.root.string;
268b6b39 1999 alc = bfd_malloc (len);
45d6a902 2000 if (alc == NULL)
14b1c01e
AM
2001 {
2002 sinfo->failed = TRUE;
2003 return FALSE;
2004 }
45d6a902
AM
2005 memcpy (alc, h->root.root.string, len - 1);
2006 alc[len - 1] = '\0';
2007 if (alc[len - 2] == ELF_VER_CHR)
2008 alc[len - 2] = '\0';
2009
2010 h->verinfo.vertree = t;
2011 t->used = TRUE;
2012 d = NULL;
2013
108ba305
JJ
2014 if (t->globals.list != NULL)
2015 d = (*t->match) (&t->globals, NULL, alc);
45d6a902
AM
2016
2017 /* See if there is anything to force this symbol to
2018 local scope. */
108ba305 2019 if (d == NULL && t->locals.list != NULL)
45d6a902 2020 {
108ba305
JJ
2021 d = (*t->match) (&t->locals, NULL, alc);
2022 if (d != NULL
2023 && h->dynindx != -1
108ba305
JJ
2024 && ! info->export_dynamic)
2025 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
45d6a902
AM
2026 }
2027
2028 free (alc);
2029 break;
2030 }
2031 }
2032
2033 /* If we are building an application, we need to create a
2034 version node for this version. */
36af4a4e 2035 if (t == NULL && info->executable)
45d6a902
AM
2036 {
2037 struct bfd_elf_version_tree **pp;
2038 int version_index;
2039
2040 /* If we aren't going to export this symbol, we don't need
2041 to worry about it. */
2042 if (h->dynindx == -1)
2043 return TRUE;
2044
2045 amt = sizeof *t;
28caa186 2046 t = bfd_zalloc (info->output_bfd, amt);
45d6a902
AM
2047 if (t == NULL)
2048 {
2049 sinfo->failed = TRUE;
2050 return FALSE;
2051 }
2052
45d6a902 2053 t->name = p;
45d6a902
AM
2054 t->name_indx = (unsigned int) -1;
2055 t->used = TRUE;
2056
2057 version_index = 1;
2058 /* Don't count anonymous version tag. */
2059 if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
2060 version_index = 0;
2061 for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
2062 ++version_index;
2063 t->vernum = version_index;
2064
2065 *pp = t;
2066
2067 h->verinfo.vertree = t;
2068 }
2069 else if (t == NULL)
2070 {
2071 /* We could not find the version for a symbol when
2072 generating a shared archive. Return an error. */
2073 (*_bfd_error_handler)
c55fe096 2074 (_("%B: version node not found for symbol %s"),
28caa186 2075 info->output_bfd, h->root.root.string);
45d6a902
AM
2076 bfd_set_error (bfd_error_bad_value);
2077 sinfo->failed = TRUE;
2078 return FALSE;
2079 }
2080
2081 if (hidden)
f5385ebf 2082 h->hidden = 1;
45d6a902
AM
2083 }
2084
2085 /* If we don't have a version for this symbol, see if we can find
2086 something. */
2087 if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
2088 {
1e8fa21e 2089 bfd_boolean hide;
ae5a3597 2090
09e2aba4 2091 h->verinfo.vertree = bfd_find_version_for_sym (sinfo->verdefs,
1e8fa21e
AM
2092 h->root.root.string, &hide);
2093 if (h->verinfo.vertree != NULL && hide)
2094 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
45d6a902
AM
2095 }
2096
2097 return TRUE;
2098}
2099\f
45d6a902
AM
2100/* Read and swap the relocs from the section indicated by SHDR. This
2101 may be either a REL or a RELA section. The relocations are
2102 translated into RELA relocations and stored in INTERNAL_RELOCS,
2103 which should have already been allocated to contain enough space.
2104 The EXTERNAL_RELOCS are a buffer where the external form of the
2105 relocations should be stored.
2106
2107 Returns FALSE if something goes wrong. */
2108
2109static bfd_boolean
268b6b39 2110elf_link_read_relocs_from_section (bfd *abfd,
243ef1e0 2111 asection *sec,
268b6b39
AM
2112 Elf_Internal_Shdr *shdr,
2113 void *external_relocs,
2114 Elf_Internal_Rela *internal_relocs)
45d6a902 2115{
9c5bfbb7 2116 const struct elf_backend_data *bed;
268b6b39 2117 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
45d6a902
AM
2118 const bfd_byte *erela;
2119 const bfd_byte *erelaend;
2120 Elf_Internal_Rela *irela;
243ef1e0
L
2121 Elf_Internal_Shdr *symtab_hdr;
2122 size_t nsyms;
45d6a902 2123
45d6a902
AM
2124 /* Position ourselves at the start of the section. */
2125 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2126 return FALSE;
2127
2128 /* Read the relocations. */
2129 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2130 return FALSE;
2131
243ef1e0 2132 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
ce98a316 2133 nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
243ef1e0 2134
45d6a902
AM
2135 bed = get_elf_backend_data (abfd);
2136
2137 /* Convert the external relocations to the internal format. */
2138 if (shdr->sh_entsize == bed->s->sizeof_rel)
2139 swap_in = bed->s->swap_reloc_in;
2140 else if (shdr->sh_entsize == bed->s->sizeof_rela)
2141 swap_in = bed->s->swap_reloca_in;
2142 else
2143 {
2144 bfd_set_error (bfd_error_wrong_format);
2145 return FALSE;
2146 }
2147
2148 erela = external_relocs;
51992aec 2149 erelaend = erela + shdr->sh_size;
45d6a902
AM
2150 irela = internal_relocs;
2151 while (erela < erelaend)
2152 {
243ef1e0
L
2153 bfd_vma r_symndx;
2154
45d6a902 2155 (*swap_in) (abfd, erela, irela);
243ef1e0
L
2156 r_symndx = ELF32_R_SYM (irela->r_info);
2157 if (bed->s->arch_size == 64)
2158 r_symndx >>= 24;
ce98a316
NC
2159 if (nsyms > 0)
2160 {
2161 if ((size_t) r_symndx >= nsyms)
2162 {
2163 (*_bfd_error_handler)
2164 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2165 " for offset 0x%lx in section `%A'"),
2166 abfd, sec,
2167 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2168 bfd_set_error (bfd_error_bad_value);
2169 return FALSE;
2170 }
2171 }
2172 else if (r_symndx != 0)
243ef1e0
L
2173 {
2174 (*_bfd_error_handler)
ce98a316
NC
2175 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2176 " when the object file has no symbol table"),
d003868e
AM
2177 abfd, sec,
2178 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
243ef1e0
L
2179 bfd_set_error (bfd_error_bad_value);
2180 return FALSE;
2181 }
45d6a902
AM
2182 irela += bed->s->int_rels_per_ext_rel;
2183 erela += shdr->sh_entsize;
2184 }
2185
2186 return TRUE;
2187}
2188
2189/* Read and swap the relocs for a section O. They may have been
2190 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2191 not NULL, they are used as buffers to read into. They are known to
2192 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2193 the return value is allocated using either malloc or bfd_alloc,
2194 according to the KEEP_MEMORY argument. If O has two relocation
2195 sections (both REL and RELA relocations), then the REL_HDR
2196 relocations will appear first in INTERNAL_RELOCS, followed by the
2197 REL_HDR2 relocations. */
2198
2199Elf_Internal_Rela *
268b6b39
AM
2200_bfd_elf_link_read_relocs (bfd *abfd,
2201 asection *o,
2202 void *external_relocs,
2203 Elf_Internal_Rela *internal_relocs,
2204 bfd_boolean keep_memory)
45d6a902
AM
2205{
2206 Elf_Internal_Shdr *rel_hdr;
268b6b39 2207 void *alloc1 = NULL;
45d6a902 2208 Elf_Internal_Rela *alloc2 = NULL;
9c5bfbb7 2209 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
45d6a902
AM
2210
2211 if (elf_section_data (o)->relocs != NULL)
2212 return elf_section_data (o)->relocs;
2213
2214 if (o->reloc_count == 0)
2215 return NULL;
2216
2217 rel_hdr = &elf_section_data (o)->rel_hdr;
2218
2219 if (internal_relocs == NULL)
2220 {
2221 bfd_size_type size;
2222
2223 size = o->reloc_count;
2224 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2225 if (keep_memory)
4dd07732 2226 internal_relocs = alloc2 = bfd_alloc (abfd, size);
45d6a902 2227 else
268b6b39 2228 internal_relocs = alloc2 = bfd_malloc (size);
45d6a902
AM
2229 if (internal_relocs == NULL)
2230 goto error_return;
2231 }
2232
2233 if (external_relocs == NULL)
2234 {
2235 bfd_size_type size = rel_hdr->sh_size;
2236
2237 if (elf_section_data (o)->rel_hdr2)
2238 size += elf_section_data (o)->rel_hdr2->sh_size;
268b6b39 2239 alloc1 = bfd_malloc (size);
45d6a902
AM
2240 if (alloc1 == NULL)
2241 goto error_return;
2242 external_relocs = alloc1;
2243 }
2244
243ef1e0 2245 if (!elf_link_read_relocs_from_section (abfd, o, rel_hdr,
45d6a902
AM
2246 external_relocs,
2247 internal_relocs))
2248 goto error_return;
51992aec
AM
2249 if (elf_section_data (o)->rel_hdr2
2250 && (!elf_link_read_relocs_from_section
2251 (abfd, o,
2252 elf_section_data (o)->rel_hdr2,
2253 ((bfd_byte *) external_relocs) + rel_hdr->sh_size,
2254 internal_relocs + (NUM_SHDR_ENTRIES (rel_hdr)
2255 * bed->s->int_rels_per_ext_rel))))
45d6a902
AM
2256 goto error_return;
2257
2258 /* Cache the results for next time, if we can. */
2259 if (keep_memory)
2260 elf_section_data (o)->relocs = internal_relocs;
2261
2262 if (alloc1 != NULL)
2263 free (alloc1);
2264
2265 /* Don't free alloc2, since if it was allocated we are passing it
2266 back (under the name of internal_relocs). */
2267
2268 return internal_relocs;
2269
2270 error_return:
2271 if (alloc1 != NULL)
2272 free (alloc1);
2273 if (alloc2 != NULL)
4dd07732
AM
2274 {
2275 if (keep_memory)
2276 bfd_release (abfd, alloc2);
2277 else
2278 free (alloc2);
2279 }
45d6a902
AM
2280 return NULL;
2281}
2282
2283/* Compute the size of, and allocate space for, REL_HDR which is the
2284 section header for a section containing relocations for O. */
2285
28caa186 2286static bfd_boolean
268b6b39
AM
2287_bfd_elf_link_size_reloc_section (bfd *abfd,
2288 Elf_Internal_Shdr *rel_hdr,
2289 asection *o)
45d6a902
AM
2290{
2291 bfd_size_type reloc_count;
2292 bfd_size_type num_rel_hashes;
2293
2294 /* Figure out how many relocations there will be. */
2295 if (rel_hdr == &elf_section_data (o)->rel_hdr)
2296 reloc_count = elf_section_data (o)->rel_count;
2297 else
2298 reloc_count = elf_section_data (o)->rel_count2;
2299
2300 num_rel_hashes = o->reloc_count;
2301 if (num_rel_hashes < reloc_count)
2302 num_rel_hashes = reloc_count;
2303
2304 /* That allows us to calculate the size of the section. */
2305 rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count;
2306
2307 /* The contents field must last into write_object_contents, so we
2308 allocate it with bfd_alloc rather than malloc. Also since we
2309 cannot be sure that the contents will actually be filled in,
2310 we zero the allocated space. */
268b6b39 2311 rel_hdr->contents = bfd_zalloc (abfd, rel_hdr->sh_size);
45d6a902
AM
2312 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2313 return FALSE;
2314
2315 /* We only allocate one set of hash entries, so we only do it the
2316 first time we are called. */
2317 if (elf_section_data (o)->rel_hashes == NULL
2318 && num_rel_hashes)
2319 {
2320 struct elf_link_hash_entry **p;
2321
268b6b39 2322 p = bfd_zmalloc (num_rel_hashes * sizeof (struct elf_link_hash_entry *));
45d6a902
AM
2323 if (p == NULL)
2324 return FALSE;
2325
2326 elf_section_data (o)->rel_hashes = p;
2327 }
2328
2329 return TRUE;
2330}
2331
2332/* Copy the relocations indicated by the INTERNAL_RELOCS (which
2333 originated from the section given by INPUT_REL_HDR) to the
2334 OUTPUT_BFD. */
2335
2336bfd_boolean
268b6b39
AM
2337_bfd_elf_link_output_relocs (bfd *output_bfd,
2338 asection *input_section,
2339 Elf_Internal_Shdr *input_rel_hdr,
eac338cf
PB
2340 Elf_Internal_Rela *internal_relocs,
2341 struct elf_link_hash_entry **rel_hash
2342 ATTRIBUTE_UNUSED)
45d6a902
AM
2343{
2344 Elf_Internal_Rela *irela;
2345 Elf_Internal_Rela *irelaend;
2346 bfd_byte *erel;
2347 Elf_Internal_Shdr *output_rel_hdr;
2348 asection *output_section;
2349 unsigned int *rel_countp = NULL;
9c5bfbb7 2350 const struct elf_backend_data *bed;
268b6b39 2351 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
45d6a902
AM
2352
2353 output_section = input_section->output_section;
2354 output_rel_hdr = NULL;
2355
2356 if (elf_section_data (output_section)->rel_hdr.sh_entsize
2357 == input_rel_hdr->sh_entsize)
2358 {
2359 output_rel_hdr = &elf_section_data (output_section)->rel_hdr;
2360 rel_countp = &elf_section_data (output_section)->rel_count;
2361 }
2362 else if (elf_section_data (output_section)->rel_hdr2
2363 && (elf_section_data (output_section)->rel_hdr2->sh_entsize
2364 == input_rel_hdr->sh_entsize))
2365 {
2366 output_rel_hdr = elf_section_data (output_section)->rel_hdr2;
2367 rel_countp = &elf_section_data (output_section)->rel_count2;
2368 }
2369 else
2370 {
2371 (*_bfd_error_handler)
d003868e
AM
2372 (_("%B: relocation size mismatch in %B section %A"),
2373 output_bfd, input_section->owner, input_section);
297d8443 2374 bfd_set_error (bfd_error_wrong_format);
45d6a902
AM
2375 return FALSE;
2376 }
2377
2378 bed = get_elf_backend_data (output_bfd);
2379 if (input_rel_hdr->sh_entsize == bed->s->sizeof_rel)
2380 swap_out = bed->s->swap_reloc_out;
2381 else if (input_rel_hdr->sh_entsize == bed->s->sizeof_rela)
2382 swap_out = bed->s->swap_reloca_out;
2383 else
2384 abort ();
2385
2386 erel = output_rel_hdr->contents;
2387 erel += *rel_countp * input_rel_hdr->sh_entsize;
2388 irela = internal_relocs;
2389 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2390 * bed->s->int_rels_per_ext_rel);
2391 while (irela < irelaend)
2392 {
2393 (*swap_out) (output_bfd, irela, erel);
2394 irela += bed->s->int_rels_per_ext_rel;
2395 erel += input_rel_hdr->sh_entsize;
2396 }
2397
2398 /* Bump the counter, so that we know where to add the next set of
2399 relocations. */
2400 *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr);
2401
2402 return TRUE;
2403}
2404\f
508c3946
L
2405/* Make weak undefined symbols in PIE dynamic. */
2406
2407bfd_boolean
2408_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2409 struct elf_link_hash_entry *h)
2410{
2411 if (info->pie
2412 && h->dynindx == -1
2413 && h->root.type == bfd_link_hash_undefweak)
2414 return bfd_elf_link_record_dynamic_symbol (info, h);
2415
2416 return TRUE;
2417}
2418
45d6a902
AM
2419/* Fix up the flags for a symbol. This handles various cases which
2420 can only be fixed after all the input files are seen. This is
2421 currently called by both adjust_dynamic_symbol and
2422 assign_sym_version, which is unnecessary but perhaps more robust in
2423 the face of future changes. */
2424
28caa186 2425static bfd_boolean
268b6b39
AM
2426_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2427 struct elf_info_failed *eif)
45d6a902 2428{
33774f08 2429 const struct elf_backend_data *bed;
508c3946 2430
45d6a902
AM
2431 /* If this symbol was mentioned in a non-ELF file, try to set
2432 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2433 permit a non-ELF file to correctly refer to a symbol defined in
2434 an ELF dynamic object. */
f5385ebf 2435 if (h->non_elf)
45d6a902
AM
2436 {
2437 while (h->root.type == bfd_link_hash_indirect)
2438 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2439
2440 if (h->root.type != bfd_link_hash_defined
2441 && h->root.type != bfd_link_hash_defweak)
f5385ebf
AM
2442 {
2443 h->ref_regular = 1;
2444 h->ref_regular_nonweak = 1;
2445 }
45d6a902
AM
2446 else
2447 {
2448 if (h->root.u.def.section->owner != NULL
2449 && (bfd_get_flavour (h->root.u.def.section->owner)
2450 == bfd_target_elf_flavour))
f5385ebf
AM
2451 {
2452 h->ref_regular = 1;
2453 h->ref_regular_nonweak = 1;
2454 }
45d6a902 2455 else
f5385ebf 2456 h->def_regular = 1;
45d6a902
AM
2457 }
2458
2459 if (h->dynindx == -1
f5385ebf
AM
2460 && (h->def_dynamic
2461 || h->ref_dynamic))
45d6a902 2462 {
c152c796 2463 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
45d6a902
AM
2464 {
2465 eif->failed = TRUE;
2466 return FALSE;
2467 }
2468 }
2469 }
2470 else
2471 {
f5385ebf 2472 /* Unfortunately, NON_ELF is only correct if the symbol
45d6a902
AM
2473 was first seen in a non-ELF file. Fortunately, if the symbol
2474 was first seen in an ELF file, we're probably OK unless the
2475 symbol was defined in a non-ELF file. Catch that case here.
2476 FIXME: We're still in trouble if the symbol was first seen in
2477 a dynamic object, and then later in a non-ELF regular object. */
2478 if ((h->root.type == bfd_link_hash_defined
2479 || h->root.type == bfd_link_hash_defweak)
f5385ebf 2480 && !h->def_regular
45d6a902
AM
2481 && (h->root.u.def.section->owner != NULL
2482 ? (bfd_get_flavour (h->root.u.def.section->owner)
2483 != bfd_target_elf_flavour)
2484 : (bfd_is_abs_section (h->root.u.def.section)
f5385ebf
AM
2485 && !h->def_dynamic)))
2486 h->def_regular = 1;
45d6a902
AM
2487 }
2488
508c3946 2489 /* Backend specific symbol fixup. */
33774f08
AM
2490 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2491 if (bed->elf_backend_fixup_symbol
2492 && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2493 return FALSE;
508c3946 2494
45d6a902
AM
2495 /* If this is a final link, and the symbol was defined as a common
2496 symbol in a regular object file, and there was no definition in
2497 any dynamic object, then the linker will have allocated space for
f5385ebf 2498 the symbol in a common section but the DEF_REGULAR
45d6a902
AM
2499 flag will not have been set. */
2500 if (h->root.type == bfd_link_hash_defined
f5385ebf
AM
2501 && !h->def_regular
2502 && h->ref_regular
2503 && !h->def_dynamic
45d6a902 2504 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
f5385ebf 2505 h->def_regular = 1;
45d6a902
AM
2506
2507 /* If -Bsymbolic was used (which means to bind references to global
2508 symbols to the definition within the shared object), and this
2509 symbol was defined in a regular object, then it actually doesn't
9c7a29a3
AM
2510 need a PLT entry. Likewise, if the symbol has non-default
2511 visibility. If the symbol has hidden or internal visibility, we
c1be741f 2512 will force it local. */
f5385ebf 2513 if (h->needs_plt
45d6a902 2514 && eif->info->shared
0eddce27 2515 && is_elf_hash_table (eif->info->hash)
55255dae 2516 && (SYMBOLIC_BIND (eif->info, h)
c1be741f 2517 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
f5385ebf 2518 && h->def_regular)
45d6a902 2519 {
45d6a902
AM
2520 bfd_boolean force_local;
2521
45d6a902
AM
2522 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2523 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2524 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2525 }
2526
2527 /* If a weak undefined symbol has non-default visibility, we also
2528 hide it from the dynamic linker. */
9c7a29a3 2529 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
45d6a902 2530 && h->root.type == bfd_link_hash_undefweak)
33774f08 2531 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
45d6a902
AM
2532
2533 /* If this is a weak defined symbol in a dynamic object, and we know
2534 the real definition in the dynamic object, copy interesting flags
2535 over to the real definition. */
f6e332e6 2536 if (h->u.weakdef != NULL)
45d6a902
AM
2537 {
2538 struct elf_link_hash_entry *weakdef;
2539
f6e332e6 2540 weakdef = h->u.weakdef;
45d6a902
AM
2541 if (h->root.type == bfd_link_hash_indirect)
2542 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2543
2544 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2545 || h->root.type == bfd_link_hash_defweak);
f5385ebf 2546 BFD_ASSERT (weakdef->def_dynamic);
45d6a902
AM
2547
2548 /* If the real definition is defined by a regular object file,
2549 don't do anything special. See the longer description in
2550 _bfd_elf_adjust_dynamic_symbol, below. */
f5385ebf 2551 if (weakdef->def_regular)
f6e332e6 2552 h->u.weakdef = NULL;
45d6a902 2553 else
a26587ba
RS
2554 {
2555 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2556 || weakdef->root.type == bfd_link_hash_defweak);
2557 (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2558 }
45d6a902
AM
2559 }
2560
2561 return TRUE;
2562}
2563
2564/* Make the backend pick a good value for a dynamic symbol. This is
2565 called via elf_link_hash_traverse, and also calls itself
2566 recursively. */
2567
28caa186 2568static bfd_boolean
268b6b39 2569_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
45d6a902 2570{
268b6b39 2571 struct elf_info_failed *eif = data;
45d6a902 2572 bfd *dynobj;
9c5bfbb7 2573 const struct elf_backend_data *bed;
45d6a902 2574
0eddce27 2575 if (! is_elf_hash_table (eif->info->hash))
45d6a902
AM
2576 return FALSE;
2577
2578 if (h->root.type == bfd_link_hash_warning)
2579 {
a6aa5195
AM
2580 h->got = elf_hash_table (eif->info)->init_got_offset;
2581 h->plt = elf_hash_table (eif->info)->init_plt_offset;
45d6a902
AM
2582
2583 /* When warning symbols are created, they **replace** the "real"
2584 entry in the hash table, thus we never get to see the real
2585 symbol in a hash traversal. So look at it now. */
2586 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2587 }
2588
2589 /* Ignore indirect symbols. These are added by the versioning code. */
2590 if (h->root.type == bfd_link_hash_indirect)
2591 return TRUE;
2592
2593 /* Fix the symbol flags. */
2594 if (! _bfd_elf_fix_symbol_flags (h, eif))
2595 return FALSE;
2596
2597 /* If this symbol does not require a PLT entry, and it is not
2598 defined by a dynamic object, or is not referenced by a regular
2599 object, ignore it. We do have to handle a weak defined symbol,
2600 even if no regular object refers to it, if we decided to add it
2601 to the dynamic symbol table. FIXME: Do we normally need to worry
2602 about symbols which are defined by one dynamic object and
2603 referenced by another one? */
f5385ebf
AM
2604 if (!h->needs_plt
2605 && (h->def_regular
2606 || !h->def_dynamic
2607 || (!h->ref_regular
f6e332e6 2608 && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
45d6a902 2609 {
a6aa5195 2610 h->plt = elf_hash_table (eif->info)->init_plt_offset;
45d6a902
AM
2611 return TRUE;
2612 }
2613
2614 /* If we've already adjusted this symbol, don't do it again. This
2615 can happen via a recursive call. */
f5385ebf 2616 if (h->dynamic_adjusted)
45d6a902
AM
2617 return TRUE;
2618
2619 /* Don't look at this symbol again. Note that we must set this
2620 after checking the above conditions, because we may look at a
2621 symbol once, decide not to do anything, and then get called
2622 recursively later after REF_REGULAR is set below. */
f5385ebf 2623 h->dynamic_adjusted = 1;
45d6a902
AM
2624
2625 /* If this is a weak definition, and we know a real definition, and
2626 the real symbol is not itself defined by a regular object file,
2627 then get a good value for the real definition. We handle the
2628 real symbol first, for the convenience of the backend routine.
2629
2630 Note that there is a confusing case here. If the real definition
2631 is defined by a regular object file, we don't get the real symbol
2632 from the dynamic object, but we do get the weak symbol. If the
2633 processor backend uses a COPY reloc, then if some routine in the
2634 dynamic object changes the real symbol, we will not see that
2635 change in the corresponding weak symbol. This is the way other
2636 ELF linkers work as well, and seems to be a result of the shared
2637 library model.
2638
2639 I will clarify this issue. Most SVR4 shared libraries define the
2640 variable _timezone and define timezone as a weak synonym. The
2641 tzset call changes _timezone. If you write
2642 extern int timezone;
2643 int _timezone = 5;
2644 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2645 you might expect that, since timezone is a synonym for _timezone,
2646 the same number will print both times. However, if the processor
2647 backend uses a COPY reloc, then actually timezone will be copied
2648 into your process image, and, since you define _timezone
2649 yourself, _timezone will not. Thus timezone and _timezone will
2650 wind up at different memory locations. The tzset call will set
2651 _timezone, leaving timezone unchanged. */
2652
f6e332e6 2653 if (h->u.weakdef != NULL)
45d6a902
AM
2654 {
2655 /* If we get to this point, we know there is an implicit
2656 reference by a regular object file via the weak symbol H.
2657 FIXME: Is this really true? What if the traversal finds
f6e332e6
AM
2658 H->U.WEAKDEF before it finds H? */
2659 h->u.weakdef->ref_regular = 1;
45d6a902 2660
f6e332e6 2661 if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
45d6a902
AM
2662 return FALSE;
2663 }
2664
2665 /* If a symbol has no type and no size and does not require a PLT
2666 entry, then we are probably about to do the wrong thing here: we
2667 are probably going to create a COPY reloc for an empty object.
2668 This case can arise when a shared object is built with assembly
2669 code, and the assembly code fails to set the symbol type. */
2670 if (h->size == 0
2671 && h->type == STT_NOTYPE
f5385ebf 2672 && !h->needs_plt)
45d6a902
AM
2673 (*_bfd_error_handler)
2674 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2675 h->root.root.string);
2676
2677 dynobj = elf_hash_table (eif->info)->dynobj;
2678 bed = get_elf_backend_data (dynobj);
e7c33416 2679
45d6a902
AM
2680 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2681 {
2682 eif->failed = TRUE;
2683 return FALSE;
2684 }
2685
2686 return TRUE;
2687}
2688
027297b7
L
2689/* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2690 DYNBSS. */
2691
2692bfd_boolean
2693_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2694 asection *dynbss)
2695{
91ac5911 2696 unsigned int power_of_two;
027297b7
L
2697 bfd_vma mask;
2698 asection *sec = h->root.u.def.section;
2699
2700 /* The section aligment of definition is the maximum alignment
91ac5911
L
2701 requirement of symbols defined in the section. Since we don't
2702 know the symbol alignment requirement, we start with the
2703 maximum alignment and check low bits of the symbol address
2704 for the minimum alignment. */
2705 power_of_two = bfd_get_section_alignment (sec->owner, sec);
2706 mask = ((bfd_vma) 1 << power_of_two) - 1;
2707 while ((h->root.u.def.value & mask) != 0)
2708 {
2709 mask >>= 1;
2710 --power_of_two;
2711 }
027297b7 2712
91ac5911
L
2713 if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2714 dynbss))
027297b7
L
2715 {
2716 /* Adjust the section alignment if needed. */
2717 if (! bfd_set_section_alignment (dynbss->owner, dynbss,
91ac5911 2718 power_of_two))
027297b7
L
2719 return FALSE;
2720 }
2721
91ac5911 2722 /* We make sure that the symbol will be aligned properly. */
027297b7
L
2723 dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2724
2725 /* Define the symbol as being at this point in DYNBSS. */
2726 h->root.u.def.section = dynbss;
2727 h->root.u.def.value = dynbss->size;
2728
2729 /* Increment the size of DYNBSS to make room for the symbol. */
2730 dynbss->size += h->size;
2731
2732 return TRUE;
2733}
2734
45d6a902
AM
2735/* Adjust all external symbols pointing into SEC_MERGE sections
2736 to reflect the object merging within the sections. */
2737
28caa186 2738static bfd_boolean
268b6b39 2739_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
45d6a902
AM
2740{
2741 asection *sec;
2742
2743 if (h->root.type == bfd_link_hash_warning)
2744 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2745
2746 if ((h->root.type == bfd_link_hash_defined
2747 || h->root.type == bfd_link_hash_defweak)
2748 && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2749 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2750 {
268b6b39 2751 bfd *output_bfd = data;
45d6a902
AM
2752
2753 h->root.u.def.value =
2754 _bfd_merged_section_offset (output_bfd,
2755 &h->root.u.def.section,
2756 elf_section_data (sec)->sec_info,
753731ee 2757 h->root.u.def.value);
45d6a902
AM
2758 }
2759
2760 return TRUE;
2761}
986a241f
RH
2762
2763/* Returns false if the symbol referred to by H should be considered
2764 to resolve local to the current module, and true if it should be
2765 considered to bind dynamically. */
2766
2767bfd_boolean
268b6b39
AM
2768_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2769 struct bfd_link_info *info,
2770 bfd_boolean ignore_protected)
986a241f
RH
2771{
2772 bfd_boolean binding_stays_local_p;
fcb93ecf
PB
2773 const struct elf_backend_data *bed;
2774 struct elf_link_hash_table *hash_table;
986a241f
RH
2775
2776 if (h == NULL)
2777 return FALSE;
2778
2779 while (h->root.type == bfd_link_hash_indirect
2780 || h->root.type == bfd_link_hash_warning)
2781 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2782
2783 /* If it was forced local, then clearly it's not dynamic. */
2784 if (h->dynindx == -1)
2785 return FALSE;
f5385ebf 2786 if (h->forced_local)
986a241f
RH
2787 return FALSE;
2788
2789 /* Identify the cases where name binding rules say that a
2790 visible symbol resolves locally. */
55255dae 2791 binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
986a241f
RH
2792
2793 switch (ELF_ST_VISIBILITY (h->other))
2794 {
2795 case STV_INTERNAL:
2796 case STV_HIDDEN:
2797 return FALSE;
2798
2799 case STV_PROTECTED:
fcb93ecf
PB
2800 hash_table = elf_hash_table (info);
2801 if (!is_elf_hash_table (hash_table))
2802 return FALSE;
2803
2804 bed = get_elf_backend_data (hash_table->dynobj);
2805
986a241f
RH
2806 /* Proper resolution for function pointer equality may require
2807 that these symbols perhaps be resolved dynamically, even though
2808 we should be resolving them to the current module. */
fcb93ecf 2809 if (!ignore_protected || !bed->is_function_type (h->type))
986a241f
RH
2810 binding_stays_local_p = TRUE;
2811 break;
2812
2813 default:
986a241f
RH
2814 break;
2815 }
2816
aa37626c 2817 /* If it isn't defined locally, then clearly it's dynamic. */
f5385ebf 2818 if (!h->def_regular)
aa37626c
L
2819 return TRUE;
2820
986a241f
RH
2821 /* Otherwise, the symbol is dynamic if binding rules don't tell
2822 us that it remains local. */
2823 return !binding_stays_local_p;
2824}
f6c52c13
AM
2825
2826/* Return true if the symbol referred to by H should be considered
2827 to resolve local to the current module, and false otherwise. Differs
2828 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2829 undefined symbols and weak symbols. */
2830
2831bfd_boolean
268b6b39
AM
2832_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2833 struct bfd_link_info *info,
2834 bfd_boolean local_protected)
f6c52c13 2835{
fcb93ecf
PB
2836 const struct elf_backend_data *bed;
2837 struct elf_link_hash_table *hash_table;
2838
f6c52c13
AM
2839 /* If it's a local sym, of course we resolve locally. */
2840 if (h == NULL)
2841 return TRUE;
2842
d95edcac
L
2843 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2844 if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2845 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2846 return TRUE;
2847
7e2294f9
AO
2848 /* Common symbols that become definitions don't get the DEF_REGULAR
2849 flag set, so test it first, and don't bail out. */
2850 if (ELF_COMMON_DEF_P (h))
2851 /* Do nothing. */;
f6c52c13 2852 /* If we don't have a definition in a regular file, then we can't
49ff44d6
L
2853 resolve locally. The sym is either undefined or dynamic. */
2854 else if (!h->def_regular)
f6c52c13
AM
2855 return FALSE;
2856
2857 /* Forced local symbols resolve locally. */
f5385ebf 2858 if (h->forced_local)
f6c52c13
AM
2859 return TRUE;
2860
2861 /* As do non-dynamic symbols. */
2862 if (h->dynindx == -1)
2863 return TRUE;
2864
2865 /* At this point, we know the symbol is defined and dynamic. In an
2866 executable it must resolve locally, likewise when building symbolic
2867 shared libraries. */
55255dae 2868 if (info->executable || SYMBOLIC_BIND (info, h))
f6c52c13
AM
2869 return TRUE;
2870
2871 /* Now deal with defined dynamic symbols in shared libraries. Ones
2872 with default visibility might not resolve locally. */
2873 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2874 return FALSE;
2875
fcb93ecf
PB
2876 hash_table = elf_hash_table (info);
2877 if (!is_elf_hash_table (hash_table))
2878 return TRUE;
2879
2880 bed = get_elf_backend_data (hash_table->dynobj);
2881
1c16dfa5 2882 /* STV_PROTECTED non-function symbols are local. */
fcb93ecf 2883 if (!bed->is_function_type (h->type))
1c16dfa5
L
2884 return TRUE;
2885
f6c52c13
AM
2886 /* Function pointer equality tests may require that STV_PROTECTED
2887 symbols be treated as dynamic symbols, even when we know that the
2888 dynamic linker will resolve them locally. */
2889 return local_protected;
2890}
e1918d23
AM
2891
2892/* Caches some TLS segment info, and ensures that the TLS segment vma is
2893 aligned. Returns the first TLS output section. */
2894
2895struct bfd_section *
2896_bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2897{
2898 struct bfd_section *sec, *tls;
2899 unsigned int align = 0;
2900
2901 for (sec = obfd->sections; sec != NULL; sec = sec->next)
2902 if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2903 break;
2904 tls = sec;
2905
2906 for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2907 if (sec->alignment_power > align)
2908 align = sec->alignment_power;
2909
2910 elf_hash_table (info)->tls_sec = tls;
2911
2912 /* Ensure the alignment of the first section is the largest alignment,
2913 so that the tls segment starts aligned. */
2914 if (tls != NULL)
2915 tls->alignment_power = align;
2916
2917 return tls;
2918}
0ad989f9
L
2919
2920/* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2921static bfd_boolean
2922is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2923 Elf_Internal_Sym *sym)
2924{
a4d8e49b
L
2925 const struct elf_backend_data *bed;
2926
0ad989f9
L
2927 /* Local symbols do not count, but target specific ones might. */
2928 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2929 && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2930 return FALSE;
2931
fcb93ecf 2932 bed = get_elf_backend_data (abfd);
0ad989f9 2933 /* Function symbols do not count. */
fcb93ecf 2934 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
0ad989f9
L
2935 return FALSE;
2936
2937 /* If the section is undefined, then so is the symbol. */
2938 if (sym->st_shndx == SHN_UNDEF)
2939 return FALSE;
2940
2941 /* If the symbol is defined in the common section, then
2942 it is a common definition and so does not count. */
a4d8e49b 2943 if (bed->common_definition (sym))
0ad989f9
L
2944 return FALSE;
2945
2946 /* If the symbol is in a target specific section then we
2947 must rely upon the backend to tell us what it is. */
2948 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2949 /* FIXME - this function is not coded yet:
2950
2951 return _bfd_is_global_symbol_definition (abfd, sym);
2952
2953 Instead for now assume that the definition is not global,
2954 Even if this is wrong, at least the linker will behave
2955 in the same way that it used to do. */
2956 return FALSE;
2957
2958 return TRUE;
2959}
2960
2961/* Search the symbol table of the archive element of the archive ABFD
2962 whose archive map contains a mention of SYMDEF, and determine if
2963 the symbol is defined in this element. */
2964static bfd_boolean
2965elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2966{
2967 Elf_Internal_Shdr * hdr;
2968 bfd_size_type symcount;
2969 bfd_size_type extsymcount;
2970 bfd_size_type extsymoff;
2971 Elf_Internal_Sym *isymbuf;
2972 Elf_Internal_Sym *isym;
2973 Elf_Internal_Sym *isymend;
2974 bfd_boolean result;
2975
2976 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2977 if (abfd == NULL)
2978 return FALSE;
2979
2980 if (! bfd_check_format (abfd, bfd_object))
2981 return FALSE;
2982
2983 /* If we have already included the element containing this symbol in the
2984 link then we do not need to include it again. Just claim that any symbol
2985 it contains is not a definition, so that our caller will not decide to
2986 (re)include this element. */
2987 if (abfd->archive_pass)
2988 return FALSE;
2989
2990 /* Select the appropriate symbol table. */
2991 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2992 hdr = &elf_tdata (abfd)->symtab_hdr;
2993 else
2994 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2995
2996 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2997
2998 /* The sh_info field of the symtab header tells us where the
2999 external symbols start. We don't care about the local symbols. */
3000 if (elf_bad_symtab (abfd))
3001 {
3002 extsymcount = symcount;
3003 extsymoff = 0;
3004 }
3005 else
3006 {
3007 extsymcount = symcount - hdr->sh_info;
3008 extsymoff = hdr->sh_info;
3009 }
3010
3011 if (extsymcount == 0)
3012 return FALSE;
3013
3014 /* Read in the symbol table. */
3015 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3016 NULL, NULL, NULL);
3017 if (isymbuf == NULL)
3018 return FALSE;
3019
3020 /* Scan the symbol table looking for SYMDEF. */
3021 result = FALSE;
3022 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3023 {
3024 const char *name;
3025
3026 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3027 isym->st_name);
3028 if (name == NULL)
3029 break;
3030
3031 if (strcmp (name, symdef->name) == 0)
3032 {
3033 result = is_global_data_symbol_definition (abfd, isym);
3034 break;
3035 }
3036 }
3037
3038 free (isymbuf);
3039
3040 return result;
3041}
3042\f
5a580b3a
AM
3043/* Add an entry to the .dynamic table. */
3044
3045bfd_boolean
3046_bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3047 bfd_vma tag,
3048 bfd_vma val)
3049{
3050 struct elf_link_hash_table *hash_table;
3051 const struct elf_backend_data *bed;
3052 asection *s;
3053 bfd_size_type newsize;
3054 bfd_byte *newcontents;
3055 Elf_Internal_Dyn dyn;
3056
3057 hash_table = elf_hash_table (info);
3058 if (! is_elf_hash_table (hash_table))
3059 return FALSE;
3060
3061 bed = get_elf_backend_data (hash_table->dynobj);
3062 s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3063 BFD_ASSERT (s != NULL);
3064
eea6121a 3065 newsize = s->size + bed->s->sizeof_dyn;
5a580b3a
AM
3066 newcontents = bfd_realloc (s->contents, newsize);
3067 if (newcontents == NULL)
3068 return FALSE;
3069
3070 dyn.d_tag = tag;
3071 dyn.d_un.d_val = val;
eea6121a 3072 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
5a580b3a 3073
eea6121a 3074 s->size = newsize;
5a580b3a
AM
3075 s->contents = newcontents;
3076
3077 return TRUE;
3078}
3079
3080/* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3081 otherwise just check whether one already exists. Returns -1 on error,
3082 1 if a DT_NEEDED tag already exists, and 0 on success. */
3083
4ad4eba5 3084static int
7e9f0867
AM
3085elf_add_dt_needed_tag (bfd *abfd,
3086 struct bfd_link_info *info,
4ad4eba5
AM
3087 const char *soname,
3088 bfd_boolean do_it)
5a580b3a
AM
3089{
3090 struct elf_link_hash_table *hash_table;
3091 bfd_size_type oldsize;
3092 bfd_size_type strindex;
3093
7e9f0867
AM
3094 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3095 return -1;
3096
5a580b3a
AM
3097 hash_table = elf_hash_table (info);
3098 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3099 strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3100 if (strindex == (bfd_size_type) -1)
3101 return -1;
3102
3103 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3104 {
3105 asection *sdyn;
3106 const struct elf_backend_data *bed;
3107 bfd_byte *extdyn;
3108
3109 bed = get_elf_backend_data (hash_table->dynobj);
3110 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
7e9f0867
AM
3111 if (sdyn != NULL)
3112 for (extdyn = sdyn->contents;
3113 extdyn < sdyn->contents + sdyn->size;
3114 extdyn += bed->s->sizeof_dyn)
3115 {
3116 Elf_Internal_Dyn dyn;
5a580b3a 3117
7e9f0867
AM
3118 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3119 if (dyn.d_tag == DT_NEEDED
3120 && dyn.d_un.d_val == strindex)
3121 {
3122 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3123 return 1;
3124 }
3125 }
5a580b3a
AM
3126 }
3127
3128 if (do_it)
3129 {
7e9f0867
AM
3130 if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3131 return -1;
3132
5a580b3a
AM
3133 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3134 return -1;
3135 }
3136 else
3137 /* We were just checking for existence of the tag. */
3138 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3139
3140 return 0;
3141}
3142
010e5ae2
AM
3143static bfd_boolean
3144on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3145{
3146 for (; needed != NULL; needed = needed->next)
3147 if (strcmp (soname, needed->name) == 0)
3148 return TRUE;
3149
3150 return FALSE;
3151}
3152
5a580b3a 3153/* Sort symbol by value and section. */
4ad4eba5
AM
3154static int
3155elf_sort_symbol (const void *arg1, const void *arg2)
5a580b3a
AM
3156{
3157 const struct elf_link_hash_entry *h1;
3158 const struct elf_link_hash_entry *h2;
10b7e05b 3159 bfd_signed_vma vdiff;
5a580b3a
AM
3160
3161 h1 = *(const struct elf_link_hash_entry **) arg1;
3162 h2 = *(const struct elf_link_hash_entry **) arg2;
10b7e05b
NC
3163 vdiff = h1->root.u.def.value - h2->root.u.def.value;
3164 if (vdiff != 0)
3165 return vdiff > 0 ? 1 : -1;
3166 else
3167 {
3168 long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3169 if (sdiff != 0)
3170 return sdiff > 0 ? 1 : -1;
3171 }
5a580b3a
AM
3172 return 0;
3173}
4ad4eba5 3174
5a580b3a
AM
3175/* This function is used to adjust offsets into .dynstr for
3176 dynamic symbols. This is called via elf_link_hash_traverse. */
3177
3178static bfd_boolean
3179elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3180{
3181 struct elf_strtab_hash *dynstr = data;
3182
3183 if (h->root.type == bfd_link_hash_warning)
3184 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3185
3186 if (h->dynindx != -1)
3187 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3188 return TRUE;
3189}
3190
3191/* Assign string offsets in .dynstr, update all structures referencing
3192 them. */
3193
4ad4eba5
AM
3194static bfd_boolean
3195elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
5a580b3a
AM
3196{
3197 struct elf_link_hash_table *hash_table = elf_hash_table (info);
3198 struct elf_link_local_dynamic_entry *entry;
3199 struct elf_strtab_hash *dynstr = hash_table->dynstr;
3200 bfd *dynobj = hash_table->dynobj;
3201 asection *sdyn;
3202 bfd_size_type size;
3203 const struct elf_backend_data *bed;
3204 bfd_byte *extdyn;
3205
3206 _bfd_elf_strtab_finalize (dynstr);
3207 size = _bfd_elf_strtab_size (dynstr);
3208
3209 bed = get_elf_backend_data (dynobj);
3210 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3211 BFD_ASSERT (sdyn != NULL);
3212
3213 /* Update all .dynamic entries referencing .dynstr strings. */
3214 for (extdyn = sdyn->contents;
eea6121a 3215 extdyn < sdyn->contents + sdyn->size;
5a580b3a
AM
3216 extdyn += bed->s->sizeof_dyn)
3217 {
3218 Elf_Internal_Dyn dyn;
3219
3220 bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3221 switch (dyn.d_tag)
3222 {
3223 case DT_STRSZ:
3224 dyn.d_un.d_val = size;
3225 break;
3226 case DT_NEEDED:
3227 case DT_SONAME:
3228 case DT_RPATH:
3229 case DT_RUNPATH:
3230 case DT_FILTER:
3231 case DT_AUXILIARY:
3232 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3233 break;
3234 default:
3235 continue;
3236 }
3237 bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3238 }
3239
3240 /* Now update local dynamic symbols. */
3241 for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3242 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3243 entry->isym.st_name);
3244
3245 /* And the rest of dynamic symbols. */
3246 elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3247
3248 /* Adjust version definitions. */
3249 if (elf_tdata (output_bfd)->cverdefs)
3250 {
3251 asection *s;
3252 bfd_byte *p;
3253 bfd_size_type i;
3254 Elf_Internal_Verdef def;
3255 Elf_Internal_Verdaux defaux;
3256
3257 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3258 p = s->contents;
3259 do
3260 {
3261 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3262 &def);
3263 p += sizeof (Elf_External_Verdef);
3e3b46e5
PB
3264 if (def.vd_aux != sizeof (Elf_External_Verdef))
3265 continue;
5a580b3a
AM
3266 for (i = 0; i < def.vd_cnt; ++i)
3267 {
3268 _bfd_elf_swap_verdaux_in (output_bfd,
3269 (Elf_External_Verdaux *) p, &defaux);
3270 defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3271 defaux.vda_name);
3272 _bfd_elf_swap_verdaux_out (output_bfd,
3273 &defaux, (Elf_External_Verdaux *) p);
3274 p += sizeof (Elf_External_Verdaux);
3275 }
3276 }
3277 while (def.vd_next);
3278 }
3279
3280 /* Adjust version references. */
3281 if (elf_tdata (output_bfd)->verref)
3282 {
3283 asection *s;
3284 bfd_byte *p;
3285 bfd_size_type i;
3286 Elf_Internal_Verneed need;
3287 Elf_Internal_Vernaux needaux;
3288
3289 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3290 p = s->contents;
3291 do
3292 {
3293 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3294 &need);
3295 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3296 _bfd_elf_swap_verneed_out (output_bfd, &need,
3297 (Elf_External_Verneed *) p);
3298 p += sizeof (Elf_External_Verneed);
3299 for (i = 0; i < need.vn_cnt; ++i)
3300 {
3301 _bfd_elf_swap_vernaux_in (output_bfd,
3302 (Elf_External_Vernaux *) p, &needaux);
3303 needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3304 needaux.vna_name);
3305 _bfd_elf_swap_vernaux_out (output_bfd,
3306 &needaux,
3307 (Elf_External_Vernaux *) p);
3308 p += sizeof (Elf_External_Vernaux);
3309 }
3310 }
3311 while (need.vn_next);
3312 }
3313
3314 return TRUE;
3315}
3316\f
13285a1b
AM
3317/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3318 The default is to only match when the INPUT and OUTPUT are exactly
3319 the same target. */
3320
3321bfd_boolean
3322_bfd_elf_default_relocs_compatible (const bfd_target *input,
3323 const bfd_target *output)
3324{
3325 return input == output;
3326}
3327
3328/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3329 This version is used when different targets for the same architecture
3330 are virtually identical. */
3331
3332bfd_boolean
3333_bfd_elf_relocs_compatible (const bfd_target *input,
3334 const bfd_target *output)
3335{
3336 const struct elf_backend_data *obed, *ibed;
3337
3338 if (input == output)
3339 return TRUE;
3340
3341 ibed = xvec_get_elf_backend_data (input);
3342 obed = xvec_get_elf_backend_data (output);
3343
3344 if (ibed->arch != obed->arch)
3345 return FALSE;
3346
3347 /* If both backends are using this function, deem them compatible. */
3348 return ibed->relocs_compatible == obed->relocs_compatible;
3349}
3350
4ad4eba5
AM
3351/* Add symbols from an ELF object file to the linker hash table. */
3352
3353static bfd_boolean
3354elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3355{
a0c402a5 3356 Elf_Internal_Ehdr *ehdr;
4ad4eba5
AM
3357 Elf_Internal_Shdr *hdr;
3358 bfd_size_type symcount;
3359 bfd_size_type extsymcount;
3360 bfd_size_type extsymoff;
3361 struct elf_link_hash_entry **sym_hash;
3362 bfd_boolean dynamic;
3363 Elf_External_Versym *extversym = NULL;
3364 Elf_External_Versym *ever;
3365 struct elf_link_hash_entry *weaks;
3366 struct elf_link_hash_entry **nondeflt_vers = NULL;
3367 bfd_size_type nondeflt_vers_cnt = 0;
3368 Elf_Internal_Sym *isymbuf = NULL;
3369 Elf_Internal_Sym *isym;
3370 Elf_Internal_Sym *isymend;
3371 const struct elf_backend_data *bed;
3372 bfd_boolean add_needed;
66eb6687 3373 struct elf_link_hash_table *htab;
4ad4eba5 3374 bfd_size_type amt;
66eb6687 3375 void *alloc_mark = NULL;
4f87808c
AM
3376 struct bfd_hash_entry **old_table = NULL;
3377 unsigned int old_size = 0;
3378 unsigned int old_count = 0;
66eb6687
AM
3379 void *old_tab = NULL;
3380 void *old_hash;
3381 void *old_ent;
3382 struct bfd_link_hash_entry *old_undefs = NULL;
3383 struct bfd_link_hash_entry *old_undefs_tail = NULL;
3384 long old_dynsymcount = 0;
3385 size_t tabsize = 0;
3386 size_t hashsize = 0;
4ad4eba5 3387
66eb6687 3388 htab = elf_hash_table (info);
4ad4eba5 3389 bed = get_elf_backend_data (abfd);
4ad4eba5
AM
3390
3391 if ((abfd->flags & DYNAMIC) == 0)
3392 dynamic = FALSE;
3393 else
3394 {
3395 dynamic = TRUE;
3396
3397 /* You can't use -r against a dynamic object. Also, there's no
3398 hope of using a dynamic object which does not exactly match
3399 the format of the output file. */
3400 if (info->relocatable
66eb6687 3401 || !is_elf_hash_table (htab)
f13a99db 3402 || info->output_bfd->xvec != abfd->xvec)
4ad4eba5 3403 {
9a0789ec
NC
3404 if (info->relocatable)
3405 bfd_set_error (bfd_error_invalid_operation);
3406 else
3407 bfd_set_error (bfd_error_wrong_format);
4ad4eba5
AM
3408 goto error_return;
3409 }
3410 }
3411
a0c402a5
L
3412 ehdr = elf_elfheader (abfd);
3413 if (info->warn_alternate_em
3414 && bed->elf_machine_code != ehdr->e_machine
3415 && ((bed->elf_machine_alt1 != 0
3416 && ehdr->e_machine == bed->elf_machine_alt1)
3417 || (bed->elf_machine_alt2 != 0
3418 && ehdr->e_machine == bed->elf_machine_alt2)))
3419 info->callbacks->einfo
3420 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3421 ehdr->e_machine, abfd, bed->elf_machine_code);
3422
4ad4eba5
AM
3423 /* As a GNU extension, any input sections which are named
3424 .gnu.warning.SYMBOL are treated as warning symbols for the given
3425 symbol. This differs from .gnu.warning sections, which generate
3426 warnings when they are included in an output file. */
3427 if (info->executable)
3428 {
3429 asection *s;
3430
3431 for (s = abfd->sections; s != NULL; s = s->next)
3432 {
3433 const char *name;
3434
3435 name = bfd_get_section_name (abfd, s);
0112cd26 3436 if (CONST_STRNEQ (name, ".gnu.warning."))
4ad4eba5
AM
3437 {
3438 char *msg;
3439 bfd_size_type sz;
4ad4eba5
AM
3440
3441 name += sizeof ".gnu.warning." - 1;
3442
3443 /* If this is a shared object, then look up the symbol
3444 in the hash table. If it is there, and it is already
3445 been defined, then we will not be using the entry
3446 from this shared object, so we don't need to warn.
3447 FIXME: If we see the definition in a regular object
3448 later on, we will warn, but we shouldn't. The only
3449 fix is to keep track of what warnings we are supposed
3450 to emit, and then handle them all at the end of the
3451 link. */
3452 if (dynamic)
3453 {
3454 struct elf_link_hash_entry *h;
3455
66eb6687 3456 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
4ad4eba5
AM
3457
3458 /* FIXME: What about bfd_link_hash_common? */
3459 if (h != NULL
3460 && (h->root.type == bfd_link_hash_defined
3461 || h->root.type == bfd_link_hash_defweak))
3462 {
3463 /* We don't want to issue this warning. Clobber
3464 the section size so that the warning does not
3465 get copied into the output file. */
eea6121a 3466 s->size = 0;
4ad4eba5
AM
3467 continue;
3468 }
3469 }
3470
eea6121a 3471 sz = s->size;
370a0e1b 3472 msg = bfd_alloc (abfd, sz + 1);
4ad4eba5
AM
3473 if (msg == NULL)
3474 goto error_return;
3475
370a0e1b 3476 if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
4ad4eba5
AM
3477 goto error_return;
3478
370a0e1b 3479 msg[sz] = '\0';
4ad4eba5
AM
3480
3481 if (! (_bfd_generic_link_add_one_symbol
3482 (info, abfd, name, BSF_WARNING, s, 0, msg,
66eb6687 3483 FALSE, bed->collect, NULL)))
4ad4eba5
AM
3484 goto error_return;
3485
3486 if (! info->relocatable)
3487 {
3488 /* Clobber the section size so that the warning does
3489 not get copied into the output file. */
eea6121a 3490 s->size = 0;
11d2f718
AM
3491
3492 /* Also set SEC_EXCLUDE, so that symbols defined in
3493 the warning section don't get copied to the output. */
3494 s->flags |= SEC_EXCLUDE;
4ad4eba5
AM
3495 }
3496 }
3497 }
3498 }
3499
3500 add_needed = TRUE;
3501 if (! dynamic)
3502 {
3503 /* If we are creating a shared library, create all the dynamic
3504 sections immediately. We need to attach them to something,
3505 so we attach them to this BFD, provided it is the right
3506 format. FIXME: If there are no input BFD's of the same
3507 format as the output, we can't make a shared library. */
3508 if (info->shared
66eb6687 3509 && is_elf_hash_table (htab)
f13a99db 3510 && info->output_bfd->xvec == abfd->xvec
66eb6687 3511 && !htab->dynamic_sections_created)
4ad4eba5
AM
3512 {
3513 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3514 goto error_return;
3515 }
3516 }
66eb6687 3517 else if (!is_elf_hash_table (htab))
4ad4eba5
AM
3518 goto error_return;
3519 else
3520 {
3521 asection *s;
3522 const char *soname = NULL;
3523 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3524 int ret;
3525
3526 /* ld --just-symbols and dynamic objects don't mix very well.
92fd189d 3527 ld shouldn't allow it. */
4ad4eba5
AM
3528 if ((s = abfd->sections) != NULL
3529 && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
92fd189d 3530 abort ();
4ad4eba5
AM
3531
3532 /* If this dynamic lib was specified on the command line with
3533 --as-needed in effect, then we don't want to add a DT_NEEDED
3534 tag unless the lib is actually used. Similary for libs brought
e56f61be
L
3535 in by another lib's DT_NEEDED. When --no-add-needed is used
3536 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3537 any dynamic library in DT_NEEDED tags in the dynamic lib at
3538 all. */
3539 add_needed = (elf_dyn_lib_class (abfd)
3540 & (DYN_AS_NEEDED | DYN_DT_NEEDED
3541 | DYN_NO_NEEDED)) == 0;
4ad4eba5
AM
3542
3543 s = bfd_get_section_by_name (abfd, ".dynamic");
3544 if (s != NULL)
3545 {
3546 bfd_byte *dynbuf;
3547 bfd_byte *extdyn;
cb33740c 3548 unsigned int elfsec;
4ad4eba5
AM
3549 unsigned long shlink;
3550
eea6121a 3551 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
4ad4eba5
AM
3552 goto error_free_dyn;
3553
3554 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
cb33740c 3555 if (elfsec == SHN_BAD)
4ad4eba5
AM
3556 goto error_free_dyn;
3557 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3558
3559 for (extdyn = dynbuf;
eea6121a 3560 extdyn < dynbuf + s->size;
4ad4eba5
AM
3561 extdyn += bed->s->sizeof_dyn)
3562 {
3563 Elf_Internal_Dyn dyn;
3564
3565 bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3566 if (dyn.d_tag == DT_SONAME)
3567 {
3568 unsigned int tagv = dyn.d_un.d_val;
3569 soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3570 if (soname == NULL)
3571 goto error_free_dyn;
3572 }
3573 if (dyn.d_tag == DT_NEEDED)
3574 {
3575 struct bfd_link_needed_list *n, **pn;
3576 char *fnm, *anm;
3577 unsigned int tagv = dyn.d_un.d_val;
3578
3579 amt = sizeof (struct bfd_link_needed_list);
3580 n = bfd_alloc (abfd, amt);
3581 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3582 if (n == NULL || fnm == NULL)
3583 goto error_free_dyn;
3584 amt = strlen (fnm) + 1;
3585 anm = bfd_alloc (abfd, amt);
3586 if (anm == NULL)
3587 goto error_free_dyn;
3588 memcpy (anm, fnm, amt);
3589 n->name = anm;
3590 n->by = abfd;
3591 n->next = NULL;
66eb6687 3592 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
4ad4eba5
AM
3593 ;
3594 *pn = n;
3595 }
3596 if (dyn.d_tag == DT_RUNPATH)
3597 {
3598 struct bfd_link_needed_list *n, **pn;
3599 char *fnm, *anm;
3600 unsigned int tagv = dyn.d_un.d_val;
3601
3602 amt = sizeof (struct bfd_link_needed_list);
3603 n = bfd_alloc (abfd, amt);
3604 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3605 if (n == NULL || fnm == NULL)
3606 goto error_free_dyn;
3607 amt = strlen (fnm) + 1;
3608 anm = bfd_alloc (abfd, amt);
3609 if (anm == NULL)
3610 goto error_free_dyn;
3611 memcpy (anm, fnm, amt);
3612 n->name = anm;
3613 n->by = abfd;
3614 n->next = NULL;
3615 for (pn = & runpath;
3616 *pn != NULL;
3617 pn = &(*pn)->next)
3618 ;
3619 *pn = n;
3620 }
3621 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3622 if (!runpath && dyn.d_tag == DT_RPATH)
3623 {
3624 struct bfd_link_needed_list *n, **pn;
3625 char *fnm, *anm;
3626 unsigned int tagv = dyn.d_un.d_val;
3627
3628 amt = sizeof (struct bfd_link_needed_list);
3629 n = bfd_alloc (abfd, amt);
3630 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3631 if (n == NULL || fnm == NULL)
3632 goto error_free_dyn;
3633 amt = strlen (fnm) + 1;
3634 anm = bfd_alloc (abfd, amt);
3635 if (anm == NULL)
3636 {
3637 error_free_dyn:
3638 free (dynbuf);
3639 goto error_return;
3640 }
3641 memcpy (anm, fnm, amt);
3642 n->name = anm;
3643 n->by = abfd;
3644 n->next = NULL;
3645 for (pn = & rpath;
3646 *pn != NULL;
3647 pn = &(*pn)->next)
3648 ;
3649 *pn = n;
3650 }
3651 }
3652
3653 free (dynbuf);
3654 }
3655
3656 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3657 frees all more recently bfd_alloc'd blocks as well. */
3658 if (runpath)
3659 rpath = runpath;
3660
3661 if (rpath)
3662 {
3663 struct bfd_link_needed_list **pn;
66eb6687 3664 for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
4ad4eba5
AM
3665 ;
3666 *pn = rpath;
3667 }
3668
3669 /* We do not want to include any of the sections in a dynamic
3670 object in the output file. We hack by simply clobbering the
3671 list of sections in the BFD. This could be handled more
3672 cleanly by, say, a new section flag; the existing
3673 SEC_NEVER_LOAD flag is not the one we want, because that one
3674 still implies that the section takes up space in the output
3675 file. */
3676 bfd_section_list_clear (abfd);
3677
4ad4eba5
AM
3678 /* Find the name to use in a DT_NEEDED entry that refers to this
3679 object. If the object has a DT_SONAME entry, we use it.
3680 Otherwise, if the generic linker stuck something in
3681 elf_dt_name, we use that. Otherwise, we just use the file
3682 name. */
3683 if (soname == NULL || *soname == '\0')
3684 {
3685 soname = elf_dt_name (abfd);
3686 if (soname == NULL || *soname == '\0')
3687 soname = bfd_get_filename (abfd);
3688 }
3689
3690 /* Save the SONAME because sometimes the linker emulation code
3691 will need to know it. */
3692 elf_dt_name (abfd) = soname;
3693
7e9f0867 3694 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4ad4eba5
AM
3695 if (ret < 0)
3696 goto error_return;
3697
3698 /* If we have already included this dynamic object in the
3699 link, just ignore it. There is no reason to include a
3700 particular dynamic object more than once. */
3701 if (ret > 0)
3702 return TRUE;
3703 }
3704
3705 /* If this is a dynamic object, we always link against the .dynsym
3706 symbol table, not the .symtab symbol table. The dynamic linker
3707 will only see the .dynsym symbol table, so there is no reason to
3708 look at .symtab for a dynamic object. */
3709
3710 if (! dynamic || elf_dynsymtab (abfd) == 0)
3711 hdr = &elf_tdata (abfd)->symtab_hdr;
3712 else
3713 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3714
3715 symcount = hdr->sh_size / bed->s->sizeof_sym;
3716
3717 /* The sh_info field of the symtab header tells us where the
3718 external symbols start. We don't care about the local symbols at
3719 this point. */
3720 if (elf_bad_symtab (abfd))
3721 {
3722 extsymcount = symcount;
3723 extsymoff = 0;
3724 }
3725 else
3726 {
3727 extsymcount = symcount - hdr->sh_info;
3728 extsymoff = hdr->sh_info;
3729 }
3730
3731 sym_hash = NULL;
3732 if (extsymcount != 0)
3733 {
3734 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3735 NULL, NULL, NULL);
3736 if (isymbuf == NULL)
3737 goto error_return;
3738
3739 /* We store a pointer to the hash table entry for each external
3740 symbol. */
3741 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3742 sym_hash = bfd_alloc (abfd, amt);
3743 if (sym_hash == NULL)
3744 goto error_free_sym;
3745 elf_sym_hashes (abfd) = sym_hash;
3746 }
3747
3748 if (dynamic)
3749 {
3750 /* Read in any version definitions. */
fc0e6df6
PB
3751 if (!_bfd_elf_slurp_version_tables (abfd,
3752 info->default_imported_symver))
4ad4eba5
AM
3753 goto error_free_sym;
3754
3755 /* Read in the symbol versions, but don't bother to convert them
3756 to internal format. */
3757 if (elf_dynversym (abfd) != 0)
3758 {
3759 Elf_Internal_Shdr *versymhdr;
3760
3761 versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3762 extversym = bfd_malloc (versymhdr->sh_size);
3763 if (extversym == NULL)
3764 goto error_free_sym;
3765 amt = versymhdr->sh_size;
3766 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3767 || bfd_bread (extversym, amt, abfd) != amt)
3768 goto error_free_vers;
3769 }
3770 }
3771
66eb6687
AM
3772 /* If we are loading an as-needed shared lib, save the symbol table
3773 state before we start adding symbols. If the lib turns out
3774 to be unneeded, restore the state. */
3775 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3776 {
3777 unsigned int i;
3778 size_t entsize;
3779
3780 for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3781 {
3782 struct bfd_hash_entry *p;
2de92251 3783 struct elf_link_hash_entry *h;
66eb6687
AM
3784
3785 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
2de92251
AM
3786 {
3787 h = (struct elf_link_hash_entry *) p;
3788 entsize += htab->root.table.entsize;
3789 if (h->root.type == bfd_link_hash_warning)
3790 entsize += htab->root.table.entsize;
3791 }
66eb6687
AM
3792 }
3793
3794 tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3795 hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3796 old_tab = bfd_malloc (tabsize + entsize + hashsize);
3797 if (old_tab == NULL)
3798 goto error_free_vers;
3799
3800 /* Remember the current objalloc pointer, so that all mem for
3801 symbols added can later be reclaimed. */
3802 alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3803 if (alloc_mark == NULL)
3804 goto error_free_vers;
3805
5061a885
AM
3806 /* Make a special call to the linker "notice" function to
3807 tell it that we are about to handle an as-needed lib. */
3808 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3809 notice_as_needed))
9af2a943 3810 goto error_free_vers;
5061a885 3811
66eb6687
AM
3812 /* Clone the symbol table and sym hashes. Remember some
3813 pointers into the symbol table, and dynamic symbol count. */
3814 old_hash = (char *) old_tab + tabsize;
3815 old_ent = (char *) old_hash + hashsize;
3816 memcpy (old_tab, htab->root.table.table, tabsize);
3817 memcpy (old_hash, sym_hash, hashsize);
3818 old_undefs = htab->root.undefs;
3819 old_undefs_tail = htab->root.undefs_tail;
4f87808c
AM
3820 old_table = htab->root.table.table;
3821 old_size = htab->root.table.size;
3822 old_count = htab->root.table.count;
66eb6687
AM
3823 old_dynsymcount = htab->dynsymcount;
3824
3825 for (i = 0; i < htab->root.table.size; i++)
3826 {
3827 struct bfd_hash_entry *p;
2de92251 3828 struct elf_link_hash_entry *h;
66eb6687
AM
3829
3830 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3831 {
3832 memcpy (old_ent, p, htab->root.table.entsize);
3833 old_ent = (char *) old_ent + htab->root.table.entsize;
2de92251
AM
3834 h = (struct elf_link_hash_entry *) p;
3835 if (h->root.type == bfd_link_hash_warning)
3836 {
3837 memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3838 old_ent = (char *) old_ent + htab->root.table.entsize;
3839 }
66eb6687
AM
3840 }
3841 }
3842 }
4ad4eba5 3843
66eb6687 3844 weaks = NULL;
4ad4eba5
AM
3845 ever = extversym != NULL ? extversym + extsymoff : NULL;
3846 for (isym = isymbuf, isymend = isymbuf + extsymcount;
3847 isym < isymend;
3848 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3849 {
3850 int bind;
3851 bfd_vma value;
af44c138 3852 asection *sec, *new_sec;
4ad4eba5
AM
3853 flagword flags;
3854 const char *name;
3855 struct elf_link_hash_entry *h;
3856 bfd_boolean definition;
3857 bfd_boolean size_change_ok;
3858 bfd_boolean type_change_ok;
3859 bfd_boolean new_weakdef;
3860 bfd_boolean override;
a4d8e49b 3861 bfd_boolean common;
4ad4eba5
AM
3862 unsigned int old_alignment;
3863 bfd *old_bfd;
3864
3865 override = FALSE;
3866
3867 flags = BSF_NO_FLAGS;
3868 sec = NULL;
3869 value = isym->st_value;
3870 *sym_hash = NULL;
a4d8e49b 3871 common = bed->common_definition (isym);
4ad4eba5
AM
3872
3873 bind = ELF_ST_BIND (isym->st_info);
3874 if (bind == STB_LOCAL)
3875 {
3876 /* This should be impossible, since ELF requires that all
3877 global symbols follow all local symbols, and that sh_info
3878 point to the first global symbol. Unfortunately, Irix 5
3879 screws this up. */
3880 continue;
3881 }
3882 else if (bind == STB_GLOBAL)
3883 {
a4d8e49b 3884 if (isym->st_shndx != SHN_UNDEF && !common)
4ad4eba5
AM
3885 flags = BSF_GLOBAL;
3886 }
3887 else if (bind == STB_WEAK)
3888 flags = BSF_WEAK;
3889 else
3890 {
3891 /* Leave it up to the processor backend. */
3892 }
3893
3894 if (isym->st_shndx == SHN_UNDEF)
3895 sec = bfd_und_section_ptr;
cb33740c
AM
3896 else if (isym->st_shndx == SHN_ABS)
3897 sec = bfd_abs_section_ptr;
3898 else if (isym->st_shndx == SHN_COMMON)
3899 {
3900 sec = bfd_com_section_ptr;
3901 /* What ELF calls the size we call the value. What ELF
3902 calls the value we call the alignment. */
3903 value = isym->st_size;
3904 }
3905 else
4ad4eba5
AM
3906 {
3907 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3908 if (sec == NULL)
3909 sec = bfd_abs_section_ptr;
529fcb95
PB
3910 else if (sec->kept_section)
3911 {
e5d08002
L
3912 /* Symbols from discarded section are undefined. We keep
3913 its visibility. */
529fcb95
PB
3914 sec = bfd_und_section_ptr;
3915 isym->st_shndx = SHN_UNDEF;
3916 }
4ad4eba5
AM
3917 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3918 value -= sec->vma;
3919 }
4ad4eba5
AM
3920
3921 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3922 isym->st_name);
3923 if (name == NULL)
3924 goto error_free_vers;
3925
3926 if (isym->st_shndx == SHN_COMMON
6a4a0940
JJ
3927 && ELF_ST_TYPE (isym->st_info) == STT_TLS
3928 && !info->relocatable)
4ad4eba5
AM
3929 {
3930 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3931
3932 if (tcomm == NULL)
3933 {
3496cb2a
L
3934 tcomm = bfd_make_section_with_flags (abfd, ".tcommon",
3935 (SEC_ALLOC
3936 | SEC_IS_COMMON
3937 | SEC_LINKER_CREATED
3938 | SEC_THREAD_LOCAL));
3939 if (tcomm == NULL)
4ad4eba5
AM
3940 goto error_free_vers;
3941 }
3942 sec = tcomm;
3943 }
66eb6687 3944 else if (bed->elf_add_symbol_hook)
4ad4eba5 3945 {
66eb6687
AM
3946 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3947 &sec, &value))
4ad4eba5
AM
3948 goto error_free_vers;
3949
3950 /* The hook function sets the name to NULL if this symbol
3951 should be skipped for some reason. */
3952 if (name == NULL)
3953 continue;
3954 }
3955
3956 /* Sanity check that all possibilities were handled. */
3957 if (sec == NULL)
3958 {
3959 bfd_set_error (bfd_error_bad_value);
3960 goto error_free_vers;
3961 }
3962
3963 if (bfd_is_und_section (sec)
3964 || bfd_is_com_section (sec))
3965 definition = FALSE;
3966 else
3967 definition = TRUE;
3968
3969 size_change_ok = FALSE;
66eb6687 3970 type_change_ok = bed->type_change_ok;
4ad4eba5
AM
3971 old_alignment = 0;
3972 old_bfd = NULL;
af44c138 3973 new_sec = sec;
4ad4eba5 3974
66eb6687 3975 if (is_elf_hash_table (htab))
4ad4eba5
AM
3976 {
3977 Elf_Internal_Versym iver;
3978 unsigned int vernum = 0;
3979 bfd_boolean skip;
3980
fc0e6df6 3981 if (ever == NULL)
4ad4eba5 3982 {
fc0e6df6
PB
3983 if (info->default_imported_symver)
3984 /* Use the default symbol version created earlier. */
3985 iver.vs_vers = elf_tdata (abfd)->cverdefs;
3986 else
3987 iver.vs_vers = 0;
3988 }
3989 else
3990 _bfd_elf_swap_versym_in (abfd, ever, &iver);
3991
3992 vernum = iver.vs_vers & VERSYM_VERSION;
3993
3994 /* If this is a hidden symbol, or if it is not version
3995 1, we append the version name to the symbol name.
cc86ff91
EB
3996 However, we do not modify a non-hidden absolute symbol
3997 if it is not a function, because it might be the version
3998 symbol itself. FIXME: What if it isn't? */
fc0e6df6 3999 if ((iver.vs_vers & VERSYM_HIDDEN) != 0
fcb93ecf
PB
4000 || (vernum > 1
4001 && (!bfd_is_abs_section (sec)
4002 || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
fc0e6df6
PB
4003 {
4004 const char *verstr;
4005 size_t namelen, verlen, newlen;
4006 char *newname, *p;
4007
4008 if (isym->st_shndx != SHN_UNDEF)
4ad4eba5 4009 {
fc0e6df6
PB
4010 if (vernum > elf_tdata (abfd)->cverdefs)
4011 verstr = NULL;
4012 else if (vernum > 1)
4013 verstr =
4014 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4015 else
4016 verstr = "";
4ad4eba5 4017
fc0e6df6 4018 if (verstr == NULL)
4ad4eba5 4019 {
fc0e6df6
PB
4020 (*_bfd_error_handler)
4021 (_("%B: %s: invalid version %u (max %d)"),
4022 abfd, name, vernum,
4023 elf_tdata (abfd)->cverdefs);
4024 bfd_set_error (bfd_error_bad_value);
4025 goto error_free_vers;
4ad4eba5 4026 }
fc0e6df6
PB
4027 }
4028 else
4029 {
4030 /* We cannot simply test for the number of
4031 entries in the VERNEED section since the
4032 numbers for the needed versions do not start
4033 at 0. */
4034 Elf_Internal_Verneed *t;
4035
4036 verstr = NULL;
4037 for (t = elf_tdata (abfd)->verref;
4038 t != NULL;
4039 t = t->vn_nextref)
4ad4eba5 4040 {
fc0e6df6 4041 Elf_Internal_Vernaux *a;
4ad4eba5 4042
fc0e6df6
PB
4043 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4044 {
4045 if (a->vna_other == vernum)
4ad4eba5 4046 {
fc0e6df6
PB
4047 verstr = a->vna_nodename;
4048 break;
4ad4eba5 4049 }
4ad4eba5 4050 }
fc0e6df6
PB
4051 if (a != NULL)
4052 break;
4053 }
4054 if (verstr == NULL)
4055 {
4056 (*_bfd_error_handler)
4057 (_("%B: %s: invalid needed version %d"),
4058 abfd, name, vernum);
4059 bfd_set_error (bfd_error_bad_value);
4060 goto error_free_vers;
4ad4eba5 4061 }
4ad4eba5 4062 }
fc0e6df6
PB
4063
4064 namelen = strlen (name);
4065 verlen = strlen (verstr);
4066 newlen = namelen + verlen + 2;
4067 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4068 && isym->st_shndx != SHN_UNDEF)
4069 ++newlen;
4070
66eb6687 4071 newname = bfd_hash_allocate (&htab->root.table, newlen);
fc0e6df6
PB
4072 if (newname == NULL)
4073 goto error_free_vers;
4074 memcpy (newname, name, namelen);
4075 p = newname + namelen;
4076 *p++ = ELF_VER_CHR;
4077 /* If this is a defined non-hidden version symbol,
4078 we add another @ to the name. This indicates the
4079 default version of the symbol. */
4080 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4081 && isym->st_shndx != SHN_UNDEF)
4082 *p++ = ELF_VER_CHR;
4083 memcpy (p, verstr, verlen + 1);
4084
4085 name = newname;
4ad4eba5
AM
4086 }
4087
af44c138
L
4088 if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec,
4089 &value, &old_alignment,
4ad4eba5
AM
4090 sym_hash, &skip, &override,
4091 &type_change_ok, &size_change_ok))
4092 goto error_free_vers;
4093
4094 if (skip)
4095 continue;
4096
4097 if (override)
4098 definition = FALSE;
4099
4100 h = *sym_hash;
4101 while (h->root.type == bfd_link_hash_indirect
4102 || h->root.type == bfd_link_hash_warning)
4103 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4104
4105 /* Remember the old alignment if this is a common symbol, so
4106 that we don't reduce the alignment later on. We can't
4107 check later, because _bfd_generic_link_add_one_symbol
4108 will set a default for the alignment which we want to
4109 override. We also remember the old bfd where the existing
4110 definition comes from. */
4111 switch (h->root.type)
4112 {
4113 default:
4114 break;
4115
4116 case bfd_link_hash_defined:
4117 case bfd_link_hash_defweak:
4118 old_bfd = h->root.u.def.section->owner;
4119 break;
4120
4121 case bfd_link_hash_common:
4122 old_bfd = h->root.u.c.p->section->owner;
4123 old_alignment = h->root.u.c.p->alignment_power;
4124 break;
4125 }
4126
4127 if (elf_tdata (abfd)->verdef != NULL
4128 && ! override
4129 && vernum > 1
4130 && definition)
4131 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4132 }
4133
4134 if (! (_bfd_generic_link_add_one_symbol
66eb6687 4135 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4ad4eba5
AM
4136 (struct bfd_link_hash_entry **) sym_hash)))
4137 goto error_free_vers;
4138
4139 h = *sym_hash;
4140 while (h->root.type == bfd_link_hash_indirect
4141 || h->root.type == bfd_link_hash_warning)
4142 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4143 *sym_hash = h;
4144
4145 new_weakdef = FALSE;
4146 if (dynamic
4147 && definition
4148 && (flags & BSF_WEAK) != 0
fcb93ecf 4149 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
66eb6687 4150 && is_elf_hash_table (htab)
f6e332e6 4151 && h->u.weakdef == NULL)
4ad4eba5
AM
4152 {
4153 /* Keep a list of all weak defined non function symbols from
4154 a dynamic object, using the weakdef field. Later in this
4155 function we will set the weakdef field to the correct
4156 value. We only put non-function symbols from dynamic
4157 objects on this list, because that happens to be the only
4158 time we need to know the normal symbol corresponding to a
4159 weak symbol, and the information is time consuming to
4160 figure out. If the weakdef field is not already NULL,
4161 then this symbol was already defined by some previous
4162 dynamic object, and we will be using that previous
4163 definition anyhow. */
4164
f6e332e6 4165 h->u.weakdef = weaks;
4ad4eba5
AM
4166 weaks = h;
4167 new_weakdef = TRUE;
4168 }
4169
4170 /* Set the alignment of a common symbol. */
a4d8e49b 4171 if ((common || bfd_is_com_section (sec))
4ad4eba5
AM
4172 && h->root.type == bfd_link_hash_common)
4173 {
4174 unsigned int align;
4175
a4d8e49b 4176 if (common)
af44c138
L
4177 align = bfd_log2 (isym->st_value);
4178 else
4179 {
4180 /* The new symbol is a common symbol in a shared object.
4181 We need to get the alignment from the section. */
4182 align = new_sec->alignment_power;
4183 }
4ad4eba5
AM
4184 if (align > old_alignment
4185 /* Permit an alignment power of zero if an alignment of one
4186 is specified and no other alignments have been specified. */
4187 || (isym->st_value == 1 && old_alignment == 0))
4188 h->root.u.c.p->alignment_power = align;
4189 else
4190 h->root.u.c.p->alignment_power = old_alignment;
4191 }
4192
66eb6687 4193 if (is_elf_hash_table (htab))
4ad4eba5 4194 {
4ad4eba5 4195 bfd_boolean dynsym;
4ad4eba5
AM
4196
4197 /* Check the alignment when a common symbol is involved. This
4198 can change when a common symbol is overridden by a normal
4199 definition or a common symbol is ignored due to the old
4200 normal definition. We need to make sure the maximum
4201 alignment is maintained. */
a4d8e49b 4202 if ((old_alignment || common)
4ad4eba5
AM
4203 && h->root.type != bfd_link_hash_common)
4204 {
4205 unsigned int common_align;
4206 unsigned int normal_align;
4207 unsigned int symbol_align;
4208 bfd *normal_bfd;
4209 bfd *common_bfd;
4210
4211 symbol_align = ffs (h->root.u.def.value) - 1;
4212 if (h->root.u.def.section->owner != NULL
4213 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4214 {
4215 normal_align = h->root.u.def.section->alignment_power;
4216 if (normal_align > symbol_align)
4217 normal_align = symbol_align;
4218 }
4219 else
4220 normal_align = symbol_align;
4221
4222 if (old_alignment)
4223 {
4224 common_align = old_alignment;
4225 common_bfd = old_bfd;
4226 normal_bfd = abfd;
4227 }
4228 else
4229 {
4230 common_align = bfd_log2 (isym->st_value);
4231 common_bfd = abfd;
4232 normal_bfd = old_bfd;
4233 }
4234
4235 if (normal_align < common_align)
d07676f8
NC
4236 {
4237 /* PR binutils/2735 */
4238 if (normal_bfd == NULL)
4239 (*_bfd_error_handler)
4240 (_("Warning: alignment %u of common symbol `%s' in %B"
4241 " is greater than the alignment (%u) of its section %A"),
4242 common_bfd, h->root.u.def.section,
4243 1 << common_align, name, 1 << normal_align);
4244 else
4245 (*_bfd_error_handler)
4246 (_("Warning: alignment %u of symbol `%s' in %B"
4247 " is smaller than %u in %B"),
4248 normal_bfd, common_bfd,
4249 1 << normal_align, name, 1 << common_align);
4250 }
4ad4eba5
AM
4251 }
4252
83ad0046
L
4253 /* Remember the symbol size if it isn't undefined. */
4254 if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
4ad4eba5
AM
4255 && (definition || h->size == 0))
4256 {
83ad0046
L
4257 if (h->size != 0
4258 && h->size != isym->st_size
4259 && ! size_change_ok)
4ad4eba5 4260 (*_bfd_error_handler)
d003868e
AM
4261 (_("Warning: size of symbol `%s' changed"
4262 " from %lu in %B to %lu in %B"),
4263 old_bfd, abfd,
4ad4eba5 4264 name, (unsigned long) h->size,
d003868e 4265 (unsigned long) isym->st_size);
4ad4eba5
AM
4266
4267 h->size = isym->st_size;
4268 }
4269
4270 /* If this is a common symbol, then we always want H->SIZE
4271 to be the size of the common symbol. The code just above
4272 won't fix the size if a common symbol becomes larger. We
4273 don't warn about a size change here, because that is
fcb93ecf
PB
4274 covered by --warn-common. Allow changed between different
4275 function types. */
4ad4eba5
AM
4276 if (h->root.type == bfd_link_hash_common)
4277 h->size = h->root.u.c.size;
4278
4279 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4280 && (definition || h->type == STT_NOTYPE))
4281 {
4282 if (h->type != STT_NOTYPE
4283 && h->type != ELF_ST_TYPE (isym->st_info)
4284 && ! type_change_ok)
4285 (*_bfd_error_handler)
d003868e
AM
4286 (_("Warning: type of symbol `%s' changed"
4287 " from %d to %d in %B"),
4288 abfd, name, h->type, ELF_ST_TYPE (isym->st_info));
4ad4eba5
AM
4289
4290 h->type = ELF_ST_TYPE (isym->st_info);
4291 }
4292
3aa14d16
L
4293 /* STT_GNU_IFUNC symbol must go through PLT. */
4294 if (h->type == STT_GNU_IFUNC)
4295 h->needs_plt = 1;
4296
54ac0771
L
4297 /* Merge st_other field. */
4298 elf_merge_st_other (abfd, h, isym, definition, dynamic);
4ad4eba5
AM
4299
4300 /* Set a flag in the hash table entry indicating the type of
4301 reference or definition we just found. Keep a count of
4302 the number of dynamic symbols we find. A dynamic symbol
4303 is one which is referenced or defined by both a regular
4304 object and a shared object. */
4ad4eba5
AM
4305 dynsym = FALSE;
4306 if (! dynamic)
4307 {
4308 if (! definition)
4309 {
f5385ebf 4310 h->ref_regular = 1;
4ad4eba5 4311 if (bind != STB_WEAK)
f5385ebf 4312 h->ref_regular_nonweak = 1;
4ad4eba5
AM
4313 }
4314 else
d8880531
L
4315 {
4316 h->def_regular = 1;
4317 if (h->def_dynamic)
4318 {
4319 h->def_dynamic = 0;
4320 h->ref_dynamic = 1;
4321 h->dynamic_def = 1;
4322 }
4323 }
4ad4eba5 4324 if (! info->executable
f5385ebf
AM
4325 || h->def_dynamic
4326 || h->ref_dynamic)
4ad4eba5
AM
4327 dynsym = TRUE;
4328 }
4329 else
4330 {
4331 if (! definition)
f5385ebf 4332 h->ref_dynamic = 1;
4ad4eba5 4333 else
f5385ebf
AM
4334 h->def_dynamic = 1;
4335 if (h->def_regular
4336 || h->ref_regular
f6e332e6 4337 || (h->u.weakdef != NULL
4ad4eba5 4338 && ! new_weakdef
f6e332e6 4339 && h->u.weakdef->dynindx != -1))
4ad4eba5
AM
4340 dynsym = TRUE;
4341 }
4342
b2064611 4343 if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
92b7c7b6
L
4344 {
4345 /* We don't want to make debug symbol dynamic. */
4346 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4347 dynsym = FALSE;
4348 }
4349
4ad4eba5
AM
4350 /* Check to see if we need to add an indirect symbol for
4351 the default name. */
4352 if (definition || h->root.type == bfd_link_hash_common)
4353 if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4354 &sec, &value, &dynsym,
4355 override))
4356 goto error_free_vers;
4357
4358 if (definition && !dynamic)
4359 {
4360 char *p = strchr (name, ELF_VER_CHR);
4361 if (p != NULL && p[1] != ELF_VER_CHR)
4362 {
4363 /* Queue non-default versions so that .symver x, x@FOO
4364 aliases can be checked. */
66eb6687 4365 if (!nondeflt_vers)
4ad4eba5 4366 {
66eb6687
AM
4367 amt = ((isymend - isym + 1)
4368 * sizeof (struct elf_link_hash_entry *));
4ad4eba5 4369 nondeflt_vers = bfd_malloc (amt);
14b1c01e
AM
4370 if (!nondeflt_vers)
4371 goto error_free_vers;
4ad4eba5 4372 }
66eb6687 4373 nondeflt_vers[nondeflt_vers_cnt++] = h;
4ad4eba5
AM
4374 }
4375 }
4376
4377 if (dynsym && h->dynindx == -1)
4378 {
c152c796 4379 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4ad4eba5 4380 goto error_free_vers;
f6e332e6 4381 if (h->u.weakdef != NULL
4ad4eba5 4382 && ! new_weakdef
f6e332e6 4383 && h->u.weakdef->dynindx == -1)
4ad4eba5 4384 {
66eb6687 4385 if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4ad4eba5
AM
4386 goto error_free_vers;
4387 }
4388 }
4389 else if (dynsym && h->dynindx != -1)
4390 /* If the symbol already has a dynamic index, but
4391 visibility says it should not be visible, turn it into
4392 a local symbol. */
4393 switch (ELF_ST_VISIBILITY (h->other))
4394 {
4395 case STV_INTERNAL:
4396 case STV_HIDDEN:
4397 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4398 dynsym = FALSE;
4399 break;
4400 }
4401
4402 if (!add_needed
4403 && definition
010e5ae2
AM
4404 && ((dynsym
4405 && h->ref_regular)
4406 || (h->ref_dynamic
4407 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4408 && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4ad4eba5
AM
4409 {
4410 int ret;
4411 const char *soname = elf_dt_name (abfd);
4412
4413 /* A symbol from a library loaded via DT_NEEDED of some
4414 other library is referenced by a regular object.
e56f61be
L
4415 Add a DT_NEEDED entry for it. Issue an error if
4416 --no-add-needed is used. */
4417 if ((elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4418 {
4419 (*_bfd_error_handler)
4420 (_("%s: invalid DSO for symbol `%s' definition"),
d003868e 4421 abfd, name);
e56f61be
L
4422 bfd_set_error (bfd_error_bad_value);
4423 goto error_free_vers;
4424 }
4425
a5db907e
AM
4426 elf_dyn_lib_class (abfd) &= ~DYN_AS_NEEDED;
4427
4ad4eba5 4428 add_needed = TRUE;
7e9f0867 4429 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4ad4eba5
AM
4430 if (ret < 0)
4431 goto error_free_vers;
4432
4433 BFD_ASSERT (ret == 0);
4434 }
4435 }
4436 }
4437
66eb6687
AM
4438 if (extversym != NULL)
4439 {
4440 free (extversym);
4441 extversym = NULL;
4442 }
4443
4444 if (isymbuf != NULL)
4445 {
4446 free (isymbuf);
4447 isymbuf = NULL;
4448 }
4449
4450 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4451 {
4452 unsigned int i;
4453
4454 /* Restore the symbol table. */
97fed1c9
JJ
4455 if (bed->as_needed_cleanup)
4456 (*bed->as_needed_cleanup) (abfd, info);
66eb6687
AM
4457 old_hash = (char *) old_tab + tabsize;
4458 old_ent = (char *) old_hash + hashsize;
4459 sym_hash = elf_sym_hashes (abfd);
4f87808c
AM
4460 htab->root.table.table = old_table;
4461 htab->root.table.size = old_size;
4462 htab->root.table.count = old_count;
66eb6687
AM
4463 memcpy (htab->root.table.table, old_tab, tabsize);
4464 memcpy (sym_hash, old_hash, hashsize);
4465 htab->root.undefs = old_undefs;
4466 htab->root.undefs_tail = old_undefs_tail;
4467 for (i = 0; i < htab->root.table.size; i++)
4468 {
4469 struct bfd_hash_entry *p;
4470 struct elf_link_hash_entry *h;
4471
4472 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4473 {
4474 h = (struct elf_link_hash_entry *) p;
2de92251
AM
4475 if (h->root.type == bfd_link_hash_warning)
4476 h = (struct elf_link_hash_entry *) h->root.u.i.link;
66eb6687
AM
4477 if (h->dynindx >= old_dynsymcount)
4478 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
2de92251 4479
66eb6687
AM
4480 memcpy (p, old_ent, htab->root.table.entsize);
4481 old_ent = (char *) old_ent + htab->root.table.entsize;
2de92251
AM
4482 h = (struct elf_link_hash_entry *) p;
4483 if (h->root.type == bfd_link_hash_warning)
4484 {
4485 memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4486 old_ent = (char *) old_ent + htab->root.table.entsize;
4487 }
66eb6687
AM
4488 }
4489 }
4490
5061a885
AM
4491 /* Make a special call to the linker "notice" function to
4492 tell it that symbols added for crefs may need to be removed. */
4493 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4494 notice_not_needed))
9af2a943 4495 goto error_free_vers;
5061a885 4496
66eb6687
AM
4497 free (old_tab);
4498 objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4499 alloc_mark);
4500 if (nondeflt_vers != NULL)
4501 free (nondeflt_vers);
4502 return TRUE;
4503 }
2de92251 4504
66eb6687
AM
4505 if (old_tab != NULL)
4506 {
5061a885
AM
4507 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4508 notice_needed))
9af2a943 4509 goto error_free_vers;
66eb6687
AM
4510 free (old_tab);
4511 old_tab = NULL;
4512 }
4513
4ad4eba5
AM
4514 /* Now that all the symbols from this input file are created, handle
4515 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4516 if (nondeflt_vers != NULL)
4517 {
4518 bfd_size_type cnt, symidx;
4519
4520 for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4521 {
4522 struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4523 char *shortname, *p;
4524
4525 p = strchr (h->root.root.string, ELF_VER_CHR);
4526 if (p == NULL
4527 || (h->root.type != bfd_link_hash_defined
4528 && h->root.type != bfd_link_hash_defweak))
4529 continue;
4530
4531 amt = p - h->root.root.string;
4532 shortname = bfd_malloc (amt + 1);
14b1c01e
AM
4533 if (!shortname)
4534 goto error_free_vers;
4ad4eba5
AM
4535 memcpy (shortname, h->root.root.string, amt);
4536 shortname[amt] = '\0';
4537
4538 hi = (struct elf_link_hash_entry *)
66eb6687 4539 bfd_link_hash_lookup (&htab->root, shortname,
4ad4eba5
AM
4540 FALSE, FALSE, FALSE);
4541 if (hi != NULL
4542 && hi->root.type == h->root.type
4543 && hi->root.u.def.value == h->root.u.def.value
4544 && hi->root.u.def.section == h->root.u.def.section)
4545 {
4546 (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4547 hi->root.type = bfd_link_hash_indirect;
4548 hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
fcfa13d2 4549 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4ad4eba5
AM
4550 sym_hash = elf_sym_hashes (abfd);
4551 if (sym_hash)
4552 for (symidx = 0; symidx < extsymcount; ++symidx)
4553 if (sym_hash[symidx] == hi)
4554 {
4555 sym_hash[symidx] = h;
4556 break;
4557 }
4558 }
4559 free (shortname);
4560 }
4561 free (nondeflt_vers);
4562 nondeflt_vers = NULL;
4563 }
4564
4ad4eba5
AM
4565 /* Now set the weakdefs field correctly for all the weak defined
4566 symbols we found. The only way to do this is to search all the
4567 symbols. Since we only need the information for non functions in
4568 dynamic objects, that's the only time we actually put anything on
4569 the list WEAKS. We need this information so that if a regular
4570 object refers to a symbol defined weakly in a dynamic object, the
4571 real symbol in the dynamic object is also put in the dynamic
4572 symbols; we also must arrange for both symbols to point to the
4573 same memory location. We could handle the general case of symbol
4574 aliasing, but a general symbol alias can only be generated in
4575 assembler code, handling it correctly would be very time
4576 consuming, and other ELF linkers don't handle general aliasing
4577 either. */
4578 if (weaks != NULL)
4579 {
4580 struct elf_link_hash_entry **hpp;
4581 struct elf_link_hash_entry **hppend;
4582 struct elf_link_hash_entry **sorted_sym_hash;
4583 struct elf_link_hash_entry *h;
4584 size_t sym_count;
4585
4586 /* Since we have to search the whole symbol list for each weak
4587 defined symbol, search time for N weak defined symbols will be
4588 O(N^2). Binary search will cut it down to O(NlogN). */
4589 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4590 sorted_sym_hash = bfd_malloc (amt);
4591 if (sorted_sym_hash == NULL)
4592 goto error_return;
4593 sym_hash = sorted_sym_hash;
4594 hpp = elf_sym_hashes (abfd);
4595 hppend = hpp + extsymcount;
4596 sym_count = 0;
4597 for (; hpp < hppend; hpp++)
4598 {
4599 h = *hpp;
4600 if (h != NULL
4601 && h->root.type == bfd_link_hash_defined
fcb93ecf 4602 && !bed->is_function_type (h->type))
4ad4eba5
AM
4603 {
4604 *sym_hash = h;
4605 sym_hash++;
4606 sym_count++;
4607 }
4608 }
4609
4610 qsort (sorted_sym_hash, sym_count,
4611 sizeof (struct elf_link_hash_entry *),
4612 elf_sort_symbol);
4613
4614 while (weaks != NULL)
4615 {
4616 struct elf_link_hash_entry *hlook;
4617 asection *slook;
4618 bfd_vma vlook;
4619 long ilook;
4620 size_t i, j, idx;
4621
4622 hlook = weaks;
f6e332e6
AM
4623 weaks = hlook->u.weakdef;
4624 hlook->u.weakdef = NULL;
4ad4eba5
AM
4625
4626 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4627 || hlook->root.type == bfd_link_hash_defweak
4628 || hlook->root.type == bfd_link_hash_common
4629 || hlook->root.type == bfd_link_hash_indirect);
4630 slook = hlook->root.u.def.section;
4631 vlook = hlook->root.u.def.value;
4632
4633 ilook = -1;
4634 i = 0;
4635 j = sym_count;
4636 while (i < j)
4637 {
4638 bfd_signed_vma vdiff;
4639 idx = (i + j) / 2;
4640 h = sorted_sym_hash [idx];
4641 vdiff = vlook - h->root.u.def.value;
4642 if (vdiff < 0)
4643 j = idx;
4644 else if (vdiff > 0)
4645 i = idx + 1;
4646 else
4647 {
a9b881be 4648 long sdiff = slook->id - h->root.u.def.section->id;
4ad4eba5
AM
4649 if (sdiff < 0)
4650 j = idx;
4651 else if (sdiff > 0)
4652 i = idx + 1;
4653 else
4654 {
4655 ilook = idx;
4656 break;
4657 }
4658 }
4659 }
4660
4661 /* We didn't find a value/section match. */
4662 if (ilook == -1)
4663 continue;
4664
4665 for (i = ilook; i < sym_count; i++)
4666 {
4667 h = sorted_sym_hash [i];
4668
4669 /* Stop if value or section doesn't match. */
4670 if (h->root.u.def.value != vlook
4671 || h->root.u.def.section != slook)
4672 break;
4673 else if (h != hlook)
4674 {
f6e332e6 4675 hlook->u.weakdef = h;
4ad4eba5
AM
4676
4677 /* If the weak definition is in the list of dynamic
4678 symbols, make sure the real definition is put
4679 there as well. */
4680 if (hlook->dynindx != -1 && h->dynindx == -1)
4681 {
c152c796 4682 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4dd07732
AM
4683 {
4684 err_free_sym_hash:
4685 free (sorted_sym_hash);
4686 goto error_return;
4687 }
4ad4eba5
AM
4688 }
4689
4690 /* If the real definition is in the list of dynamic
4691 symbols, make sure the weak definition is put
4692 there as well. If we don't do this, then the
4693 dynamic loader might not merge the entries for the
4694 real definition and the weak definition. */
4695 if (h->dynindx != -1 && hlook->dynindx == -1)
4696 {
c152c796 4697 if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4dd07732 4698 goto err_free_sym_hash;
4ad4eba5
AM
4699 }
4700 break;
4701 }
4702 }
4703 }
4704
4705 free (sorted_sym_hash);
4706 }
4707
33177bb1
AM
4708 if (bed->check_directives
4709 && !(*bed->check_directives) (abfd, info))
4710 return FALSE;
85fbca6a 4711
4ad4eba5
AM
4712 /* If this object is the same format as the output object, and it is
4713 not a shared library, then let the backend look through the
4714 relocs.
4715
4716 This is required to build global offset table entries and to
4717 arrange for dynamic relocs. It is not required for the
4718 particular common case of linking non PIC code, even when linking
4719 against shared libraries, but unfortunately there is no way of
4720 knowing whether an object file has been compiled PIC or not.
4721 Looking through the relocs is not particularly time consuming.
4722 The problem is that we must either (1) keep the relocs in memory,
4723 which causes the linker to require additional runtime memory or
4724 (2) read the relocs twice from the input file, which wastes time.
4725 This would be a good case for using mmap.
4726
4727 I have no idea how to handle linking PIC code into a file of a
4728 different format. It probably can't be done. */
4ad4eba5 4729 if (! dynamic
66eb6687 4730 && is_elf_hash_table (htab)
13285a1b 4731 && bed->check_relocs != NULL
f13a99db 4732 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4ad4eba5
AM
4733 {
4734 asection *o;
4735
4736 for (o = abfd->sections; o != NULL; o = o->next)
4737 {
4738 Elf_Internal_Rela *internal_relocs;
4739 bfd_boolean ok;
4740
4741 if ((o->flags & SEC_RELOC) == 0
4742 || o->reloc_count == 0
4743 || ((info->strip == strip_all || info->strip == strip_debugger)
4744 && (o->flags & SEC_DEBUGGING) != 0)
4745 || bfd_is_abs_section (o->output_section))
4746 continue;
4747
4748 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4749 info->keep_memory);
4750 if (internal_relocs == NULL)
4751 goto error_return;
4752
66eb6687 4753 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4ad4eba5
AM
4754
4755 if (elf_section_data (o)->relocs != internal_relocs)
4756 free (internal_relocs);
4757
4758 if (! ok)
4759 goto error_return;
4760 }
4761 }
4762
4763 /* If this is a non-traditional link, try to optimize the handling
4764 of the .stab/.stabstr sections. */
4765 if (! dynamic
4766 && ! info->traditional_format
66eb6687 4767 && is_elf_hash_table (htab)
4ad4eba5
AM
4768 && (info->strip != strip_all && info->strip != strip_debugger))
4769 {
4770 asection *stabstr;
4771
4772 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4773 if (stabstr != NULL)
4774 {
4775 bfd_size_type string_offset = 0;
4776 asection *stab;
4777
4778 for (stab = abfd->sections; stab; stab = stab->next)
0112cd26 4779 if (CONST_STRNEQ (stab->name, ".stab")
4ad4eba5
AM
4780 && (!stab->name[5] ||
4781 (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4782 && (stab->flags & SEC_MERGE) == 0
4783 && !bfd_is_abs_section (stab->output_section))
4784 {
4785 struct bfd_elf_section_data *secdata;
4786
4787 secdata = elf_section_data (stab);
66eb6687
AM
4788 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4789 stabstr, &secdata->sec_info,
4ad4eba5
AM
4790 &string_offset))
4791 goto error_return;
4792 if (secdata->sec_info)
4793 stab->sec_info_type = ELF_INFO_TYPE_STABS;
4794 }
4795 }
4796 }
4797
66eb6687 4798 if (is_elf_hash_table (htab) && add_needed)
4ad4eba5
AM
4799 {
4800 /* Add this bfd to the loaded list. */
4801 struct elf_link_loaded_list *n;
4802
4803 n = bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4804 if (n == NULL)
4805 goto error_return;
4806 n->abfd = abfd;
66eb6687
AM
4807 n->next = htab->loaded;
4808 htab->loaded = n;
4ad4eba5
AM
4809 }
4810
4811 return TRUE;
4812
4813 error_free_vers:
66eb6687
AM
4814 if (old_tab != NULL)
4815 free (old_tab);
4ad4eba5
AM
4816 if (nondeflt_vers != NULL)
4817 free (nondeflt_vers);
4818 if (extversym != NULL)
4819 free (extversym);
4820 error_free_sym:
4821 if (isymbuf != NULL)
4822 free (isymbuf);
4823 error_return:
4824 return FALSE;
4825}
4826
8387904d
AM
4827/* Return the linker hash table entry of a symbol that might be
4828 satisfied by an archive symbol. Return -1 on error. */
4829
4830struct elf_link_hash_entry *
4831_bfd_elf_archive_symbol_lookup (bfd *abfd,
4832 struct bfd_link_info *info,
4833 const char *name)
4834{
4835 struct elf_link_hash_entry *h;
4836 char *p, *copy;
4837 size_t len, first;
4838
4839 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4840 if (h != NULL)
4841 return h;
4842
4843 /* If this is a default version (the name contains @@), look up the
4844 symbol again with only one `@' as well as without the version.
4845 The effect is that references to the symbol with and without the
4846 version will be matched by the default symbol in the archive. */
4847
4848 p = strchr (name, ELF_VER_CHR);
4849 if (p == NULL || p[1] != ELF_VER_CHR)
4850 return h;
4851
4852 /* First check with only one `@'. */
4853 len = strlen (name);
4854 copy = bfd_alloc (abfd, len);
4855 if (copy == NULL)
4856 return (struct elf_link_hash_entry *) 0 - 1;
4857
4858 first = p - name + 1;
4859 memcpy (copy, name, first);
4860 memcpy (copy + first, name + first + 1, len - first);
4861
4862 h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, FALSE);
4863 if (h == NULL)
4864 {
4865 /* We also need to check references to the symbol without the
4866 version. */
4867 copy[first - 1] = '\0';
4868 h = elf_link_hash_lookup (elf_hash_table (info), copy,
4869 FALSE, FALSE, FALSE);
4870 }
4871
4872 bfd_release (abfd, copy);
4873 return h;
4874}
4875
0ad989f9
L
4876/* Add symbols from an ELF archive file to the linker hash table. We
4877 don't use _bfd_generic_link_add_archive_symbols because of a
4878 problem which arises on UnixWare. The UnixWare libc.so is an
4879 archive which includes an entry libc.so.1 which defines a bunch of
4880 symbols. The libc.so archive also includes a number of other
4881 object files, which also define symbols, some of which are the same
4882 as those defined in libc.so.1. Correct linking requires that we
4883 consider each object file in turn, and include it if it defines any
4884 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4885 this; it looks through the list of undefined symbols, and includes
4886 any object file which defines them. When this algorithm is used on
4887 UnixWare, it winds up pulling in libc.so.1 early and defining a
4888 bunch of symbols. This means that some of the other objects in the
4889 archive are not included in the link, which is incorrect since they
4890 precede libc.so.1 in the archive.
4891
4892 Fortunately, ELF archive handling is simpler than that done by
4893 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4894 oddities. In ELF, if we find a symbol in the archive map, and the
4895 symbol is currently undefined, we know that we must pull in that
4896 object file.
4897
4898 Unfortunately, we do have to make multiple passes over the symbol
4899 table until nothing further is resolved. */
4900
4ad4eba5
AM
4901static bfd_boolean
4902elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
0ad989f9
L
4903{
4904 symindex c;
4905 bfd_boolean *defined = NULL;
4906 bfd_boolean *included = NULL;
4907 carsym *symdefs;
4908 bfd_boolean loop;
4909 bfd_size_type amt;
8387904d
AM
4910 const struct elf_backend_data *bed;
4911 struct elf_link_hash_entry * (*archive_symbol_lookup)
4912 (bfd *, struct bfd_link_info *, const char *);
0ad989f9
L
4913
4914 if (! bfd_has_map (abfd))
4915 {
4916 /* An empty archive is a special case. */
4917 if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4918 return TRUE;
4919 bfd_set_error (bfd_error_no_armap);
4920 return FALSE;
4921 }
4922
4923 /* Keep track of all symbols we know to be already defined, and all
4924 files we know to be already included. This is to speed up the
4925 second and subsequent passes. */
4926 c = bfd_ardata (abfd)->symdef_count;
4927 if (c == 0)
4928 return TRUE;
4929 amt = c;
4930 amt *= sizeof (bfd_boolean);
4931 defined = bfd_zmalloc (amt);
4932 included = bfd_zmalloc (amt);
4933 if (defined == NULL || included == NULL)
4934 goto error_return;
4935
4936 symdefs = bfd_ardata (abfd)->symdefs;
8387904d
AM
4937 bed = get_elf_backend_data (abfd);
4938 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
0ad989f9
L
4939
4940 do
4941 {
4942 file_ptr last;
4943 symindex i;
4944 carsym *symdef;
4945 carsym *symdefend;
4946
4947 loop = FALSE;
4948 last = -1;
4949
4950 symdef = symdefs;
4951 symdefend = symdef + c;
4952 for (i = 0; symdef < symdefend; symdef++, i++)
4953 {
4954 struct elf_link_hash_entry *h;
4955 bfd *element;
4956 struct bfd_link_hash_entry *undefs_tail;
4957 symindex mark;
4958
4959 if (defined[i] || included[i])
4960 continue;
4961 if (symdef->file_offset == last)
4962 {
4963 included[i] = TRUE;
4964 continue;
4965 }
4966
8387904d
AM
4967 h = archive_symbol_lookup (abfd, info, symdef->name);
4968 if (h == (struct elf_link_hash_entry *) 0 - 1)
4969 goto error_return;
0ad989f9
L
4970
4971 if (h == NULL)
4972 continue;
4973
4974 if (h->root.type == bfd_link_hash_common)
4975 {
4976 /* We currently have a common symbol. The archive map contains
4977 a reference to this symbol, so we may want to include it. We
4978 only want to include it however, if this archive element
4979 contains a definition of the symbol, not just another common
4980 declaration of it.
4981
4982 Unfortunately some archivers (including GNU ar) will put
4983 declarations of common symbols into their archive maps, as
4984 well as real definitions, so we cannot just go by the archive
4985 map alone. Instead we must read in the element's symbol
4986 table and check that to see what kind of symbol definition
4987 this is. */
4988 if (! elf_link_is_defined_archive_symbol (abfd, symdef))
4989 continue;
4990 }
4991 else if (h->root.type != bfd_link_hash_undefined)
4992 {
4993 if (h->root.type != bfd_link_hash_undefweak)
4994 defined[i] = TRUE;
4995 continue;
4996 }
4997
4998 /* We need to include this archive member. */
4999 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5000 if (element == NULL)
5001 goto error_return;
5002
5003 if (! bfd_check_format (element, bfd_object))
5004 goto error_return;
5005
5006 /* Doublecheck that we have not included this object
5007 already--it should be impossible, but there may be
5008 something wrong with the archive. */
5009 if (element->archive_pass != 0)
5010 {
5011 bfd_set_error (bfd_error_bad_value);
5012 goto error_return;
5013 }
5014 element->archive_pass = 1;
5015
5016 undefs_tail = info->hash->undefs_tail;
5017
5018 if (! (*info->callbacks->add_archive_element) (info, element,
5019 symdef->name))
5020 goto error_return;
5021 if (! bfd_link_add_symbols (element, info))
5022 goto error_return;
5023
5024 /* If there are any new undefined symbols, we need to make
5025 another pass through the archive in order to see whether
5026 they can be defined. FIXME: This isn't perfect, because
5027 common symbols wind up on undefs_tail and because an
5028 undefined symbol which is defined later on in this pass
5029 does not require another pass. This isn't a bug, but it
5030 does make the code less efficient than it could be. */
5031 if (undefs_tail != info->hash->undefs_tail)
5032 loop = TRUE;
5033
5034 /* Look backward to mark all symbols from this object file
5035 which we have already seen in this pass. */
5036 mark = i;
5037 do
5038 {
5039 included[mark] = TRUE;
5040 if (mark == 0)
5041 break;
5042 --mark;
5043 }
5044 while (symdefs[mark].file_offset == symdef->file_offset);
5045
5046 /* We mark subsequent symbols from this object file as we go
5047 on through the loop. */
5048 last = symdef->file_offset;
5049 }
5050 }
5051 while (loop);
5052
5053 free (defined);
5054 free (included);
5055
5056 return TRUE;
5057
5058 error_return:
5059 if (defined != NULL)
5060 free (defined);
5061 if (included != NULL)
5062 free (included);
5063 return FALSE;
5064}
4ad4eba5
AM
5065
5066/* Given an ELF BFD, add symbols to the global hash table as
5067 appropriate. */
5068
5069bfd_boolean
5070bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5071{
5072 switch (bfd_get_format (abfd))
5073 {
5074 case bfd_object:
5075 return elf_link_add_object_symbols (abfd, info);
5076 case bfd_archive:
5077 return elf_link_add_archive_symbols (abfd, info);
5078 default:
5079 bfd_set_error (bfd_error_wrong_format);
5080 return FALSE;
5081 }
5082}
5a580b3a 5083\f
14b1c01e
AM
5084struct hash_codes_info
5085{
5086 unsigned long *hashcodes;
5087 bfd_boolean error;
5088};
a0c8462f 5089
5a580b3a
AM
5090/* This function will be called though elf_link_hash_traverse to store
5091 all hash value of the exported symbols in an array. */
5092
5093static bfd_boolean
5094elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5095{
14b1c01e 5096 struct hash_codes_info *inf = data;
5a580b3a
AM
5097 const char *name;
5098 char *p;
5099 unsigned long ha;
5100 char *alc = NULL;
5101
5102 if (h->root.type == bfd_link_hash_warning)
5103 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5104
5105 /* Ignore indirect symbols. These are added by the versioning code. */
5106 if (h->dynindx == -1)
5107 return TRUE;
5108
5109 name = h->root.root.string;
5110 p = strchr (name, ELF_VER_CHR);
5111 if (p != NULL)
5112 {
5113 alc = bfd_malloc (p - name + 1);
14b1c01e
AM
5114 if (alc == NULL)
5115 {
5116 inf->error = TRUE;
5117 return FALSE;
5118 }
5a580b3a
AM
5119 memcpy (alc, name, p - name);
5120 alc[p - name] = '\0';
5121 name = alc;
5122 }
5123
5124 /* Compute the hash value. */
5125 ha = bfd_elf_hash (name);
5126
5127 /* Store the found hash value in the array given as the argument. */
14b1c01e 5128 *(inf->hashcodes)++ = ha;
5a580b3a
AM
5129
5130 /* And store it in the struct so that we can put it in the hash table
5131 later. */
f6e332e6 5132 h->u.elf_hash_value = ha;
5a580b3a
AM
5133
5134 if (alc != NULL)
5135 free (alc);
5136
5137 return TRUE;
5138}
5139
fdc90cb4
JJ
5140struct collect_gnu_hash_codes
5141{
5142 bfd *output_bfd;
5143 const struct elf_backend_data *bed;
5144 unsigned long int nsyms;
5145 unsigned long int maskbits;
5146 unsigned long int *hashcodes;
5147 unsigned long int *hashval;
5148 unsigned long int *indx;
5149 unsigned long int *counts;
5150 bfd_vma *bitmask;
5151 bfd_byte *contents;
5152 long int min_dynindx;
5153 unsigned long int bucketcount;
5154 unsigned long int symindx;
5155 long int local_indx;
5156 long int shift1, shift2;
5157 unsigned long int mask;
14b1c01e 5158 bfd_boolean error;
fdc90cb4
JJ
5159};
5160
5161/* This function will be called though elf_link_hash_traverse to store
5162 all hash value of the exported symbols in an array. */
5163
5164static bfd_boolean
5165elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5166{
5167 struct collect_gnu_hash_codes *s = data;
5168 const char *name;
5169 char *p;
5170 unsigned long ha;
5171 char *alc = NULL;
5172
5173 if (h->root.type == bfd_link_hash_warning)
5174 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5175
5176 /* Ignore indirect symbols. These are added by the versioning code. */
5177 if (h->dynindx == -1)
5178 return TRUE;
5179
5180 /* Ignore also local symbols and undefined symbols. */
5181 if (! (*s->bed->elf_hash_symbol) (h))
5182 return TRUE;
5183
5184 name = h->root.root.string;
5185 p = strchr (name, ELF_VER_CHR);
5186 if (p != NULL)
5187 {
5188 alc = bfd_malloc (p - name + 1);
14b1c01e
AM
5189 if (alc == NULL)
5190 {
5191 s->error = TRUE;
5192 return FALSE;
5193 }
fdc90cb4
JJ
5194 memcpy (alc, name, p - name);
5195 alc[p - name] = '\0';
5196 name = alc;
5197 }
5198
5199 /* Compute the hash value. */
5200 ha = bfd_elf_gnu_hash (name);
5201
5202 /* Store the found hash value in the array for compute_bucket_count,
5203 and also for .dynsym reordering purposes. */
5204 s->hashcodes[s->nsyms] = ha;
5205 s->hashval[h->dynindx] = ha;
5206 ++s->nsyms;
5207 if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5208 s->min_dynindx = h->dynindx;
5209
5210 if (alc != NULL)
5211 free (alc);
5212
5213 return TRUE;
5214}
5215
5216/* This function will be called though elf_link_hash_traverse to do
5217 final dynaminc symbol renumbering. */
5218
5219static bfd_boolean
5220elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5221{
5222 struct collect_gnu_hash_codes *s = data;
5223 unsigned long int bucket;
5224 unsigned long int val;
5225
5226 if (h->root.type == bfd_link_hash_warning)
5227 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5228
5229 /* Ignore indirect symbols. */
5230 if (h->dynindx == -1)
5231 return TRUE;
5232
5233 /* Ignore also local symbols and undefined symbols. */
5234 if (! (*s->bed->elf_hash_symbol) (h))
5235 {
5236 if (h->dynindx >= s->min_dynindx)
5237 h->dynindx = s->local_indx++;
5238 return TRUE;
5239 }
5240
5241 bucket = s->hashval[h->dynindx] % s->bucketcount;
5242 val = (s->hashval[h->dynindx] >> s->shift1)
5243 & ((s->maskbits >> s->shift1) - 1);
5244 s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5245 s->bitmask[val]
5246 |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5247 val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5248 if (s->counts[bucket] == 1)
5249 /* Last element terminates the chain. */
5250 val |= 1;
5251 bfd_put_32 (s->output_bfd, val,
5252 s->contents + (s->indx[bucket] - s->symindx) * 4);
5253 --s->counts[bucket];
5254 h->dynindx = s->indx[bucket]++;
5255 return TRUE;
5256}
5257
5258/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5259
5260bfd_boolean
5261_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5262{
5263 return !(h->forced_local
5264 || h->root.type == bfd_link_hash_undefined
5265 || h->root.type == bfd_link_hash_undefweak
5266 || ((h->root.type == bfd_link_hash_defined
5267 || h->root.type == bfd_link_hash_defweak)
5268 && h->root.u.def.section->output_section == NULL));
5269}
5270
5a580b3a
AM
5271/* Array used to determine the number of hash table buckets to use
5272 based on the number of symbols there are. If there are fewer than
5273 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5274 fewer than 37 we use 17 buckets, and so forth. We never use more
5275 than 32771 buckets. */
5276
5277static const size_t elf_buckets[] =
5278{
5279 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5280 16411, 32771, 0
5281};
5282
5283/* Compute bucket count for hashing table. We do not use a static set
5284 of possible tables sizes anymore. Instead we determine for all
5285 possible reasonable sizes of the table the outcome (i.e., the
5286 number of collisions etc) and choose the best solution. The
5287 weighting functions are not too simple to allow the table to grow
5288 without bounds. Instead one of the weighting factors is the size.
5289 Therefore the result is always a good payoff between few collisions
5290 (= short chain lengths) and table size. */
5291static size_t
d40f3da9
AM
5292compute_bucket_count (struct bfd_link_info *info,
5293 unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5294 unsigned long int nsyms,
5295 int gnu_hash)
5a580b3a 5296{
5a580b3a 5297 size_t best_size = 0;
5a580b3a 5298 unsigned long int i;
5a580b3a 5299
5a580b3a
AM
5300 /* We have a problem here. The following code to optimize the table
5301 size requires an integer type with more the 32 bits. If
5302 BFD_HOST_U_64_BIT is set we know about such a type. */
5303#ifdef BFD_HOST_U_64_BIT
5304 if (info->optimize)
5305 {
5a580b3a
AM
5306 size_t minsize;
5307 size_t maxsize;
5308 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5a580b3a 5309 bfd *dynobj = elf_hash_table (info)->dynobj;
d40f3da9 5310 size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5a580b3a 5311 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
fdc90cb4 5312 unsigned long int *counts;
d40f3da9 5313 bfd_size_type amt;
5a580b3a
AM
5314
5315 /* Possible optimization parameters: if we have NSYMS symbols we say
5316 that the hashing table must at least have NSYMS/4 and at most
5317 2*NSYMS buckets. */
5318 minsize = nsyms / 4;
5319 if (minsize == 0)
5320 minsize = 1;
5321 best_size = maxsize = nsyms * 2;
fdc90cb4
JJ
5322 if (gnu_hash)
5323 {
5324 if (minsize < 2)
5325 minsize = 2;
5326 if ((best_size & 31) == 0)
5327 ++best_size;
5328 }
5a580b3a
AM
5329
5330 /* Create array where we count the collisions in. We must use bfd_malloc
5331 since the size could be large. */
5332 amt = maxsize;
5333 amt *= sizeof (unsigned long int);
5334 counts = bfd_malloc (amt);
5335 if (counts == NULL)
fdc90cb4 5336 return 0;
5a580b3a
AM
5337
5338 /* Compute the "optimal" size for the hash table. The criteria is a
5339 minimal chain length. The minor criteria is (of course) the size
5340 of the table. */
5341 for (i = minsize; i < maxsize; ++i)
5342 {
5343 /* Walk through the array of hashcodes and count the collisions. */
5344 BFD_HOST_U_64_BIT max;
5345 unsigned long int j;
5346 unsigned long int fact;
5347
fdc90cb4
JJ
5348 if (gnu_hash && (i & 31) == 0)
5349 continue;
5350
5a580b3a
AM
5351 memset (counts, '\0', i * sizeof (unsigned long int));
5352
5353 /* Determine how often each hash bucket is used. */
5354 for (j = 0; j < nsyms; ++j)
5355 ++counts[hashcodes[j] % i];
5356
5357 /* For the weight function we need some information about the
5358 pagesize on the target. This is information need not be 100%
5359 accurate. Since this information is not available (so far) we
5360 define it here to a reasonable default value. If it is crucial
5361 to have a better value some day simply define this value. */
5362# ifndef BFD_TARGET_PAGESIZE
5363# define BFD_TARGET_PAGESIZE (4096)
5364# endif
5365
fdc90cb4
JJ
5366 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5367 and the chains. */
5368 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5a580b3a
AM
5369
5370# if 1
5371 /* Variant 1: optimize for short chains. We add the squares
5372 of all the chain lengths (which favors many small chain
5373 over a few long chains). */
5374 for (j = 0; j < i; ++j)
5375 max += counts[j] * counts[j];
5376
5377 /* This adds penalties for the overall size of the table. */
fdc90cb4 5378 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5a580b3a
AM
5379 max *= fact * fact;
5380# else
5381 /* Variant 2: Optimize a lot more for small table. Here we
5382 also add squares of the size but we also add penalties for
5383 empty slots (the +1 term). */
5384 for (j = 0; j < i; ++j)
5385 max += (1 + counts[j]) * (1 + counts[j]);
5386
5387 /* The overall size of the table is considered, but not as
5388 strong as in variant 1, where it is squared. */
fdc90cb4 5389 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5a580b3a
AM
5390 max *= fact;
5391# endif
5392
5393 /* Compare with current best results. */
5394 if (max < best_chlen)
5395 {
5396 best_chlen = max;
5397 best_size = i;
5398 }
5399 }
5400
5401 free (counts);
5402 }
5403 else
5404#endif /* defined (BFD_HOST_U_64_BIT) */
5405 {
5406 /* This is the fallback solution if no 64bit type is available or if we
5407 are not supposed to spend much time on optimizations. We select the
5408 bucket count using a fixed set of numbers. */
5409 for (i = 0; elf_buckets[i] != 0; i++)
5410 {
5411 best_size = elf_buckets[i];
fdc90cb4 5412 if (nsyms < elf_buckets[i + 1])
5a580b3a
AM
5413 break;
5414 }
fdc90cb4
JJ
5415 if (gnu_hash && best_size < 2)
5416 best_size = 2;
5a580b3a
AM
5417 }
5418
5a580b3a
AM
5419 return best_size;
5420}
5421
5422/* Set up the sizes and contents of the ELF dynamic sections. This is
5423 called by the ELF linker emulation before_allocation routine. We
5424 must set the sizes of the sections before the linker sets the
5425 addresses of the various sections. */
5426
5427bfd_boolean
5428bfd_elf_size_dynamic_sections (bfd *output_bfd,
5429 const char *soname,
5430 const char *rpath,
5431 const char *filter_shlib,
5432 const char * const *auxiliary_filters,
5433 struct bfd_link_info *info,
5434 asection **sinterpptr,
5435 struct bfd_elf_version_tree *verdefs)
5436{
5437 bfd_size_type soname_indx;
5438 bfd *dynobj;
5439 const struct elf_backend_data *bed;
28caa186 5440 struct elf_info_failed asvinfo;
5a580b3a
AM
5441
5442 *sinterpptr = NULL;
5443
5444 soname_indx = (bfd_size_type) -1;
5445
5446 if (!is_elf_hash_table (info->hash))
5447 return TRUE;
5448
6bfdb61b 5449 bed = get_elf_backend_data (output_bfd);
5a580b3a
AM
5450 if (info->execstack)
5451 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5452 else if (info->noexecstack)
5453 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W;
5454 else
5455 {
5456 bfd *inputobj;
5457 asection *notesec = NULL;
5458 int exec = 0;
5459
5460 for (inputobj = info->input_bfds;
5461 inputobj;
5462 inputobj = inputobj->link_next)
5463 {
5464 asection *s;
5465
a94b9d2d 5466 if (inputobj->flags & (DYNAMIC | EXEC_P | BFD_LINKER_CREATED))
5a580b3a
AM
5467 continue;
5468 s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5469 if (s)
5470 {
5471 if (s->flags & SEC_CODE)
5472 exec = PF_X;
5473 notesec = s;
5474 }
6bfdb61b 5475 else if (bed->default_execstack)
5a580b3a
AM
5476 exec = PF_X;
5477 }
5478 if (notesec)
5479 {
5480 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | exec;
5481 if (exec && info->relocatable
5482 && notesec->output_section != bfd_abs_section_ptr)
5483 notesec->output_section->flags |= SEC_CODE;
5484 }
5485 }
5486
5487 /* Any syms created from now on start with -1 in
5488 got.refcount/offset and plt.refcount/offset. */
a6aa5195
AM
5489 elf_hash_table (info)->init_got_refcount
5490 = elf_hash_table (info)->init_got_offset;
5491 elf_hash_table (info)->init_plt_refcount
5492 = elf_hash_table (info)->init_plt_offset;
5a580b3a
AM
5493
5494 /* The backend may have to create some sections regardless of whether
5495 we're dynamic or not. */
5a580b3a
AM
5496 if (bed->elf_backend_always_size_sections
5497 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5498 return FALSE;
5499
eb3d5f3b
JB
5500 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5501 return FALSE;
5502
5a580b3a
AM
5503 dynobj = elf_hash_table (info)->dynobj;
5504
5505 /* If there were no dynamic objects in the link, there is nothing to
5506 do here. */
5507 if (dynobj == NULL)
5508 return TRUE;
5509
5a580b3a
AM
5510 if (elf_hash_table (info)->dynamic_sections_created)
5511 {
5512 struct elf_info_failed eif;
5513 struct elf_link_hash_entry *h;
5514 asection *dynstr;
5515 struct bfd_elf_version_tree *t;
5516 struct bfd_elf_version_expr *d;
046183de 5517 asection *s;
5a580b3a
AM
5518 bfd_boolean all_defined;
5519
5520 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
5521 BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5522
5523 if (soname != NULL)
5524 {
5525 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5526 soname, TRUE);
5527 if (soname_indx == (bfd_size_type) -1
5528 || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5529 return FALSE;
5530 }
5531
5532 if (info->symbolic)
5533 {
5534 if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5535 return FALSE;
5536 info->flags |= DF_SYMBOLIC;
5537 }
5538
5539 if (rpath != NULL)
5540 {
5541 bfd_size_type indx;
5542
5543 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5544 TRUE);
5545 if (indx == (bfd_size_type) -1
5546 || !_bfd_elf_add_dynamic_entry (info, DT_RPATH, indx))
5547 return FALSE;
5548
5549 if (info->new_dtags)
5550 {
5551 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
5552 if (!_bfd_elf_add_dynamic_entry (info, DT_RUNPATH, indx))
5553 return FALSE;
5554 }
5555 }
5556
5557 if (filter_shlib != NULL)
5558 {
5559 bfd_size_type indx;
5560
5561 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5562 filter_shlib, TRUE);
5563 if (indx == (bfd_size_type) -1
5564 || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5565 return FALSE;
5566 }
5567
5568 if (auxiliary_filters != NULL)
5569 {
5570 const char * const *p;
5571
5572 for (p = auxiliary_filters; *p != NULL; p++)
5573 {
5574 bfd_size_type indx;
5575
5576 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5577 *p, TRUE);
5578 if (indx == (bfd_size_type) -1
5579 || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5580 return FALSE;
5581 }
5582 }
5583
5584 eif.info = info;
5585 eif.verdefs = verdefs;
5586 eif.failed = FALSE;
5587
5588 /* If we are supposed to export all symbols into the dynamic symbol
5589 table (this is not the normal case), then do so. */
55255dae
L
5590 if (info->export_dynamic
5591 || (info->executable && info->dynamic))
5a580b3a
AM
5592 {
5593 elf_link_hash_traverse (elf_hash_table (info),
5594 _bfd_elf_export_symbol,
5595 &eif);
5596 if (eif.failed)
5597 return FALSE;
5598 }
5599
5600 /* Make all global versions with definition. */
5601 for (t = verdefs; t != NULL; t = t->next)
5602 for (d = t->globals.list; d != NULL; d = d->next)
ae5a3597 5603 if (!d->symver && d->literal)
5a580b3a
AM
5604 {
5605 const char *verstr, *name;
5606 size_t namelen, verlen, newlen;
5607 char *newname, *p;
5608 struct elf_link_hash_entry *newh;
5609
ae5a3597 5610 name = d->pattern;
5a580b3a
AM
5611 namelen = strlen (name);
5612 verstr = t->name;
5613 verlen = strlen (verstr);
5614 newlen = namelen + verlen + 3;
5615
5616 newname = bfd_malloc (newlen);
5617 if (newname == NULL)
5618 return FALSE;
5619 memcpy (newname, name, namelen);
5620
5621 /* Check the hidden versioned definition. */
5622 p = newname + namelen;
5623 *p++ = ELF_VER_CHR;
5624 memcpy (p, verstr, verlen + 1);
5625 newh = elf_link_hash_lookup (elf_hash_table (info),
5626 newname, FALSE, FALSE,
5627 FALSE);
5628 if (newh == NULL
5629 || (newh->root.type != bfd_link_hash_defined
5630 && newh->root.type != bfd_link_hash_defweak))
5631 {
5632 /* Check the default versioned definition. */
5633 *p++ = ELF_VER_CHR;
5634 memcpy (p, verstr, verlen + 1);
5635 newh = elf_link_hash_lookup (elf_hash_table (info),
5636 newname, FALSE, FALSE,
5637 FALSE);
5638 }
5639 free (newname);
5640
5641 /* Mark this version if there is a definition and it is
5642 not defined in a shared object. */
5643 if (newh != NULL
f5385ebf 5644 && !newh->def_dynamic
5a580b3a
AM
5645 && (newh->root.type == bfd_link_hash_defined
5646 || newh->root.type == bfd_link_hash_defweak))
5647 d->symver = 1;
5648 }
5649
5650 /* Attach all the symbols to their version information. */
5a580b3a
AM
5651 asvinfo.info = info;
5652 asvinfo.verdefs = verdefs;
5653 asvinfo.failed = FALSE;
5654
5655 elf_link_hash_traverse (elf_hash_table (info),
5656 _bfd_elf_link_assign_sym_version,
5657 &asvinfo);
5658 if (asvinfo.failed)
5659 return FALSE;
5660
5661 if (!info->allow_undefined_version)
5662 {
5663 /* Check if all global versions have a definition. */
5664 all_defined = TRUE;
5665 for (t = verdefs; t != NULL; t = t->next)
5666 for (d = t->globals.list; d != NULL; d = d->next)
ae5a3597 5667 if (d->literal && !d->symver && !d->script)
5a580b3a
AM
5668 {
5669 (*_bfd_error_handler)
5670 (_("%s: undefined version: %s"),
5671 d->pattern, t->name);
5672 all_defined = FALSE;
5673 }
5674
5675 if (!all_defined)
5676 {
5677 bfd_set_error (bfd_error_bad_value);
5678 return FALSE;
5679 }
5680 }
5681
5682 /* Find all symbols which were defined in a dynamic object and make
5683 the backend pick a reasonable value for them. */
5684 elf_link_hash_traverse (elf_hash_table (info),
5685 _bfd_elf_adjust_dynamic_symbol,
5686 &eif);
5687 if (eif.failed)
5688 return FALSE;
5689
5690 /* Add some entries to the .dynamic section. We fill in some of the
ee75fd95 5691 values later, in bfd_elf_final_link, but we must add the entries
5a580b3a
AM
5692 now so that we know the final size of the .dynamic section. */
5693
5694 /* If there are initialization and/or finalization functions to
5695 call then add the corresponding DT_INIT/DT_FINI entries. */
5696 h = (info->init_function
5697 ? elf_link_hash_lookup (elf_hash_table (info),
5698 info->init_function, FALSE,
5699 FALSE, FALSE)
5700 : NULL);
5701 if (h != NULL
f5385ebf
AM
5702 && (h->ref_regular
5703 || h->def_regular))
5a580b3a
AM
5704 {
5705 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5706 return FALSE;
5707 }
5708 h = (info->fini_function
5709 ? elf_link_hash_lookup (elf_hash_table (info),
5710 info->fini_function, FALSE,
5711 FALSE, FALSE)
5712 : NULL);
5713 if (h != NULL
f5385ebf
AM
5714 && (h->ref_regular
5715 || h->def_regular))
5a580b3a
AM
5716 {
5717 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5718 return FALSE;
5719 }
5720
046183de
AM
5721 s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5722 if (s != NULL && s->linker_has_input)
5a580b3a
AM
5723 {
5724 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5725 if (! info->executable)
5726 {
5727 bfd *sub;
5728 asection *o;
5729
5730 for (sub = info->input_bfds; sub != NULL;
5731 sub = sub->link_next)
3fcd97f1
JJ
5732 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5733 for (o = sub->sections; o != NULL; o = o->next)
5734 if (elf_section_data (o)->this_hdr.sh_type
5735 == SHT_PREINIT_ARRAY)
5736 {
5737 (*_bfd_error_handler)
5738 (_("%B: .preinit_array section is not allowed in DSO"),
5739 sub);
5740 break;
5741 }
5a580b3a
AM
5742
5743 bfd_set_error (bfd_error_nonrepresentable_section);
5744 return FALSE;
5745 }
5746
5747 if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5748 || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5749 return FALSE;
5750 }
046183de
AM
5751 s = bfd_get_section_by_name (output_bfd, ".init_array");
5752 if (s != NULL && s->linker_has_input)
5a580b3a
AM
5753 {
5754 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5755 || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5756 return FALSE;
5757 }
046183de
AM
5758 s = bfd_get_section_by_name (output_bfd, ".fini_array");
5759 if (s != NULL && s->linker_has_input)
5a580b3a
AM
5760 {
5761 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5762 || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5763 return FALSE;
5764 }
5765
5766 dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
5767 /* If .dynstr is excluded from the link, we don't want any of
5768 these tags. Strictly, we should be checking each section
5769 individually; This quick check covers for the case where
5770 someone does a /DISCARD/ : { *(*) }. */
5771 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5772 {
5773 bfd_size_type strsize;
5774
5775 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
fdc90cb4
JJ
5776 if ((info->emit_hash
5777 && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5778 || (info->emit_gnu_hash
5779 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5a580b3a
AM
5780 || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5781 || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5782 || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5783 || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5784 bed->s->sizeof_sym))
5785 return FALSE;
5786 }
5787 }
5788
5789 /* The backend must work out the sizes of all the other dynamic
5790 sections. */
5791 if (bed->elf_backend_size_dynamic_sections
5792 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5793 return FALSE;
5794
5795 if (elf_hash_table (info)->dynamic_sections_created)
5796 {
554220db 5797 unsigned long section_sym_count;
5a580b3a 5798 asection *s;
5a580b3a
AM
5799
5800 /* Set up the version definition section. */
5801 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
5802 BFD_ASSERT (s != NULL);
5803
5804 /* We may have created additional version definitions if we are
5805 just linking a regular application. */
5806 verdefs = asvinfo.verdefs;
5807
5808 /* Skip anonymous version tag. */
5809 if (verdefs != NULL && verdefs->vernum == 0)
5810 verdefs = verdefs->next;
5811
3e3b46e5 5812 if (verdefs == NULL && !info->create_default_symver)
8423293d 5813 s->flags |= SEC_EXCLUDE;
5a580b3a
AM
5814 else
5815 {
5816 unsigned int cdefs;
5817 bfd_size_type size;
5818 struct bfd_elf_version_tree *t;
5819 bfd_byte *p;
5820 Elf_Internal_Verdef def;
5821 Elf_Internal_Verdaux defaux;
3e3b46e5
PB
5822 struct bfd_link_hash_entry *bh;
5823 struct elf_link_hash_entry *h;
5824 const char *name;
5a580b3a
AM
5825
5826 cdefs = 0;
5827 size = 0;
5828
5829 /* Make space for the base version. */
5830 size += sizeof (Elf_External_Verdef);
5831 size += sizeof (Elf_External_Verdaux);
5832 ++cdefs;
5833
3e3b46e5
PB
5834 /* Make space for the default version. */
5835 if (info->create_default_symver)
5836 {
5837 size += sizeof (Elf_External_Verdef);
5838 ++cdefs;
5839 }
5840
5a580b3a
AM
5841 for (t = verdefs; t != NULL; t = t->next)
5842 {
5843 struct bfd_elf_version_deps *n;
5844
5845 size += sizeof (Elf_External_Verdef);
5846 size += sizeof (Elf_External_Verdaux);
5847 ++cdefs;
5848
5849 for (n = t->deps; n != NULL; n = n->next)
5850 size += sizeof (Elf_External_Verdaux);
5851 }
5852
eea6121a
AM
5853 s->size = size;
5854 s->contents = bfd_alloc (output_bfd, s->size);
5855 if (s->contents == NULL && s->size != 0)
5a580b3a
AM
5856 return FALSE;
5857
5858 /* Fill in the version definition section. */
5859
5860 p = s->contents;
5861
5862 def.vd_version = VER_DEF_CURRENT;
5863 def.vd_flags = VER_FLG_BASE;
5864 def.vd_ndx = 1;
5865 def.vd_cnt = 1;
3e3b46e5
PB
5866 if (info->create_default_symver)
5867 {
5868 def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5869 def.vd_next = sizeof (Elf_External_Verdef);
5870 }
5871 else
5872 {
5873 def.vd_aux = sizeof (Elf_External_Verdef);
5874 def.vd_next = (sizeof (Elf_External_Verdef)
5875 + sizeof (Elf_External_Verdaux));
5876 }
5a580b3a
AM
5877
5878 if (soname_indx != (bfd_size_type) -1)
5879 {
5880 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
5881 soname_indx);
5882 def.vd_hash = bfd_elf_hash (soname);
5883 defaux.vda_name = soname_indx;
3e3b46e5 5884 name = soname;
5a580b3a
AM
5885 }
5886 else
5887 {
5a580b3a
AM
5888 bfd_size_type indx;
5889
06084812 5890 name = lbasename (output_bfd->filename);
5a580b3a
AM
5891 def.vd_hash = bfd_elf_hash (name);
5892 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5893 name, FALSE);
5894 if (indx == (bfd_size_type) -1)
5895 return FALSE;
5896 defaux.vda_name = indx;
5897 }
5898 defaux.vda_next = 0;
5899
5900 _bfd_elf_swap_verdef_out (output_bfd, &def,
5901 (Elf_External_Verdef *) p);
5902 p += sizeof (Elf_External_Verdef);
3e3b46e5
PB
5903 if (info->create_default_symver)
5904 {
5905 /* Add a symbol representing this version. */
5906 bh = NULL;
5907 if (! (_bfd_generic_link_add_one_symbol
5908 (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
5909 0, NULL, FALSE,
5910 get_elf_backend_data (dynobj)->collect, &bh)))
5911 return FALSE;
5912 h = (struct elf_link_hash_entry *) bh;
5913 h->non_elf = 0;
5914 h->def_regular = 1;
5915 h->type = STT_OBJECT;
5916 h->verinfo.vertree = NULL;
5917
5918 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5919 return FALSE;
5920
5921 /* Create a duplicate of the base version with the same
5922 aux block, but different flags. */
5923 def.vd_flags = 0;
5924 def.vd_ndx = 2;
5925 def.vd_aux = sizeof (Elf_External_Verdef);
5926 if (verdefs)
5927 def.vd_next = (sizeof (Elf_External_Verdef)
5928 + sizeof (Elf_External_Verdaux));
5929 else
5930 def.vd_next = 0;
5931 _bfd_elf_swap_verdef_out (output_bfd, &def,
5932 (Elf_External_Verdef *) p);
5933 p += sizeof (Elf_External_Verdef);
5934 }
5a580b3a
AM
5935 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
5936 (Elf_External_Verdaux *) p);
5937 p += sizeof (Elf_External_Verdaux);
5938
5939 for (t = verdefs; t != NULL; t = t->next)
5940 {
5941 unsigned int cdeps;
5942 struct bfd_elf_version_deps *n;
5a580b3a
AM
5943
5944 cdeps = 0;
5945 for (n = t->deps; n != NULL; n = n->next)
5946 ++cdeps;
5947
5948 /* Add a symbol representing this version. */
5949 bh = NULL;
5950 if (! (_bfd_generic_link_add_one_symbol
5951 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
5952 0, NULL, FALSE,
5953 get_elf_backend_data (dynobj)->collect, &bh)))
5954 return FALSE;
5955 h = (struct elf_link_hash_entry *) bh;
f5385ebf
AM
5956 h->non_elf = 0;
5957 h->def_regular = 1;
5a580b3a
AM
5958 h->type = STT_OBJECT;
5959 h->verinfo.vertree = t;
5960
c152c796 5961 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5a580b3a
AM
5962 return FALSE;
5963
5964 def.vd_version = VER_DEF_CURRENT;
5965 def.vd_flags = 0;
5966 if (t->globals.list == NULL
5967 && t->locals.list == NULL
5968 && ! t->used)
5969 def.vd_flags |= VER_FLG_WEAK;
3e3b46e5 5970 def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
5a580b3a
AM
5971 def.vd_cnt = cdeps + 1;
5972 def.vd_hash = bfd_elf_hash (t->name);
5973 def.vd_aux = sizeof (Elf_External_Verdef);
5974 def.vd_next = 0;
5975 if (t->next != NULL)
5976 def.vd_next = (sizeof (Elf_External_Verdef)
5977 + (cdeps + 1) * sizeof (Elf_External_Verdaux));
5978
5979 _bfd_elf_swap_verdef_out (output_bfd, &def,
5980 (Elf_External_Verdef *) p);
5981 p += sizeof (Elf_External_Verdef);
5982
5983 defaux.vda_name = h->dynstr_index;
5984 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
5985 h->dynstr_index);
5986 defaux.vda_next = 0;
5987 if (t->deps != NULL)
5988 defaux.vda_next = sizeof (Elf_External_Verdaux);
5989 t->name_indx = defaux.vda_name;
5990
5991 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
5992 (Elf_External_Verdaux *) p);
5993 p += sizeof (Elf_External_Verdaux);
5994
5995 for (n = t->deps; n != NULL; n = n->next)
5996 {
5997 if (n->version_needed == NULL)
5998 {
5999 /* This can happen if there was an error in the
6000 version script. */
6001 defaux.vda_name = 0;
6002 }
6003 else
6004 {
6005 defaux.vda_name = n->version_needed->name_indx;
6006 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6007 defaux.vda_name);
6008 }
6009 if (n->next == NULL)
6010 defaux.vda_next = 0;
6011 else
6012 defaux.vda_next = sizeof (Elf_External_Verdaux);
6013
6014 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6015 (Elf_External_Verdaux *) p);
6016 p += sizeof (Elf_External_Verdaux);
6017 }
6018 }
6019
6020 if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6021 || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6022 return FALSE;
6023
6024 elf_tdata (output_bfd)->cverdefs = cdefs;
6025 }
6026
6027 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6028 {
6029 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6030 return FALSE;
6031 }
6032 else if (info->flags & DF_BIND_NOW)
6033 {
6034 if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6035 return FALSE;
6036 }
6037
6038 if (info->flags_1)
6039 {
6040 if (info->executable)
6041 info->flags_1 &= ~ (DF_1_INITFIRST
6042 | DF_1_NODELETE
6043 | DF_1_NOOPEN);
6044 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6045 return FALSE;
6046 }
6047
6048 /* Work out the size of the version reference section. */
6049
6050 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
6051 BFD_ASSERT (s != NULL);
6052 {
6053 struct elf_find_verdep_info sinfo;
6054
5a580b3a
AM
6055 sinfo.info = info;
6056 sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6057 if (sinfo.vers == 0)
6058 sinfo.vers = 1;
6059 sinfo.failed = FALSE;
6060
6061 elf_link_hash_traverse (elf_hash_table (info),
6062 _bfd_elf_link_find_version_dependencies,
6063 &sinfo);
14b1c01e
AM
6064 if (sinfo.failed)
6065 return FALSE;
5a580b3a
AM
6066
6067 if (elf_tdata (output_bfd)->verref == NULL)
8423293d 6068 s->flags |= SEC_EXCLUDE;
5a580b3a
AM
6069 else
6070 {
6071 Elf_Internal_Verneed *t;
6072 unsigned int size;
6073 unsigned int crefs;
6074 bfd_byte *p;
6075
6076 /* Build the version definition section. */
6077 size = 0;
6078 crefs = 0;
6079 for (t = elf_tdata (output_bfd)->verref;
6080 t != NULL;
6081 t = t->vn_nextref)
6082 {
6083 Elf_Internal_Vernaux *a;
6084
6085 size += sizeof (Elf_External_Verneed);
6086 ++crefs;
6087 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6088 size += sizeof (Elf_External_Vernaux);
6089 }
6090
eea6121a
AM
6091 s->size = size;
6092 s->contents = bfd_alloc (output_bfd, s->size);
5a580b3a
AM
6093 if (s->contents == NULL)
6094 return FALSE;
6095
6096 p = s->contents;
6097 for (t = elf_tdata (output_bfd)->verref;
6098 t != NULL;
6099 t = t->vn_nextref)
6100 {
6101 unsigned int caux;
6102 Elf_Internal_Vernaux *a;
6103 bfd_size_type indx;
6104
6105 caux = 0;
6106 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6107 ++caux;
6108
6109 t->vn_version = VER_NEED_CURRENT;
6110 t->vn_cnt = caux;
6111 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6112 elf_dt_name (t->vn_bfd) != NULL
6113 ? elf_dt_name (t->vn_bfd)
06084812 6114 : lbasename (t->vn_bfd->filename),
5a580b3a
AM
6115 FALSE);
6116 if (indx == (bfd_size_type) -1)
6117 return FALSE;
6118 t->vn_file = indx;
6119 t->vn_aux = sizeof (Elf_External_Verneed);
6120 if (t->vn_nextref == NULL)
6121 t->vn_next = 0;
6122 else
6123 t->vn_next = (sizeof (Elf_External_Verneed)
6124 + caux * sizeof (Elf_External_Vernaux));
6125
6126 _bfd_elf_swap_verneed_out (output_bfd, t,
6127 (Elf_External_Verneed *) p);
6128 p += sizeof (Elf_External_Verneed);
6129
6130 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6131 {
6132 a->vna_hash = bfd_elf_hash (a->vna_nodename);
6133 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6134 a->vna_nodename, FALSE);
6135 if (indx == (bfd_size_type) -1)
6136 return FALSE;
6137 a->vna_name = indx;
6138 if (a->vna_nextptr == NULL)
6139 a->vna_next = 0;
6140 else
6141 a->vna_next = sizeof (Elf_External_Vernaux);
6142
6143 _bfd_elf_swap_vernaux_out (output_bfd, a,
6144 (Elf_External_Vernaux *) p);
6145 p += sizeof (Elf_External_Vernaux);
6146 }
6147 }
6148
6149 if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6150 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6151 return FALSE;
6152
6153 elf_tdata (output_bfd)->cverrefs = crefs;
6154 }
6155 }
6156
8423293d
AM
6157 if ((elf_tdata (output_bfd)->cverrefs == 0
6158 && elf_tdata (output_bfd)->cverdefs == 0)
6159 || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6160 &section_sym_count) == 0)
6161 {
6162 s = bfd_get_section_by_name (dynobj, ".gnu.version");
6163 s->flags |= SEC_EXCLUDE;
6164 }
6165 }
6166 return TRUE;
6167}
6168
74541ad4
AM
6169/* Find the first non-excluded output section. We'll use its
6170 section symbol for some emitted relocs. */
6171void
6172_bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6173{
6174 asection *s;
6175
6176 for (s = output_bfd->sections; s != NULL; s = s->next)
6177 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6178 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6179 {
6180 elf_hash_table (info)->text_index_section = s;
6181 break;
6182 }
6183}
6184
6185/* Find two non-excluded output sections, one for code, one for data.
6186 We'll use their section symbols for some emitted relocs. */
6187void
6188_bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6189{
6190 asection *s;
6191
266b05cf
DJ
6192 /* Data first, since setting text_index_section changes
6193 _bfd_elf_link_omit_section_dynsym. */
74541ad4 6194 for (s = output_bfd->sections; s != NULL; s = s->next)
266b05cf 6195 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
74541ad4
AM
6196 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6197 {
266b05cf 6198 elf_hash_table (info)->data_index_section = s;
74541ad4
AM
6199 break;
6200 }
6201
6202 for (s = output_bfd->sections; s != NULL; s = s->next)
266b05cf
DJ
6203 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6204 == (SEC_ALLOC | SEC_READONLY))
74541ad4
AM
6205 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6206 {
266b05cf 6207 elf_hash_table (info)->text_index_section = s;
74541ad4
AM
6208 break;
6209 }
6210
6211 if (elf_hash_table (info)->text_index_section == NULL)
6212 elf_hash_table (info)->text_index_section
6213 = elf_hash_table (info)->data_index_section;
6214}
6215
8423293d
AM
6216bfd_boolean
6217bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6218{
74541ad4
AM
6219 const struct elf_backend_data *bed;
6220
8423293d
AM
6221 if (!is_elf_hash_table (info->hash))
6222 return TRUE;
6223
74541ad4
AM
6224 bed = get_elf_backend_data (output_bfd);
6225 (*bed->elf_backend_init_index_section) (output_bfd, info);
6226
8423293d
AM
6227 if (elf_hash_table (info)->dynamic_sections_created)
6228 {
6229 bfd *dynobj;
8423293d
AM
6230 asection *s;
6231 bfd_size_type dynsymcount;
6232 unsigned long section_sym_count;
8423293d
AM
6233 unsigned int dtagcount;
6234
6235 dynobj = elf_hash_table (info)->dynobj;
6236
5a580b3a
AM
6237 /* Assign dynsym indicies. In a shared library we generate a
6238 section symbol for each output section, which come first.
6239 Next come all of the back-end allocated local dynamic syms,
6240 followed by the rest of the global symbols. */
6241
554220db
AM
6242 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6243 &section_sym_count);
5a580b3a
AM
6244
6245 /* Work out the size of the symbol version section. */
6246 s = bfd_get_section_by_name (dynobj, ".gnu.version");
6247 BFD_ASSERT (s != NULL);
8423293d
AM
6248 if (dynsymcount != 0
6249 && (s->flags & SEC_EXCLUDE) == 0)
5a580b3a 6250 {
eea6121a
AM
6251 s->size = dynsymcount * sizeof (Elf_External_Versym);
6252 s->contents = bfd_zalloc (output_bfd, s->size);
5a580b3a
AM
6253 if (s->contents == NULL)
6254 return FALSE;
6255
6256 if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6257 return FALSE;
6258 }
6259
6260 /* Set the size of the .dynsym and .hash sections. We counted
6261 the number of dynamic symbols in elf_link_add_object_symbols.
6262 We will build the contents of .dynsym and .hash when we build
6263 the final symbol table, because until then we do not know the
6264 correct value to give the symbols. We built the .dynstr
6265 section as we went along in elf_link_add_object_symbols. */
6266 s = bfd_get_section_by_name (dynobj, ".dynsym");
6267 BFD_ASSERT (s != NULL);
eea6121a 6268 s->size = dynsymcount * bed->s->sizeof_sym;
5a580b3a
AM
6269
6270 if (dynsymcount != 0)
6271 {
554220db
AM
6272 s->contents = bfd_alloc (output_bfd, s->size);
6273 if (s->contents == NULL)
6274 return FALSE;
5a580b3a 6275
554220db
AM
6276 /* The first entry in .dynsym is a dummy symbol.
6277 Clear all the section syms, in case we don't output them all. */
6278 ++section_sym_count;
6279 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
5a580b3a
AM
6280 }
6281
fdc90cb4
JJ
6282 elf_hash_table (info)->bucketcount = 0;
6283
5a580b3a
AM
6284 /* Compute the size of the hashing table. As a side effect this
6285 computes the hash values for all the names we export. */
fdc90cb4
JJ
6286 if (info->emit_hash)
6287 {
6288 unsigned long int *hashcodes;
14b1c01e 6289 struct hash_codes_info hashinf;
fdc90cb4
JJ
6290 bfd_size_type amt;
6291 unsigned long int nsyms;
6292 size_t bucketcount;
6293 size_t hash_entry_size;
6294
6295 /* Compute the hash values for all exported symbols. At the same
6296 time store the values in an array so that we could use them for
6297 optimizations. */
6298 amt = dynsymcount * sizeof (unsigned long int);
6299 hashcodes = bfd_malloc (amt);
6300 if (hashcodes == NULL)
6301 return FALSE;
14b1c01e
AM
6302 hashinf.hashcodes = hashcodes;
6303 hashinf.error = FALSE;
5a580b3a 6304
fdc90cb4
JJ
6305 /* Put all hash values in HASHCODES. */
6306 elf_link_hash_traverse (elf_hash_table (info),
14b1c01e
AM
6307 elf_collect_hash_codes, &hashinf);
6308 if (hashinf.error)
4dd07732
AM
6309 {
6310 free (hashcodes);
6311 return FALSE;
6312 }
5a580b3a 6313
14b1c01e 6314 nsyms = hashinf.hashcodes - hashcodes;
fdc90cb4
JJ
6315 bucketcount
6316 = compute_bucket_count (info, hashcodes, nsyms, 0);
6317 free (hashcodes);
6318
6319 if (bucketcount == 0)
6320 return FALSE;
5a580b3a 6321
fdc90cb4
JJ
6322 elf_hash_table (info)->bucketcount = bucketcount;
6323
6324 s = bfd_get_section_by_name (dynobj, ".hash");
6325 BFD_ASSERT (s != NULL);
6326 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6327 s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6328 s->contents = bfd_zalloc (output_bfd, s->size);
6329 if (s->contents == NULL)
6330 return FALSE;
6331
6332 bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6333 bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6334 s->contents + hash_entry_size);
6335 }
6336
6337 if (info->emit_gnu_hash)
6338 {
6339 size_t i, cnt;
6340 unsigned char *contents;
6341 struct collect_gnu_hash_codes cinfo;
6342 bfd_size_type amt;
6343 size_t bucketcount;
6344
6345 memset (&cinfo, 0, sizeof (cinfo));
6346
6347 /* Compute the hash values for all exported symbols. At the same
6348 time store the values in an array so that we could use them for
6349 optimizations. */
6350 amt = dynsymcount * 2 * sizeof (unsigned long int);
6351 cinfo.hashcodes = bfd_malloc (amt);
6352 if (cinfo.hashcodes == NULL)
6353 return FALSE;
6354
6355 cinfo.hashval = cinfo.hashcodes + dynsymcount;
6356 cinfo.min_dynindx = -1;
6357 cinfo.output_bfd = output_bfd;
6358 cinfo.bed = bed;
6359
6360 /* Put all hash values in HASHCODES. */
6361 elf_link_hash_traverse (elf_hash_table (info),
6362 elf_collect_gnu_hash_codes, &cinfo);
14b1c01e 6363 if (cinfo.error)
4dd07732
AM
6364 {
6365 free (cinfo.hashcodes);
6366 return FALSE;
6367 }
fdc90cb4
JJ
6368
6369 bucketcount
6370 = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6371
6372 if (bucketcount == 0)
6373 {
6374 free (cinfo.hashcodes);
6375 return FALSE;
6376 }
6377
6378 s = bfd_get_section_by_name (dynobj, ".gnu.hash");
6379 BFD_ASSERT (s != NULL);
6380
6381 if (cinfo.nsyms == 0)
6382 {
6383 /* Empty .gnu.hash section is special. */
6384 BFD_ASSERT (cinfo.min_dynindx == -1);
6385 free (cinfo.hashcodes);
6386 s->size = 5 * 4 + bed->s->arch_size / 8;
6387 contents = bfd_zalloc (output_bfd, s->size);
6388 if (contents == NULL)
6389 return FALSE;
6390 s->contents = contents;
6391 /* 1 empty bucket. */
6392 bfd_put_32 (output_bfd, 1, contents);
6393 /* SYMIDX above the special symbol 0. */
6394 bfd_put_32 (output_bfd, 1, contents + 4);
6395 /* Just one word for bitmask. */
6396 bfd_put_32 (output_bfd, 1, contents + 8);
6397 /* Only hash fn bloom filter. */
6398 bfd_put_32 (output_bfd, 0, contents + 12);
6399 /* No hashes are valid - empty bitmask. */
6400 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6401 /* No hashes in the only bucket. */
6402 bfd_put_32 (output_bfd, 0,
6403 contents + 16 + bed->s->arch_size / 8);
6404 }
6405 else
6406 {
fdc90cb4 6407 unsigned long int maskwords, maskbitslog2;
0b33793d 6408 BFD_ASSERT (cinfo.min_dynindx != -1);
fdc90cb4
JJ
6409
6410 maskbitslog2 = bfd_log2 (cinfo.nsyms) + 1;
6411 if (maskbitslog2 < 3)
6412 maskbitslog2 = 5;
6413 else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6414 maskbitslog2 = maskbitslog2 + 3;
6415 else
6416 maskbitslog2 = maskbitslog2 + 2;
6417 if (bed->s->arch_size == 64)
6418 {
6419 if (maskbitslog2 == 5)
6420 maskbitslog2 = 6;
6421 cinfo.shift1 = 6;
6422 }
6423 else
6424 cinfo.shift1 = 5;
6425 cinfo.mask = (1 << cinfo.shift1) - 1;
2ccdbfcc 6426 cinfo.shift2 = maskbitslog2;
fdc90cb4
JJ
6427 cinfo.maskbits = 1 << maskbitslog2;
6428 maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6429 amt = bucketcount * sizeof (unsigned long int) * 2;
6430 amt += maskwords * sizeof (bfd_vma);
6431 cinfo.bitmask = bfd_malloc (amt);
6432 if (cinfo.bitmask == NULL)
6433 {
6434 free (cinfo.hashcodes);
6435 return FALSE;
6436 }
6437
6438 cinfo.counts = (void *) (cinfo.bitmask + maskwords);
6439 cinfo.indx = cinfo.counts + bucketcount;
6440 cinfo.symindx = dynsymcount - cinfo.nsyms;
6441 memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6442
6443 /* Determine how often each hash bucket is used. */
6444 memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6445 for (i = 0; i < cinfo.nsyms; ++i)
6446 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6447
6448 for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6449 if (cinfo.counts[i] != 0)
6450 {
6451 cinfo.indx[i] = cnt;
6452 cnt += cinfo.counts[i];
6453 }
6454 BFD_ASSERT (cnt == dynsymcount);
6455 cinfo.bucketcount = bucketcount;
6456 cinfo.local_indx = cinfo.min_dynindx;
6457
6458 s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6459 s->size += cinfo.maskbits / 8;
6460 contents = bfd_zalloc (output_bfd, s->size);
6461 if (contents == NULL)
6462 {
6463 free (cinfo.bitmask);
6464 free (cinfo.hashcodes);
6465 return FALSE;
6466 }
6467
6468 s->contents = contents;
6469 bfd_put_32 (output_bfd, bucketcount, contents);
6470 bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6471 bfd_put_32 (output_bfd, maskwords, contents + 8);
6472 bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6473 contents += 16 + cinfo.maskbits / 8;
6474
6475 for (i = 0; i < bucketcount; ++i)
6476 {
6477 if (cinfo.counts[i] == 0)
6478 bfd_put_32 (output_bfd, 0, contents);
6479 else
6480 bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6481 contents += 4;
6482 }
6483
6484 cinfo.contents = contents;
6485
6486 /* Renumber dynamic symbols, populate .gnu.hash section. */
6487 elf_link_hash_traverse (elf_hash_table (info),
6488 elf_renumber_gnu_hash_syms, &cinfo);
6489
6490 contents = s->contents + 16;
6491 for (i = 0; i < maskwords; ++i)
6492 {
6493 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6494 contents);
6495 contents += bed->s->arch_size / 8;
6496 }
6497
6498 free (cinfo.bitmask);
6499 free (cinfo.hashcodes);
6500 }
6501 }
5a580b3a
AM
6502
6503 s = bfd_get_section_by_name (dynobj, ".dynstr");
6504 BFD_ASSERT (s != NULL);
6505
4ad4eba5 6506 elf_finalize_dynstr (output_bfd, info);
5a580b3a 6507
eea6121a 6508 s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5a580b3a
AM
6509
6510 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6511 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6512 return FALSE;
6513 }
6514
6515 return TRUE;
6516}
4d269e42
AM
6517\f
6518/* Indicate that we are only retrieving symbol values from this
6519 section. */
6520
6521void
6522_bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
6523{
6524 if (is_elf_hash_table (info->hash))
6525 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
6526 _bfd_generic_link_just_syms (sec, info);
6527}
6528
6529/* Make sure sec_info_type is cleared if sec_info is cleared too. */
6530
6531static void
6532merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6533 asection *sec)
6534{
6535 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
6536 sec->sec_info_type = ELF_INFO_TYPE_NONE;
6537}
6538
6539/* Finish SHF_MERGE section merging. */
6540
6541bfd_boolean
6542_bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6543{
6544 bfd *ibfd;
6545 asection *sec;
6546
6547 if (!is_elf_hash_table (info->hash))
6548 return FALSE;
6549
6550 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6551 if ((ibfd->flags & DYNAMIC) == 0)
6552 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6553 if ((sec->flags & SEC_MERGE) != 0
6554 && !bfd_is_abs_section (sec->output_section))
6555 {
6556 struct bfd_elf_section_data *secdata;
6557
6558 secdata = elf_section_data (sec);
6559 if (! _bfd_add_merge_section (abfd,
6560 &elf_hash_table (info)->merge_info,
6561 sec, &secdata->sec_info))
6562 return FALSE;
6563 else if (secdata->sec_info)
6564 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
6565 }
6566
6567 if (elf_hash_table (info)->merge_info != NULL)
6568 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6569 merge_sections_remove_hook);
6570 return TRUE;
6571}
6572
6573/* Create an entry in an ELF linker hash table. */
6574
6575struct bfd_hash_entry *
6576_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6577 struct bfd_hash_table *table,
6578 const char *string)
6579{
6580 /* Allocate the structure if it has not already been allocated by a
6581 subclass. */
6582 if (entry == NULL)
6583 {
6584 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6585 if (entry == NULL)
6586 return entry;
6587 }
6588
6589 /* Call the allocation method of the superclass. */
6590 entry = _bfd_link_hash_newfunc (entry, table, string);
6591 if (entry != NULL)
6592 {
6593 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6594 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6595
6596 /* Set local fields. */
6597 ret->indx = -1;
6598 ret->dynindx = -1;
6599 ret->got = htab->init_got_refcount;
6600 ret->plt = htab->init_plt_refcount;
6601 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6602 - offsetof (struct elf_link_hash_entry, size)));
6603 /* Assume that we have been called by a non-ELF symbol reader.
6604 This flag is then reset by the code which reads an ELF input
6605 file. This ensures that a symbol created by a non-ELF symbol
6606 reader will have the flag set correctly. */
6607 ret->non_elf = 1;
6608 }
6609
6610 return entry;
6611}
6612
6613/* Copy data from an indirect symbol to its direct symbol, hiding the
6614 old indirect symbol. Also used for copying flags to a weakdef. */
6615
6616void
6617_bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6618 struct elf_link_hash_entry *dir,
6619 struct elf_link_hash_entry *ind)
6620{
6621 struct elf_link_hash_table *htab;
6622
6623 /* Copy down any references that we may have already seen to the
6624 symbol which just became indirect. */
6625
6626 dir->ref_dynamic |= ind->ref_dynamic;
6627 dir->ref_regular |= ind->ref_regular;
6628 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6629 dir->non_got_ref |= ind->non_got_ref;
6630 dir->needs_plt |= ind->needs_plt;
6631 dir->pointer_equality_needed |= ind->pointer_equality_needed;
6632
6633 if (ind->root.type != bfd_link_hash_indirect)
6634 return;
6635
6636 /* Copy over the global and procedure linkage table refcount entries.
6637 These may have been already set up by a check_relocs routine. */
6638 htab = elf_hash_table (info);
6639 if (ind->got.refcount > htab->init_got_refcount.refcount)
6640 {
6641 if (dir->got.refcount < 0)
6642 dir->got.refcount = 0;
6643 dir->got.refcount += ind->got.refcount;
6644 ind->got.refcount = htab->init_got_refcount.refcount;
6645 }
6646
6647 if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6648 {
6649 if (dir->plt.refcount < 0)
6650 dir->plt.refcount = 0;
6651 dir->plt.refcount += ind->plt.refcount;
6652 ind->plt.refcount = htab->init_plt_refcount.refcount;
6653 }
6654
6655 if (ind->dynindx != -1)
6656 {
6657 if (dir->dynindx != -1)
6658 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6659 dir->dynindx = ind->dynindx;
6660 dir->dynstr_index = ind->dynstr_index;
6661 ind->dynindx = -1;
6662 ind->dynstr_index = 0;
6663 }
6664}
6665
6666void
6667_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6668 struct elf_link_hash_entry *h,
6669 bfd_boolean force_local)
6670{
3aa14d16
L
6671 /* STT_GNU_IFUNC symbol must go through PLT. */
6672 if (h->type != STT_GNU_IFUNC)
6673 {
6674 h->plt = elf_hash_table (info)->init_plt_offset;
6675 h->needs_plt = 0;
6676 }
4d269e42
AM
6677 if (force_local)
6678 {
6679 h->forced_local = 1;
6680 if (h->dynindx != -1)
6681 {
6682 h->dynindx = -1;
6683 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6684 h->dynstr_index);
6685 }
6686 }
6687}
6688
6689/* Initialize an ELF linker hash table. */
6690
6691bfd_boolean
6692_bfd_elf_link_hash_table_init
6693 (struct elf_link_hash_table *table,
6694 bfd *abfd,
6695 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6696 struct bfd_hash_table *,
6697 const char *),
6698 unsigned int entsize)
6699{
6700 bfd_boolean ret;
6701 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6702
6703 memset (table, 0, sizeof * table);
6704 table->init_got_refcount.refcount = can_refcount - 1;
6705 table->init_plt_refcount.refcount = can_refcount - 1;
6706 table->init_got_offset.offset = -(bfd_vma) 1;
6707 table->init_plt_offset.offset = -(bfd_vma) 1;
6708 /* The first dynamic symbol is a dummy. */
6709 table->dynsymcount = 1;
6710
6711 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6712 table->root.type = bfd_link_elf_hash_table;
6713
6714 return ret;
6715}
6716
6717/* Create an ELF linker hash table. */
6718
6719struct bfd_link_hash_table *
6720_bfd_elf_link_hash_table_create (bfd *abfd)
6721{
6722 struct elf_link_hash_table *ret;
6723 bfd_size_type amt = sizeof (struct elf_link_hash_table);
6724
6725 ret = bfd_malloc (amt);
6726 if (ret == NULL)
6727 return NULL;
6728
6729 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6730 sizeof (struct elf_link_hash_entry)))
6731 {
6732 free (ret);
6733 return NULL;
6734 }
6735
6736 return &ret->root;
6737}
6738
6739/* This is a hook for the ELF emulation code in the generic linker to
6740 tell the backend linker what file name to use for the DT_NEEDED
6741 entry for a dynamic object. */
6742
6743void
6744bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6745{
6746 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6747 && bfd_get_format (abfd) == bfd_object)
6748 elf_dt_name (abfd) = name;
6749}
6750
6751int
6752bfd_elf_get_dyn_lib_class (bfd *abfd)
6753{
6754 int lib_class;
6755 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6756 && bfd_get_format (abfd) == bfd_object)
6757 lib_class = elf_dyn_lib_class (abfd);
6758 else
6759 lib_class = 0;
6760 return lib_class;
6761}
6762
6763void
6764bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6765{
6766 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6767 && bfd_get_format (abfd) == bfd_object)
6768 elf_dyn_lib_class (abfd) = lib_class;
6769}
6770
6771/* Get the list of DT_NEEDED entries for a link. This is a hook for
6772 the linker ELF emulation code. */
6773
6774struct bfd_link_needed_list *
6775bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6776 struct bfd_link_info *info)
6777{
6778 if (! is_elf_hash_table (info->hash))
6779 return NULL;
6780 return elf_hash_table (info)->needed;
6781}
6782
6783/* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6784 hook for the linker ELF emulation code. */
6785
6786struct bfd_link_needed_list *
6787bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6788 struct bfd_link_info *info)
6789{
6790 if (! is_elf_hash_table (info->hash))
6791 return NULL;
6792 return elf_hash_table (info)->runpath;
6793}
6794
6795/* Get the name actually used for a dynamic object for a link. This
6796 is the SONAME entry if there is one. Otherwise, it is the string
6797 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6798
6799const char *
6800bfd_elf_get_dt_soname (bfd *abfd)
6801{
6802 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6803 && bfd_get_format (abfd) == bfd_object)
6804 return elf_dt_name (abfd);
6805 return NULL;
6806}
6807
6808/* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6809 the ELF linker emulation code. */
6810
6811bfd_boolean
6812bfd_elf_get_bfd_needed_list (bfd *abfd,
6813 struct bfd_link_needed_list **pneeded)
6814{
6815 asection *s;
6816 bfd_byte *dynbuf = NULL;
cb33740c 6817 unsigned int elfsec;
4d269e42
AM
6818 unsigned long shlink;
6819 bfd_byte *extdyn, *extdynend;
6820 size_t extdynsize;
6821 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6822
6823 *pneeded = NULL;
6824
6825 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6826 || bfd_get_format (abfd) != bfd_object)
6827 return TRUE;
6828
6829 s = bfd_get_section_by_name (abfd, ".dynamic");
6830 if (s == NULL || s->size == 0)
6831 return TRUE;
6832
6833 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6834 goto error_return;
6835
6836 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
cb33740c 6837 if (elfsec == SHN_BAD)
4d269e42
AM
6838 goto error_return;
6839
6840 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
c152c796 6841
4d269e42
AM
6842 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6843 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6844
6845 extdyn = dynbuf;
6846 extdynend = extdyn + s->size;
6847 for (; extdyn < extdynend; extdyn += extdynsize)
6848 {
6849 Elf_Internal_Dyn dyn;
6850
6851 (*swap_dyn_in) (abfd, extdyn, &dyn);
6852
6853 if (dyn.d_tag == DT_NULL)
6854 break;
6855
6856 if (dyn.d_tag == DT_NEEDED)
6857 {
6858 const char *string;
6859 struct bfd_link_needed_list *l;
6860 unsigned int tagv = dyn.d_un.d_val;
6861 bfd_size_type amt;
6862
6863 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
6864 if (string == NULL)
6865 goto error_return;
6866
6867 amt = sizeof *l;
6868 l = bfd_alloc (abfd, amt);
6869 if (l == NULL)
6870 goto error_return;
6871
6872 l->by = abfd;
6873 l->name = string;
6874 l->next = *pneeded;
6875 *pneeded = l;
6876 }
6877 }
6878
6879 free (dynbuf);
6880
6881 return TRUE;
6882
6883 error_return:
6884 if (dynbuf != NULL)
6885 free (dynbuf);
6886 return FALSE;
6887}
6888
6889struct elf_symbuf_symbol
6890{
6891 unsigned long st_name; /* Symbol name, index in string tbl */
6892 unsigned char st_info; /* Type and binding attributes */
6893 unsigned char st_other; /* Visibilty, and target specific */
6894};
6895
6896struct elf_symbuf_head
6897{
6898 struct elf_symbuf_symbol *ssym;
6899 bfd_size_type count;
6900 unsigned int st_shndx;
6901};
6902
6903struct elf_symbol
6904{
6905 union
6906 {
6907 Elf_Internal_Sym *isym;
6908 struct elf_symbuf_symbol *ssym;
6909 } u;
6910 const char *name;
6911};
6912
6913/* Sort references to symbols by ascending section number. */
6914
6915static int
6916elf_sort_elf_symbol (const void *arg1, const void *arg2)
6917{
6918 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
6919 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
6920
6921 return s1->st_shndx - s2->st_shndx;
6922}
6923
6924static int
6925elf_sym_name_compare (const void *arg1, const void *arg2)
6926{
6927 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
6928 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
6929 return strcmp (s1->name, s2->name);
6930}
6931
6932static struct elf_symbuf_head *
6933elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
6934{
14b1c01e 6935 Elf_Internal_Sym **ind, **indbufend, **indbuf;
4d269e42
AM
6936 struct elf_symbuf_symbol *ssym;
6937 struct elf_symbuf_head *ssymbuf, *ssymhead;
3ae181ee 6938 bfd_size_type i, shndx_count, total_size;
4d269e42 6939
14b1c01e 6940 indbuf = bfd_malloc2 (symcount, sizeof (*indbuf));
4d269e42
AM
6941 if (indbuf == NULL)
6942 return NULL;
6943
6944 for (ind = indbuf, i = 0; i < symcount; i++)
6945 if (isymbuf[i].st_shndx != SHN_UNDEF)
6946 *ind++ = &isymbuf[i];
6947 indbufend = ind;
6948
6949 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
6950 elf_sort_elf_symbol);
6951
6952 shndx_count = 0;
6953 if (indbufend > indbuf)
6954 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
6955 if (ind[0]->st_shndx != ind[1]->st_shndx)
6956 shndx_count++;
6957
3ae181ee
L
6958 total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
6959 + (indbufend - indbuf) * sizeof (*ssym));
6960 ssymbuf = bfd_malloc (total_size);
4d269e42
AM
6961 if (ssymbuf == NULL)
6962 {
6963 free (indbuf);
6964 return NULL;
6965 }
6966
3ae181ee 6967 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
4d269e42
AM
6968 ssymbuf->ssym = NULL;
6969 ssymbuf->count = shndx_count;
6970 ssymbuf->st_shndx = 0;
6971 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
6972 {
6973 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
6974 {
6975 ssymhead++;
6976 ssymhead->ssym = ssym;
6977 ssymhead->count = 0;
6978 ssymhead->st_shndx = (*ind)->st_shndx;
6979 }
6980 ssym->st_name = (*ind)->st_name;
6981 ssym->st_info = (*ind)->st_info;
6982 ssym->st_other = (*ind)->st_other;
6983 ssymhead->count++;
6984 }
3ae181ee
L
6985 BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
6986 && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
6987 == total_size));
4d269e42
AM
6988
6989 free (indbuf);
6990 return ssymbuf;
6991}
6992
6993/* Check if 2 sections define the same set of local and global
6994 symbols. */
6995
8f317e31 6996static bfd_boolean
4d269e42
AM
6997bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
6998 struct bfd_link_info *info)
6999{
7000 bfd *bfd1, *bfd2;
7001 const struct elf_backend_data *bed1, *bed2;
7002 Elf_Internal_Shdr *hdr1, *hdr2;
7003 bfd_size_type symcount1, symcount2;
7004 Elf_Internal_Sym *isymbuf1, *isymbuf2;
7005 struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7006 Elf_Internal_Sym *isym, *isymend;
7007 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7008 bfd_size_type count1, count2, i;
cb33740c 7009 unsigned int shndx1, shndx2;
4d269e42
AM
7010 bfd_boolean result;
7011
7012 bfd1 = sec1->owner;
7013 bfd2 = sec2->owner;
7014
4d269e42
AM
7015 /* Both sections have to be in ELF. */
7016 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7017 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7018 return FALSE;
7019
7020 if (elf_section_type (sec1) != elf_section_type (sec2))
7021 return FALSE;
7022
4d269e42
AM
7023 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7024 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
cb33740c 7025 if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
4d269e42
AM
7026 return FALSE;
7027
7028 bed1 = get_elf_backend_data (bfd1);
7029 bed2 = get_elf_backend_data (bfd2);
7030 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7031 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7032 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7033 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7034
7035 if (symcount1 == 0 || symcount2 == 0)
7036 return FALSE;
7037
7038 result = FALSE;
7039 isymbuf1 = NULL;
7040 isymbuf2 = NULL;
7041 ssymbuf1 = elf_tdata (bfd1)->symbuf;
7042 ssymbuf2 = elf_tdata (bfd2)->symbuf;
7043
7044 if (ssymbuf1 == NULL)
7045 {
7046 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7047 NULL, NULL, NULL);
7048 if (isymbuf1 == NULL)
7049 goto done;
7050
7051 if (!info->reduce_memory_overheads)
7052 elf_tdata (bfd1)->symbuf = ssymbuf1
7053 = elf_create_symbuf (symcount1, isymbuf1);
7054 }
7055
7056 if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7057 {
7058 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7059 NULL, NULL, NULL);
7060 if (isymbuf2 == NULL)
7061 goto done;
7062
7063 if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7064 elf_tdata (bfd2)->symbuf = ssymbuf2
7065 = elf_create_symbuf (symcount2, isymbuf2);
7066 }
7067
7068 if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7069 {
7070 /* Optimized faster version. */
7071 bfd_size_type lo, hi, mid;
7072 struct elf_symbol *symp;
7073 struct elf_symbuf_symbol *ssym, *ssymend;
7074
7075 lo = 0;
7076 hi = ssymbuf1->count;
7077 ssymbuf1++;
7078 count1 = 0;
7079 while (lo < hi)
7080 {
7081 mid = (lo + hi) / 2;
cb33740c 7082 if (shndx1 < ssymbuf1[mid].st_shndx)
4d269e42 7083 hi = mid;
cb33740c 7084 else if (shndx1 > ssymbuf1[mid].st_shndx)
4d269e42
AM
7085 lo = mid + 1;
7086 else
7087 {
7088 count1 = ssymbuf1[mid].count;
7089 ssymbuf1 += mid;
7090 break;
7091 }
7092 }
7093
7094 lo = 0;
7095 hi = ssymbuf2->count;
7096 ssymbuf2++;
7097 count2 = 0;
7098 while (lo < hi)
7099 {
7100 mid = (lo + hi) / 2;
cb33740c 7101 if (shndx2 < ssymbuf2[mid].st_shndx)
4d269e42 7102 hi = mid;
cb33740c 7103 else if (shndx2 > ssymbuf2[mid].st_shndx)
4d269e42
AM
7104 lo = mid + 1;
7105 else
7106 {
7107 count2 = ssymbuf2[mid].count;
7108 ssymbuf2 += mid;
7109 break;
7110 }
7111 }
7112
7113 if (count1 == 0 || count2 == 0 || count1 != count2)
7114 goto done;
7115
7116 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
7117 symtable2 = bfd_malloc (count2 * sizeof (struct elf_symbol));
7118 if (symtable1 == NULL || symtable2 == NULL)
7119 goto done;
7120
7121 symp = symtable1;
7122 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7123 ssym < ssymend; ssym++, symp++)
7124 {
7125 symp->u.ssym = ssym;
7126 symp->name = bfd_elf_string_from_elf_section (bfd1,
7127 hdr1->sh_link,
7128 ssym->st_name);
7129 }
7130
7131 symp = symtable2;
7132 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7133 ssym < ssymend; ssym++, symp++)
7134 {
7135 symp->u.ssym = ssym;
7136 symp->name = bfd_elf_string_from_elf_section (bfd2,
7137 hdr2->sh_link,
7138 ssym->st_name);
7139 }
7140
7141 /* Sort symbol by name. */
7142 qsort (symtable1, count1, sizeof (struct elf_symbol),
7143 elf_sym_name_compare);
7144 qsort (symtable2, count1, sizeof (struct elf_symbol),
7145 elf_sym_name_compare);
7146
7147 for (i = 0; i < count1; i++)
7148 /* Two symbols must have the same binding, type and name. */
7149 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7150 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7151 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7152 goto done;
7153
7154 result = TRUE;
7155 goto done;
7156 }
7157
7158 symtable1 = bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7159 symtable2 = bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7160 if (symtable1 == NULL || symtable2 == NULL)
7161 goto done;
7162
7163 /* Count definitions in the section. */
7164 count1 = 0;
7165 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
cb33740c 7166 if (isym->st_shndx == shndx1)
4d269e42
AM
7167 symtable1[count1++].u.isym = isym;
7168
7169 count2 = 0;
7170 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
cb33740c 7171 if (isym->st_shndx == shndx2)
4d269e42
AM
7172 symtable2[count2++].u.isym = isym;
7173
7174 if (count1 == 0 || count2 == 0 || count1 != count2)
7175 goto done;
7176
7177 for (i = 0; i < count1; i++)
7178 symtable1[i].name
7179 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7180 symtable1[i].u.isym->st_name);
7181
7182 for (i = 0; i < count2; i++)
7183 symtable2[i].name
7184 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7185 symtable2[i].u.isym->st_name);
7186
7187 /* Sort symbol by name. */
7188 qsort (symtable1, count1, sizeof (struct elf_symbol),
7189 elf_sym_name_compare);
7190 qsort (symtable2, count1, sizeof (struct elf_symbol),
7191 elf_sym_name_compare);
7192
7193 for (i = 0; i < count1; i++)
7194 /* Two symbols must have the same binding, type and name. */
7195 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7196 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7197 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7198 goto done;
7199
7200 result = TRUE;
7201
7202done:
7203 if (symtable1)
7204 free (symtable1);
7205 if (symtable2)
7206 free (symtable2);
7207 if (isymbuf1)
7208 free (isymbuf1);
7209 if (isymbuf2)
7210 free (isymbuf2);
7211
7212 return result;
7213}
7214
7215/* Return TRUE if 2 section types are compatible. */
7216
7217bfd_boolean
7218_bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7219 bfd *bbfd, const asection *bsec)
7220{
7221 if (asec == NULL
7222 || bsec == NULL
7223 || abfd->xvec->flavour != bfd_target_elf_flavour
7224 || bbfd->xvec->flavour != bfd_target_elf_flavour)
7225 return TRUE;
7226
7227 return elf_section_type (asec) == elf_section_type (bsec);
7228}
7229\f
c152c796
AM
7230/* Final phase of ELF linker. */
7231
7232/* A structure we use to avoid passing large numbers of arguments. */
7233
7234struct elf_final_link_info
7235{
7236 /* General link information. */
7237 struct bfd_link_info *info;
7238 /* Output BFD. */
7239 bfd *output_bfd;
7240 /* Symbol string table. */
7241 struct bfd_strtab_hash *symstrtab;
7242 /* .dynsym section. */
7243 asection *dynsym_sec;
7244 /* .hash section. */
7245 asection *hash_sec;
7246 /* symbol version section (.gnu.version). */
7247 asection *symver_sec;
7248 /* Buffer large enough to hold contents of any section. */
7249 bfd_byte *contents;
7250 /* Buffer large enough to hold external relocs of any section. */
7251 void *external_relocs;
7252 /* Buffer large enough to hold internal relocs of any section. */
7253 Elf_Internal_Rela *internal_relocs;
7254 /* Buffer large enough to hold external local symbols of any input
7255 BFD. */
7256 bfd_byte *external_syms;
7257 /* And a buffer for symbol section indices. */
7258 Elf_External_Sym_Shndx *locsym_shndx;
7259 /* Buffer large enough to hold internal local symbols of any input
7260 BFD. */
7261 Elf_Internal_Sym *internal_syms;
7262 /* Array large enough to hold a symbol index for each local symbol
7263 of any input BFD. */
7264 long *indices;
7265 /* Array large enough to hold a section pointer for each local
7266 symbol of any input BFD. */
7267 asection **sections;
7268 /* Buffer to hold swapped out symbols. */
7269 bfd_byte *symbuf;
7270 /* And one for symbol section indices. */
7271 Elf_External_Sym_Shndx *symshndxbuf;
7272 /* Number of swapped out symbols in buffer. */
7273 size_t symbuf_count;
7274 /* Number of symbols which fit in symbuf. */
7275 size_t symbuf_size;
7276 /* And same for symshndxbuf. */
7277 size_t shndxbuf_size;
7278};
7279
7280/* This struct is used to pass information to elf_link_output_extsym. */
7281
7282struct elf_outext_info
7283{
7284 bfd_boolean failed;
7285 bfd_boolean localsyms;
7286 struct elf_final_link_info *finfo;
7287};
7288
d9352518
DB
7289
7290/* Support for evaluating a complex relocation.
7291
7292 Complex relocations are generalized, self-describing relocations. The
7293 implementation of them consists of two parts: complex symbols, and the
a0c8462f 7294 relocations themselves.
d9352518
DB
7295
7296 The relocations are use a reserved elf-wide relocation type code (R_RELC
7297 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7298 information (start bit, end bit, word width, etc) into the addend. This
7299 information is extracted from CGEN-generated operand tables within gas.
7300
7301 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7302 internal) representing prefix-notation expressions, including but not
7303 limited to those sorts of expressions normally encoded as addends in the
7304 addend field. The symbol mangling format is:
7305
7306 <node> := <literal>
7307 | <unary-operator> ':' <node>
7308 | <binary-operator> ':' <node> ':' <node>
7309 ;
7310
7311 <literal> := 's' <digits=N> ':' <N character symbol name>
7312 | 'S' <digits=N> ':' <N character section name>
7313 | '#' <hexdigits>
7314 ;
7315
7316 <binary-operator> := as in C
7317 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7318
7319static void
a0c8462f
AM
7320set_symbol_value (bfd *bfd_with_globals,
7321 Elf_Internal_Sym *isymbuf,
7322 size_t locsymcount,
7323 size_t symidx,
7324 bfd_vma val)
d9352518 7325{
8977835c
AM
7326 struct elf_link_hash_entry **sym_hashes;
7327 struct elf_link_hash_entry *h;
7328 size_t extsymoff = locsymcount;
d9352518 7329
8977835c 7330 if (symidx < locsymcount)
d9352518 7331 {
8977835c
AM
7332 Elf_Internal_Sym *sym;
7333
7334 sym = isymbuf + symidx;
7335 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7336 {
7337 /* It is a local symbol: move it to the
7338 "absolute" section and give it a value. */
7339 sym->st_shndx = SHN_ABS;
7340 sym->st_value = val;
7341 return;
7342 }
7343 BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7344 extsymoff = 0;
d9352518 7345 }
8977835c
AM
7346
7347 /* It is a global symbol: set its link type
7348 to "defined" and give it a value. */
7349
7350 sym_hashes = elf_sym_hashes (bfd_with_globals);
7351 h = sym_hashes [symidx - extsymoff];
7352 while (h->root.type == bfd_link_hash_indirect
7353 || h->root.type == bfd_link_hash_warning)
7354 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7355 h->root.type = bfd_link_hash_defined;
7356 h->root.u.def.value = val;
7357 h->root.u.def.section = bfd_abs_section_ptr;
d9352518
DB
7358}
7359
a0c8462f
AM
7360static bfd_boolean
7361resolve_symbol (const char *name,
7362 bfd *input_bfd,
7363 struct elf_final_link_info *finfo,
7364 bfd_vma *result,
7365 Elf_Internal_Sym *isymbuf,
7366 size_t locsymcount)
d9352518 7367{
a0c8462f
AM
7368 Elf_Internal_Sym *sym;
7369 struct bfd_link_hash_entry *global_entry;
7370 const char *candidate = NULL;
7371 Elf_Internal_Shdr *symtab_hdr;
7372 size_t i;
7373
d9352518
DB
7374 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7375
7376 for (i = 0; i < locsymcount; ++ i)
7377 {
8977835c 7378 sym = isymbuf + i;
d9352518
DB
7379
7380 if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7381 continue;
7382
7383 candidate = bfd_elf_string_from_elf_section (input_bfd,
7384 symtab_hdr->sh_link,
7385 sym->st_name);
7386#ifdef DEBUG
0f02bbd9
AM
7387 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7388 name, candidate, (unsigned long) sym->st_value);
d9352518
DB
7389#endif
7390 if (candidate && strcmp (candidate, name) == 0)
7391 {
0f02bbd9 7392 asection *sec = finfo->sections [i];
d9352518 7393
0f02bbd9
AM
7394 *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7395 *result += sec->output_offset + sec->output_section->vma;
d9352518 7396#ifdef DEBUG
0f02bbd9
AM
7397 printf ("Found symbol with value %8.8lx\n",
7398 (unsigned long) *result);
d9352518
DB
7399#endif
7400 return TRUE;
7401 }
7402 }
7403
7404 /* Hmm, haven't found it yet. perhaps it is a global. */
a0c8462f
AM
7405 global_entry = bfd_link_hash_lookup (finfo->info->hash, name,
7406 FALSE, FALSE, TRUE);
d9352518
DB
7407 if (!global_entry)
7408 return FALSE;
a0c8462f 7409
d9352518
DB
7410 if (global_entry->type == bfd_link_hash_defined
7411 || global_entry->type == bfd_link_hash_defweak)
7412 {
a0c8462f
AM
7413 *result = (global_entry->u.def.value
7414 + global_entry->u.def.section->output_section->vma
7415 + global_entry->u.def.section->output_offset);
d9352518 7416#ifdef DEBUG
0f02bbd9
AM
7417 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7418 global_entry->root.string, (unsigned long) *result);
d9352518
DB
7419#endif
7420 return TRUE;
a0c8462f 7421 }
d9352518 7422
d9352518
DB
7423 return FALSE;
7424}
7425
7426static bfd_boolean
a0c8462f
AM
7427resolve_section (const char *name,
7428 asection *sections,
7429 bfd_vma *result)
d9352518 7430{
a0c8462f
AM
7431 asection *curr;
7432 unsigned int len;
d9352518 7433
a0c8462f 7434 for (curr = sections; curr; curr = curr->next)
d9352518
DB
7435 if (strcmp (curr->name, name) == 0)
7436 {
7437 *result = curr->vma;
7438 return TRUE;
7439 }
7440
7441 /* Hmm. still haven't found it. try pseudo-section names. */
a0c8462f 7442 for (curr = sections; curr; curr = curr->next)
d9352518
DB
7443 {
7444 len = strlen (curr->name);
a0c8462f 7445 if (len > strlen (name))
d9352518
DB
7446 continue;
7447
7448 if (strncmp (curr->name, name, len) == 0)
7449 {
7450 if (strncmp (".end", name + len, 4) == 0)
7451 {
7452 *result = curr->vma + curr->size;
7453 return TRUE;
7454 }
7455
7456 /* Insert more pseudo-section names here, if you like. */
7457 }
7458 }
a0c8462f 7459
d9352518
DB
7460 return FALSE;
7461}
7462
7463static void
a0c8462f 7464undefined_reference (const char *reftype, const char *name)
d9352518 7465{
a0c8462f
AM
7466 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7467 reftype, name);
d9352518
DB
7468}
7469
7470static bfd_boolean
a0c8462f
AM
7471eval_symbol (bfd_vma *result,
7472 const char **symp,
7473 bfd *input_bfd,
7474 struct elf_final_link_info *finfo,
7475 bfd_vma dot,
7476 Elf_Internal_Sym *isymbuf,
7477 size_t locsymcount,
7478 int signed_p)
d9352518 7479{
4b93929b
NC
7480 size_t len;
7481 size_t symlen;
a0c8462f
AM
7482 bfd_vma a;
7483 bfd_vma b;
4b93929b 7484 char symbuf[4096];
0f02bbd9 7485 const char *sym = *symp;
a0c8462f
AM
7486 const char *symend;
7487 bfd_boolean symbol_is_section = FALSE;
d9352518
DB
7488
7489 len = strlen (sym);
7490 symend = sym + len;
7491
4b93929b 7492 if (len < 1 || len > sizeof (symbuf))
d9352518
DB
7493 {
7494 bfd_set_error (bfd_error_invalid_operation);
7495 return FALSE;
7496 }
a0c8462f 7497
d9352518
DB
7498 switch (* sym)
7499 {
7500 case '.':
0f02bbd9
AM
7501 *result = dot;
7502 *symp = sym + 1;
d9352518
DB
7503 return TRUE;
7504
7505 case '#':
0f02bbd9
AM
7506 ++sym;
7507 *result = strtoul (sym, (char **) symp, 16);
d9352518
DB
7508 return TRUE;
7509
7510 case 'S':
7511 symbol_is_section = TRUE;
a0c8462f 7512 case 's':
0f02bbd9
AM
7513 ++sym;
7514 symlen = strtol (sym, (char **) symp, 10);
7515 sym = *symp + 1; /* Skip the trailing ':'. */
d9352518 7516
4b93929b 7517 if (symend < sym || symlen + 1 > sizeof (symbuf))
d9352518
DB
7518 {
7519 bfd_set_error (bfd_error_invalid_operation);
7520 return FALSE;
7521 }
7522
7523 memcpy (symbuf, sym, symlen);
a0c8462f 7524 symbuf[symlen] = '\0';
0f02bbd9 7525 *symp = sym + symlen;
a0c8462f
AM
7526
7527 /* Is it always possible, with complex symbols, that gas "mis-guessed"
d9352518
DB
7528 the symbol as a section, or vice-versa. so we're pretty liberal in our
7529 interpretation here; section means "try section first", not "must be a
7530 section", and likewise with symbol. */
7531
a0c8462f 7532 if (symbol_is_section)
d9352518 7533 {
8977835c
AM
7534 if (!resolve_section (symbuf, finfo->output_bfd->sections, result)
7535 && !resolve_symbol (symbuf, input_bfd, finfo, result,
7536 isymbuf, locsymcount))
d9352518
DB
7537 {
7538 undefined_reference ("section", symbuf);
7539 return FALSE;
7540 }
a0c8462f
AM
7541 }
7542 else
d9352518 7543 {
8977835c
AM
7544 if (!resolve_symbol (symbuf, input_bfd, finfo, result,
7545 isymbuf, locsymcount)
7546 && !resolve_section (symbuf, finfo->output_bfd->sections,
7547 result))
d9352518
DB
7548 {
7549 undefined_reference ("symbol", symbuf);
7550 return FALSE;
7551 }
7552 }
7553
7554 return TRUE;
a0c8462f 7555
d9352518
DB
7556 /* All that remains are operators. */
7557
7558#define UNARY_OP(op) \
7559 if (strncmp (sym, #op, strlen (#op)) == 0) \
7560 { \
7561 sym += strlen (#op); \
a0c8462f
AM
7562 if (*sym == ':') \
7563 ++sym; \
0f02bbd9
AM
7564 *symp = sym; \
7565 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7566 isymbuf, locsymcount, signed_p)) \
a0c8462f
AM
7567 return FALSE; \
7568 if (signed_p) \
0f02bbd9 7569 *result = op ((bfd_signed_vma) a); \
a0c8462f
AM
7570 else \
7571 *result = op a; \
d9352518
DB
7572 return TRUE; \
7573 }
7574
7575#define BINARY_OP(op) \
7576 if (strncmp (sym, #op, strlen (#op)) == 0) \
7577 { \
7578 sym += strlen (#op); \
a0c8462f
AM
7579 if (*sym == ':') \
7580 ++sym; \
0f02bbd9
AM
7581 *symp = sym; \
7582 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7583 isymbuf, locsymcount, signed_p)) \
a0c8462f 7584 return FALSE; \
0f02bbd9
AM
7585 ++*symp; \
7586 if (!eval_symbol (&b, symp, input_bfd, finfo, dot, \
7587 isymbuf, locsymcount, signed_p)) \
a0c8462f
AM
7588 return FALSE; \
7589 if (signed_p) \
0f02bbd9 7590 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
a0c8462f
AM
7591 else \
7592 *result = a op b; \
d9352518
DB
7593 return TRUE; \
7594 }
7595
7596 default:
7597 UNARY_OP (0-);
7598 BINARY_OP (<<);
7599 BINARY_OP (>>);
7600 BINARY_OP (==);
7601 BINARY_OP (!=);
7602 BINARY_OP (<=);
7603 BINARY_OP (>=);
7604 BINARY_OP (&&);
7605 BINARY_OP (||);
7606 UNARY_OP (~);
7607 UNARY_OP (!);
7608 BINARY_OP (*);
7609 BINARY_OP (/);
7610 BINARY_OP (%);
7611 BINARY_OP (^);
7612 BINARY_OP (|);
7613 BINARY_OP (&);
7614 BINARY_OP (+);
7615 BINARY_OP (-);
7616 BINARY_OP (<);
7617 BINARY_OP (>);
7618#undef UNARY_OP
7619#undef BINARY_OP
7620 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7621 bfd_set_error (bfd_error_invalid_operation);
7622 return FALSE;
7623 }
7624}
7625
d9352518 7626static void
a0c8462f
AM
7627put_value (bfd_vma size,
7628 unsigned long chunksz,
7629 bfd *input_bfd,
7630 bfd_vma x,
7631 bfd_byte *location)
d9352518
DB
7632{
7633 location += (size - chunksz);
7634
a0c8462f 7635 for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
d9352518
DB
7636 {
7637 switch (chunksz)
7638 {
7639 default:
7640 case 0:
7641 abort ();
7642 case 1:
7643 bfd_put_8 (input_bfd, x, location);
7644 break;
7645 case 2:
7646 bfd_put_16 (input_bfd, x, location);
7647 break;
7648 case 4:
7649 bfd_put_32 (input_bfd, x, location);
7650 break;
7651 case 8:
7652#ifdef BFD64
7653 bfd_put_64 (input_bfd, x, location);
7654#else
7655 abort ();
7656#endif
7657 break;
7658 }
7659 }
7660}
7661
a0c8462f
AM
7662static bfd_vma
7663get_value (bfd_vma size,
7664 unsigned long chunksz,
7665 bfd *input_bfd,
7666 bfd_byte *location)
d9352518
DB
7667{
7668 bfd_vma x = 0;
7669
a0c8462f 7670 for (; size; size -= chunksz, location += chunksz)
d9352518
DB
7671 {
7672 switch (chunksz)
7673 {
7674 default:
7675 case 0:
7676 abort ();
7677 case 1:
7678 x = (x << (8 * chunksz)) | bfd_get_8 (input_bfd, location);
7679 break;
7680 case 2:
7681 x = (x << (8 * chunksz)) | bfd_get_16 (input_bfd, location);
7682 break;
7683 case 4:
7684 x = (x << (8 * chunksz)) | bfd_get_32 (input_bfd, location);
7685 break;
7686 case 8:
7687#ifdef BFD64
7688 x = (x << (8 * chunksz)) | bfd_get_64 (input_bfd, location);
7689#else
7690 abort ();
7691#endif
7692 break;
7693 }
7694 }
7695 return x;
7696}
7697
a0c8462f
AM
7698static void
7699decode_complex_addend (unsigned long *start, /* in bits */
7700 unsigned long *oplen, /* in bits */
7701 unsigned long *len, /* in bits */
7702 unsigned long *wordsz, /* in bytes */
7703 unsigned long *chunksz, /* in bytes */
7704 unsigned long *lsb0_p,
7705 unsigned long *signed_p,
7706 unsigned long *trunc_p,
7707 unsigned long encoded)
d9352518
DB
7708{
7709 * start = encoded & 0x3F;
7710 * len = (encoded >> 6) & 0x3F;
7711 * oplen = (encoded >> 12) & 0x3F;
7712 * wordsz = (encoded >> 18) & 0xF;
7713 * chunksz = (encoded >> 22) & 0xF;
7714 * lsb0_p = (encoded >> 27) & 1;
7715 * signed_p = (encoded >> 28) & 1;
7716 * trunc_p = (encoded >> 29) & 1;
7717}
7718
cdfeee4f 7719bfd_reloc_status_type
0f02bbd9 7720bfd_elf_perform_complex_relocation (bfd *input_bfd,
cdfeee4f 7721 asection *input_section ATTRIBUTE_UNUSED,
0f02bbd9
AM
7722 bfd_byte *contents,
7723 Elf_Internal_Rela *rel,
7724 bfd_vma relocation)
d9352518 7725{
0f02bbd9
AM
7726 bfd_vma shift, x, mask;
7727 unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
cdfeee4f 7728 bfd_reloc_status_type r;
d9352518
DB
7729
7730 /* Perform this reloc, since it is complex.
7731 (this is not to say that it necessarily refers to a complex
7732 symbol; merely that it is a self-describing CGEN based reloc.
7733 i.e. the addend has the complete reloc information (bit start, end,
a0c8462f 7734 word size, etc) encoded within it.). */
d9352518 7735
a0c8462f
AM
7736 decode_complex_addend (&start, &oplen, &len, &wordsz,
7737 &chunksz, &lsb0_p, &signed_p,
7738 &trunc_p, rel->r_addend);
d9352518
DB
7739
7740 mask = (((1L << (len - 1)) - 1) << 1) | 1;
7741
7742 if (lsb0_p)
7743 shift = (start + 1) - len;
7744 else
7745 shift = (8 * wordsz) - (start + len);
7746
a0c8462f 7747 x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
d9352518
DB
7748
7749#ifdef DEBUG
7750 printf ("Doing complex reloc: "
7751 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7752 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7753 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7754 lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7755 oplen, x, mask, relocation);
7756#endif
7757
cdfeee4f 7758 r = bfd_reloc_ok;
d9352518 7759 if (! trunc_p)
cdfeee4f
AM
7760 /* Now do an overflow check. */
7761 r = bfd_check_overflow ((signed_p
7762 ? complain_overflow_signed
7763 : complain_overflow_unsigned),
7764 len, 0, (8 * wordsz),
7765 relocation);
a0c8462f 7766
d9352518
DB
7767 /* Do the deed. */
7768 x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7769
7770#ifdef DEBUG
7771 printf (" relocation: %8.8lx\n"
7772 " shifted mask: %8.8lx\n"
7773 " shifted/masked reloc: %8.8lx\n"
7774 " result: %8.8lx\n",
a0c8462f 7775 relocation, (mask << shift),
d9352518
DB
7776 ((relocation & mask) << shift), x);
7777#endif
7778 put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
cdfeee4f 7779 return r;
d9352518
DB
7780}
7781
c152c796
AM
7782/* When performing a relocatable link, the input relocations are
7783 preserved. But, if they reference global symbols, the indices
7784 referenced must be updated. Update all the relocations in
7785 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
7786
7787static void
7788elf_link_adjust_relocs (bfd *abfd,
7789 Elf_Internal_Shdr *rel_hdr,
7790 unsigned int count,
7791 struct elf_link_hash_entry **rel_hash)
7792{
7793 unsigned int i;
7794 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7795 bfd_byte *erela;
7796 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7797 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7798 bfd_vma r_type_mask;
7799 int r_sym_shift;
7800
7801 if (rel_hdr->sh_entsize == bed->s->sizeof_rel)
7802 {
7803 swap_in = bed->s->swap_reloc_in;
7804 swap_out = bed->s->swap_reloc_out;
7805 }
7806 else if (rel_hdr->sh_entsize == bed->s->sizeof_rela)
7807 {
7808 swap_in = bed->s->swap_reloca_in;
7809 swap_out = bed->s->swap_reloca_out;
7810 }
7811 else
7812 abort ();
7813
7814 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
7815 abort ();
7816
7817 if (bed->s->arch_size == 32)
7818 {
7819 r_type_mask = 0xff;
7820 r_sym_shift = 8;
7821 }
7822 else
7823 {
7824 r_type_mask = 0xffffffff;
7825 r_sym_shift = 32;
7826 }
7827
7828 erela = rel_hdr->contents;
7829 for (i = 0; i < count; i++, rel_hash++, erela += rel_hdr->sh_entsize)
7830 {
7831 Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
7832 unsigned int j;
7833
7834 if (*rel_hash == NULL)
7835 continue;
7836
7837 BFD_ASSERT ((*rel_hash)->indx >= 0);
7838
7839 (*swap_in) (abfd, erela, irela);
7840 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
7841 irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
7842 | (irela[j].r_info & r_type_mask));
7843 (*swap_out) (abfd, irela, erela);
7844 }
7845}
7846
7847struct elf_link_sort_rela
7848{
7849 union {
7850 bfd_vma offset;
7851 bfd_vma sym_mask;
7852 } u;
7853 enum elf_reloc_type_class type;
7854 /* We use this as an array of size int_rels_per_ext_rel. */
7855 Elf_Internal_Rela rela[1];
7856};
7857
7858static int
7859elf_link_sort_cmp1 (const void *A, const void *B)
7860{
7861 const struct elf_link_sort_rela *a = A;
7862 const struct elf_link_sort_rela *b = B;
7863 int relativea, relativeb;
7864
7865 relativea = a->type == reloc_class_relative;
7866 relativeb = b->type == reloc_class_relative;
7867
7868 if (relativea < relativeb)
7869 return 1;
7870 if (relativea > relativeb)
7871 return -1;
7872 if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
7873 return -1;
7874 if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
7875 return 1;
7876 if (a->rela->r_offset < b->rela->r_offset)
7877 return -1;
7878 if (a->rela->r_offset > b->rela->r_offset)
7879 return 1;
7880 return 0;
7881}
7882
7883static int
7884elf_link_sort_cmp2 (const void *A, const void *B)
7885{
7886 const struct elf_link_sort_rela *a = A;
7887 const struct elf_link_sort_rela *b = B;
7888 int copya, copyb;
7889
7890 if (a->u.offset < b->u.offset)
7891 return -1;
7892 if (a->u.offset > b->u.offset)
7893 return 1;
7894 copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
7895 copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
7896 if (copya < copyb)
7897 return -1;
7898 if (copya > copyb)
7899 return 1;
7900 if (a->rela->r_offset < b->rela->r_offset)
7901 return -1;
7902 if (a->rela->r_offset > b->rela->r_offset)
7903 return 1;
7904 return 0;
7905}
7906
7907static size_t
7908elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
7909{
3410fea8 7910 asection *dynamic_relocs;
fc66a176
L
7911 asection *rela_dyn;
7912 asection *rel_dyn;
c152c796
AM
7913 bfd_size_type count, size;
7914 size_t i, ret, sort_elt, ext_size;
7915 bfd_byte *sort, *s_non_relative, *p;
7916 struct elf_link_sort_rela *sq;
7917 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7918 int i2e = bed->s->int_rels_per_ext_rel;
7919 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7920 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7921 struct bfd_link_order *lo;
7922 bfd_vma r_sym_mask;
3410fea8 7923 bfd_boolean use_rela;
c152c796 7924
3410fea8
NC
7925 /* Find a dynamic reloc section. */
7926 rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
7927 rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn");
7928 if (rela_dyn != NULL && rela_dyn->size > 0
7929 && rel_dyn != NULL && rel_dyn->size > 0)
c152c796 7930 {
3410fea8
NC
7931 bfd_boolean use_rela_initialised = FALSE;
7932
7933 /* This is just here to stop gcc from complaining.
7934 It's initialization checking code is not perfect. */
7935 use_rela = TRUE;
7936
7937 /* Both sections are present. Examine the sizes
7938 of the indirect sections to help us choose. */
7939 for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
7940 if (lo->type == bfd_indirect_link_order)
7941 {
7942 asection *o = lo->u.indirect.section;
7943
7944 if ((o->size % bed->s->sizeof_rela) == 0)
7945 {
7946 if ((o->size % bed->s->sizeof_rel) == 0)
7947 /* Section size is divisible by both rel and rela sizes.
7948 It is of no help to us. */
7949 ;
7950 else
7951 {
7952 /* Section size is only divisible by rela. */
7953 if (use_rela_initialised && (use_rela == FALSE))
7954 {
7955 _bfd_error_handler
7956 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
7957 bfd_set_error (bfd_error_invalid_operation);
7958 return 0;
7959 }
7960 else
7961 {
7962 use_rela = TRUE;
7963 use_rela_initialised = TRUE;
7964 }
7965 }
7966 }
7967 else if ((o->size % bed->s->sizeof_rel) == 0)
7968 {
7969 /* Section size is only divisible by rel. */
7970 if (use_rela_initialised && (use_rela == TRUE))
7971 {
7972 _bfd_error_handler
7973 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
7974 bfd_set_error (bfd_error_invalid_operation);
7975 return 0;
7976 }
7977 else
7978 {
7979 use_rela = FALSE;
7980 use_rela_initialised = TRUE;
7981 }
7982 }
7983 else
7984 {
7985 /* The section size is not divisible by either - something is wrong. */
7986 _bfd_error_handler
7987 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
7988 bfd_set_error (bfd_error_invalid_operation);
7989 return 0;
7990 }
7991 }
7992
7993 for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
7994 if (lo->type == bfd_indirect_link_order)
7995 {
7996 asection *o = lo->u.indirect.section;
7997
7998 if ((o->size % bed->s->sizeof_rela) == 0)
7999 {
8000 if ((o->size % bed->s->sizeof_rel) == 0)
8001 /* Section size is divisible by both rel and rela sizes.
8002 It is of no help to us. */
8003 ;
8004 else
8005 {
8006 /* Section size is only divisible by rela. */
8007 if (use_rela_initialised && (use_rela == FALSE))
8008 {
8009 _bfd_error_handler
8010 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8011 bfd_set_error (bfd_error_invalid_operation);
8012 return 0;
8013 }
8014 else
8015 {
8016 use_rela = TRUE;
8017 use_rela_initialised = TRUE;
8018 }
8019 }
8020 }
8021 else if ((o->size % bed->s->sizeof_rel) == 0)
8022 {
8023 /* Section size is only divisible by rel. */
8024 if (use_rela_initialised && (use_rela == TRUE))
8025 {
8026 _bfd_error_handler
8027 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8028 bfd_set_error (bfd_error_invalid_operation);
8029 return 0;
8030 }
8031 else
8032 {
8033 use_rela = FALSE;
8034 use_rela_initialised = TRUE;
8035 }
8036 }
8037 else
8038 {
8039 /* The section size is not divisible by either - something is wrong. */
8040 _bfd_error_handler
8041 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8042 bfd_set_error (bfd_error_invalid_operation);
8043 return 0;
8044 }
8045 }
8046
8047 if (! use_rela_initialised)
8048 /* Make a guess. */
8049 use_rela = TRUE;
c152c796 8050 }
fc66a176
L
8051 else if (rela_dyn != NULL && rela_dyn->size > 0)
8052 use_rela = TRUE;
8053 else if (rel_dyn != NULL && rel_dyn->size > 0)
3410fea8 8054 use_rela = FALSE;
c152c796 8055 else
fc66a176 8056 return 0;
3410fea8
NC
8057
8058 if (use_rela)
c152c796 8059 {
3410fea8 8060 dynamic_relocs = rela_dyn;
c152c796
AM
8061 ext_size = bed->s->sizeof_rela;
8062 swap_in = bed->s->swap_reloca_in;
8063 swap_out = bed->s->swap_reloca_out;
8064 }
3410fea8
NC
8065 else
8066 {
8067 dynamic_relocs = rel_dyn;
8068 ext_size = bed->s->sizeof_rel;
8069 swap_in = bed->s->swap_reloc_in;
8070 swap_out = bed->s->swap_reloc_out;
8071 }
c152c796
AM
8072
8073 size = 0;
3410fea8 8074 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
c152c796 8075 if (lo->type == bfd_indirect_link_order)
3410fea8 8076 size += lo->u.indirect.section->size;
c152c796 8077
3410fea8 8078 if (size != dynamic_relocs->size)
c152c796
AM
8079 return 0;
8080
8081 sort_elt = (sizeof (struct elf_link_sort_rela)
8082 + (i2e - 1) * sizeof (Elf_Internal_Rela));
3410fea8
NC
8083
8084 count = dynamic_relocs->size / ext_size;
c152c796 8085 sort = bfd_zmalloc (sort_elt * count);
3410fea8 8086
c152c796
AM
8087 if (sort == NULL)
8088 {
8089 (*info->callbacks->warning)
8090 (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8091 return 0;
8092 }
8093
8094 if (bed->s->arch_size == 32)
8095 r_sym_mask = ~(bfd_vma) 0xff;
8096 else
8097 r_sym_mask = ~(bfd_vma) 0xffffffff;
8098
3410fea8 8099 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
c152c796
AM
8100 if (lo->type == bfd_indirect_link_order)
8101 {
8102 bfd_byte *erel, *erelend;
8103 asection *o = lo->u.indirect.section;
8104
1da212d6
AM
8105 if (o->contents == NULL && o->size != 0)
8106 {
8107 /* This is a reloc section that is being handled as a normal
8108 section. See bfd_section_from_shdr. We can't combine
8109 relocs in this case. */
8110 free (sort);
8111 return 0;
8112 }
c152c796 8113 erel = o->contents;
eea6121a 8114 erelend = o->contents + o->size;
c152c796 8115 p = sort + o->output_offset / ext_size * sort_elt;
3410fea8 8116
c152c796
AM
8117 while (erel < erelend)
8118 {
8119 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
3410fea8 8120
c152c796
AM
8121 (*swap_in) (abfd, erel, s->rela);
8122 s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
8123 s->u.sym_mask = r_sym_mask;
8124 p += sort_elt;
8125 erel += ext_size;
8126 }
8127 }
8128
8129 qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8130
8131 for (i = 0, p = sort; i < count; i++, p += sort_elt)
8132 {
8133 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8134 if (s->type != reloc_class_relative)
8135 break;
8136 }
8137 ret = i;
8138 s_non_relative = p;
8139
8140 sq = (struct elf_link_sort_rela *) s_non_relative;
8141 for (; i < count; i++, p += sort_elt)
8142 {
8143 struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8144 if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8145 sq = sp;
8146 sp->u.offset = sq->rela->r_offset;
8147 }
8148
8149 qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8150
3410fea8 8151 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
c152c796
AM
8152 if (lo->type == bfd_indirect_link_order)
8153 {
8154 bfd_byte *erel, *erelend;
8155 asection *o = lo->u.indirect.section;
8156
8157 erel = o->contents;
eea6121a 8158 erelend = o->contents + o->size;
c152c796
AM
8159 p = sort + o->output_offset / ext_size * sort_elt;
8160 while (erel < erelend)
8161 {
8162 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8163 (*swap_out) (abfd, s->rela, erel);
8164 p += sort_elt;
8165 erel += ext_size;
8166 }
8167 }
8168
8169 free (sort);
3410fea8 8170 *psec = dynamic_relocs;
c152c796
AM
8171 return ret;
8172}
8173
8174/* Flush the output symbols to the file. */
8175
8176static bfd_boolean
8177elf_link_flush_output_syms (struct elf_final_link_info *finfo,
8178 const struct elf_backend_data *bed)
8179{
8180 if (finfo->symbuf_count > 0)
8181 {
8182 Elf_Internal_Shdr *hdr;
8183 file_ptr pos;
8184 bfd_size_type amt;
8185
8186 hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
8187 pos = hdr->sh_offset + hdr->sh_size;
8188 amt = finfo->symbuf_count * bed->s->sizeof_sym;
8189 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
8190 || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
8191 return FALSE;
8192
8193 hdr->sh_size += amt;
8194 finfo->symbuf_count = 0;
8195 }
8196
8197 return TRUE;
8198}
8199
8200/* Add a symbol to the output symbol table. */
8201
6e0b88f1 8202static int
c152c796
AM
8203elf_link_output_sym (struct elf_final_link_info *finfo,
8204 const char *name,
8205 Elf_Internal_Sym *elfsym,
8206 asection *input_sec,
8207 struct elf_link_hash_entry *h)
8208{
8209 bfd_byte *dest;
8210 Elf_External_Sym_Shndx *destshndx;
6e0b88f1 8211 int (*output_symbol_hook)
c152c796
AM
8212 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8213 struct elf_link_hash_entry *);
8214 const struct elf_backend_data *bed;
8215
8216 bed = get_elf_backend_data (finfo->output_bfd);
8217 output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8218 if (output_symbol_hook != NULL)
8219 {
6e0b88f1
AM
8220 int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h);
8221 if (ret != 1)
8222 return ret;
c152c796
AM
8223 }
8224
8225 if (name == NULL || *name == '\0')
8226 elfsym->st_name = 0;
8227 else if (input_sec->flags & SEC_EXCLUDE)
8228 elfsym->st_name = 0;
8229 else
8230 {
8231 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
8232 name, TRUE, FALSE);
8233 if (elfsym->st_name == (unsigned long) -1)
6e0b88f1 8234 return 0;
c152c796
AM
8235 }
8236
8237 if (finfo->symbuf_count >= finfo->symbuf_size)
8238 {
8239 if (! elf_link_flush_output_syms (finfo, bed))
6e0b88f1 8240 return 0;
c152c796
AM
8241 }
8242
8243 dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
8244 destshndx = finfo->symshndxbuf;
8245 if (destshndx != NULL)
8246 {
8247 if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
8248 {
8249 bfd_size_type amt;
8250
8251 amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
515ef31d 8252 destshndx = bfd_realloc (destshndx, amt * 2);
c152c796 8253 if (destshndx == NULL)
6e0b88f1 8254 return 0;
515ef31d 8255 finfo->symshndxbuf = destshndx;
c152c796
AM
8256 memset ((char *) destshndx + amt, 0, amt);
8257 finfo->shndxbuf_size *= 2;
8258 }
8259 destshndx += bfd_get_symcount (finfo->output_bfd);
8260 }
8261
8262 bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
8263 finfo->symbuf_count += 1;
8264 bfd_get_symcount (finfo->output_bfd) += 1;
8265
6e0b88f1 8266 return 1;
c152c796
AM
8267}
8268
c0d5a53d
L
8269/* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8270
8271static bfd_boolean
8272check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8273{
4fbb74a6
AM
8274 if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8275 && sym->st_shndx < SHN_LORESERVE)
c0d5a53d
L
8276 {
8277 /* The gABI doesn't support dynamic symbols in output sections
a0c8462f 8278 beyond 64k. */
c0d5a53d
L
8279 (*_bfd_error_handler)
8280 (_("%B: Too many sections: %d (>= %d)"),
4fbb74a6 8281 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
c0d5a53d
L
8282 bfd_set_error (bfd_error_nonrepresentable_section);
8283 return FALSE;
8284 }
8285 return TRUE;
8286}
8287
c152c796
AM
8288/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8289 allowing an unsatisfied unversioned symbol in the DSO to match a
8290 versioned symbol that would normally require an explicit version.
8291 We also handle the case that a DSO references a hidden symbol
8292 which may be satisfied by a versioned symbol in another DSO. */
8293
8294static bfd_boolean
8295elf_link_check_versioned_symbol (struct bfd_link_info *info,
8296 const struct elf_backend_data *bed,
8297 struct elf_link_hash_entry *h)
8298{
8299 bfd *abfd;
8300 struct elf_link_loaded_list *loaded;
8301
8302 if (!is_elf_hash_table (info->hash))
8303 return FALSE;
8304
8305 switch (h->root.type)
8306 {
8307 default:
8308 abfd = NULL;
8309 break;
8310
8311 case bfd_link_hash_undefined:
8312 case bfd_link_hash_undefweak:
8313 abfd = h->root.u.undef.abfd;
8314 if ((abfd->flags & DYNAMIC) == 0
e56f61be 8315 || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
c152c796
AM
8316 return FALSE;
8317 break;
8318
8319 case bfd_link_hash_defined:
8320 case bfd_link_hash_defweak:
8321 abfd = h->root.u.def.section->owner;
8322 break;
8323
8324 case bfd_link_hash_common:
8325 abfd = h->root.u.c.p->section->owner;
8326 break;
8327 }
8328 BFD_ASSERT (abfd != NULL);
8329
8330 for (loaded = elf_hash_table (info)->loaded;
8331 loaded != NULL;
8332 loaded = loaded->next)
8333 {
8334 bfd *input;
8335 Elf_Internal_Shdr *hdr;
8336 bfd_size_type symcount;
8337 bfd_size_type extsymcount;
8338 bfd_size_type extsymoff;
8339 Elf_Internal_Shdr *versymhdr;
8340 Elf_Internal_Sym *isym;
8341 Elf_Internal_Sym *isymend;
8342 Elf_Internal_Sym *isymbuf;
8343 Elf_External_Versym *ever;
8344 Elf_External_Versym *extversym;
8345
8346 input = loaded->abfd;
8347
8348 /* We check each DSO for a possible hidden versioned definition. */
8349 if (input == abfd
8350 || (input->flags & DYNAMIC) == 0
8351 || elf_dynversym (input) == 0)
8352 continue;
8353
8354 hdr = &elf_tdata (input)->dynsymtab_hdr;
8355
8356 symcount = hdr->sh_size / bed->s->sizeof_sym;
8357 if (elf_bad_symtab (input))
8358 {
8359 extsymcount = symcount;
8360 extsymoff = 0;
8361 }
8362 else
8363 {
8364 extsymcount = symcount - hdr->sh_info;
8365 extsymoff = hdr->sh_info;
8366 }
8367
8368 if (extsymcount == 0)
8369 continue;
8370
8371 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8372 NULL, NULL, NULL);
8373 if (isymbuf == NULL)
8374 return FALSE;
8375
8376 /* Read in any version definitions. */
8377 versymhdr = &elf_tdata (input)->dynversym_hdr;
8378 extversym = bfd_malloc (versymhdr->sh_size);
8379 if (extversym == NULL)
8380 goto error_ret;
8381
8382 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8383 || (bfd_bread (extversym, versymhdr->sh_size, input)
8384 != versymhdr->sh_size))
8385 {
8386 free (extversym);
8387 error_ret:
8388 free (isymbuf);
8389 return FALSE;
8390 }
8391
8392 ever = extversym + extsymoff;
8393 isymend = isymbuf + extsymcount;
8394 for (isym = isymbuf; isym < isymend; isym++, ever++)
8395 {
8396 const char *name;
8397 Elf_Internal_Versym iver;
8398 unsigned short version_index;
8399
8400 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8401 || isym->st_shndx == SHN_UNDEF)
8402 continue;
8403
8404 name = bfd_elf_string_from_elf_section (input,
8405 hdr->sh_link,
8406 isym->st_name);
8407 if (strcmp (name, h->root.root.string) != 0)
8408 continue;
8409
8410 _bfd_elf_swap_versym_in (input, ever, &iver);
8411
8412 if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
8413 {
8414 /* If we have a non-hidden versioned sym, then it should
8415 have provided a definition for the undefined sym. */
8416 abort ();
8417 }
8418
8419 version_index = iver.vs_vers & VERSYM_VERSION;
8420 if (version_index == 1 || version_index == 2)
8421 {
8422 /* This is the base or first version. We can use it. */
8423 free (extversym);
8424 free (isymbuf);
8425 return TRUE;
8426 }
8427 }
8428
8429 free (extversym);
8430 free (isymbuf);
8431 }
8432
8433 return FALSE;
8434}
8435
8436/* Add an external symbol to the symbol table. This is called from
8437 the hash table traversal routine. When generating a shared object,
8438 we go through the symbol table twice. The first time we output
8439 anything that might have been forced to local scope in a version
8440 script. The second time we output the symbols that are still
8441 global symbols. */
8442
8443static bfd_boolean
8444elf_link_output_extsym (struct elf_link_hash_entry *h, void *data)
8445{
8446 struct elf_outext_info *eoinfo = data;
8447 struct elf_final_link_info *finfo = eoinfo->finfo;
8448 bfd_boolean strip;
8449 Elf_Internal_Sym sym;
8450 asection *input_sec;
8451 const struct elf_backend_data *bed;
6e0b88f1
AM
8452 long indx;
8453 int ret;
c152c796
AM
8454
8455 if (h->root.type == bfd_link_hash_warning)
8456 {
8457 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8458 if (h->root.type == bfd_link_hash_new)
8459 return TRUE;
8460 }
8461
8462 /* Decide whether to output this symbol in this pass. */
8463 if (eoinfo->localsyms)
8464 {
f5385ebf 8465 if (!h->forced_local)
c152c796
AM
8466 return TRUE;
8467 }
8468 else
8469 {
f5385ebf 8470 if (h->forced_local)
c152c796
AM
8471 return TRUE;
8472 }
8473
8474 bed = get_elf_backend_data (finfo->output_bfd);
8475
12ac1cf5 8476 if (h->root.type == bfd_link_hash_undefined)
c152c796 8477 {
12ac1cf5
NC
8478 /* If we have an undefined symbol reference here then it must have
8479 come from a shared library that is being linked in. (Undefined
8480 references in regular files have already been handled). */
8481 bfd_boolean ignore_undef = FALSE;
8482
8483 /* Some symbols may be special in that the fact that they're
8484 undefined can be safely ignored - let backend determine that. */
8485 if (bed->elf_backend_ignore_undef_symbol)
8486 ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8487
8488 /* If we are reporting errors for this situation then do so now. */
8489 if (ignore_undef == FALSE
8490 && h->ref_dynamic
8491 && ! h->ref_regular
8492 && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
8493 && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
c152c796 8494 {
12ac1cf5
NC
8495 if (! (finfo->info->callbacks->undefined_symbol
8496 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
8497 NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
8498 {
8499 eoinfo->failed = TRUE;
8500 return FALSE;
8501 }
c152c796
AM
8502 }
8503 }
8504
8505 /* We should also warn if a forced local symbol is referenced from
8506 shared libraries. */
8507 if (! finfo->info->relocatable
8508 && (! finfo->info->shared)
f5385ebf
AM
8509 && h->forced_local
8510 && h->ref_dynamic
8511 && !h->dynamic_def
8512 && !h->dynamic_weak
c152c796
AM
8513 && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
8514 {
8515 (*_bfd_error_handler)
d003868e 8516 (_("%B: %s symbol `%s' in %B is referenced by DSO"),
cfca085c
L
8517 finfo->output_bfd,
8518 h->root.u.def.section == bfd_abs_section_ptr
8519 ? finfo->output_bfd : h->root.u.def.section->owner,
c152c796
AM
8520 ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
8521 ? "internal"
8522 : ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
d003868e
AM
8523 ? "hidden" : "local",
8524 h->root.root.string);
c152c796
AM
8525 eoinfo->failed = TRUE;
8526 return FALSE;
8527 }
8528
8529 /* We don't want to output symbols that have never been mentioned by
8530 a regular file, or that we have been told to strip. However, if
8531 h->indx is set to -2, the symbol is used by a reloc and we must
8532 output it. */
8533 if (h->indx == -2)
8534 strip = FALSE;
f5385ebf 8535 else if ((h->def_dynamic
77cfaee6
AM
8536 || h->ref_dynamic
8537 || h->root.type == bfd_link_hash_new)
f5385ebf
AM
8538 && !h->def_regular
8539 && !h->ref_regular)
c152c796
AM
8540 strip = TRUE;
8541 else if (finfo->info->strip == strip_all)
8542 strip = TRUE;
8543 else if (finfo->info->strip == strip_some
8544 && bfd_hash_lookup (finfo->info->keep_hash,
8545 h->root.root.string, FALSE, FALSE) == NULL)
8546 strip = TRUE;
8547 else if (finfo->info->strip_discarded
8548 && (h->root.type == bfd_link_hash_defined
8549 || h->root.type == bfd_link_hash_defweak)
8550 && elf_discarded_section (h->root.u.def.section))
8551 strip = TRUE;
8552 else
8553 strip = FALSE;
8554
8555 /* If we're stripping it, and it's not a dynamic symbol, there's
8556 nothing else to do unless it is a forced local symbol. */
8557 if (strip
8558 && h->dynindx == -1
f5385ebf 8559 && !h->forced_local)
c152c796
AM
8560 return TRUE;
8561
8562 sym.st_value = 0;
8563 sym.st_size = h->size;
8564 sym.st_other = h->other;
f5385ebf 8565 if (h->forced_local)
c152c796
AM
8566 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8567 else if (h->root.type == bfd_link_hash_undefweak
8568 || h->root.type == bfd_link_hash_defweak)
8569 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8570 else
8571 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8572
8573 switch (h->root.type)
8574 {
8575 default:
8576 case bfd_link_hash_new:
8577 case bfd_link_hash_warning:
8578 abort ();
8579 return FALSE;
8580
8581 case bfd_link_hash_undefined:
8582 case bfd_link_hash_undefweak:
8583 input_sec = bfd_und_section_ptr;
8584 sym.st_shndx = SHN_UNDEF;
8585 break;
8586
8587 case bfd_link_hash_defined:
8588 case bfd_link_hash_defweak:
8589 {
8590 input_sec = h->root.u.def.section;
8591 if (input_sec->output_section != NULL)
8592 {
8593 sym.st_shndx =
8594 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
8595 input_sec->output_section);
8596 if (sym.st_shndx == SHN_BAD)
8597 {
8598 (*_bfd_error_handler)
d003868e
AM
8599 (_("%B: could not find output section %A for input section %A"),
8600 finfo->output_bfd, input_sec->output_section, input_sec);
c152c796
AM
8601 eoinfo->failed = TRUE;
8602 return FALSE;
8603 }
8604
8605 /* ELF symbols in relocatable files are section relative,
8606 but in nonrelocatable files they are virtual
8607 addresses. */
8608 sym.st_value = h->root.u.def.value + input_sec->output_offset;
8609 if (! finfo->info->relocatable)
8610 {
8611 sym.st_value += input_sec->output_section->vma;
8612 if (h->type == STT_TLS)
8613 {
430a16a5
NC
8614 asection *tls_sec = elf_hash_table (finfo->info)->tls_sec;
8615 if (tls_sec != NULL)
8616 sym.st_value -= tls_sec->vma;
8617 else
8618 {
8619 /* The TLS section may have been garbage collected. */
8620 BFD_ASSERT (finfo->info->gc_sections
8621 && !input_sec->gc_mark);
8622 }
c152c796
AM
8623 }
8624 }
8625 }
8626 else
8627 {
8628 BFD_ASSERT (input_sec->owner == NULL
8629 || (input_sec->owner->flags & DYNAMIC) != 0);
8630 sym.st_shndx = SHN_UNDEF;
8631 input_sec = bfd_und_section_ptr;
8632 }
8633 }
8634 break;
8635
8636 case bfd_link_hash_common:
8637 input_sec = h->root.u.c.p->section;
a4d8e49b 8638 sym.st_shndx = bed->common_section_index (input_sec);
c152c796
AM
8639 sym.st_value = 1 << h->root.u.c.p->alignment_power;
8640 break;
8641
8642 case bfd_link_hash_indirect:
8643 /* These symbols are created by symbol versioning. They point
8644 to the decorated version of the name. For example, if the
8645 symbol foo@@GNU_1.2 is the default, which should be used when
8646 foo is used with no version, then we add an indirect symbol
8647 foo which points to foo@@GNU_1.2. We ignore these symbols,
8648 since the indirected symbol is already in the hash table. */
8649 return TRUE;
8650 }
8651
8652 /* Give the processor backend a chance to tweak the symbol value,
8653 and also to finish up anything that needs to be done for this
8654 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
3aa14d16
L
8655 forced local syms when non-shared is due to a historical quirk.
8656 STT_GNU_IFUNC symbol must go through PLT. */
8657 if ((h->type == STT_GNU_IFUNC
8658 && h->ref_regular
8659 && !finfo->info->relocatable)
8660 || ((h->dynindx != -1
8661 || h->forced_local)
8662 && ((finfo->info->shared
8663 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8664 || h->root.type != bfd_link_hash_undefweak))
8665 || !h->forced_local)
8666 && elf_hash_table (finfo->info)->dynamic_sections_created))
c152c796
AM
8667 {
8668 if (! ((*bed->elf_backend_finish_dynamic_symbol)
8669 (finfo->output_bfd, finfo->info, h, &sym)))
8670 {
8671 eoinfo->failed = TRUE;
8672 return FALSE;
8673 }
8674 }
8675
8676 /* If we are marking the symbol as undefined, and there are no
8677 non-weak references to this symbol from a regular object, then
8678 mark the symbol as weak undefined; if there are non-weak
8679 references, mark the symbol as strong. We can't do this earlier,
8680 because it might not be marked as undefined until the
8681 finish_dynamic_symbol routine gets through with it. */
8682 if (sym.st_shndx == SHN_UNDEF
f5385ebf 8683 && h->ref_regular
c152c796
AM
8684 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
8685 || ELF_ST_BIND (sym.st_info) == STB_WEAK))
8686 {
8687 int bindtype;
8688
f5385ebf 8689 if (h->ref_regular_nonweak)
c152c796
AM
8690 bindtype = STB_GLOBAL;
8691 else
8692 bindtype = STB_WEAK;
8693 sym.st_info = ELF_ST_INFO (bindtype, ELF_ST_TYPE (sym.st_info));
8694 }
8695
bda987c2
CD
8696 /* If this is a symbol defined in a dynamic library, don't use the
8697 symbol size from the dynamic library. Relinking an executable
8698 against a new library may introduce gratuitous changes in the
8699 executable's symbols if we keep the size. */
8700 if (sym.st_shndx == SHN_UNDEF
8701 && !h->def_regular
8702 && h->def_dynamic)
8703 sym.st_size = 0;
8704
c152c796
AM
8705 /* If a non-weak symbol with non-default visibility is not defined
8706 locally, it is a fatal error. */
8707 if (! finfo->info->relocatable
8708 && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
8709 && ELF_ST_BIND (sym.st_info) != STB_WEAK
8710 && h->root.type == bfd_link_hash_undefined
f5385ebf 8711 && !h->def_regular)
c152c796
AM
8712 {
8713 (*_bfd_error_handler)
d003868e
AM
8714 (_("%B: %s symbol `%s' isn't defined"),
8715 finfo->output_bfd,
8716 ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED
8717 ? "protected"
8718 : ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL
8719 ? "internal" : "hidden",
8720 h->root.root.string);
c152c796
AM
8721 eoinfo->failed = TRUE;
8722 return FALSE;
8723 }
8724
8725 /* If this symbol should be put in the .dynsym section, then put it
8726 there now. We already know the symbol index. We also fill in
8727 the entry in the .hash section. */
8728 if (h->dynindx != -1
8729 && elf_hash_table (finfo->info)->dynamic_sections_created)
8730 {
c152c796
AM
8731 bfd_byte *esym;
8732
8733 sym.st_name = h->dynstr_index;
8734 esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
c0d5a53d
L
8735 if (! check_dynsym (finfo->output_bfd, &sym))
8736 {
8737 eoinfo->failed = TRUE;
8738 return FALSE;
8739 }
c152c796
AM
8740 bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
8741
fdc90cb4
JJ
8742 if (finfo->hash_sec != NULL)
8743 {
8744 size_t hash_entry_size;
8745 bfd_byte *bucketpos;
8746 bfd_vma chain;
41198d0c
L
8747 size_t bucketcount;
8748 size_t bucket;
8749
8750 bucketcount = elf_hash_table (finfo->info)->bucketcount;
8751 bucket = h->u.elf_hash_value % bucketcount;
fdc90cb4
JJ
8752
8753 hash_entry_size
8754 = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
8755 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
8756 + (bucket + 2) * hash_entry_size);
8757 chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
8758 bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
8759 bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
8760 ((bfd_byte *) finfo->hash_sec->contents
8761 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
8762 }
c152c796
AM
8763
8764 if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
8765 {
8766 Elf_Internal_Versym iversym;
8767 Elf_External_Versym *eversym;
8768
f5385ebf 8769 if (!h->def_regular)
c152c796
AM
8770 {
8771 if (h->verinfo.verdef == NULL)
8772 iversym.vs_vers = 0;
8773 else
8774 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
8775 }
8776 else
8777 {
8778 if (h->verinfo.vertree == NULL)
8779 iversym.vs_vers = 1;
8780 else
8781 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
3e3b46e5
PB
8782 if (finfo->info->create_default_symver)
8783 iversym.vs_vers++;
c152c796
AM
8784 }
8785
f5385ebf 8786 if (h->hidden)
c152c796
AM
8787 iversym.vs_vers |= VERSYM_HIDDEN;
8788
8789 eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
8790 eversym += h->dynindx;
8791 _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
8792 }
8793 }
8794
8795 /* If we're stripping it, then it was just a dynamic symbol, and
8796 there's nothing else to do. */
8797 if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
8798 return TRUE;
8799
6e0b88f1
AM
8800 indx = bfd_get_symcount (finfo->output_bfd);
8801 ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h);
8802 if (ret == 0)
c152c796
AM
8803 {
8804 eoinfo->failed = TRUE;
8805 return FALSE;
8806 }
6e0b88f1
AM
8807 else if (ret == 1)
8808 h->indx = indx;
8809 else if (h->indx == -2)
8810 abort();
c152c796
AM
8811
8812 return TRUE;
8813}
8814
cdd3575c
AM
8815/* Return TRUE if special handling is done for relocs in SEC against
8816 symbols defined in discarded sections. */
8817
c152c796
AM
8818static bfd_boolean
8819elf_section_ignore_discarded_relocs (asection *sec)
8820{
8821 const struct elf_backend_data *bed;
8822
cdd3575c
AM
8823 switch (sec->sec_info_type)
8824 {
8825 case ELF_INFO_TYPE_STABS:
8826 case ELF_INFO_TYPE_EH_FRAME:
8827 return TRUE;
8828 default:
8829 break;
8830 }
c152c796
AM
8831
8832 bed = get_elf_backend_data (sec->owner);
8833 if (bed->elf_backend_ignore_discarded_relocs != NULL
8834 && (*bed->elf_backend_ignore_discarded_relocs) (sec))
8835 return TRUE;
8836
8837 return FALSE;
8838}
8839
9e66c942
AM
8840/* Return a mask saying how ld should treat relocations in SEC against
8841 symbols defined in discarded sections. If this function returns
8842 COMPLAIN set, ld will issue a warning message. If this function
8843 returns PRETEND set, and the discarded section was link-once and the
8844 same size as the kept link-once section, ld will pretend that the
8845 symbol was actually defined in the kept section. Otherwise ld will
8846 zero the reloc (at least that is the intent, but some cooperation by
8847 the target dependent code is needed, particularly for REL targets). */
8848
8a696751
AM
8849unsigned int
8850_bfd_elf_default_action_discarded (asection *sec)
cdd3575c 8851{
9e66c942 8852 if (sec->flags & SEC_DEBUGGING)
69d54b1b 8853 return PRETEND;
cdd3575c
AM
8854
8855 if (strcmp (".eh_frame", sec->name) == 0)
9e66c942 8856 return 0;
cdd3575c
AM
8857
8858 if (strcmp (".gcc_except_table", sec->name) == 0)
9e66c942 8859 return 0;
cdd3575c 8860
9e66c942 8861 return COMPLAIN | PRETEND;
cdd3575c
AM
8862}
8863
3d7f7666
L
8864/* Find a match between a section and a member of a section group. */
8865
8866static asection *
c0f00686
L
8867match_group_member (asection *sec, asection *group,
8868 struct bfd_link_info *info)
3d7f7666
L
8869{
8870 asection *first = elf_next_in_group (group);
8871 asection *s = first;
8872
8873 while (s != NULL)
8874 {
c0f00686 8875 if (bfd_elf_match_symbols_in_sections (s, sec, info))
3d7f7666
L
8876 return s;
8877
83180ade 8878 s = elf_next_in_group (s);
3d7f7666
L
8879 if (s == first)
8880 break;
8881 }
8882
8883 return NULL;
8884}
8885
01b3c8ab 8886/* Check if the kept section of a discarded section SEC can be used
c2370991
AM
8887 to replace it. Return the replacement if it is OK. Otherwise return
8888 NULL. */
01b3c8ab
L
8889
8890asection *
c0f00686 8891_bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
01b3c8ab
L
8892{
8893 asection *kept;
8894
8895 kept = sec->kept_section;
8896 if (kept != NULL)
8897 {
c2370991 8898 if ((kept->flags & SEC_GROUP) != 0)
c0f00686 8899 kept = match_group_member (sec, kept, info);
1dd2625f
BW
8900 if (kept != NULL
8901 && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
8902 != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
01b3c8ab 8903 kept = NULL;
c2370991 8904 sec->kept_section = kept;
01b3c8ab
L
8905 }
8906 return kept;
8907}
8908
c152c796
AM
8909/* Link an input file into the linker output file. This function
8910 handles all the sections and relocations of the input file at once.
8911 This is so that we only have to read the local symbols once, and
8912 don't have to keep them in memory. */
8913
8914static bfd_boolean
8915elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
8916{
ece5ef60 8917 int (*relocate_section)
c152c796
AM
8918 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
8919 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
8920 bfd *output_bfd;
8921 Elf_Internal_Shdr *symtab_hdr;
8922 size_t locsymcount;
8923 size_t extsymoff;
8924 Elf_Internal_Sym *isymbuf;
8925 Elf_Internal_Sym *isym;
8926 Elf_Internal_Sym *isymend;
8927 long *pindex;
8928 asection **ppsection;
8929 asection *o;
8930 const struct elf_backend_data *bed;
c152c796
AM
8931 struct elf_link_hash_entry **sym_hashes;
8932
8933 output_bfd = finfo->output_bfd;
8934 bed = get_elf_backend_data (output_bfd);
8935 relocate_section = bed->elf_backend_relocate_section;
8936
8937 /* If this is a dynamic object, we don't want to do anything here:
8938 we don't want the local symbols, and we don't want the section
8939 contents. */
8940 if ((input_bfd->flags & DYNAMIC) != 0)
8941 return TRUE;
8942
c152c796
AM
8943 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8944 if (elf_bad_symtab (input_bfd))
8945 {
8946 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
8947 extsymoff = 0;
8948 }
8949 else
8950 {
8951 locsymcount = symtab_hdr->sh_info;
8952 extsymoff = symtab_hdr->sh_info;
8953 }
8954
8955 /* Read the local symbols. */
8956 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8957 if (isymbuf == NULL && locsymcount != 0)
8958 {
8959 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
8960 finfo->internal_syms,
8961 finfo->external_syms,
8962 finfo->locsym_shndx);
8963 if (isymbuf == NULL)
8964 return FALSE;
8965 }
8966
8967 /* Find local symbol sections and adjust values of symbols in
8968 SEC_MERGE sections. Write out those local symbols we know are
8969 going into the output file. */
8970 isymend = isymbuf + locsymcount;
8971 for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
8972 isym < isymend;
8973 isym++, pindex++, ppsection++)
8974 {
8975 asection *isec;
8976 const char *name;
8977 Elf_Internal_Sym osym;
6e0b88f1
AM
8978 long indx;
8979 int ret;
c152c796
AM
8980
8981 *pindex = -1;
8982
8983 if (elf_bad_symtab (input_bfd))
8984 {
8985 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
8986 {
8987 *ppsection = NULL;
8988 continue;
8989 }
8990 }
8991
8992 if (isym->st_shndx == SHN_UNDEF)
8993 isec = bfd_und_section_ptr;
c152c796
AM
8994 else if (isym->st_shndx == SHN_ABS)
8995 isec = bfd_abs_section_ptr;
8996 else if (isym->st_shndx == SHN_COMMON)
8997 isec = bfd_com_section_ptr;
8998 else
8999 {
cb33740c
AM
9000 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9001 if (isec == NULL)
9002 {
9003 /* Don't attempt to output symbols with st_shnx in the
9004 reserved range other than SHN_ABS and SHN_COMMON. */
9005 *ppsection = NULL;
9006 continue;
9007 }
9008 else if (isec->sec_info_type == ELF_INFO_TYPE_MERGE
9009 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9010 isym->st_value =
9011 _bfd_merged_section_offset (output_bfd, &isec,
9012 elf_section_data (isec)->sec_info,
9013 isym->st_value);
c152c796
AM
9014 }
9015
9016 *ppsection = isec;
9017
9018 /* Don't output the first, undefined, symbol. */
9019 if (ppsection == finfo->sections)
9020 continue;
9021
9022 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9023 {
9024 /* We never output section symbols. Instead, we use the
9025 section symbol of the corresponding section in the output
9026 file. */
9027 continue;
9028 }
9029
9030 /* If we are stripping all symbols, we don't want to output this
9031 one. */
9032 if (finfo->info->strip == strip_all)
9033 continue;
9034
9035 /* If we are discarding all local symbols, we don't want to
9036 output this one. If we are generating a relocatable output
9037 file, then some of the local symbols may be required by
9038 relocs; we output them below as we discover that they are
9039 needed. */
9040 if (finfo->info->discard == discard_all)
9041 continue;
9042
9043 /* If this symbol is defined in a section which we are
f02571c5
AM
9044 discarding, we don't need to keep it. */
9045 if (isym->st_shndx != SHN_UNDEF
4fbb74a6
AM
9046 && isym->st_shndx < SHN_LORESERVE
9047 && bfd_section_removed_from_list (output_bfd,
9048 isec->output_section))
e75a280b
L
9049 continue;
9050
c152c796
AM
9051 /* Get the name of the symbol. */
9052 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9053 isym->st_name);
9054 if (name == NULL)
9055 return FALSE;
9056
9057 /* See if we are discarding symbols with this name. */
9058 if ((finfo->info->strip == strip_some
9059 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
9060 == NULL))
9061 || (((finfo->info->discard == discard_sec_merge
9062 && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable)
9063 || finfo->info->discard == discard_l)
9064 && bfd_is_local_label_name (input_bfd, name)))
9065 continue;
9066
c152c796
AM
9067 osym = *isym;
9068
9069 /* Adjust the section index for the output file. */
9070 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9071 isec->output_section);
9072 if (osym.st_shndx == SHN_BAD)
9073 return FALSE;
9074
c152c796
AM
9075 /* ELF symbols in relocatable files are section relative, but
9076 in executable files they are virtual addresses. Note that
9077 this code assumes that all ELF sections have an associated
9078 BFD section with a reasonable value for output_offset; below
9079 we assume that they also have a reasonable value for
9080 output_section. Any special sections must be set up to meet
9081 these requirements. */
9082 osym.st_value += isec->output_offset;
9083 if (! finfo->info->relocatable)
9084 {
9085 osym.st_value += isec->output_section->vma;
9086 if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9087 {
9088 /* STT_TLS symbols are relative to PT_TLS segment base. */
9089 BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL);
9090 osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma;
9091 }
9092 }
9093
6e0b88f1
AM
9094 indx = bfd_get_symcount (output_bfd);
9095 ret = elf_link_output_sym (finfo, name, &osym, isec, NULL);
9096 if (ret == 0)
c152c796 9097 return FALSE;
6e0b88f1
AM
9098 else if (ret == 1)
9099 *pindex = indx;
c152c796
AM
9100 }
9101
9102 /* Relocate the contents of each section. */
9103 sym_hashes = elf_sym_hashes (input_bfd);
9104 for (o = input_bfd->sections; o != NULL; o = o->next)
9105 {
9106 bfd_byte *contents;
9107
9108 if (! o->linker_mark)
9109 {
9110 /* This section was omitted from the link. */
9111 continue;
9112 }
9113
bcacc0f5
AM
9114 if (finfo->info->relocatable
9115 && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9116 {
9117 /* Deal with the group signature symbol. */
9118 struct bfd_elf_section_data *sec_data = elf_section_data (o);
9119 unsigned long symndx = sec_data->this_hdr.sh_info;
9120 asection *osec = o->output_section;
9121
9122 if (symndx >= locsymcount
9123 || (elf_bad_symtab (input_bfd)
9124 && finfo->sections[symndx] == NULL))
9125 {
9126 struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9127 while (h->root.type == bfd_link_hash_indirect
9128 || h->root.type == bfd_link_hash_warning)
9129 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9130 /* Arrange for symbol to be output. */
9131 h->indx = -2;
9132 elf_section_data (osec)->this_hdr.sh_info = -2;
9133 }
9134 else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9135 {
9136 /* We'll use the output section target_index. */
9137 asection *sec = finfo->sections[symndx]->output_section;
9138 elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9139 }
9140 else
9141 {
9142 if (finfo->indices[symndx] == -1)
9143 {
9144 /* Otherwise output the local symbol now. */
9145 Elf_Internal_Sym sym = isymbuf[symndx];
9146 asection *sec = finfo->sections[symndx]->output_section;
9147 const char *name;
6e0b88f1
AM
9148 long indx;
9149 int ret;
bcacc0f5
AM
9150
9151 name = bfd_elf_string_from_elf_section (input_bfd,
9152 symtab_hdr->sh_link,
9153 sym.st_name);
9154 if (name == NULL)
9155 return FALSE;
9156
9157 sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9158 sec);
9159 if (sym.st_shndx == SHN_BAD)
9160 return FALSE;
9161
9162 sym.st_value += o->output_offset;
9163
6e0b88f1
AM
9164 indx = bfd_get_symcount (output_bfd);
9165 ret = elf_link_output_sym (finfo, name, &sym, o, NULL);
9166 if (ret == 0)
bcacc0f5 9167 return FALSE;
6e0b88f1
AM
9168 else if (ret == 1)
9169 finfo->indices[symndx] = indx;
9170 else
9171 abort ();
bcacc0f5
AM
9172 }
9173 elf_section_data (osec)->this_hdr.sh_info
9174 = finfo->indices[symndx];
9175 }
9176 }
9177
c152c796 9178 if ((o->flags & SEC_HAS_CONTENTS) == 0
eea6121a 9179 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
c152c796
AM
9180 continue;
9181
9182 if ((o->flags & SEC_LINKER_CREATED) != 0)
9183 {
9184 /* Section was created by _bfd_elf_link_create_dynamic_sections
9185 or somesuch. */
9186 continue;
9187 }
9188
9189 /* Get the contents of the section. They have been cached by a
9190 relaxation routine. Note that o is a section in an input
9191 file, so the contents field will not have been set by any of
9192 the routines which work on output files. */
9193 if (elf_section_data (o)->this_hdr.contents != NULL)
9194 contents = elf_section_data (o)->this_hdr.contents;
9195 else
9196 {
eea6121a
AM
9197 bfd_size_type amt = o->rawsize ? o->rawsize : o->size;
9198
c152c796 9199 contents = finfo->contents;
eea6121a 9200 if (! bfd_get_section_contents (input_bfd, o, contents, 0, amt))
c152c796
AM
9201 return FALSE;
9202 }
9203
9204 if ((o->flags & SEC_RELOC) != 0)
9205 {
9206 Elf_Internal_Rela *internal_relocs;
0f02bbd9 9207 Elf_Internal_Rela *rel, *relend;
c152c796
AM
9208 bfd_vma r_type_mask;
9209 int r_sym_shift;
0f02bbd9 9210 int action_discarded;
ece5ef60 9211 int ret;
c152c796
AM
9212
9213 /* Get the swapped relocs. */
9214 internal_relocs
9215 = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs,
9216 finfo->internal_relocs, FALSE);
9217 if (internal_relocs == NULL
9218 && o->reloc_count > 0)
9219 return FALSE;
9220
9221 if (bed->s->arch_size == 32)
9222 {
9223 r_type_mask = 0xff;
9224 r_sym_shift = 8;
9225 }
9226 else
9227 {
9228 r_type_mask = 0xffffffff;
9229 r_sym_shift = 32;
9230 }
9231
0f02bbd9 9232 action_discarded = -1;
c152c796 9233 if (!elf_section_ignore_discarded_relocs (o))
0f02bbd9
AM
9234 action_discarded = (*bed->action_discarded) (o);
9235
9236 /* Run through the relocs evaluating complex reloc symbols and
9237 looking for relocs against symbols from discarded sections
9238 or section symbols from removed link-once sections.
9239 Complain about relocs against discarded sections. Zero
9240 relocs against removed link-once sections. */
9241
9242 rel = internal_relocs;
9243 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9244 for ( ; rel < relend; rel++)
c152c796 9245 {
0f02bbd9
AM
9246 unsigned long r_symndx = rel->r_info >> r_sym_shift;
9247 unsigned int s_type;
9248 asection **ps, *sec;
9249 struct elf_link_hash_entry *h = NULL;
9250 const char *sym_name;
c152c796 9251
0f02bbd9
AM
9252 if (r_symndx == STN_UNDEF)
9253 continue;
c152c796 9254
0f02bbd9
AM
9255 if (r_symndx >= locsymcount
9256 || (elf_bad_symtab (input_bfd)
9257 && finfo->sections[r_symndx] == NULL))
9258 {
9259 h = sym_hashes[r_symndx - extsymoff];
ee75fd95 9260
0f02bbd9
AM
9261 /* Badly formatted input files can contain relocs that
9262 reference non-existant symbols. Check here so that
9263 we do not seg fault. */
9264 if (h == NULL)
c152c796 9265 {
0f02bbd9 9266 char buffer [32];
dce669a1 9267
0f02bbd9
AM
9268 sprintf_vma (buffer, rel->r_info);
9269 (*_bfd_error_handler)
9270 (_("error: %B contains a reloc (0x%s) for section %A "
9271 "that references a non-existent global symbol"),
9272 input_bfd, o, buffer);
9273 bfd_set_error (bfd_error_bad_value);
9274 return FALSE;
9275 }
3b36f7e6 9276
0f02bbd9
AM
9277 while (h->root.type == bfd_link_hash_indirect
9278 || h->root.type == bfd_link_hash_warning)
9279 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c152c796 9280
0f02bbd9 9281 s_type = h->type;
cdd3575c 9282
0f02bbd9
AM
9283 ps = NULL;
9284 if (h->root.type == bfd_link_hash_defined
9285 || h->root.type == bfd_link_hash_defweak)
9286 ps = &h->root.u.def.section;
9287
9288 sym_name = h->root.root.string;
9289 }
9290 else
9291 {
9292 Elf_Internal_Sym *sym = isymbuf + r_symndx;
9293
9294 s_type = ELF_ST_TYPE (sym->st_info);
9295 ps = &finfo->sections[r_symndx];
9296 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9297 sym, *ps);
9298 }
c152c796 9299
c301e700
DD
9300 if ((s_type == STT_RELC || s_type == STT_SRELC)
9301 && !finfo->info->relocatable)
0f02bbd9
AM
9302 {
9303 bfd_vma val;
9304 bfd_vma dot = (rel->r_offset
9305 + o->output_offset + o->output_section->vma);
9306#ifdef DEBUG
9307 printf ("Encountered a complex symbol!");
9308 printf (" (input_bfd %s, section %s, reloc %ld\n",
9309 input_bfd->filename, o->name, rel - internal_relocs);
9310 printf (" symbol: idx %8.8lx, name %s\n",
9311 r_symndx, sym_name);
9312 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9313 (unsigned long) rel->r_info,
9314 (unsigned long) rel->r_offset);
9315#endif
9316 if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot,
9317 isymbuf, locsymcount, s_type == STT_SRELC))
9318 return FALSE;
9319
9320 /* Symbol evaluated OK. Update to absolute value. */
9321 set_symbol_value (input_bfd, isymbuf, locsymcount,
9322 r_symndx, val);
9323 continue;
9324 }
9325
9326 if (action_discarded != -1 && ps != NULL)
9327 {
cdd3575c
AM
9328 /* Complain if the definition comes from a
9329 discarded section. */
9330 if ((sec = *ps) != NULL && elf_discarded_section (sec))
9331 {
87e5235d 9332 BFD_ASSERT (r_symndx != 0);
0f02bbd9 9333 if (action_discarded & COMPLAIN)
e1fffbe6
AM
9334 (*finfo->info->callbacks->einfo)
9335 (_("%X`%s' referenced in section `%A' of %B: "
58ac56d0 9336 "defined in discarded section `%A' of %B\n"),
e1fffbe6 9337 sym_name, o, input_bfd, sec, sec->owner);
cdd3575c 9338
87e5235d 9339 /* Try to do the best we can to support buggy old
e0ae6d6f 9340 versions of gcc. Pretend that the symbol is
87e5235d
AM
9341 really defined in the kept linkonce section.
9342 FIXME: This is quite broken. Modifying the
9343 symbol here means we will be changing all later
e0ae6d6f 9344 uses of the symbol, not just in this section. */
0f02bbd9 9345 if (action_discarded & PRETEND)
87e5235d 9346 {
01b3c8ab
L
9347 asection *kept;
9348
c0f00686
L
9349 kept = _bfd_elf_check_kept_section (sec,
9350 finfo->info);
01b3c8ab 9351 if (kept != NULL)
87e5235d
AM
9352 {
9353 *ps = kept;
9354 continue;
9355 }
9356 }
c152c796
AM
9357 }
9358 }
9359 }
9360
9361 /* Relocate the section by invoking a back end routine.
9362
9363 The back end routine is responsible for adjusting the
9364 section contents as necessary, and (if using Rela relocs
9365 and generating a relocatable output file) adjusting the
9366 reloc addend as necessary.
9367
9368 The back end routine does not have to worry about setting
9369 the reloc address or the reloc symbol index.
9370
9371 The back end routine is given a pointer to the swapped in
9372 internal symbols, and can access the hash table entries
9373 for the external symbols via elf_sym_hashes (input_bfd).
9374
9375 When generating relocatable output, the back end routine
9376 must handle STB_LOCAL/STT_SECTION symbols specially. The
9377 output symbol is going to be a section symbol
9378 corresponding to the output section, which will require
9379 the addend to be adjusted. */
9380
ece5ef60 9381 ret = (*relocate_section) (output_bfd, finfo->info,
c152c796
AM
9382 input_bfd, o, contents,
9383 internal_relocs,
9384 isymbuf,
ece5ef60
AM
9385 finfo->sections);
9386 if (!ret)
c152c796
AM
9387 return FALSE;
9388
ece5ef60
AM
9389 if (ret == 2
9390 || finfo->info->relocatable
9391 || finfo->info->emitrelocations)
c152c796
AM
9392 {
9393 Elf_Internal_Rela *irela;
9394 Elf_Internal_Rela *irelaend;
9395 bfd_vma last_offset;
9396 struct elf_link_hash_entry **rel_hash;
eac338cf 9397 struct elf_link_hash_entry **rel_hash_list;
c152c796
AM
9398 Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
9399 unsigned int next_erel;
c152c796
AM
9400 bfd_boolean rela_normal;
9401
9402 input_rel_hdr = &elf_section_data (o)->rel_hdr;
9403 rela_normal = (bed->rela_normal
9404 && (input_rel_hdr->sh_entsize
9405 == bed->s->sizeof_rela));
9406
9407 /* Adjust the reloc addresses and symbol indices. */
9408
9409 irela = internal_relocs;
9410 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9411 rel_hash = (elf_section_data (o->output_section)->rel_hashes
9412 + elf_section_data (o->output_section)->rel_count
9413 + elf_section_data (o->output_section)->rel_count2);
eac338cf 9414 rel_hash_list = rel_hash;
c152c796
AM
9415 last_offset = o->output_offset;
9416 if (!finfo->info->relocatable)
9417 last_offset += o->output_section->vma;
9418 for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9419 {
9420 unsigned long r_symndx;
9421 asection *sec;
9422 Elf_Internal_Sym sym;
9423
9424 if (next_erel == bed->s->int_rels_per_ext_rel)
9425 {
9426 rel_hash++;
9427 next_erel = 0;
9428 }
9429
9430 irela->r_offset = _bfd_elf_section_offset (output_bfd,
9431 finfo->info, o,
9432 irela->r_offset);
9433 if (irela->r_offset >= (bfd_vma) -2)
9434 {
9435 /* This is a reloc for a deleted entry or somesuch.
9436 Turn it into an R_*_NONE reloc, at the same
9437 offset as the last reloc. elf_eh_frame.c and
e460dd0d 9438 bfd_elf_discard_info rely on reloc offsets
c152c796
AM
9439 being ordered. */
9440 irela->r_offset = last_offset;
9441 irela->r_info = 0;
9442 irela->r_addend = 0;
9443 continue;
9444 }
9445
9446 irela->r_offset += o->output_offset;
9447
9448 /* Relocs in an executable have to be virtual addresses. */
9449 if (!finfo->info->relocatable)
9450 irela->r_offset += o->output_section->vma;
9451
9452 last_offset = irela->r_offset;
9453
9454 r_symndx = irela->r_info >> r_sym_shift;
9455 if (r_symndx == STN_UNDEF)
9456 continue;
9457
9458 if (r_symndx >= locsymcount
9459 || (elf_bad_symtab (input_bfd)
9460 && finfo->sections[r_symndx] == NULL))
9461 {
9462 struct elf_link_hash_entry *rh;
9463 unsigned long indx;
9464
9465 /* This is a reloc against a global symbol. We
9466 have not yet output all the local symbols, so
9467 we do not know the symbol index of any global
9468 symbol. We set the rel_hash entry for this
9469 reloc to point to the global hash table entry
9470 for this symbol. The symbol index is then
ee75fd95 9471 set at the end of bfd_elf_final_link. */
c152c796
AM
9472 indx = r_symndx - extsymoff;
9473 rh = elf_sym_hashes (input_bfd)[indx];
9474 while (rh->root.type == bfd_link_hash_indirect
9475 || rh->root.type == bfd_link_hash_warning)
9476 rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
9477
9478 /* Setting the index to -2 tells
9479 elf_link_output_extsym that this symbol is
9480 used by a reloc. */
9481 BFD_ASSERT (rh->indx < 0);
9482 rh->indx = -2;
9483
9484 *rel_hash = rh;
9485
9486 continue;
9487 }
9488
9489 /* This is a reloc against a local symbol. */
9490
9491 *rel_hash = NULL;
9492 sym = isymbuf[r_symndx];
9493 sec = finfo->sections[r_symndx];
9494 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
9495 {
9496 /* I suppose the backend ought to fill in the
9497 section of any STT_SECTION symbol against a
6a8d1586
AM
9498 processor specific section. */
9499 r_symndx = 0;
9500 if (bfd_is_abs_section (sec))
9501 ;
c152c796
AM
9502 else if (sec == NULL || sec->owner == NULL)
9503 {
9504 bfd_set_error (bfd_error_bad_value);
9505 return FALSE;
9506 }
9507 else
9508 {
6a8d1586
AM
9509 asection *osec = sec->output_section;
9510
9511 /* If we have discarded a section, the output
9512 section will be the absolute section. In
ab96bf03
AM
9513 case of discarded SEC_MERGE sections, use
9514 the kept section. relocate_section should
9515 have already handled discarded linkonce
9516 sections. */
6a8d1586
AM
9517 if (bfd_is_abs_section (osec)
9518 && sec->kept_section != NULL
9519 && sec->kept_section->output_section != NULL)
9520 {
9521 osec = sec->kept_section->output_section;
9522 irela->r_addend -= osec->vma;
9523 }
9524
9525 if (!bfd_is_abs_section (osec))
9526 {
9527 r_symndx = osec->target_index;
74541ad4
AM
9528 if (r_symndx == 0)
9529 {
9530 struct elf_link_hash_table *htab;
9531 asection *oi;
9532
9533 htab = elf_hash_table (finfo->info);
9534 oi = htab->text_index_section;
9535 if ((osec->flags & SEC_READONLY) == 0
9536 && htab->data_index_section != NULL)
9537 oi = htab->data_index_section;
9538
9539 if (oi != NULL)
9540 {
9541 irela->r_addend += osec->vma - oi->vma;
9542 r_symndx = oi->target_index;
9543 }
9544 }
9545
6a8d1586
AM
9546 BFD_ASSERT (r_symndx != 0);
9547 }
c152c796
AM
9548 }
9549
9550 /* Adjust the addend according to where the
9551 section winds up in the output section. */
9552 if (rela_normal)
9553 irela->r_addend += sec->output_offset;
9554 }
9555 else
9556 {
9557 if (finfo->indices[r_symndx] == -1)
9558 {
9559 unsigned long shlink;
9560 const char *name;
9561 asection *osec;
6e0b88f1 9562 long indx;
c152c796
AM
9563
9564 if (finfo->info->strip == strip_all)
9565 {
9566 /* You can't do ld -r -s. */
9567 bfd_set_error (bfd_error_invalid_operation);
9568 return FALSE;
9569 }
9570
9571 /* This symbol was skipped earlier, but
9572 since it is needed by a reloc, we
9573 must output it now. */
9574 shlink = symtab_hdr->sh_link;
9575 name = (bfd_elf_string_from_elf_section
9576 (input_bfd, shlink, sym.st_name));
9577 if (name == NULL)
9578 return FALSE;
9579
9580 osec = sec->output_section;
9581 sym.st_shndx =
9582 _bfd_elf_section_from_bfd_section (output_bfd,
9583 osec);
9584 if (sym.st_shndx == SHN_BAD)
9585 return FALSE;
9586
9587 sym.st_value += sec->output_offset;
9588 if (! finfo->info->relocatable)
9589 {
9590 sym.st_value += osec->vma;
9591 if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
9592 {
9593 /* STT_TLS symbols are relative to PT_TLS
9594 segment base. */
9595 BFD_ASSERT (elf_hash_table (finfo->info)
9596 ->tls_sec != NULL);
9597 sym.st_value -= (elf_hash_table (finfo->info)
9598 ->tls_sec->vma);
9599 }
9600 }
9601
6e0b88f1
AM
9602 indx = bfd_get_symcount (output_bfd);
9603 ret = elf_link_output_sym (finfo, name, &sym, sec,
9604 NULL);
9605 if (ret == 0)
c152c796 9606 return FALSE;
6e0b88f1
AM
9607 else if (ret == 1)
9608 finfo->indices[r_symndx] = indx;
9609 else
9610 abort ();
c152c796
AM
9611 }
9612
9613 r_symndx = finfo->indices[r_symndx];
9614 }
9615
9616 irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
9617 | (irela->r_info & r_type_mask));
9618 }
9619
9620 /* Swap out the relocs. */
c152c796 9621 if (input_rel_hdr->sh_size != 0
eac338cf
PB
9622 && !bed->elf_backend_emit_relocs (output_bfd, o,
9623 input_rel_hdr,
9624 internal_relocs,
9625 rel_hash_list))
c152c796
AM
9626 return FALSE;
9627
9628 input_rel_hdr2 = elf_section_data (o)->rel_hdr2;
9629 if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0)
9630 {
9631 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
9632 * bed->s->int_rels_per_ext_rel);
eac338cf
PB
9633 rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
9634 if (!bed->elf_backend_emit_relocs (output_bfd, o,
9635 input_rel_hdr2,
9636 internal_relocs,
9637 rel_hash_list))
c152c796
AM
9638 return FALSE;
9639 }
9640 }
9641 }
9642
9643 /* Write out the modified section contents. */
9644 if (bed->elf_backend_write_section
c7b8f16e
JB
9645 && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
9646 contents))
c152c796
AM
9647 {
9648 /* Section written out. */
9649 }
9650 else switch (o->sec_info_type)
9651 {
9652 case ELF_INFO_TYPE_STABS:
9653 if (! (_bfd_write_section_stabs
9654 (output_bfd,
9655 &elf_hash_table (finfo->info)->stab_info,
9656 o, &elf_section_data (o)->sec_info, contents)))
9657 return FALSE;
9658 break;
9659 case ELF_INFO_TYPE_MERGE:
9660 if (! _bfd_write_merged_section (output_bfd, o,
9661 elf_section_data (o)->sec_info))
9662 return FALSE;
9663 break;
9664 case ELF_INFO_TYPE_EH_FRAME:
9665 {
9666 if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
9667 o, contents))
9668 return FALSE;
9669 }
9670 break;
9671 default:
9672 {
c152c796 9673 if (! (o->flags & SEC_EXCLUDE)
ace79388 9674 && ! (o->output_section->flags & SEC_NEVER_LOAD)
c152c796
AM
9675 && ! bfd_set_section_contents (output_bfd, o->output_section,
9676 contents,
9677 (file_ptr) o->output_offset,
eea6121a 9678 o->size))
c152c796
AM
9679 return FALSE;
9680 }
9681 break;
9682 }
9683 }
9684
9685 return TRUE;
9686}
9687
9688/* Generate a reloc when linking an ELF file. This is a reloc
3a800eb9 9689 requested by the linker, and does not come from any input file. This
c152c796
AM
9690 is used to build constructor and destructor tables when linking
9691 with -Ur. */
9692
9693static bfd_boolean
9694elf_reloc_link_order (bfd *output_bfd,
9695 struct bfd_link_info *info,
9696 asection *output_section,
9697 struct bfd_link_order *link_order)
9698{
9699 reloc_howto_type *howto;
9700 long indx;
9701 bfd_vma offset;
9702 bfd_vma addend;
9703 struct elf_link_hash_entry **rel_hash_ptr;
9704 Elf_Internal_Shdr *rel_hdr;
9705 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9706 Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
9707 bfd_byte *erel;
9708 unsigned int i;
9709
9710 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
9711 if (howto == NULL)
9712 {
9713 bfd_set_error (bfd_error_bad_value);
9714 return FALSE;
9715 }
9716
9717 addend = link_order->u.reloc.p->addend;
9718
9719 /* Figure out the symbol index. */
9720 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
9721 + elf_section_data (output_section)->rel_count
9722 + elf_section_data (output_section)->rel_count2);
9723 if (link_order->type == bfd_section_reloc_link_order)
9724 {
9725 indx = link_order->u.reloc.p->u.section->target_index;
9726 BFD_ASSERT (indx != 0);
9727 *rel_hash_ptr = NULL;
9728 }
9729 else
9730 {
9731 struct elf_link_hash_entry *h;
9732
9733 /* Treat a reloc against a defined symbol as though it were
9734 actually against the section. */
9735 h = ((struct elf_link_hash_entry *)
9736 bfd_wrapped_link_hash_lookup (output_bfd, info,
9737 link_order->u.reloc.p->u.name,
9738 FALSE, FALSE, TRUE));
9739 if (h != NULL
9740 && (h->root.type == bfd_link_hash_defined
9741 || h->root.type == bfd_link_hash_defweak))
9742 {
9743 asection *section;
9744
9745 section = h->root.u.def.section;
9746 indx = section->output_section->target_index;
9747 *rel_hash_ptr = NULL;
9748 /* It seems that we ought to add the symbol value to the
9749 addend here, but in practice it has already been added
9750 because it was passed to constructor_callback. */
9751 addend += section->output_section->vma + section->output_offset;
9752 }
9753 else if (h != NULL)
9754 {
9755 /* Setting the index to -2 tells elf_link_output_extsym that
9756 this symbol is used by a reloc. */
9757 h->indx = -2;
9758 *rel_hash_ptr = h;
9759 indx = 0;
9760 }
9761 else
9762 {
9763 if (! ((*info->callbacks->unattached_reloc)
9764 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
9765 return FALSE;
9766 indx = 0;
9767 }
9768 }
9769
9770 /* If this is an inplace reloc, we must write the addend into the
9771 object file. */
9772 if (howto->partial_inplace && addend != 0)
9773 {
9774 bfd_size_type size;
9775 bfd_reloc_status_type rstat;
9776 bfd_byte *buf;
9777 bfd_boolean ok;
9778 const char *sym_name;
9779
9780 size = bfd_get_reloc_size (howto);
9781 buf = bfd_zmalloc (size);
9782 if (buf == NULL)
9783 return FALSE;
9784 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
9785 switch (rstat)
9786 {
9787 case bfd_reloc_ok:
9788 break;
9789
9790 default:
9791 case bfd_reloc_outofrange:
9792 abort ();
9793
9794 case bfd_reloc_overflow:
9795 if (link_order->type == bfd_section_reloc_link_order)
9796 sym_name = bfd_section_name (output_bfd,
9797 link_order->u.reloc.p->u.section);
9798 else
9799 sym_name = link_order->u.reloc.p->u.name;
9800 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L
9801 (info, NULL, sym_name, howto->name, addend, NULL,
9802 NULL, (bfd_vma) 0)))
c152c796
AM
9803 {
9804 free (buf);
9805 return FALSE;
9806 }
9807 break;
9808 }
9809 ok = bfd_set_section_contents (output_bfd, output_section, buf,
9810 link_order->offset, size);
9811 free (buf);
9812 if (! ok)
9813 return FALSE;
9814 }
9815
9816 /* The address of a reloc is relative to the section in a
9817 relocatable file, and is a virtual address in an executable
9818 file. */
9819 offset = link_order->offset;
9820 if (! info->relocatable)
9821 offset += output_section->vma;
9822
9823 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
9824 {
9825 irel[i].r_offset = offset;
9826 irel[i].r_info = 0;
9827 irel[i].r_addend = 0;
9828 }
9829 if (bed->s->arch_size == 32)
9830 irel[0].r_info = ELF32_R_INFO (indx, howto->type);
9831 else
9832 irel[0].r_info = ELF64_R_INFO (indx, howto->type);
9833
9834 rel_hdr = &elf_section_data (output_section)->rel_hdr;
9835 erel = rel_hdr->contents;
9836 if (rel_hdr->sh_type == SHT_REL)
9837 {
9838 erel += (elf_section_data (output_section)->rel_count
9839 * bed->s->sizeof_rel);
9840 (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
9841 }
9842 else
9843 {
9844 irel[0].r_addend = addend;
9845 erel += (elf_section_data (output_section)->rel_count
9846 * bed->s->sizeof_rela);
9847 (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
9848 }
9849
9850 ++elf_section_data (output_section)->rel_count;
9851
9852 return TRUE;
9853}
9854
0b52efa6
PB
9855
9856/* Get the output vma of the section pointed to by the sh_link field. */
9857
9858static bfd_vma
9859elf_get_linked_section_vma (struct bfd_link_order *p)
9860{
9861 Elf_Internal_Shdr **elf_shdrp;
9862 asection *s;
9863 int elfsec;
9864
9865 s = p->u.indirect.section;
9866 elf_shdrp = elf_elfsections (s->owner);
9867 elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
9868 elfsec = elf_shdrp[elfsec]->sh_link;
185d09ad
L
9869 /* PR 290:
9870 The Intel C compiler generates SHT_IA_64_UNWIND with
e04bcc6d 9871 SHF_LINK_ORDER. But it doesn't set the sh_link or
185d09ad
L
9872 sh_info fields. Hence we could get the situation
9873 where elfsec is 0. */
9874 if (elfsec == 0)
9875 {
9876 const struct elf_backend_data *bed
9877 = get_elf_backend_data (s->owner);
9878 if (bed->link_order_error_handler)
d003868e
AM
9879 bed->link_order_error_handler
9880 (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
185d09ad
L
9881 return 0;
9882 }
9883 else
9884 {
9885 s = elf_shdrp[elfsec]->bfd_section;
9886 return s->output_section->vma + s->output_offset;
9887 }
0b52efa6
PB
9888}
9889
9890
9891/* Compare two sections based on the locations of the sections they are
9892 linked to. Used by elf_fixup_link_order. */
9893
9894static int
9895compare_link_order (const void * a, const void * b)
9896{
9897 bfd_vma apos;
9898 bfd_vma bpos;
9899
9900 apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
9901 bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
9902 if (apos < bpos)
9903 return -1;
9904 return apos > bpos;
9905}
9906
9907
9908/* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
9909 order as their linked sections. Returns false if this could not be done
9910 because an output section includes both ordered and unordered
9911 sections. Ideally we'd do this in the linker proper. */
9912
9913static bfd_boolean
9914elf_fixup_link_order (bfd *abfd, asection *o)
9915{
9916 int seen_linkorder;
9917 int seen_other;
9918 int n;
9919 struct bfd_link_order *p;
9920 bfd *sub;
9921 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
b761a207 9922 unsigned elfsec;
0b52efa6 9923 struct bfd_link_order **sections;
d33cdfe3 9924 asection *s, *other_sec, *linkorder_sec;
0b52efa6 9925 bfd_vma offset;
3b36f7e6 9926
d33cdfe3
L
9927 other_sec = NULL;
9928 linkorder_sec = NULL;
0b52efa6
PB
9929 seen_other = 0;
9930 seen_linkorder = 0;
8423293d 9931 for (p = o->map_head.link_order; p != NULL; p = p->next)
0b52efa6 9932 {
d33cdfe3 9933 if (p->type == bfd_indirect_link_order)
0b52efa6
PB
9934 {
9935 s = p->u.indirect.section;
d33cdfe3
L
9936 sub = s->owner;
9937 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
9938 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
b761a207
BE
9939 && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
9940 && elfsec < elf_numsections (sub)
4fbb74a6
AM
9941 && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
9942 && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
d33cdfe3
L
9943 {
9944 seen_linkorder++;
9945 linkorder_sec = s;
9946 }
0b52efa6 9947 else
d33cdfe3
L
9948 {
9949 seen_other++;
9950 other_sec = s;
9951 }
0b52efa6
PB
9952 }
9953 else
9954 seen_other++;
d33cdfe3
L
9955
9956 if (seen_other && seen_linkorder)
9957 {
9958 if (other_sec && linkorder_sec)
9959 (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
9960 o, linkorder_sec,
9961 linkorder_sec->owner, other_sec,
9962 other_sec->owner);
9963 else
9964 (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
9965 o);
9966 bfd_set_error (bfd_error_bad_value);
9967 return FALSE;
9968 }
0b52efa6
PB
9969 }
9970
9971 if (!seen_linkorder)
9972 return TRUE;
9973
0b52efa6 9974 sections = (struct bfd_link_order **)
14b1c01e
AM
9975 bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
9976 if (sections == NULL)
9977 return FALSE;
0b52efa6 9978 seen_linkorder = 0;
3b36f7e6 9979
8423293d 9980 for (p = o->map_head.link_order; p != NULL; p = p->next)
0b52efa6
PB
9981 {
9982 sections[seen_linkorder++] = p;
9983 }
9984 /* Sort the input sections in the order of their linked section. */
9985 qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
9986 compare_link_order);
9987
9988 /* Change the offsets of the sections. */
9989 offset = 0;
9990 for (n = 0; n < seen_linkorder; n++)
9991 {
9992 s = sections[n]->u.indirect.section;
461686a3 9993 offset &= ~(bfd_vma) 0 << s->alignment_power;
0b52efa6
PB
9994 s->output_offset = offset;
9995 sections[n]->offset = offset;
9996 offset += sections[n]->size;
9997 }
9998
4dd07732 9999 free (sections);
0b52efa6
PB
10000 return TRUE;
10001}
10002
10003
c152c796
AM
10004/* Do the final step of an ELF link. */
10005
10006bfd_boolean
10007bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10008{
10009 bfd_boolean dynamic;
10010 bfd_boolean emit_relocs;
10011 bfd *dynobj;
10012 struct elf_final_link_info finfo;
10013 register asection *o;
10014 register struct bfd_link_order *p;
10015 register bfd *sub;
10016 bfd_size_type max_contents_size;
10017 bfd_size_type max_external_reloc_size;
10018 bfd_size_type max_internal_reloc_count;
10019 bfd_size_type max_sym_count;
10020 bfd_size_type max_sym_shndx_count;
10021 file_ptr off;
10022 Elf_Internal_Sym elfsym;
10023 unsigned int i;
10024 Elf_Internal_Shdr *symtab_hdr;
10025 Elf_Internal_Shdr *symtab_shndx_hdr;
10026 Elf_Internal_Shdr *symstrtab_hdr;
10027 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10028 struct elf_outext_info eoinfo;
10029 bfd_boolean merged;
10030 size_t relativecount = 0;
10031 asection *reldyn = 0;
10032 bfd_size_type amt;
104d59d1
JM
10033 asection *attr_section = NULL;
10034 bfd_vma attr_size = 0;
10035 const char *std_attrs_section;
c152c796
AM
10036
10037 if (! is_elf_hash_table (info->hash))
10038 return FALSE;
10039
10040 if (info->shared)
10041 abfd->flags |= DYNAMIC;
10042
10043 dynamic = elf_hash_table (info)->dynamic_sections_created;
10044 dynobj = elf_hash_table (info)->dynobj;
10045
10046 emit_relocs = (info->relocatable
a4676736 10047 || info->emitrelocations);
c152c796
AM
10048
10049 finfo.info = info;
10050 finfo.output_bfd = abfd;
10051 finfo.symstrtab = _bfd_elf_stringtab_init ();
10052 if (finfo.symstrtab == NULL)
10053 return FALSE;
10054
10055 if (! dynamic)
10056 {
10057 finfo.dynsym_sec = NULL;
10058 finfo.hash_sec = NULL;
10059 finfo.symver_sec = NULL;
10060 }
10061 else
10062 {
10063 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
10064 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
fdc90cb4 10065 BFD_ASSERT (finfo.dynsym_sec != NULL);
c152c796
AM
10066 finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
10067 /* Note that it is OK if symver_sec is NULL. */
10068 }
10069
10070 finfo.contents = NULL;
10071 finfo.external_relocs = NULL;
10072 finfo.internal_relocs = NULL;
10073 finfo.external_syms = NULL;
10074 finfo.locsym_shndx = NULL;
10075 finfo.internal_syms = NULL;
10076 finfo.indices = NULL;
10077 finfo.sections = NULL;
10078 finfo.symbuf = NULL;
10079 finfo.symshndxbuf = NULL;
10080 finfo.symbuf_count = 0;
10081 finfo.shndxbuf_size = 0;
10082
104d59d1
JM
10083 /* The object attributes have been merged. Remove the input
10084 sections from the link, and set the contents of the output
10085 secton. */
10086 std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10087 for (o = abfd->sections; o != NULL; o = o->next)
10088 {
10089 if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10090 || strcmp (o->name, ".gnu.attributes") == 0)
10091 {
10092 for (p = o->map_head.link_order; p != NULL; p = p->next)
10093 {
10094 asection *input_section;
10095
10096 if (p->type != bfd_indirect_link_order)
10097 continue;
10098 input_section = p->u.indirect.section;
10099 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10100 elf_link_input_bfd ignores this section. */
10101 input_section->flags &= ~SEC_HAS_CONTENTS;
10102 }
a0c8462f 10103
104d59d1
JM
10104 attr_size = bfd_elf_obj_attr_size (abfd);
10105 if (attr_size)
10106 {
10107 bfd_set_section_size (abfd, o, attr_size);
10108 attr_section = o;
10109 /* Skip this section later on. */
10110 o->map_head.link_order = NULL;
10111 }
10112 else
10113 o->flags |= SEC_EXCLUDE;
10114 }
10115 }
10116
c152c796
AM
10117 /* Count up the number of relocations we will output for each output
10118 section, so that we know the sizes of the reloc sections. We
10119 also figure out some maximum sizes. */
10120 max_contents_size = 0;
10121 max_external_reloc_size = 0;
10122 max_internal_reloc_count = 0;
10123 max_sym_count = 0;
10124 max_sym_shndx_count = 0;
10125 merged = FALSE;
10126 for (o = abfd->sections; o != NULL; o = o->next)
10127 {
10128 struct bfd_elf_section_data *esdo = elf_section_data (o);
10129 o->reloc_count = 0;
10130
8423293d 10131 for (p = o->map_head.link_order; p != NULL; p = p->next)
c152c796
AM
10132 {
10133 unsigned int reloc_count = 0;
10134 struct bfd_elf_section_data *esdi = NULL;
10135 unsigned int *rel_count1;
10136
10137 if (p->type == bfd_section_reloc_link_order
10138 || p->type == bfd_symbol_reloc_link_order)
10139 reloc_count = 1;
10140 else if (p->type == bfd_indirect_link_order)
10141 {
10142 asection *sec;
10143
10144 sec = p->u.indirect.section;
10145 esdi = elf_section_data (sec);
10146
10147 /* Mark all sections which are to be included in the
10148 link. This will normally be every section. We need
10149 to do this so that we can identify any sections which
10150 the linker has decided to not include. */
10151 sec->linker_mark = TRUE;
10152
10153 if (sec->flags & SEC_MERGE)
10154 merged = TRUE;
10155
10156 if (info->relocatable || info->emitrelocations)
10157 reloc_count = sec->reloc_count;
10158 else if (bed->elf_backend_count_relocs)
58217f29 10159 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
c152c796 10160
eea6121a
AM
10161 if (sec->rawsize > max_contents_size)
10162 max_contents_size = sec->rawsize;
10163 if (sec->size > max_contents_size)
10164 max_contents_size = sec->size;
c152c796
AM
10165
10166 /* We are interested in just local symbols, not all
10167 symbols. */
10168 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10169 && (sec->owner->flags & DYNAMIC) == 0)
10170 {
10171 size_t sym_count;
10172
10173 if (elf_bad_symtab (sec->owner))
10174 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10175 / bed->s->sizeof_sym);
10176 else
10177 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10178
10179 if (sym_count > max_sym_count)
10180 max_sym_count = sym_count;
10181
10182 if (sym_count > max_sym_shndx_count
10183 && elf_symtab_shndx (sec->owner) != 0)
10184 max_sym_shndx_count = sym_count;
10185
10186 if ((sec->flags & SEC_RELOC) != 0)
10187 {
10188 size_t ext_size;
10189
10190 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
10191 if (ext_size > max_external_reloc_size)
10192 max_external_reloc_size = ext_size;
10193 if (sec->reloc_count > max_internal_reloc_count)
10194 max_internal_reloc_count = sec->reloc_count;
10195 }
10196 }
10197 }
10198
10199 if (reloc_count == 0)
10200 continue;
10201
10202 o->reloc_count += reloc_count;
10203
10204 /* MIPS may have a mix of REL and RELA relocs on sections.
10205 To support this curious ABI we keep reloc counts in
10206 elf_section_data too. We must be careful to add the
10207 relocations from the input section to the right output
10208 count. FIXME: Get rid of one count. We have
10209 o->reloc_count == esdo->rel_count + esdo->rel_count2. */
10210 rel_count1 = &esdo->rel_count;
10211 if (esdi != NULL)
10212 {
10213 bfd_boolean same_size;
10214 bfd_size_type entsize1;
10215
10216 entsize1 = esdi->rel_hdr.sh_entsize;
2c2b4ed4
NC
10217 /* PR 9827: If the header size has not been set yet then
10218 assume that it will match the output section's reloc type. */
10219 if (entsize1 == 0)
10220 entsize1 = o->use_rela_p ? bed->s->sizeof_rela : bed->s->sizeof_rel;
10221 else
10222 BFD_ASSERT (entsize1 == bed->s->sizeof_rel
10223 || entsize1 == bed->s->sizeof_rela);
c152c796
AM
10224 same_size = !o->use_rela_p == (entsize1 == bed->s->sizeof_rel);
10225
10226 if (!same_size)
10227 rel_count1 = &esdo->rel_count2;
10228
10229 if (esdi->rel_hdr2 != NULL)
10230 {
10231 bfd_size_type entsize2 = esdi->rel_hdr2->sh_entsize;
10232 unsigned int alt_count;
10233 unsigned int *rel_count2;
10234
10235 BFD_ASSERT (entsize2 != entsize1
10236 && (entsize2 == bed->s->sizeof_rel
10237 || entsize2 == bed->s->sizeof_rela));
10238
10239 rel_count2 = &esdo->rel_count2;
10240 if (!same_size)
10241 rel_count2 = &esdo->rel_count;
10242
10243 /* The following is probably too simplistic if the
10244 backend counts output relocs unusually. */
10245 BFD_ASSERT (bed->elf_backend_count_relocs == NULL);
10246 alt_count = NUM_SHDR_ENTRIES (esdi->rel_hdr2);
10247 *rel_count2 += alt_count;
10248 reloc_count -= alt_count;
10249 }
10250 }
10251 *rel_count1 += reloc_count;
10252 }
10253
10254 if (o->reloc_count > 0)
10255 o->flags |= SEC_RELOC;
10256 else
10257 {
10258 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10259 set it (this is probably a bug) and if it is set
10260 assign_section_numbers will create a reloc section. */
10261 o->flags &=~ SEC_RELOC;
10262 }
10263
10264 /* If the SEC_ALLOC flag is not set, force the section VMA to
10265 zero. This is done in elf_fake_sections as well, but forcing
10266 the VMA to 0 here will ensure that relocs against these
10267 sections are handled correctly. */
10268 if ((o->flags & SEC_ALLOC) == 0
10269 && ! o->user_set_vma)
10270 o->vma = 0;
10271 }
10272
10273 if (! info->relocatable && merged)
10274 elf_link_hash_traverse (elf_hash_table (info),
10275 _bfd_elf_link_sec_merge_syms, abfd);
10276
10277 /* Figure out the file positions for everything but the symbol table
10278 and the relocs. We set symcount to force assign_section_numbers
10279 to create a symbol table. */
10280 bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
10281 BFD_ASSERT (! abfd->output_has_begun);
10282 if (! _bfd_elf_compute_section_file_positions (abfd, info))
10283 goto error_return;
10284
ee75fd95 10285 /* Set sizes, and assign file positions for reloc sections. */
c152c796
AM
10286 for (o = abfd->sections; o != NULL; o = o->next)
10287 {
10288 if ((o->flags & SEC_RELOC) != 0)
10289 {
10290 if (!(_bfd_elf_link_size_reloc_section
10291 (abfd, &elf_section_data (o)->rel_hdr, o)))
10292 goto error_return;
10293
10294 if (elf_section_data (o)->rel_hdr2
10295 && !(_bfd_elf_link_size_reloc_section
10296 (abfd, elf_section_data (o)->rel_hdr2, o)))
10297 goto error_return;
10298 }
10299
10300 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10301 to count upwards while actually outputting the relocations. */
10302 elf_section_data (o)->rel_count = 0;
10303 elf_section_data (o)->rel_count2 = 0;
10304 }
10305
10306 _bfd_elf_assign_file_positions_for_relocs (abfd);
10307
10308 /* We have now assigned file positions for all the sections except
10309 .symtab and .strtab. We start the .symtab section at the current
10310 file position, and write directly to it. We build the .strtab
10311 section in memory. */
10312 bfd_get_symcount (abfd) = 0;
10313 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10314 /* sh_name is set in prep_headers. */
10315 symtab_hdr->sh_type = SHT_SYMTAB;
10316 /* sh_flags, sh_addr and sh_size all start off zero. */
10317 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10318 /* sh_link is set in assign_section_numbers. */
10319 /* sh_info is set below. */
10320 /* sh_offset is set just below. */
72de5009 10321 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
c152c796
AM
10322
10323 off = elf_tdata (abfd)->next_file_pos;
10324 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10325
10326 /* Note that at this point elf_tdata (abfd)->next_file_pos is
10327 incorrect. We do not yet know the size of the .symtab section.
10328 We correct next_file_pos below, after we do know the size. */
10329
10330 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10331 continuously seeking to the right position in the file. */
10332 if (! info->keep_memory || max_sym_count < 20)
10333 finfo.symbuf_size = 20;
10334 else
10335 finfo.symbuf_size = max_sym_count;
10336 amt = finfo.symbuf_size;
10337 amt *= bed->s->sizeof_sym;
10338 finfo.symbuf = bfd_malloc (amt);
10339 if (finfo.symbuf == NULL)
10340 goto error_return;
4fbb74a6 10341 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
c152c796
AM
10342 {
10343 /* Wild guess at number of output symbols. realloc'd as needed. */
10344 amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10345 finfo.shndxbuf_size = amt;
10346 amt *= sizeof (Elf_External_Sym_Shndx);
10347 finfo.symshndxbuf = bfd_zmalloc (amt);
10348 if (finfo.symshndxbuf == NULL)
10349 goto error_return;
10350 }
10351
10352 /* Start writing out the symbol table. The first symbol is always a
10353 dummy symbol. */
10354 if (info->strip != strip_all
10355 || emit_relocs)
10356 {
10357 elfsym.st_value = 0;
10358 elfsym.st_size = 0;
10359 elfsym.st_info = 0;
10360 elfsym.st_other = 0;
10361 elfsym.st_shndx = SHN_UNDEF;
6e0b88f1
AM
10362 if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr,
10363 NULL) != 1)
c152c796
AM
10364 goto error_return;
10365 }
10366
c152c796
AM
10367 /* Output a symbol for each section. We output these even if we are
10368 discarding local symbols, since they are used for relocs. These
10369 symbols have no names. We store the index of each one in the
10370 index field of the section, so that we can find it again when
10371 outputting relocs. */
10372 if (info->strip != strip_all
10373 || emit_relocs)
10374 {
10375 elfsym.st_size = 0;
10376 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10377 elfsym.st_other = 0;
f0b5bb34 10378 elfsym.st_value = 0;
c152c796
AM
10379 for (i = 1; i < elf_numsections (abfd); i++)
10380 {
10381 o = bfd_section_from_elf_index (abfd, i);
10382 if (o != NULL)
f0b5bb34
AM
10383 {
10384 o->target_index = bfd_get_symcount (abfd);
10385 elfsym.st_shndx = i;
10386 if (!info->relocatable)
10387 elfsym.st_value = o->vma;
6e0b88f1 10388 if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1)
f0b5bb34
AM
10389 goto error_return;
10390 }
c152c796
AM
10391 }
10392 }
10393
10394 /* Allocate some memory to hold information read in from the input
10395 files. */
10396 if (max_contents_size != 0)
10397 {
10398 finfo.contents = bfd_malloc (max_contents_size);
10399 if (finfo.contents == NULL)
10400 goto error_return;
10401 }
10402
10403 if (max_external_reloc_size != 0)
10404 {
10405 finfo.external_relocs = bfd_malloc (max_external_reloc_size);
10406 if (finfo.external_relocs == NULL)
10407 goto error_return;
10408 }
10409
10410 if (max_internal_reloc_count != 0)
10411 {
10412 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10413 amt *= sizeof (Elf_Internal_Rela);
10414 finfo.internal_relocs = bfd_malloc (amt);
10415 if (finfo.internal_relocs == NULL)
10416 goto error_return;
10417 }
10418
10419 if (max_sym_count != 0)
10420 {
10421 amt = max_sym_count * bed->s->sizeof_sym;
10422 finfo.external_syms = bfd_malloc (amt);
10423 if (finfo.external_syms == NULL)
10424 goto error_return;
10425
10426 amt = max_sym_count * sizeof (Elf_Internal_Sym);
10427 finfo.internal_syms = bfd_malloc (amt);
10428 if (finfo.internal_syms == NULL)
10429 goto error_return;
10430
10431 amt = max_sym_count * sizeof (long);
10432 finfo.indices = bfd_malloc (amt);
10433 if (finfo.indices == NULL)
10434 goto error_return;
10435
10436 amt = max_sym_count * sizeof (asection *);
10437 finfo.sections = bfd_malloc (amt);
10438 if (finfo.sections == NULL)
10439 goto error_return;
10440 }
10441
10442 if (max_sym_shndx_count != 0)
10443 {
10444 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
10445 finfo.locsym_shndx = bfd_malloc (amt);
10446 if (finfo.locsym_shndx == NULL)
10447 goto error_return;
10448 }
10449
10450 if (elf_hash_table (info)->tls_sec)
10451 {
10452 bfd_vma base, end = 0;
10453 asection *sec;
10454
10455 for (sec = elf_hash_table (info)->tls_sec;
10456 sec && (sec->flags & SEC_THREAD_LOCAL);
10457 sec = sec->next)
10458 {
3a800eb9 10459 bfd_size_type size = sec->size;
c152c796 10460
3a800eb9
AM
10461 if (size == 0
10462 && (sec->flags & SEC_HAS_CONTENTS) == 0)
c152c796 10463 {
3a800eb9
AM
10464 struct bfd_link_order *o = sec->map_tail.link_order;
10465 if (o != NULL)
10466 size = o->offset + o->size;
c152c796
AM
10467 }
10468 end = sec->vma + size;
10469 }
10470 base = elf_hash_table (info)->tls_sec->vma;
10471 end = align_power (end, elf_hash_table (info)->tls_sec->alignment_power);
10472 elf_hash_table (info)->tls_size = end - base;
10473 }
10474
0b52efa6
PB
10475 /* Reorder SHF_LINK_ORDER sections. */
10476 for (o = abfd->sections; o != NULL; o = o->next)
10477 {
10478 if (!elf_fixup_link_order (abfd, o))
10479 return FALSE;
10480 }
10481
c152c796
AM
10482 /* Since ELF permits relocations to be against local symbols, we
10483 must have the local symbols available when we do the relocations.
10484 Since we would rather only read the local symbols once, and we
10485 would rather not keep them in memory, we handle all the
10486 relocations for a single input file at the same time.
10487
10488 Unfortunately, there is no way to know the total number of local
10489 symbols until we have seen all of them, and the local symbol
10490 indices precede the global symbol indices. This means that when
10491 we are generating relocatable output, and we see a reloc against
10492 a global symbol, we can not know the symbol index until we have
10493 finished examining all the local symbols to see which ones we are
10494 going to output. To deal with this, we keep the relocations in
10495 memory, and don't output them until the end of the link. This is
10496 an unfortunate waste of memory, but I don't see a good way around
10497 it. Fortunately, it only happens when performing a relocatable
10498 link, which is not the common case. FIXME: If keep_memory is set
10499 we could write the relocs out and then read them again; I don't
10500 know how bad the memory loss will be. */
10501
10502 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10503 sub->output_has_begun = FALSE;
10504 for (o = abfd->sections; o != NULL; o = o->next)
10505 {
8423293d 10506 for (p = o->map_head.link_order; p != NULL; p = p->next)
c152c796
AM
10507 {
10508 if (p->type == bfd_indirect_link_order
10509 && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
10510 == bfd_target_elf_flavour)
10511 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
10512 {
10513 if (! sub->output_has_begun)
10514 {
10515 if (! elf_link_input_bfd (&finfo, sub))
10516 goto error_return;
10517 sub->output_has_begun = TRUE;
10518 }
10519 }
10520 else if (p->type == bfd_section_reloc_link_order
10521 || p->type == bfd_symbol_reloc_link_order)
10522 {
10523 if (! elf_reloc_link_order (abfd, info, o, p))
10524 goto error_return;
10525 }
10526 else
10527 {
10528 if (! _bfd_default_link_order (abfd, info, o, p))
10529 goto error_return;
10530 }
10531 }
10532 }
10533
c0f00686
L
10534 /* Free symbol buffer if needed. */
10535 if (!info->reduce_memory_overheads)
10536 {
10537 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3fcd97f1
JJ
10538 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10539 && elf_tdata (sub)->symbuf)
c0f00686
L
10540 {
10541 free (elf_tdata (sub)->symbuf);
10542 elf_tdata (sub)->symbuf = NULL;
10543 }
10544 }
10545
c152c796
AM
10546 /* Output any global symbols that got converted to local in a
10547 version script or due to symbol visibility. We do this in a
10548 separate step since ELF requires all local symbols to appear
10549 prior to any global symbols. FIXME: We should only do this if
10550 some global symbols were, in fact, converted to become local.
10551 FIXME: Will this work correctly with the Irix 5 linker? */
10552 eoinfo.failed = FALSE;
10553 eoinfo.finfo = &finfo;
10554 eoinfo.localsyms = TRUE;
10555 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
10556 &eoinfo);
10557 if (eoinfo.failed)
10558 return FALSE;
10559
4e617b1e
PB
10560 /* If backend needs to output some local symbols not present in the hash
10561 table, do it now. */
10562 if (bed->elf_backend_output_arch_local_syms)
10563 {
6e0b88f1 10564 typedef int (*out_sym_func)
4e617b1e
PB
10565 (void *, const char *, Elf_Internal_Sym *, asection *,
10566 struct elf_link_hash_entry *);
10567
10568 if (! ((*bed->elf_backend_output_arch_local_syms)
10569 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10570 return FALSE;
10571 }
10572
c152c796
AM
10573 /* That wrote out all the local symbols. Finish up the symbol table
10574 with the global symbols. Even if we want to strip everything we
10575 can, we still need to deal with those global symbols that got
10576 converted to local in a version script. */
10577
10578 /* The sh_info field records the index of the first non local symbol. */
10579 symtab_hdr->sh_info = bfd_get_symcount (abfd);
10580
10581 if (dynamic
10582 && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
10583 {
10584 Elf_Internal_Sym sym;
10585 bfd_byte *dynsym = finfo.dynsym_sec->contents;
10586 long last_local = 0;
10587
10588 /* Write out the section symbols for the output sections. */
67687978 10589 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
c152c796
AM
10590 {
10591 asection *s;
10592
10593 sym.st_size = 0;
10594 sym.st_name = 0;
10595 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10596 sym.st_other = 0;
10597
10598 for (s = abfd->sections; s != NULL; s = s->next)
10599 {
10600 int indx;
10601 bfd_byte *dest;
10602 long dynindx;
10603
c152c796 10604 dynindx = elf_section_data (s)->dynindx;
8c37241b
JJ
10605 if (dynindx <= 0)
10606 continue;
10607 indx = elf_section_data (s)->this_idx;
c152c796
AM
10608 BFD_ASSERT (indx > 0);
10609 sym.st_shndx = indx;
c0d5a53d
L
10610 if (! check_dynsym (abfd, &sym))
10611 return FALSE;
c152c796
AM
10612 sym.st_value = s->vma;
10613 dest = dynsym + dynindx * bed->s->sizeof_sym;
8c37241b
JJ
10614 if (last_local < dynindx)
10615 last_local = dynindx;
c152c796
AM
10616 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10617 }
c152c796
AM
10618 }
10619
10620 /* Write out the local dynsyms. */
10621 if (elf_hash_table (info)->dynlocal)
10622 {
10623 struct elf_link_local_dynamic_entry *e;
10624 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
10625 {
10626 asection *s;
10627 bfd_byte *dest;
10628
10629 sym.st_size = e->isym.st_size;
10630 sym.st_other = e->isym.st_other;
10631
10632 /* Copy the internal symbol as is.
10633 Note that we saved a word of storage and overwrote
10634 the original st_name with the dynstr_index. */
10635 sym = e->isym;
10636
cb33740c
AM
10637 s = bfd_section_from_elf_index (e->input_bfd,
10638 e->isym.st_shndx);
10639 if (s != NULL)
c152c796 10640 {
c152c796
AM
10641 sym.st_shndx =
10642 elf_section_data (s->output_section)->this_idx;
c0d5a53d
L
10643 if (! check_dynsym (abfd, &sym))
10644 return FALSE;
c152c796
AM
10645 sym.st_value = (s->output_section->vma
10646 + s->output_offset
10647 + e->isym.st_value);
10648 }
10649
10650 if (last_local < e->dynindx)
10651 last_local = e->dynindx;
10652
10653 dest = dynsym + e->dynindx * bed->s->sizeof_sym;
10654 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10655 }
10656 }
10657
10658 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
10659 last_local + 1;
10660 }
10661
10662 /* We get the global symbols from the hash table. */
10663 eoinfo.failed = FALSE;
10664 eoinfo.localsyms = FALSE;
10665 eoinfo.finfo = &finfo;
10666 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
10667 &eoinfo);
10668 if (eoinfo.failed)
10669 return FALSE;
10670
10671 /* If backend needs to output some symbols not present in the hash
10672 table, do it now. */
10673 if (bed->elf_backend_output_arch_syms)
10674 {
6e0b88f1 10675 typedef int (*out_sym_func)
c152c796
AM
10676 (void *, const char *, Elf_Internal_Sym *, asection *,
10677 struct elf_link_hash_entry *);
10678
10679 if (! ((*bed->elf_backend_output_arch_syms)
10680 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10681 return FALSE;
10682 }
10683
10684 /* Flush all symbols to the file. */
10685 if (! elf_link_flush_output_syms (&finfo, bed))
10686 return FALSE;
10687
10688 /* Now we know the size of the symtab section. */
10689 off += symtab_hdr->sh_size;
10690
10691 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
10692 if (symtab_shndx_hdr->sh_name != 0)
10693 {
10694 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
10695 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
10696 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
10697 amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
10698 symtab_shndx_hdr->sh_size = amt;
10699
10700 off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
10701 off, TRUE);
10702
10703 if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
10704 || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
10705 return FALSE;
10706 }
10707
10708
10709 /* Finish up and write out the symbol string table (.strtab)
10710 section. */
10711 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
10712 /* sh_name was set in prep_headers. */
10713 symstrtab_hdr->sh_type = SHT_STRTAB;
10714 symstrtab_hdr->sh_flags = 0;
10715 symstrtab_hdr->sh_addr = 0;
10716 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
10717 symstrtab_hdr->sh_entsize = 0;
10718 symstrtab_hdr->sh_link = 0;
10719 symstrtab_hdr->sh_info = 0;
10720 /* sh_offset is set just below. */
10721 symstrtab_hdr->sh_addralign = 1;
10722
10723 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
10724 elf_tdata (abfd)->next_file_pos = off;
10725
10726 if (bfd_get_symcount (abfd) > 0)
10727 {
10728 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
10729 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
10730 return FALSE;
10731 }
10732
10733 /* Adjust the relocs to have the correct symbol indices. */
10734 for (o = abfd->sections; o != NULL; o = o->next)
10735 {
10736 if ((o->flags & SEC_RELOC) == 0)
10737 continue;
10738
10739 elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr,
10740 elf_section_data (o)->rel_count,
10741 elf_section_data (o)->rel_hashes);
10742 if (elf_section_data (o)->rel_hdr2 != NULL)
10743 elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2,
10744 elf_section_data (o)->rel_count2,
10745 (elf_section_data (o)->rel_hashes
10746 + elf_section_data (o)->rel_count));
10747
10748 /* Set the reloc_count field to 0 to prevent write_relocs from
10749 trying to swap the relocs out itself. */
10750 o->reloc_count = 0;
10751 }
10752
10753 if (dynamic && info->combreloc && dynobj != NULL)
10754 relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
10755
10756 /* If we are linking against a dynamic object, or generating a
10757 shared library, finish up the dynamic linking information. */
10758 if (dynamic)
10759 {
10760 bfd_byte *dyncon, *dynconend;
10761
10762 /* Fix up .dynamic entries. */
10763 o = bfd_get_section_by_name (dynobj, ".dynamic");
10764 BFD_ASSERT (o != NULL);
10765
10766 dyncon = o->contents;
eea6121a 10767 dynconend = o->contents + o->size;
c152c796
AM
10768 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
10769 {
10770 Elf_Internal_Dyn dyn;
10771 const char *name;
10772 unsigned int type;
10773
10774 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
10775
10776 switch (dyn.d_tag)
10777 {
10778 default:
10779 continue;
10780 case DT_NULL:
10781 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
10782 {
10783 switch (elf_section_data (reldyn)->this_hdr.sh_type)
10784 {
10785 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
10786 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
10787 default: continue;
10788 }
10789 dyn.d_un.d_val = relativecount;
10790 relativecount = 0;
10791 break;
10792 }
10793 continue;
10794
10795 case DT_INIT:
10796 name = info->init_function;
10797 goto get_sym;
10798 case DT_FINI:
10799 name = info->fini_function;
10800 get_sym:
10801 {
10802 struct elf_link_hash_entry *h;
10803
10804 h = elf_link_hash_lookup (elf_hash_table (info), name,
10805 FALSE, FALSE, TRUE);
10806 if (h != NULL
10807 && (h->root.type == bfd_link_hash_defined
10808 || h->root.type == bfd_link_hash_defweak))
10809 {
bef26483 10810 dyn.d_un.d_ptr = h->root.u.def.value;
c152c796
AM
10811 o = h->root.u.def.section;
10812 if (o->output_section != NULL)
bef26483 10813 dyn.d_un.d_ptr += (o->output_section->vma
c152c796
AM
10814 + o->output_offset);
10815 else
10816 {
10817 /* The symbol is imported from another shared
10818 library and does not apply to this one. */
bef26483 10819 dyn.d_un.d_ptr = 0;
c152c796
AM
10820 }
10821 break;
10822 }
10823 }
10824 continue;
10825
10826 case DT_PREINIT_ARRAYSZ:
10827 name = ".preinit_array";
10828 goto get_size;
10829 case DT_INIT_ARRAYSZ:
10830 name = ".init_array";
10831 goto get_size;
10832 case DT_FINI_ARRAYSZ:
10833 name = ".fini_array";
10834 get_size:
10835 o = bfd_get_section_by_name (abfd, name);
10836 if (o == NULL)
10837 {
10838 (*_bfd_error_handler)
d003868e 10839 (_("%B: could not find output section %s"), abfd, name);
c152c796
AM
10840 goto error_return;
10841 }
eea6121a 10842 if (o->size == 0)
c152c796
AM
10843 (*_bfd_error_handler)
10844 (_("warning: %s section has zero size"), name);
eea6121a 10845 dyn.d_un.d_val = o->size;
c152c796
AM
10846 break;
10847
10848 case DT_PREINIT_ARRAY:
10849 name = ".preinit_array";
10850 goto get_vma;
10851 case DT_INIT_ARRAY:
10852 name = ".init_array";
10853 goto get_vma;
10854 case DT_FINI_ARRAY:
10855 name = ".fini_array";
10856 goto get_vma;
10857
10858 case DT_HASH:
10859 name = ".hash";
10860 goto get_vma;
fdc90cb4
JJ
10861 case DT_GNU_HASH:
10862 name = ".gnu.hash";
10863 goto get_vma;
c152c796
AM
10864 case DT_STRTAB:
10865 name = ".dynstr";
10866 goto get_vma;
10867 case DT_SYMTAB:
10868 name = ".dynsym";
10869 goto get_vma;
10870 case DT_VERDEF:
10871 name = ".gnu.version_d";
10872 goto get_vma;
10873 case DT_VERNEED:
10874 name = ".gnu.version_r";
10875 goto get_vma;
10876 case DT_VERSYM:
10877 name = ".gnu.version";
10878 get_vma:
10879 o = bfd_get_section_by_name (abfd, name);
10880 if (o == NULL)
10881 {
10882 (*_bfd_error_handler)
d003868e 10883 (_("%B: could not find output section %s"), abfd, name);
c152c796
AM
10884 goto error_return;
10885 }
10886 dyn.d_un.d_ptr = o->vma;
10887 break;
10888
10889 case DT_REL:
10890 case DT_RELA:
10891 case DT_RELSZ:
10892 case DT_RELASZ:
10893 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
10894 type = SHT_REL;
10895 else
10896 type = SHT_RELA;
10897 dyn.d_un.d_val = 0;
bef26483 10898 dyn.d_un.d_ptr = 0;
c152c796
AM
10899 for (i = 1; i < elf_numsections (abfd); i++)
10900 {
10901 Elf_Internal_Shdr *hdr;
10902
10903 hdr = elf_elfsections (abfd)[i];
10904 if (hdr->sh_type == type
10905 && (hdr->sh_flags & SHF_ALLOC) != 0)
10906 {
10907 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
10908 dyn.d_un.d_val += hdr->sh_size;
10909 else
10910 {
bef26483
AM
10911 if (dyn.d_un.d_ptr == 0
10912 || hdr->sh_addr < dyn.d_un.d_ptr)
10913 dyn.d_un.d_ptr = hdr->sh_addr;
c152c796
AM
10914 }
10915 }
10916 }
10917 break;
10918 }
10919 bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
10920 }
10921 }
10922
10923 /* If we have created any dynamic sections, then output them. */
10924 if (dynobj != NULL)
10925 {
10926 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
10927 goto error_return;
10928
943284cc
DJ
10929 /* Check for DT_TEXTREL (late, in case the backend removes it). */
10930 if (info->warn_shared_textrel && info->shared)
10931 {
10932 bfd_byte *dyncon, *dynconend;
10933
10934 /* Fix up .dynamic entries. */
10935 o = bfd_get_section_by_name (dynobj, ".dynamic");
10936 BFD_ASSERT (o != NULL);
10937
10938 dyncon = o->contents;
10939 dynconend = o->contents + o->size;
10940 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
10941 {
10942 Elf_Internal_Dyn dyn;
10943
10944 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
10945
10946 if (dyn.d_tag == DT_TEXTREL)
10947 {
a0c8462f 10948 info->callbacks->einfo
9267588c 10949 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
943284cc
DJ
10950 break;
10951 }
10952 }
10953 }
10954
c152c796
AM
10955 for (o = dynobj->sections; o != NULL; o = o->next)
10956 {
10957 if ((o->flags & SEC_HAS_CONTENTS) == 0
eea6121a 10958 || o->size == 0
c152c796
AM
10959 || o->output_section == bfd_abs_section_ptr)
10960 continue;
10961 if ((o->flags & SEC_LINKER_CREATED) == 0)
10962 {
10963 /* At this point, we are only interested in sections
10964 created by _bfd_elf_link_create_dynamic_sections. */
10965 continue;
10966 }
3722b82f
AM
10967 if (elf_hash_table (info)->stab_info.stabstr == o)
10968 continue;
eea6121a
AM
10969 if (elf_hash_table (info)->eh_info.hdr_sec == o)
10970 continue;
c152c796
AM
10971 if ((elf_section_data (o->output_section)->this_hdr.sh_type
10972 != SHT_STRTAB)
10973 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
10974 {
10975 if (! bfd_set_section_contents (abfd, o->output_section,
10976 o->contents,
10977 (file_ptr) o->output_offset,
eea6121a 10978 o->size))
c152c796
AM
10979 goto error_return;
10980 }
10981 else
10982 {
10983 /* The contents of the .dynstr section are actually in a
10984 stringtab. */
10985 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
10986 if (bfd_seek (abfd, off, SEEK_SET) != 0
10987 || ! _bfd_elf_strtab_emit (abfd,
10988 elf_hash_table (info)->dynstr))
10989 goto error_return;
10990 }
10991 }
10992 }
10993
10994 if (info->relocatable)
10995 {
10996 bfd_boolean failed = FALSE;
10997
10998 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
10999 if (failed)
11000 goto error_return;
11001 }
11002
11003 /* If we have optimized stabs strings, output them. */
3722b82f 11004 if (elf_hash_table (info)->stab_info.stabstr != NULL)
c152c796
AM
11005 {
11006 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11007 goto error_return;
11008 }
11009
11010 if (info->eh_frame_hdr)
11011 {
11012 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11013 goto error_return;
11014 }
11015
11016 if (finfo.symstrtab != NULL)
11017 _bfd_stringtab_free (finfo.symstrtab);
11018 if (finfo.contents != NULL)
11019 free (finfo.contents);
11020 if (finfo.external_relocs != NULL)
11021 free (finfo.external_relocs);
11022 if (finfo.internal_relocs != NULL)
11023 free (finfo.internal_relocs);
11024 if (finfo.external_syms != NULL)
11025 free (finfo.external_syms);
11026 if (finfo.locsym_shndx != NULL)
11027 free (finfo.locsym_shndx);
11028 if (finfo.internal_syms != NULL)
11029 free (finfo.internal_syms);
11030 if (finfo.indices != NULL)
11031 free (finfo.indices);
11032 if (finfo.sections != NULL)
11033 free (finfo.sections);
11034 if (finfo.symbuf != NULL)
11035 free (finfo.symbuf);
11036 if (finfo.symshndxbuf != NULL)
11037 free (finfo.symshndxbuf);
11038 for (o = abfd->sections; o != NULL; o = o->next)
11039 {
11040 if ((o->flags & SEC_RELOC) != 0
11041 && elf_section_data (o)->rel_hashes != NULL)
11042 free (elf_section_data (o)->rel_hashes);
11043 }
11044
11045 elf_tdata (abfd)->linker = TRUE;
11046
104d59d1
JM
11047 if (attr_section)
11048 {
11049 bfd_byte *contents = bfd_malloc (attr_size);
11050 if (contents == NULL)
d0f16d5e 11051 return FALSE; /* Bail out and fail. */
104d59d1
JM
11052 bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11053 bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11054 free (contents);
11055 }
11056
c152c796
AM
11057 return TRUE;
11058
11059 error_return:
11060 if (finfo.symstrtab != NULL)
11061 _bfd_stringtab_free (finfo.symstrtab);
11062 if (finfo.contents != NULL)
11063 free (finfo.contents);
11064 if (finfo.external_relocs != NULL)
11065 free (finfo.external_relocs);
11066 if (finfo.internal_relocs != NULL)
11067 free (finfo.internal_relocs);
11068 if (finfo.external_syms != NULL)
11069 free (finfo.external_syms);
11070 if (finfo.locsym_shndx != NULL)
11071 free (finfo.locsym_shndx);
11072 if (finfo.internal_syms != NULL)
11073 free (finfo.internal_syms);
11074 if (finfo.indices != NULL)
11075 free (finfo.indices);
11076 if (finfo.sections != NULL)
11077 free (finfo.sections);
11078 if (finfo.symbuf != NULL)
11079 free (finfo.symbuf);
11080 if (finfo.symshndxbuf != NULL)
11081 free (finfo.symshndxbuf);
11082 for (o = abfd->sections; o != NULL; o = o->next)
11083 {
11084 if ((o->flags & SEC_RELOC) != 0
11085 && elf_section_data (o)->rel_hashes != NULL)
11086 free (elf_section_data (o)->rel_hashes);
11087 }
11088
11089 return FALSE;
11090}
11091\f
5241d853
RS
11092/* Initialize COOKIE for input bfd ABFD. */
11093
11094static bfd_boolean
11095init_reloc_cookie (struct elf_reloc_cookie *cookie,
11096 struct bfd_link_info *info, bfd *abfd)
11097{
11098 Elf_Internal_Shdr *symtab_hdr;
11099 const struct elf_backend_data *bed;
11100
11101 bed = get_elf_backend_data (abfd);
11102 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11103
11104 cookie->abfd = abfd;
11105 cookie->sym_hashes = elf_sym_hashes (abfd);
11106 cookie->bad_symtab = elf_bad_symtab (abfd);
11107 if (cookie->bad_symtab)
11108 {
11109 cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11110 cookie->extsymoff = 0;
11111 }
11112 else
11113 {
11114 cookie->locsymcount = symtab_hdr->sh_info;
11115 cookie->extsymoff = symtab_hdr->sh_info;
11116 }
11117
11118 if (bed->s->arch_size == 32)
11119 cookie->r_sym_shift = 8;
11120 else
11121 cookie->r_sym_shift = 32;
11122
11123 cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11124 if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11125 {
11126 cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11127 cookie->locsymcount, 0,
11128 NULL, NULL, NULL);
11129 if (cookie->locsyms == NULL)
11130 {
11131 info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11132 return FALSE;
11133 }
11134 if (info->keep_memory)
11135 symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11136 }
11137 return TRUE;
11138}
11139
11140/* Free the memory allocated by init_reloc_cookie, if appropriate. */
11141
11142static void
11143fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11144{
11145 Elf_Internal_Shdr *symtab_hdr;
11146
11147 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11148 if (cookie->locsyms != NULL
11149 && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11150 free (cookie->locsyms);
11151}
11152
11153/* Initialize the relocation information in COOKIE for input section SEC
11154 of input bfd ABFD. */
11155
11156static bfd_boolean
11157init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11158 struct bfd_link_info *info, bfd *abfd,
11159 asection *sec)
11160{
11161 const struct elf_backend_data *bed;
11162
11163 if (sec->reloc_count == 0)
11164 {
11165 cookie->rels = NULL;
11166 cookie->relend = NULL;
11167 }
11168 else
11169 {
11170 bed = get_elf_backend_data (abfd);
11171
11172 cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11173 info->keep_memory);
11174 if (cookie->rels == NULL)
11175 return FALSE;
11176 cookie->rel = cookie->rels;
11177 cookie->relend = (cookie->rels
11178 + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11179 }
11180 cookie->rel = cookie->rels;
11181 return TRUE;
11182}
11183
11184/* Free the memory allocated by init_reloc_cookie_rels,
11185 if appropriate. */
11186
11187static void
11188fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11189 asection *sec)
11190{
11191 if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11192 free (cookie->rels);
11193}
11194
11195/* Initialize the whole of COOKIE for input section SEC. */
11196
11197static bfd_boolean
11198init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11199 struct bfd_link_info *info,
11200 asection *sec)
11201{
11202 if (!init_reloc_cookie (cookie, info, sec->owner))
11203 goto error1;
11204 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11205 goto error2;
11206 return TRUE;
11207
11208 error2:
11209 fini_reloc_cookie (cookie, sec->owner);
11210 error1:
11211 return FALSE;
11212}
11213
11214/* Free the memory allocated by init_reloc_cookie_for_section,
11215 if appropriate. */
11216
11217static void
11218fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11219 asection *sec)
11220{
11221 fini_reloc_cookie_rels (cookie, sec);
11222 fini_reloc_cookie (cookie, sec->owner);
11223}
11224\f
c152c796
AM
11225/* Garbage collect unused sections. */
11226
07adf181
AM
11227/* Default gc_mark_hook. */
11228
11229asection *
11230_bfd_elf_gc_mark_hook (asection *sec,
11231 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11232 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11233 struct elf_link_hash_entry *h,
11234 Elf_Internal_Sym *sym)
11235{
11236 if (h != NULL)
11237 {
11238 switch (h->root.type)
11239 {
11240 case bfd_link_hash_defined:
11241 case bfd_link_hash_defweak:
11242 return h->root.u.def.section;
11243
11244 case bfd_link_hash_common:
11245 return h->root.u.c.p->section;
11246
11247 default:
11248 break;
11249 }
11250 }
11251 else
11252 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11253
11254 return NULL;
11255}
11256
5241d853
RS
11257/* COOKIE->rel describes a relocation against section SEC, which is
11258 a section we've decided to keep. Return the section that contains
11259 the relocation symbol, or NULL if no section contains it. */
11260
11261asection *
11262_bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11263 elf_gc_mark_hook_fn gc_mark_hook,
11264 struct elf_reloc_cookie *cookie)
11265{
11266 unsigned long r_symndx;
11267 struct elf_link_hash_entry *h;
11268
11269 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11270 if (r_symndx == 0)
11271 return NULL;
11272
11273 if (r_symndx >= cookie->locsymcount
11274 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11275 {
11276 h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11277 while (h->root.type == bfd_link_hash_indirect
11278 || h->root.type == bfd_link_hash_warning)
11279 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11280 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11281 }
11282
11283 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11284 &cookie->locsyms[r_symndx]);
11285}
11286
11287/* COOKIE->rel describes a relocation against section SEC, which is
11288 a section we've decided to keep. Mark the section that contains
9d0a14d3 11289 the relocation symbol. */
5241d853
RS
11290
11291bfd_boolean
11292_bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11293 asection *sec,
11294 elf_gc_mark_hook_fn gc_mark_hook,
9d0a14d3 11295 struct elf_reloc_cookie *cookie)
5241d853
RS
11296{
11297 asection *rsec;
11298
11299 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11300 if (rsec && !rsec->gc_mark)
11301 {
11302 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
11303 rsec->gc_mark = 1;
5241d853
RS
11304 else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11305 return FALSE;
11306 }
11307 return TRUE;
11308}
11309
07adf181
AM
11310/* The mark phase of garbage collection. For a given section, mark
11311 it and any sections in this section's group, and all the sections
11312 which define symbols to which it refers. */
11313
ccfa59ea
AM
11314bfd_boolean
11315_bfd_elf_gc_mark (struct bfd_link_info *info,
11316 asection *sec,
6a5bb875 11317 elf_gc_mark_hook_fn gc_mark_hook)
c152c796
AM
11318{
11319 bfd_boolean ret;
9d0a14d3 11320 asection *group_sec, *eh_frame;
c152c796
AM
11321
11322 sec->gc_mark = 1;
11323
11324 /* Mark all the sections in the group. */
11325 group_sec = elf_section_data (sec)->next_in_group;
11326 if (group_sec && !group_sec->gc_mark)
ccfa59ea 11327 if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
c152c796
AM
11328 return FALSE;
11329
11330 /* Look through the section relocs. */
11331 ret = TRUE;
9d0a14d3
RS
11332 eh_frame = elf_eh_frame_section (sec->owner);
11333 if ((sec->flags & SEC_RELOC) != 0
11334 && sec->reloc_count > 0
11335 && sec != eh_frame)
c152c796 11336 {
5241d853 11337 struct elf_reloc_cookie cookie;
c152c796 11338
5241d853
RS
11339 if (!init_reloc_cookie_for_section (&cookie, info, sec))
11340 ret = FALSE;
c152c796 11341 else
c152c796 11342 {
5241d853 11343 for (; cookie.rel < cookie.relend; cookie.rel++)
9d0a14d3 11344 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
5241d853
RS
11345 {
11346 ret = FALSE;
11347 break;
11348 }
11349 fini_reloc_cookie_for_section (&cookie, sec);
c152c796
AM
11350 }
11351 }
9d0a14d3
RS
11352
11353 if (ret && eh_frame && elf_fde_list (sec))
11354 {
11355 struct elf_reloc_cookie cookie;
11356
11357 if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11358 ret = FALSE;
11359 else
11360 {
11361 if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11362 gc_mark_hook, &cookie))
11363 ret = FALSE;
11364 fini_reloc_cookie_for_section (&cookie, eh_frame);
11365 }
11366 }
11367
c152c796
AM
11368 return ret;
11369}
11370
11371/* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11372
c17d87de
NC
11373struct elf_gc_sweep_symbol_info
11374{
ccabcbe5
AM
11375 struct bfd_link_info *info;
11376 void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
11377 bfd_boolean);
11378};
11379
c152c796 11380static bfd_boolean
ccabcbe5 11381elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
c152c796 11382{
c152c796
AM
11383 if (h->root.type == bfd_link_hash_warning)
11384 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11385
ccabcbe5
AM
11386 if ((h->root.type == bfd_link_hash_defined
11387 || h->root.type == bfd_link_hash_defweak)
11388 && !h->root.u.def.section->gc_mark
11389 && !(h->root.u.def.section->owner->flags & DYNAMIC))
11390 {
11391 struct elf_gc_sweep_symbol_info *inf = data;
11392 (*inf->hide_symbol) (inf->info, h, TRUE);
11393 }
c152c796
AM
11394
11395 return TRUE;
11396}
11397
11398/* The sweep phase of garbage collection. Remove all garbage sections. */
11399
11400typedef bfd_boolean (*gc_sweep_hook_fn)
11401 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
11402
11403static bfd_boolean
ccabcbe5 11404elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
c152c796
AM
11405{
11406 bfd *sub;
ccabcbe5
AM
11407 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11408 gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
11409 unsigned long section_sym_count;
11410 struct elf_gc_sweep_symbol_info sweep_info;
c152c796
AM
11411
11412 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11413 {
11414 asection *o;
11415
11416 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11417 continue;
11418
11419 for (o = sub->sections; o != NULL; o = o->next)
11420 {
a33dafc3
L
11421 /* When any section in a section group is kept, we keep all
11422 sections in the section group. If the first member of
11423 the section group is excluded, we will also exclude the
11424 group section. */
11425 if (o->flags & SEC_GROUP)
11426 {
11427 asection *first = elf_next_in_group (o);
11428 o->gc_mark = first->gc_mark;
11429 }
11430 else if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
11431 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
11432 {
11433 /* Keep debug and special sections. */
11434 o->gc_mark = 1;
11435 }
c152c796
AM
11436
11437 if (o->gc_mark)
11438 continue;
11439
11440 /* Skip sweeping sections already excluded. */
11441 if (o->flags & SEC_EXCLUDE)
11442 continue;
11443
11444 /* Since this is early in the link process, it is simple
11445 to remove a section from the output. */
11446 o->flags |= SEC_EXCLUDE;
11447
c55fe096 11448 if (info->print_gc_sections && o->size != 0)
c17d87de
NC
11449 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
11450
c152c796
AM
11451 /* But we also have to update some of the relocation
11452 info we collected before. */
11453 if (gc_sweep_hook
e8aaee2a
AM
11454 && (o->flags & SEC_RELOC) != 0
11455 && o->reloc_count > 0
11456 && !bfd_is_abs_section (o->output_section))
c152c796
AM
11457 {
11458 Elf_Internal_Rela *internal_relocs;
11459 bfd_boolean r;
11460
11461 internal_relocs
11462 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
11463 info->keep_memory);
11464 if (internal_relocs == NULL)
11465 return FALSE;
11466
11467 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
11468
11469 if (elf_section_data (o)->relocs != internal_relocs)
11470 free (internal_relocs);
11471
11472 if (!r)
11473 return FALSE;
11474 }
11475 }
11476 }
11477
11478 /* Remove the symbols that were in the swept sections from the dynamic
11479 symbol table. GCFIXME: Anyone know how to get them out of the
11480 static symbol table as well? */
ccabcbe5
AM
11481 sweep_info.info = info;
11482 sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
11483 elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
11484 &sweep_info);
c152c796 11485
ccabcbe5 11486 _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
c152c796
AM
11487 return TRUE;
11488}
11489
11490/* Propagate collected vtable information. This is called through
11491 elf_link_hash_traverse. */
11492
11493static bfd_boolean
11494elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
11495{
11496 if (h->root.type == bfd_link_hash_warning)
11497 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11498
11499 /* Those that are not vtables. */
f6e332e6 11500 if (h->vtable == NULL || h->vtable->parent == NULL)
c152c796
AM
11501 return TRUE;
11502
11503 /* Those vtables that do not have parents, we cannot merge. */
f6e332e6 11504 if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
c152c796
AM
11505 return TRUE;
11506
11507 /* If we've already been done, exit. */
f6e332e6 11508 if (h->vtable->used && h->vtable->used[-1])
c152c796
AM
11509 return TRUE;
11510
11511 /* Make sure the parent's table is up to date. */
f6e332e6 11512 elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
c152c796 11513
f6e332e6 11514 if (h->vtable->used == NULL)
c152c796
AM
11515 {
11516 /* None of this table's entries were referenced. Re-use the
11517 parent's table. */
f6e332e6
AM
11518 h->vtable->used = h->vtable->parent->vtable->used;
11519 h->vtable->size = h->vtable->parent->vtable->size;
c152c796
AM
11520 }
11521 else
11522 {
11523 size_t n;
11524 bfd_boolean *cu, *pu;
11525
11526 /* Or the parent's entries into ours. */
f6e332e6 11527 cu = h->vtable->used;
c152c796 11528 cu[-1] = TRUE;
f6e332e6 11529 pu = h->vtable->parent->vtable->used;
c152c796
AM
11530 if (pu != NULL)
11531 {
11532 const struct elf_backend_data *bed;
11533 unsigned int log_file_align;
11534
11535 bed = get_elf_backend_data (h->root.u.def.section->owner);
11536 log_file_align = bed->s->log_file_align;
f6e332e6 11537 n = h->vtable->parent->vtable->size >> log_file_align;
c152c796
AM
11538 while (n--)
11539 {
11540 if (*pu)
11541 *cu = TRUE;
11542 pu++;
11543 cu++;
11544 }
11545 }
11546 }
11547
11548 return TRUE;
11549}
11550
11551static bfd_boolean
11552elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
11553{
11554 asection *sec;
11555 bfd_vma hstart, hend;
11556 Elf_Internal_Rela *relstart, *relend, *rel;
11557 const struct elf_backend_data *bed;
11558 unsigned int log_file_align;
11559
11560 if (h->root.type == bfd_link_hash_warning)
11561 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11562
11563 /* Take care of both those symbols that do not describe vtables as
11564 well as those that are not loaded. */
f6e332e6 11565 if (h->vtable == NULL || h->vtable->parent == NULL)
c152c796
AM
11566 return TRUE;
11567
11568 BFD_ASSERT (h->root.type == bfd_link_hash_defined
11569 || h->root.type == bfd_link_hash_defweak);
11570
11571 sec = h->root.u.def.section;
11572 hstart = h->root.u.def.value;
11573 hend = hstart + h->size;
11574
11575 relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
11576 if (!relstart)
11577 return *(bfd_boolean *) okp = FALSE;
11578 bed = get_elf_backend_data (sec->owner);
11579 log_file_align = bed->s->log_file_align;
11580
11581 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
11582
11583 for (rel = relstart; rel < relend; ++rel)
11584 if (rel->r_offset >= hstart && rel->r_offset < hend)
11585 {
11586 /* If the entry is in use, do nothing. */
f6e332e6
AM
11587 if (h->vtable->used
11588 && (rel->r_offset - hstart) < h->vtable->size)
c152c796
AM
11589 {
11590 bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
f6e332e6 11591 if (h->vtable->used[entry])
c152c796
AM
11592 continue;
11593 }
11594 /* Otherwise, kill it. */
11595 rel->r_offset = rel->r_info = rel->r_addend = 0;
11596 }
11597
11598 return TRUE;
11599}
11600
87538722
AM
11601/* Mark sections containing dynamically referenced symbols. When
11602 building shared libraries, we must assume that any visible symbol is
11603 referenced. */
715df9b8 11604
64d03ab5
AM
11605bfd_boolean
11606bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
715df9b8 11607{
87538722
AM
11608 struct bfd_link_info *info = (struct bfd_link_info *) inf;
11609
715df9b8
EB
11610 if (h->root.type == bfd_link_hash_warning)
11611 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11612
11613 if ((h->root.type == bfd_link_hash_defined
11614 || h->root.type == bfd_link_hash_defweak)
87538722 11615 && (h->ref_dynamic
5adcfd8b 11616 || (!info->executable
87538722
AM
11617 && h->def_regular
11618 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
11619 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN)))
715df9b8
EB
11620 h->root.u.def.section->flags |= SEC_KEEP;
11621
11622 return TRUE;
11623}
3b36f7e6 11624
74f0fb50
AM
11625/* Keep all sections containing symbols undefined on the command-line,
11626 and the section containing the entry symbol. */
11627
11628void
11629_bfd_elf_gc_keep (struct bfd_link_info *info)
11630{
11631 struct bfd_sym_chain *sym;
11632
11633 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
11634 {
11635 struct elf_link_hash_entry *h;
11636
11637 h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
11638 FALSE, FALSE, FALSE);
11639
11640 if (h != NULL
11641 && (h->root.type == bfd_link_hash_defined
11642 || h->root.type == bfd_link_hash_defweak)
11643 && !bfd_is_abs_section (h->root.u.def.section))
11644 h->root.u.def.section->flags |= SEC_KEEP;
11645 }
11646}
11647
c152c796
AM
11648/* Do mark and sweep of unused sections. */
11649
11650bfd_boolean
11651bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
11652{
11653 bfd_boolean ok = TRUE;
11654 bfd *sub;
6a5bb875 11655 elf_gc_mark_hook_fn gc_mark_hook;
64d03ab5 11656 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
c152c796 11657
64d03ab5 11658 if (!bed->can_gc_sections
715df9b8 11659 || !is_elf_hash_table (info->hash))
c152c796
AM
11660 {
11661 (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
11662 return TRUE;
11663 }
11664
74f0fb50
AM
11665 bed->gc_keep (info);
11666
9d0a14d3
RS
11667 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
11668 at the .eh_frame section if we can mark the FDEs individually. */
11669 _bfd_elf_begin_eh_frame_parsing (info);
11670 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11671 {
11672 asection *sec;
11673 struct elf_reloc_cookie cookie;
11674
11675 sec = bfd_get_section_by_name (sub, ".eh_frame");
11676 if (sec && init_reloc_cookie_for_section (&cookie, info, sec))
11677 {
11678 _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
11679 if (elf_section_data (sec)->sec_info)
11680 elf_eh_frame_section (sub) = sec;
11681 fini_reloc_cookie_for_section (&cookie, sec);
11682 }
11683 }
11684 _bfd_elf_end_eh_frame_parsing (info);
11685
c152c796
AM
11686 /* Apply transitive closure to the vtable entry usage info. */
11687 elf_link_hash_traverse (elf_hash_table (info),
11688 elf_gc_propagate_vtable_entries_used,
11689 &ok);
11690 if (!ok)
11691 return FALSE;
11692
11693 /* Kill the vtable relocations that were not used. */
11694 elf_link_hash_traverse (elf_hash_table (info),
11695 elf_gc_smash_unused_vtentry_relocs,
11696 &ok);
11697 if (!ok)
11698 return FALSE;
11699
715df9b8
EB
11700 /* Mark dynamically referenced symbols. */
11701 if (elf_hash_table (info)->dynamic_sections_created)
11702 elf_link_hash_traverse (elf_hash_table (info),
64d03ab5 11703 bed->gc_mark_dynamic_ref,
87538722 11704 info);
c152c796 11705
715df9b8 11706 /* Grovel through relocs to find out who stays ... */
64d03ab5 11707 gc_mark_hook = bed->gc_mark_hook;
c152c796
AM
11708 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11709 {
11710 asection *o;
11711
11712 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11713 continue;
11714
11715 for (o = sub->sections; o != NULL; o = o->next)
a14a5de3 11716 if ((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP && !o->gc_mark)
39c2f51b
AM
11717 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
11718 return FALSE;
c152c796
AM
11719 }
11720
6a5bb875
PB
11721 /* Allow the backend to mark additional target specific sections. */
11722 if (bed->gc_mark_extra_sections)
74f0fb50 11723 bed->gc_mark_extra_sections (info, gc_mark_hook);
6a5bb875 11724
c152c796 11725 /* ... and mark SEC_EXCLUDE for those that go. */
ccabcbe5 11726 return elf_gc_sweep (abfd, info);
c152c796
AM
11727}
11728\f
11729/* Called from check_relocs to record the existence of a VTINHERIT reloc. */
11730
11731bfd_boolean
11732bfd_elf_gc_record_vtinherit (bfd *abfd,
11733 asection *sec,
11734 struct elf_link_hash_entry *h,
11735 bfd_vma offset)
11736{
11737 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
11738 struct elf_link_hash_entry **search, *child;
11739 bfd_size_type extsymcount;
11740 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11741
11742 /* The sh_info field of the symtab header tells us where the
11743 external symbols start. We don't care about the local symbols at
11744 this point. */
11745 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
11746 if (!elf_bad_symtab (abfd))
11747 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
11748
11749 sym_hashes = elf_sym_hashes (abfd);
11750 sym_hashes_end = sym_hashes + extsymcount;
11751
11752 /* Hunt down the child symbol, which is in this section at the same
11753 offset as the relocation. */
11754 for (search = sym_hashes; search != sym_hashes_end; ++search)
11755 {
11756 if ((child = *search) != NULL
11757 && (child->root.type == bfd_link_hash_defined
11758 || child->root.type == bfd_link_hash_defweak)
11759 && child->root.u.def.section == sec
11760 && child->root.u.def.value == offset)
11761 goto win;
11762 }
11763
d003868e
AM
11764 (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
11765 abfd, sec, (unsigned long) offset);
c152c796
AM
11766 bfd_set_error (bfd_error_invalid_operation);
11767 return FALSE;
11768
11769 win:
f6e332e6
AM
11770 if (!child->vtable)
11771 {
11772 child->vtable = bfd_zalloc (abfd, sizeof (*child->vtable));
11773 if (!child->vtable)
11774 return FALSE;
11775 }
c152c796
AM
11776 if (!h)
11777 {
11778 /* This *should* only be the absolute section. It could potentially
11779 be that someone has defined a non-global vtable though, which
11780 would be bad. It isn't worth paging in the local symbols to be
11781 sure though; that case should simply be handled by the assembler. */
11782
f6e332e6 11783 child->vtable->parent = (struct elf_link_hash_entry *) -1;
c152c796
AM
11784 }
11785 else
f6e332e6 11786 child->vtable->parent = h;
c152c796
AM
11787
11788 return TRUE;
11789}
11790
11791/* Called from check_relocs to record the existence of a VTENTRY reloc. */
11792
11793bfd_boolean
11794bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
11795 asection *sec ATTRIBUTE_UNUSED,
11796 struct elf_link_hash_entry *h,
11797 bfd_vma addend)
11798{
11799 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11800 unsigned int log_file_align = bed->s->log_file_align;
11801
f6e332e6
AM
11802 if (!h->vtable)
11803 {
11804 h->vtable = bfd_zalloc (abfd, sizeof (*h->vtable));
11805 if (!h->vtable)
11806 return FALSE;
11807 }
11808
11809 if (addend >= h->vtable->size)
c152c796
AM
11810 {
11811 size_t size, bytes, file_align;
f6e332e6 11812 bfd_boolean *ptr = h->vtable->used;
c152c796
AM
11813
11814 /* While the symbol is undefined, we have to be prepared to handle
11815 a zero size. */
11816 file_align = 1 << log_file_align;
11817 if (h->root.type == bfd_link_hash_undefined)
11818 size = addend + file_align;
11819 else
11820 {
11821 size = h->size;
11822 if (addend >= size)
11823 {
11824 /* Oops! We've got a reference past the defined end of
11825 the table. This is probably a bug -- shall we warn? */
11826 size = addend + file_align;
11827 }
11828 }
11829 size = (size + file_align - 1) & -file_align;
11830
11831 /* Allocate one extra entry for use as a "done" flag for the
11832 consolidation pass. */
11833 bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
11834
11835 if (ptr)
11836 {
11837 ptr = bfd_realloc (ptr - 1, bytes);
11838
11839 if (ptr != NULL)
11840 {
11841 size_t oldbytes;
11842
f6e332e6 11843 oldbytes = (((h->vtable->size >> log_file_align) + 1)
c152c796
AM
11844 * sizeof (bfd_boolean));
11845 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
11846 }
11847 }
11848 else
11849 ptr = bfd_zmalloc (bytes);
11850
11851 if (ptr == NULL)
11852 return FALSE;
11853
11854 /* And arrange for that done flag to be at index -1. */
f6e332e6
AM
11855 h->vtable->used = ptr + 1;
11856 h->vtable->size = size;
c152c796
AM
11857 }
11858
f6e332e6 11859 h->vtable->used[addend >> log_file_align] = TRUE;
c152c796
AM
11860
11861 return TRUE;
11862}
11863
11864struct alloc_got_off_arg {
11865 bfd_vma gotoff;
10455f89 11866 struct bfd_link_info *info;
c152c796
AM
11867};
11868
11869/* We need a special top-level link routine to convert got reference counts
11870 to real got offsets. */
11871
11872static bfd_boolean
11873elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
11874{
11875 struct alloc_got_off_arg *gofarg = arg;
10455f89
HPN
11876 bfd *obfd = gofarg->info->output_bfd;
11877 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
c152c796
AM
11878
11879 if (h->root.type == bfd_link_hash_warning)
11880 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11881
11882 if (h->got.refcount > 0)
11883 {
11884 h->got.offset = gofarg->gotoff;
10455f89 11885 gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
c152c796
AM
11886 }
11887 else
11888 h->got.offset = (bfd_vma) -1;
11889
11890 return TRUE;
11891}
11892
11893/* And an accompanying bit to work out final got entry offsets once
11894 we're done. Should be called from final_link. */
11895
11896bfd_boolean
11897bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
11898 struct bfd_link_info *info)
11899{
11900 bfd *i;
11901 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11902 bfd_vma gotoff;
c152c796
AM
11903 struct alloc_got_off_arg gofarg;
11904
10455f89
HPN
11905 BFD_ASSERT (abfd == info->output_bfd);
11906
c152c796
AM
11907 if (! is_elf_hash_table (info->hash))
11908 return FALSE;
11909
11910 /* The GOT offset is relative to the .got section, but the GOT header is
11911 put into the .got.plt section, if the backend uses it. */
11912 if (bed->want_got_plt)
11913 gotoff = 0;
11914 else
11915 gotoff = bed->got_header_size;
11916
11917 /* Do the local .got entries first. */
11918 for (i = info->input_bfds; i; i = i->link_next)
11919 {
11920 bfd_signed_vma *local_got;
11921 bfd_size_type j, locsymcount;
11922 Elf_Internal_Shdr *symtab_hdr;
11923
11924 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
11925 continue;
11926
11927 local_got = elf_local_got_refcounts (i);
11928 if (!local_got)
11929 continue;
11930
11931 symtab_hdr = &elf_tdata (i)->symtab_hdr;
11932 if (elf_bad_symtab (i))
11933 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11934 else
11935 locsymcount = symtab_hdr->sh_info;
11936
11937 for (j = 0; j < locsymcount; ++j)
11938 {
11939 if (local_got[j] > 0)
11940 {
11941 local_got[j] = gotoff;
10455f89 11942 gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
c152c796
AM
11943 }
11944 else
11945 local_got[j] = (bfd_vma) -1;
11946 }
11947 }
11948
11949 /* Then the global .got entries. .plt refcounts are handled by
11950 adjust_dynamic_symbol */
11951 gofarg.gotoff = gotoff;
10455f89 11952 gofarg.info = info;
c152c796
AM
11953 elf_link_hash_traverse (elf_hash_table (info),
11954 elf_gc_allocate_got_offsets,
11955 &gofarg);
11956 return TRUE;
11957}
11958
11959/* Many folk need no more in the way of final link than this, once
11960 got entry reference counting is enabled. */
11961
11962bfd_boolean
11963bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
11964{
11965 if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
11966 return FALSE;
11967
11968 /* Invoke the regular ELF backend linker to do all the work. */
11969 return bfd_elf_final_link (abfd, info);
11970}
11971
11972bfd_boolean
11973bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
11974{
11975 struct elf_reloc_cookie *rcookie = cookie;
11976
11977 if (rcookie->bad_symtab)
11978 rcookie->rel = rcookie->rels;
11979
11980 for (; rcookie->rel < rcookie->relend; rcookie->rel++)
11981 {
11982 unsigned long r_symndx;
11983
11984 if (! rcookie->bad_symtab)
11985 if (rcookie->rel->r_offset > offset)
11986 return FALSE;
11987 if (rcookie->rel->r_offset != offset)
11988 continue;
11989
11990 r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
11991 if (r_symndx == SHN_UNDEF)
11992 return TRUE;
11993
11994 if (r_symndx >= rcookie->locsymcount
11995 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11996 {
11997 struct elf_link_hash_entry *h;
11998
11999 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12000
12001 while (h->root.type == bfd_link_hash_indirect
12002 || h->root.type == bfd_link_hash_warning)
12003 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12004
12005 if ((h->root.type == bfd_link_hash_defined
12006 || h->root.type == bfd_link_hash_defweak)
12007 && elf_discarded_section (h->root.u.def.section))
12008 return TRUE;
12009 else
12010 return FALSE;
12011 }
12012 else
12013 {
12014 /* It's not a relocation against a global symbol,
12015 but it could be a relocation against a local
12016 symbol for a discarded section. */
12017 asection *isec;
12018 Elf_Internal_Sym *isym;
12019
12020 /* Need to: get the symbol; get the section. */
12021 isym = &rcookie->locsyms[r_symndx];
cb33740c
AM
12022 isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12023 if (isec != NULL && elf_discarded_section (isec))
12024 return TRUE;
c152c796
AM
12025 }
12026 return FALSE;
12027 }
12028 return FALSE;
12029}
12030
12031/* Discard unneeded references to discarded sections.
12032 Returns TRUE if any section's size was changed. */
12033/* This function assumes that the relocations are in sorted order,
12034 which is true for all known assemblers. */
12035
12036bfd_boolean
12037bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12038{
12039 struct elf_reloc_cookie cookie;
12040 asection *stab, *eh;
c152c796
AM
12041 const struct elf_backend_data *bed;
12042 bfd *abfd;
c152c796
AM
12043 bfd_boolean ret = FALSE;
12044
12045 if (info->traditional_format
12046 || !is_elf_hash_table (info->hash))
12047 return FALSE;
12048
ca92cecb 12049 _bfd_elf_begin_eh_frame_parsing (info);
c152c796
AM
12050 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
12051 {
12052 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12053 continue;
12054
12055 bed = get_elf_backend_data (abfd);
12056
12057 if ((abfd->flags & DYNAMIC) != 0)
12058 continue;
12059
8da3dbc5
AM
12060 eh = NULL;
12061 if (!info->relocatable)
12062 {
12063 eh = bfd_get_section_by_name (abfd, ".eh_frame");
12064 if (eh != NULL
eea6121a 12065 && (eh->size == 0
8da3dbc5
AM
12066 || bfd_is_abs_section (eh->output_section)))
12067 eh = NULL;
12068 }
c152c796
AM
12069
12070 stab = bfd_get_section_by_name (abfd, ".stab");
12071 if (stab != NULL
eea6121a 12072 && (stab->size == 0
c152c796
AM
12073 || bfd_is_abs_section (stab->output_section)
12074 || stab->sec_info_type != ELF_INFO_TYPE_STABS))
12075 stab = NULL;
12076
12077 if (stab == NULL
12078 && eh == NULL
12079 && bed->elf_backend_discard_info == NULL)
12080 continue;
12081
5241d853
RS
12082 if (!init_reloc_cookie (&cookie, info, abfd))
12083 return FALSE;
c152c796 12084
5241d853
RS
12085 if (stab != NULL
12086 && stab->reloc_count > 0
12087 && init_reloc_cookie_rels (&cookie, info, abfd, stab))
c152c796 12088 {
5241d853
RS
12089 if (_bfd_discard_section_stabs (abfd, stab,
12090 elf_section_data (stab)->sec_info,
12091 bfd_elf_reloc_symbol_deleted_p,
12092 &cookie))
12093 ret = TRUE;
12094 fini_reloc_cookie_rels (&cookie, stab);
c152c796
AM
12095 }
12096
5241d853
RS
12097 if (eh != NULL
12098 && init_reloc_cookie_rels (&cookie, info, abfd, eh))
c152c796 12099 {
ca92cecb 12100 _bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
c152c796
AM
12101 if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
12102 bfd_elf_reloc_symbol_deleted_p,
12103 &cookie))
12104 ret = TRUE;
5241d853 12105 fini_reloc_cookie_rels (&cookie, eh);
c152c796
AM
12106 }
12107
12108 if (bed->elf_backend_discard_info != NULL
12109 && (*bed->elf_backend_discard_info) (abfd, &cookie, info))
12110 ret = TRUE;
12111
5241d853 12112 fini_reloc_cookie (&cookie, abfd);
c152c796 12113 }
ca92cecb 12114 _bfd_elf_end_eh_frame_parsing (info);
c152c796
AM
12115
12116 if (info->eh_frame_hdr
12117 && !info->relocatable
12118 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12119 ret = TRUE;
12120
12121 return ret;
12122}
082b7297 12123
9659de1c
AM
12124/* For a SHT_GROUP section, return the group signature. For other
12125 sections, return the normal section name. */
12126
12127static const char *
12128section_signature (asection *sec)
12129{
12130 if ((sec->flags & SEC_GROUP) != 0
12131 && elf_next_in_group (sec) != NULL
12132 && elf_group_name (elf_next_in_group (sec)) != NULL)
12133 return elf_group_name (elf_next_in_group (sec));
12134 return sec->name;
12135}
12136
082b7297 12137void
9659de1c 12138_bfd_elf_section_already_linked (bfd *abfd, asection *sec,
c0f00686 12139 struct bfd_link_info *info)
082b7297
L
12140{
12141 flagword flags;
6d2cd210 12142 const char *name, *p;
082b7297
L
12143 struct bfd_section_already_linked *l;
12144 struct bfd_section_already_linked_hash_entry *already_linked_list;
3d7f7666 12145
3d7f7666
L
12146 if (sec->output_section == bfd_abs_section_ptr)
12147 return;
082b7297
L
12148
12149 flags = sec->flags;
3d7f7666 12150
c2370991
AM
12151 /* Return if it isn't a linkonce section. A comdat group section
12152 also has SEC_LINK_ONCE set. */
12153 if ((flags & SEC_LINK_ONCE) == 0)
082b7297
L
12154 return;
12155
c2370991
AM
12156 /* Don't put group member sections on our list of already linked
12157 sections. They are handled as a group via their group section. */
12158 if (elf_sec_group (sec) != NULL)
12159 return;
3d7f7666 12160
082b7297
L
12161 /* FIXME: When doing a relocatable link, we may have trouble
12162 copying relocations in other sections that refer to local symbols
12163 in the section being discarded. Those relocations will have to
12164 be converted somehow; as of this writing I'm not sure that any of
12165 the backends handle that correctly.
12166
12167 It is tempting to instead not discard link once sections when
12168 doing a relocatable link (technically, they should be discarded
12169 whenever we are building constructors). However, that fails,
12170 because the linker winds up combining all the link once sections
12171 into a single large link once section, which defeats the purpose
12172 of having link once sections in the first place.
12173
12174 Also, not merging link once sections in a relocatable link
12175 causes trouble for MIPS ELF, which relies on link once semantics
12176 to handle the .reginfo section correctly. */
12177
9659de1c 12178 name = section_signature (sec);
082b7297 12179
0112cd26 12180 if (CONST_STRNEQ (name, ".gnu.linkonce.")
6d2cd210
JJ
12181 && (p = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12182 p++;
12183 else
12184 p = name;
12185
12186 already_linked_list = bfd_section_already_linked_table_lookup (p);
082b7297
L
12187
12188 for (l = already_linked_list->entry; l != NULL; l = l->next)
12189 {
c2370991
AM
12190 /* We may have 2 different types of sections on the list: group
12191 sections and linkonce sections. Match like sections. */
3d7f7666 12192 if ((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
9659de1c 12193 && strcmp (name, section_signature (l->sec)) == 0
082b7297
L
12194 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL)
12195 {
12196 /* The section has already been linked. See if we should
6d2cd210 12197 issue a warning. */
082b7297
L
12198 switch (flags & SEC_LINK_DUPLICATES)
12199 {
12200 default:
12201 abort ();
12202
12203 case SEC_LINK_DUPLICATES_DISCARD:
12204 break;
12205
12206 case SEC_LINK_DUPLICATES_ONE_ONLY:
12207 (*_bfd_error_handler)
c93625e2 12208 (_("%B: ignoring duplicate section `%A'"),
d003868e 12209 abfd, sec);
082b7297
L
12210 break;
12211
12212 case SEC_LINK_DUPLICATES_SAME_SIZE:
12213 if (sec->size != l->sec->size)
12214 (*_bfd_error_handler)
c93625e2 12215 (_("%B: duplicate section `%A' has different size"),
d003868e 12216 abfd, sec);
082b7297 12217 break;
ea5158d8
DJ
12218
12219 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
12220 if (sec->size != l->sec->size)
12221 (*_bfd_error_handler)
c93625e2 12222 (_("%B: duplicate section `%A' has different size"),
ea5158d8
DJ
12223 abfd, sec);
12224 else if (sec->size != 0)
12225 {
12226 bfd_byte *sec_contents, *l_sec_contents;
12227
12228 if (!bfd_malloc_and_get_section (abfd, sec, &sec_contents))
12229 (*_bfd_error_handler)
c93625e2 12230 (_("%B: warning: could not read contents of section `%A'"),
ea5158d8
DJ
12231 abfd, sec);
12232 else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec,
12233 &l_sec_contents))
12234 (*_bfd_error_handler)
c93625e2 12235 (_("%B: warning: could not read contents of section `%A'"),
ea5158d8
DJ
12236 l->sec->owner, l->sec);
12237 else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0)
12238 (*_bfd_error_handler)
c93625e2 12239 (_("%B: warning: duplicate section `%A' has different contents"),
ea5158d8
DJ
12240 abfd, sec);
12241
12242 if (sec_contents)
12243 free (sec_contents);
12244 if (l_sec_contents)
12245 free (l_sec_contents);
12246 }
12247 break;
082b7297
L
12248 }
12249
12250 /* Set the output_section field so that lang_add_section
12251 does not create a lang_input_section structure for this
12252 section. Since there might be a symbol in the section
12253 being discarded, we must retain a pointer to the section
12254 which we are really going to use. */
12255 sec->output_section = bfd_abs_section_ptr;
12256 sec->kept_section = l->sec;
3b36f7e6 12257
082b7297 12258 if (flags & SEC_GROUP)
3d7f7666
L
12259 {
12260 asection *first = elf_next_in_group (sec);
12261 asection *s = first;
12262
12263 while (s != NULL)
12264 {
12265 s->output_section = bfd_abs_section_ptr;
12266 /* Record which group discards it. */
12267 s->kept_section = l->sec;
12268 s = elf_next_in_group (s);
12269 /* These lists are circular. */
12270 if (s == first)
12271 break;
12272 }
12273 }
082b7297
L
12274
12275 return;
12276 }
12277 }
12278
c2370991
AM
12279 /* A single member comdat group section may be discarded by a
12280 linkonce section and vice versa. */
12281
12282 if ((flags & SEC_GROUP) != 0)
3d7f7666 12283 {
c2370991
AM
12284 asection *first = elf_next_in_group (sec);
12285
12286 if (first != NULL && elf_next_in_group (first) == first)
12287 /* Check this single member group against linkonce sections. */
12288 for (l = already_linked_list->entry; l != NULL; l = l->next)
12289 if ((l->sec->flags & SEC_GROUP) == 0
12290 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL
12291 && bfd_elf_match_symbols_in_sections (l->sec, first, info))
12292 {
12293 first->output_section = bfd_abs_section_ptr;
12294 first->kept_section = l->sec;
12295 sec->output_section = bfd_abs_section_ptr;
12296 break;
12297 }
3d7f7666
L
12298 }
12299 else
c2370991 12300 /* Check this linkonce section against single member groups. */
6d2cd210
JJ
12301 for (l = already_linked_list->entry; l != NULL; l = l->next)
12302 if (l->sec->flags & SEC_GROUP)
12303 {
12304 asection *first = elf_next_in_group (l->sec);
12305
12306 if (first != NULL
12307 && elf_next_in_group (first) == first
c0f00686 12308 && bfd_elf_match_symbols_in_sections (first, sec, info))
6d2cd210
JJ
12309 {
12310 sec->output_section = bfd_abs_section_ptr;
c2370991 12311 sec->kept_section = first;
6d2cd210
JJ
12312 break;
12313 }
12314 }
12315
80c29487
JK
12316 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12317 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12318 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12319 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12320 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12321 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12322 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12323 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12324 The reverse order cannot happen as there is never a bfd with only the
12325 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12326 matter as here were are looking only for cross-bfd sections. */
12327
12328 if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
12329 for (l = already_linked_list->entry; l != NULL; l = l->next)
12330 if ((l->sec->flags & SEC_GROUP) == 0
12331 && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
12332 {
12333 if (abfd != l->sec->owner)
12334 sec->output_section = bfd_abs_section_ptr;
12335 break;
12336 }
12337
082b7297 12338 /* This is the first section with this name. Record it. */
a6626e8c 12339 if (! bfd_section_already_linked_table_insert (already_linked_list, sec))
bb6198d2 12340 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
082b7297 12341}
81e1b023 12342
a4d8e49b
L
12343bfd_boolean
12344_bfd_elf_common_definition (Elf_Internal_Sym *sym)
12345{
12346 return sym->st_shndx == SHN_COMMON;
12347}
12348
12349unsigned int
12350_bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
12351{
12352 return SHN_COMMON;
12353}
12354
12355asection *
12356_bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
12357{
12358 return bfd_com_section_ptr;
12359}
10455f89
HPN
12360
12361bfd_vma
12362_bfd_elf_default_got_elt_size (bfd *abfd,
12363 struct bfd_link_info *info ATTRIBUTE_UNUSED,
12364 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
12365 bfd *ibfd ATTRIBUTE_UNUSED,
12366 unsigned long symndx ATTRIBUTE_UNUSED)
12367{
12368 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12369 return bed->s->arch_size / 8;
12370}
83bac4b0
NC
12371
12372/* Routines to support the creation of dynamic relocs. */
12373
12374/* Return true if NAME is a name of a relocation
12375 section associated with section S. */
12376
12377static bfd_boolean
12378is_reloc_section (bfd_boolean rela, const char * name, asection * s)
12379{
12380 if (rela)
12381 return CONST_STRNEQ (name, ".rela")
12382 && strcmp (bfd_get_section_name (NULL, s), name + 5) == 0;
12383
12384 return CONST_STRNEQ (name, ".rel")
12385 && strcmp (bfd_get_section_name (NULL, s), name + 4) == 0;
12386}
12387
12388/* Returns the name of the dynamic reloc section associated with SEC. */
12389
12390static const char *
12391get_dynamic_reloc_section_name (bfd * abfd,
12392 asection * sec,
12393 bfd_boolean is_rela)
12394{
12395 const char * name;
12396 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
12397 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
12398
12399 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
12400 if (name == NULL)
12401 return NULL;
12402
12403 if (! is_reloc_section (is_rela, name, sec))
12404 {
12405 static bfd_boolean complained = FALSE;
12406
12407 if (! complained)
12408 {
12409 (*_bfd_error_handler)
12410 (_("%B: bad relocation section name `%s\'"), abfd, name);
12411 complained = TRUE;
12412 }
12413 name = NULL;
12414 }
12415
12416 return name;
12417}
12418
12419/* Returns the dynamic reloc section associated with SEC.
12420 If necessary compute the name of the dynamic reloc section based
12421 on SEC's name (looked up in ABFD's string table) and the setting
12422 of IS_RELA. */
12423
12424asection *
12425_bfd_elf_get_dynamic_reloc_section (bfd * abfd,
12426 asection * sec,
12427 bfd_boolean is_rela)
12428{
12429 asection * reloc_sec = elf_section_data (sec)->sreloc;
12430
12431 if (reloc_sec == NULL)
12432 {
12433 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12434
12435 if (name != NULL)
12436 {
12437 reloc_sec = bfd_get_section_by_name (abfd, name);
12438
12439 if (reloc_sec != NULL)
12440 elf_section_data (sec)->sreloc = reloc_sec;
12441 }
12442 }
12443
12444 return reloc_sec;
12445}
12446
12447/* Returns the dynamic reloc section associated with SEC. If the
12448 section does not exist it is created and attached to the DYNOBJ
12449 bfd and stored in the SRELOC field of SEC's elf_section_data
12450 structure.
12451
12452 ALIGNMENT is the alignment for the newly created section and
12453 IS_RELA defines whether the name should be .rela.<SEC's name>
12454 or .rel.<SEC's name>. The section name is looked up in the
12455 string table associated with ABFD. */
12456
12457asection *
12458_bfd_elf_make_dynamic_reloc_section (asection * sec,
12459 bfd * dynobj,
12460 unsigned int alignment,
12461 bfd * abfd,
12462 bfd_boolean is_rela)
12463{
12464 asection * reloc_sec = elf_section_data (sec)->sreloc;
12465
12466 if (reloc_sec == NULL)
12467 {
12468 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12469
12470 if (name == NULL)
12471 return NULL;
12472
12473 reloc_sec = bfd_get_section_by_name (dynobj, name);
12474
12475 if (reloc_sec == NULL)
12476 {
12477 flagword flags;
12478
12479 flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED);
12480 if ((sec->flags & SEC_ALLOC) != 0)
12481 flags |= SEC_ALLOC | SEC_LOAD;
12482
12483 reloc_sec = bfd_make_section_with_flags (dynobj, name, flags);
12484 if (reloc_sec != NULL)
12485 {
12486 if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
12487 reloc_sec = NULL;
12488 }
12489 }
12490
12491 elf_section_data (sec)->sreloc = reloc_sec;
12492 }
12493
12494 return reloc_sec;
12495}
This page took 1.463798 seconds and 4 git commands to generate.