* dwarf2read.c (read_initial_length): Handle older, non-standard,
[deliverable/binutils-gdb.git] / bfd / elflink.h
CommitLineData
252b5132 1/* ELF linker support.
c8e5ddc8 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
7898deda 3 Free Software Foundation, Inc.
252b5132
RH
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21/* ELF linker code. */
22
23/* This struct is used to pass information to routines called via
24 elf_link_hash_traverse which must return failure. */
25
26struct elf_info_failed
27{
28 boolean failed;
29 struct bfd_link_info *info;
bc2b6df7 30 struct bfd_elf_version_tree *verdefs;
252b5132
RH
31};
32
a7b97311
AM
33static boolean is_global_data_symbol_definition
34 PARAMS ((bfd *, Elf_Internal_Sym *));
35static boolean elf_link_is_defined_archive_symbol
36 PARAMS ((bfd *, carsym *));
252b5132
RH
37static boolean elf_link_add_object_symbols
38 PARAMS ((bfd *, struct bfd_link_info *));
39static boolean elf_link_add_archive_symbols
40 PARAMS ((bfd *, struct bfd_link_info *));
41static boolean elf_merge_symbol
215007a6
L
42 PARAMS ((bfd *, struct bfd_link_info *, const char *,
43 Elf_Internal_Sym *, asection **, bfd_vma *,
44 struct elf_link_hash_entry **, boolean *, boolean *,
45 boolean *, boolean));
46static boolean elf_add_default_symbol
47 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
48 const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
49 boolean *, boolean, boolean));
252b5132
RH
50static boolean elf_export_symbol
51 PARAMS ((struct elf_link_hash_entry *, PTR));
2b0f7ef9
JJ
52static boolean elf_finalize_dynstr
53 PARAMS ((bfd *, struct bfd_link_info *));
252b5132
RH
54static boolean elf_fix_symbol_flags
55 PARAMS ((struct elf_link_hash_entry *, struct elf_info_failed *));
56static boolean elf_adjust_dynamic_symbol
57 PARAMS ((struct elf_link_hash_entry *, PTR));
58static boolean elf_link_find_version_dependencies
59 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
60static boolean elf_link_assign_sym_version
61 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
62static boolean elf_collect_hash_codes
63 PARAMS ((struct elf_link_hash_entry *, PTR));
3e932841 64static boolean elf_link_read_relocs_from_section
6b5bd373 65 PARAMS ((bfd *, Elf_Internal_Shdr *, PTR, Elf_Internal_Rela *));
a7b97311
AM
66static size_t compute_bucket_count
67 PARAMS ((struct bfd_link_info *));
41241523 68static boolean elf_link_output_relocs
23bc299b
MM
69 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *));
70static boolean elf_link_size_reloc_section
71 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
3e932841
KH
72static void elf_link_adjust_relocs
73 PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned int,
31367b81 74 struct elf_link_hash_entry **));
db6751f2
JJ
75static int elf_link_sort_cmp1
76 PARAMS ((const void *, const void *));
77static int elf_link_sort_cmp2
78 PARAMS ((const void *, const void *));
79static size_t elf_link_sort_relocs
80 PARAMS ((bfd *, struct bfd_link_info *, asection **));
73d074b4
DJ
81static boolean elf_section_ignore_discarded_relocs
82 PARAMS ((asection *));
252b5132
RH
83
84/* Given an ELF BFD, add symbols to the global hash table as
85 appropriate. */
86
87boolean
88elf_bfd_link_add_symbols (abfd, info)
89 bfd *abfd;
90 struct bfd_link_info *info;
91{
92 switch (bfd_get_format (abfd))
93 {
94 case bfd_object:
95 return elf_link_add_object_symbols (abfd, info);
96 case bfd_archive:
97 return elf_link_add_archive_symbols (abfd, info);
98 default:
99 bfd_set_error (bfd_error_wrong_format);
100 return false;
101 }
102}
103\f
7da9d88f 104/* Return true iff this is a non-common, definition of a non-function symbol. */
48dfb430 105static boolean
7da9d88f 106is_global_data_symbol_definition (abfd, sym)
86033394 107 bfd * abfd ATTRIBUTE_UNUSED;
48dfb430
NC
108 Elf_Internal_Sym * sym;
109{
110 /* Local symbols do not count, but target specific ones might. */
111 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
112 && ELF_ST_BIND (sym->st_info) < STB_LOOS)
113 return false;
114
7da9d88f
NC
115 /* Function symbols do not count. */
116 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
117 return false;
118
48dfb430
NC
119 /* If the section is undefined, then so is the symbol. */
120 if (sym->st_shndx == SHN_UNDEF)
121 return false;
3e932841 122
48dfb430
NC
123 /* If the symbol is defined in the common section, then
124 it is a common definition and so does not count. */
125 if (sym->st_shndx == SHN_COMMON)
126 return false;
127
128 /* If the symbol is in a target specific section then we
129 must rely upon the backend to tell us what it is. */
130 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
131 /* FIXME - this function is not coded yet:
3e932841 132
48dfb430 133 return _bfd_is_global_symbol_definition (abfd, sym);
3e932841 134
48dfb430
NC
135 Instead for now assume that the definition is not global,
136 Even if this is wrong, at least the linker will behave
137 in the same way that it used to do. */
138 return false;
3e932841 139
48dfb430
NC
140 return true;
141}
142
a3a8c91d 143/* Search the symbol table of the archive element of the archive ABFD
4e8a9624 144 whose archive map contains a mention of SYMDEF, and determine if
a3a8c91d
NC
145 the symbol is defined in this element. */
146static boolean
147elf_link_is_defined_archive_symbol (abfd, symdef)
148 bfd * abfd;
149 carsym * symdef;
150{
151 Elf_Internal_Shdr * hdr;
dc810e39
AM
152 bfd_size_type symcount;
153 bfd_size_type extsymcount;
154 bfd_size_type extsymoff;
6cdc0ccc
AM
155 Elf_Internal_Sym *isymbuf;
156 Elf_Internal_Sym *isym;
157 Elf_Internal_Sym *isymend;
158 boolean result;
3e932841 159
a3a8c91d
NC
160 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
161 if (abfd == (bfd *) NULL)
162 return false;
163
164 if (! bfd_check_format (abfd, bfd_object))
165 return false;
166
48dfb430
NC
167 /* If we have already included the element containing this symbol in the
168 link then we do not need to include it again. Just claim that any symbol
169 it contains is not a definition, so that our caller will not decide to
170 (re)include this element. */
171 if (abfd->archive_pass)
172 return false;
3e932841 173
a3a8c91d
NC
174 /* Select the appropriate symbol table. */
175 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
6cdc0ccc 176 hdr = &elf_tdata (abfd)->symtab_hdr;
a3a8c91d 177 else
6cdc0ccc 178 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
a3a8c91d
NC
179
180 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
181
182 /* The sh_info field of the symtab header tells us where the
183 external symbols start. We don't care about the local symbols. */
184 if (elf_bad_symtab (abfd))
185 {
186 extsymcount = symcount;
187 extsymoff = 0;
188 }
189 else
190 {
191 extsymcount = symcount - hdr->sh_info;
192 extsymoff = hdr->sh_info;
193 }
194
6cdc0ccc 195 if (extsymcount == 0)
a3a8c91d
NC
196 return false;
197
6cdc0ccc
AM
198 /* Read in the symbol table. */
199 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
200 NULL, NULL, NULL);
201 if (isymbuf == NULL)
202 return false;
a3a8c91d
NC
203
204 /* Scan the symbol table looking for SYMDEF. */
6cdc0ccc
AM
205 result = false;
206 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
a3a8c91d 207 {
6cdc0ccc 208 const char *name;
a3a8c91d 209
6cdc0ccc
AM
210 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
211 isym->st_name);
a3a8c91d
NC
212 if (name == (const char *) NULL)
213 break;
214
215 if (strcmp (name, symdef->name) == 0)
216 {
6cdc0ccc 217 result = is_global_data_symbol_definition (abfd, isym);
a3a8c91d
NC
218 break;
219 }
220 }
221
6cdc0ccc 222 free (isymbuf);
3e932841 223
a3a8c91d
NC
224 return result;
225}
226\f
252b5132
RH
227/* Add symbols from an ELF archive file to the linker hash table. We
228 don't use _bfd_generic_link_add_archive_symbols because of a
229 problem which arises on UnixWare. The UnixWare libc.so is an
230 archive which includes an entry libc.so.1 which defines a bunch of
231 symbols. The libc.so archive also includes a number of other
232 object files, which also define symbols, some of which are the same
233 as those defined in libc.so.1. Correct linking requires that we
234 consider each object file in turn, and include it if it defines any
235 symbols we need. _bfd_generic_link_add_archive_symbols does not do
236 this; it looks through the list of undefined symbols, and includes
237 any object file which defines them. When this algorithm is used on
238 UnixWare, it winds up pulling in libc.so.1 early and defining a
239 bunch of symbols. This means that some of the other objects in the
240 archive are not included in the link, which is incorrect since they
241 precede libc.so.1 in the archive.
242
243 Fortunately, ELF archive handling is simpler than that done by
244 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
245 oddities. In ELF, if we find a symbol in the archive map, and the
246 symbol is currently undefined, we know that we must pull in that
247 object file.
248
249 Unfortunately, we do have to make multiple passes over the symbol
250 table until nothing further is resolved. */
251
252static boolean
253elf_link_add_archive_symbols (abfd, info)
254 bfd *abfd;
255 struct bfd_link_info *info;
256{
257 symindex c;
258 boolean *defined = NULL;
259 boolean *included = NULL;
260 carsym *symdefs;
261 boolean loop;
dc810e39 262 bfd_size_type amt;
252b5132
RH
263
264 if (! bfd_has_map (abfd))
265 {
266 /* An empty archive is a special case. */
267 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
268 return true;
269 bfd_set_error (bfd_error_no_armap);
270 return false;
271 }
272
273 /* Keep track of all symbols we know to be already defined, and all
274 files we know to be already included. This is to speed up the
275 second and subsequent passes. */
276 c = bfd_ardata (abfd)->symdef_count;
277 if (c == 0)
278 return true;
dc810e39
AM
279 amt = c;
280 amt *= sizeof (boolean);
1126897b
AM
281 defined = (boolean *) bfd_zmalloc (amt);
282 included = (boolean *) bfd_zmalloc (amt);
252b5132
RH
283 if (defined == (boolean *) NULL || included == (boolean *) NULL)
284 goto error_return;
252b5132
RH
285
286 symdefs = bfd_ardata (abfd)->symdefs;
287
288 do
289 {
290 file_ptr last;
291 symindex i;
292 carsym *symdef;
293 carsym *symdefend;
294
295 loop = false;
296 last = -1;
297
298 symdef = symdefs;
299 symdefend = symdef + c;
300 for (i = 0; symdef < symdefend; symdef++, i++)
301 {
302 struct elf_link_hash_entry *h;
303 bfd *element;
304 struct bfd_link_hash_entry *undefs_tail;
305 symindex mark;
306
307 if (defined[i] || included[i])
308 continue;
309 if (symdef->file_offset == last)
310 {
311 included[i] = true;
312 continue;
313 }
314
315 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
316 false, false, false);
317
318 if (h == NULL)
319 {
320 char *p, *copy;
48fc70a2 321 size_t len, first;
252b5132
RH
322
323 /* If this is a default version (the name contains @@),
48fc70a2
AM
324 look up the symbol again with only one `@' as well
325 as without the version. The effect is that references
326 to the symbol with and without the version will be
327 matched by the default symbol in the archive. */
252b5132
RH
328
329 p = strchr (symdef->name, ELF_VER_CHR);
330 if (p == NULL || p[1] != ELF_VER_CHR)
331 continue;
332
48fc70a2
AM
333 /* First check with only one `@'. */
334 len = strlen (symdef->name);
335 copy = bfd_alloc (abfd, (bfd_size_type) len);
252b5132
RH
336 if (copy == NULL)
337 goto error_return;
48fc70a2
AM
338 first = p - symdef->name + 1;
339 memcpy (copy, symdef->name, first);
340 memcpy (copy + first, symdef->name + first + 1, len - first);
252b5132
RH
341
342 h = elf_link_hash_lookup (elf_hash_table (info), copy,
343 false, false, false);
344
48fc70a2 345 if (h == NULL)
58821868 346 {
48fc70a2
AM
347 /* We also need to check references to the symbol
348 without the version. */
349
350 copy[first - 1] = '\0';
351 h = elf_link_hash_lookup (elf_hash_table (info),
352 copy, false, false, false);
353 }
354
252b5132
RH
355 bfd_release (abfd, copy);
356 }
357
358 if (h == NULL)
359 continue;
360
a3a8c91d
NC
361 if (h->root.type == bfd_link_hash_common)
362 {
363 /* We currently have a common symbol. The archive map contains
364 a reference to this symbol, so we may want to include it. We
365 only want to include it however, if this archive element
366 contains a definition of the symbol, not just another common
367 declaration of it.
368
369 Unfortunately some archivers (including GNU ar) will put
370 declarations of common symbols into their archive maps, as
371 well as real definitions, so we cannot just go by the archive
372 map alone. Instead we must read in the element's symbol
373 table and check that to see what kind of symbol definition
374 this is. */
375 if (! elf_link_is_defined_archive_symbol (abfd, symdef))
376 continue;
377 }
378 else if (h->root.type != bfd_link_hash_undefined)
252b5132
RH
379 {
380 if (h->root.type != bfd_link_hash_undefweak)
381 defined[i] = true;
382 continue;
383 }
384
385 /* We need to include this archive member. */
252b5132
RH
386 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
387 if (element == (bfd *) NULL)
388 goto error_return;
389
390 if (! bfd_check_format (element, bfd_object))
391 goto error_return;
392
393 /* Doublecheck that we have not included this object
394 already--it should be impossible, but there may be
395 something wrong with the archive. */
396 if (element->archive_pass != 0)
397 {
398 bfd_set_error (bfd_error_bad_value);
399 goto error_return;
400 }
401 element->archive_pass = 1;
402
403 undefs_tail = info->hash->undefs_tail;
404
405 if (! (*info->callbacks->add_archive_element) (info, element,
406 symdef->name))
407 goto error_return;
408 if (! elf_link_add_object_symbols (element, info))
409 goto error_return;
410
411 /* If there are any new undefined symbols, we need to make
412 another pass through the archive in order to see whether
413 they can be defined. FIXME: This isn't perfect, because
414 common symbols wind up on undefs_tail and because an
415 undefined symbol which is defined later on in this pass
416 does not require another pass. This isn't a bug, but it
417 does make the code less efficient than it could be. */
418 if (undefs_tail != info->hash->undefs_tail)
419 loop = true;
420
421 /* Look backward to mark all symbols from this object file
422 which we have already seen in this pass. */
423 mark = i;
424 do
425 {
426 included[mark] = true;
427 if (mark == 0)
428 break;
429 --mark;
430 }
431 while (symdefs[mark].file_offset == symdef->file_offset);
432
433 /* We mark subsequent symbols from this object file as we go
434 on through the loop. */
435 last = symdef->file_offset;
436 }
437 }
438 while (loop);
439
440 free (defined);
441 free (included);
442
443 return true;
444
445 error_return:
446 if (defined != (boolean *) NULL)
447 free (defined);
448 if (included != (boolean *) NULL)
449 free (included);
450 return false;
451}
452
453/* This function is called when we want to define a new symbol. It
454 handles the various cases which arise when we find a definition in
455 a dynamic object, or when there is already a definition in a
456 dynamic object. The new symbol is described by NAME, SYM, PSEC,
457 and PVALUE. We set SYM_HASH to the hash table entry. We set
458 OVERRIDE if the old symbol is overriding a new definition. We set
459 TYPE_CHANGE_OK if it is OK for the type to change. We set
460 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
461 change, we mean that we shouldn't warn if the type or size does
456981d7
L
462 change. DT_NEEDED indicates if it comes from a DT_NEEDED entry of
463 a shared object. */
252b5132
RH
464
465static boolean
466elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash,
456981d7 467 override, type_change_ok, size_change_ok, dt_needed)
252b5132
RH
468 bfd *abfd;
469 struct bfd_link_info *info;
470 const char *name;
471 Elf_Internal_Sym *sym;
472 asection **psec;
473 bfd_vma *pvalue;
474 struct elf_link_hash_entry **sym_hash;
475 boolean *override;
476 boolean *type_change_ok;
477 boolean *size_change_ok;
456981d7 478 boolean dt_needed;
252b5132
RH
479{
480 asection *sec;
481 struct elf_link_hash_entry *h;
482 int bind;
483 bfd *oldbfd;
484 boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
485
486 *override = false;
487
488 sec = *psec;
489 bind = ELF_ST_BIND (sym->st_info);
490
491 if (! bfd_is_und_section (sec))
492 h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
493 else
494 h = ((struct elf_link_hash_entry *)
495 bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
496 if (h == NULL)
497 return false;
498 *sym_hash = h;
499
500 /* This code is for coping with dynamic objects, and is only useful
501 if we are doing an ELF link. */
502 if (info->hash->creator != abfd->xvec)
503 return true;
504
505 /* For merging, we only care about real symbols. */
506
507 while (h->root.type == bfd_link_hash_indirect
508 || h->root.type == bfd_link_hash_warning)
509 h = (struct elf_link_hash_entry *) h->root.u.i.link;
510
511 /* If we just created the symbol, mark it as being an ELF symbol.
512 Other than that, there is nothing to do--there is no merge issue
513 with a newly defined symbol--so we just return. */
514
515 if (h->root.type == bfd_link_hash_new)
516 {
517 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
518 return true;
519 }
520
521 /* OLDBFD is a BFD associated with the existing symbol. */
522
523 switch (h->root.type)
524 {
525 default:
526 oldbfd = NULL;
527 break;
528
529 case bfd_link_hash_undefined:
530 case bfd_link_hash_undefweak:
531 oldbfd = h->root.u.undef.abfd;
532 break;
533
534 case bfd_link_hash_defined:
535 case bfd_link_hash_defweak:
536 oldbfd = h->root.u.def.section->owner;
537 break;
538
539 case bfd_link_hash_common:
540 oldbfd = h->root.u.c.p->section->owner;
541 break;
542 }
543
b4536acd
ILT
544 /* In cases involving weak versioned symbols, we may wind up trying
545 to merge a symbol with itself. Catch that here, to avoid the
546 confusion that results if we try to override a symbol with
accc7f69
ILT
547 itself. The additional tests catch cases like
548 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
549 dynamic object, which we do want to handle here. */
550 if (abfd == oldbfd
551 && ((abfd->flags & DYNAMIC) == 0
552 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
b4536acd
ILT
553 return true;
554
252b5132
RH
555 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
556 respectively, is from a dynamic object. */
557
558 if ((abfd->flags & DYNAMIC) != 0)
559 newdyn = true;
560 else
561 newdyn = false;
562
0035bd7b
ILT
563 if (oldbfd != NULL)
564 olddyn = (oldbfd->flags & DYNAMIC) != 0;
252b5132 565 else
0035bd7b
ILT
566 {
567 asection *hsec;
568
569 /* This code handles the special SHN_MIPS_{TEXT,DATA} section
c44233aa 570 indices used by MIPS ELF. */
0035bd7b
ILT
571 switch (h->root.type)
572 {
573 default:
574 hsec = NULL;
575 break;
576
577 case bfd_link_hash_defined:
578 case bfd_link_hash_defweak:
579 hsec = h->root.u.def.section;
580 break;
581
582 case bfd_link_hash_common:
583 hsec = h->root.u.c.p->section;
584 break;
585 }
586
587 if (hsec == NULL)
588 olddyn = false;
589 else
590 olddyn = (hsec->symbol->flags & BSF_DYNAMIC) != 0;
591 }
252b5132
RH
592
593 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
594 respectively, appear to be a definition rather than reference. */
595
596 if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
597 newdef = false;
598 else
599 newdef = true;
600
601 if (h->root.type == bfd_link_hash_undefined
602 || h->root.type == bfd_link_hash_undefweak
603 || h->root.type == bfd_link_hash_common)
604 olddef = false;
605 else
606 olddef = true;
607
608 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
609 symbol, respectively, appears to be a common symbol in a dynamic
610 object. If a symbol appears in an uninitialized section, and is
611 not weak, and is not a function, then it may be a common symbol
612 which was resolved when the dynamic object was created. We want
613 to treat such symbols specially, because they raise special
614 considerations when setting the symbol size: if the symbol
615 appears as a common symbol in a regular object, and the size in
616 the regular object is larger, we must make sure that we use the
617 larger size. This problematic case can always be avoided in C,
618 but it must be handled correctly when using Fortran shared
619 libraries.
620
621 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
622 likewise for OLDDYNCOMMON and OLDDEF.
623
624 Note that this test is just a heuristic, and that it is quite
625 possible to have an uninitialized symbol in a shared object which
626 is really a definition, rather than a common symbol. This could
627 lead to some minor confusion when the symbol really is a common
628 symbol in some regular object. However, I think it will be
629 harmless. */
630
631 if (newdyn
632 && newdef
633 && (sec->flags & SEC_ALLOC) != 0
634 && (sec->flags & SEC_LOAD) == 0
635 && sym->st_size > 0
636 && bind != STB_WEAK
637 && ELF_ST_TYPE (sym->st_info) != STT_FUNC)
638 newdyncommon = true;
639 else
640 newdyncommon = false;
641
642 if (olddyn
643 && olddef
644 && h->root.type == bfd_link_hash_defined
645 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
646 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
647 && (h->root.u.def.section->flags & SEC_LOAD) == 0
648 && h->size > 0
649 && h->type != STT_FUNC)
650 olddyncommon = true;
651 else
652 olddyncommon = false;
653
654 /* It's OK to change the type if either the existing symbol or the
456981d7
L
655 new symbol is weak unless it comes from a DT_NEEDED entry of
656 a shared object, in which case, the DT_NEEDED entry may not be
3e932841 657 required at the run time. */
252b5132 658
456981d7 659 if ((! dt_needed && h->root.type == bfd_link_hash_defweak)
252b5132
RH
660 || h->root.type == bfd_link_hash_undefweak
661 || bind == STB_WEAK)
662 *type_change_ok = true;
663
664 /* It's OK to change the size if either the existing symbol or the
665 new symbol is weak, or if the old symbol is undefined. */
666
667 if (*type_change_ok
668 || h->root.type == bfd_link_hash_undefined)
669 *size_change_ok = true;
670
671 /* If both the old and the new symbols look like common symbols in a
672 dynamic object, set the size of the symbol to the larger of the
673 two. */
674
675 if (olddyncommon
676 && newdyncommon
677 && sym->st_size != h->size)
678 {
679 /* Since we think we have two common symbols, issue a multiple
c44233aa
AM
680 common warning if desired. Note that we only warn if the
681 size is different. If the size is the same, we simply let
682 the old symbol override the new one as normally happens with
683 symbols defined in dynamic objects. */
252b5132
RH
684
685 if (! ((*info->callbacks->multiple_common)
686 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
687 h->size, abfd, bfd_link_hash_common, sym->st_size)))
688 return false;
689
690 if (sym->st_size > h->size)
691 h->size = sym->st_size;
692
693 *size_change_ok = true;
694 }
695
696 /* If we are looking at a dynamic object, and we have found a
697 definition, we need to see if the symbol was already defined by
698 some other object. If so, we want to use the existing
699 definition, and we do not want to report a multiple symbol
700 definition error; we do this by clobbering *PSEC to be
701 bfd_und_section_ptr.
702
703 We treat a common symbol as a definition if the symbol in the
704 shared library is a function, since common symbols always
705 represent variables; this can cause confusion in principle, but
706 any such confusion would seem to indicate an erroneous program or
707 shared library. We also permit a common symbol in a regular
0525d26e
ILT
708 object to override a weak symbol in a shared object.
709
710 We prefer a non-weak definition in a shared library to a weak
456981d7
L
711 definition in the executable unless it comes from a DT_NEEDED
712 entry of a shared object, in which case, the DT_NEEDED entry
3e932841 713 may not be required at the run time. */
252b5132
RH
714
715 if (newdyn
716 && newdef
717 && (olddef
718 || (h->root.type == bfd_link_hash_common
719 && (bind == STB_WEAK
0525d26e 720 || ELF_ST_TYPE (sym->st_info) == STT_FUNC)))
3e932841 721 && (h->root.type != bfd_link_hash_defweak
456981d7 722 || dt_needed
0525d26e 723 || bind == STB_WEAK))
252b5132
RH
724 {
725 *override = true;
726 newdef = false;
727 newdyncommon = false;
728
729 *psec = sec = bfd_und_section_ptr;
730 *size_change_ok = true;
731
732 /* If we get here when the old symbol is a common symbol, then
c44233aa
AM
733 we are explicitly letting it override a weak symbol or
734 function in a dynamic object, and we don't want to warn about
735 a type change. If the old symbol is a defined symbol, a type
736 change warning may still be appropriate. */
252b5132
RH
737
738 if (h->root.type == bfd_link_hash_common)
739 *type_change_ok = true;
740 }
741
742 /* Handle the special case of an old common symbol merging with a
743 new symbol which looks like a common symbol in a shared object.
744 We change *PSEC and *PVALUE to make the new symbol look like a
745 common symbol, and let _bfd_generic_link_add_one_symbol will do
746 the right thing. */
747
748 if (newdyncommon
749 && h->root.type == bfd_link_hash_common)
750 {
751 *override = true;
752 newdef = false;
753 newdyncommon = false;
754 *pvalue = sym->st_size;
755 *psec = sec = bfd_com_section_ptr;
756 *size_change_ok = true;
757 }
758
759 /* If the old symbol is from a dynamic object, and the new symbol is
760 a definition which is not from a dynamic object, then the new
761 symbol overrides the old symbol. Symbols from regular files
762 always take precedence over symbols from dynamic objects, even if
763 they are defined after the dynamic object in the link.
764
765 As above, we again permit a common symbol in a regular object to
766 override a definition in a shared object if the shared object
0525d26e
ILT
767 symbol is a function or is weak.
768
769 As above, we permit a non-weak definition in a shared object to
770 override a weak definition in a regular object. */
252b5132
RH
771
772 if (! newdyn
773 && (newdef
774 || (bfd_is_com_section (sec)
775 && (h->root.type == bfd_link_hash_defweak
776 || h->type == STT_FUNC)))
777 && olddyn
778 && olddef
0525d26e
ILT
779 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
780 && (bind != STB_WEAK
781 || h->root.type == bfd_link_hash_defweak))
252b5132
RH
782 {
783 /* Change the hash table entry to undefined, and let
784 _bfd_generic_link_add_one_symbol do the right thing with the
785 new definition. */
786
787 h->root.type = bfd_link_hash_undefined;
788 h->root.u.undef.abfd = h->root.u.def.section->owner;
789 *size_change_ok = true;
790
791 olddef = false;
792 olddyncommon = false;
793
794 /* We again permit a type change when a common symbol may be
c44233aa 795 overriding a function. */
252b5132
RH
796
797 if (bfd_is_com_section (sec))
798 *type_change_ok = true;
799
800 /* This union may have been set to be non-NULL when this symbol
801 was seen in a dynamic object. We must force the union to be
802 NULL, so that it is correct for a regular symbol. */
803
804 h->verinfo.vertree = NULL;
805
806 /* In this special case, if H is the target of an indirection,
c44233aa
AM
807 we want the caller to frob with H rather than with the
808 indirect symbol. That will permit the caller to redefine the
809 target of the indirection, rather than the indirect symbol
810 itself. FIXME: This will break the -y option if we store a
811 symbol with a different name. */
252b5132
RH
812 *sym_hash = h;
813 }
814
815 /* Handle the special case of a new common symbol merging with an
816 old symbol that looks like it might be a common symbol defined in
817 a shared object. Note that we have already handled the case in
818 which a new common symbol should simply override the definition
819 in the shared library. */
820
821 if (! newdyn
822 && bfd_is_com_section (sec)
823 && olddyncommon)
824 {
825 /* It would be best if we could set the hash table entry to a
826 common symbol, but we don't know what to use for the section
827 or the alignment. */
828 if (! ((*info->callbacks->multiple_common)
829 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
830 h->size, abfd, bfd_link_hash_common, sym->st_size)))
831 return false;
832
833 /* If the predumed common symbol in the dynamic object is
c44233aa 834 larger, pretend that the new symbol has its size. */
252b5132
RH
835
836 if (h->size > *pvalue)
837 *pvalue = h->size;
838
839 /* FIXME: We no longer know the alignment required by the symbol
840 in the dynamic object, so we just wind up using the one from
841 the regular object. */
842
843 olddef = false;
844 olddyncommon = false;
845
846 h->root.type = bfd_link_hash_undefined;
847 h->root.u.undef.abfd = h->root.u.def.section->owner;
848
849 *size_change_ok = true;
850 *type_change_ok = true;
851
852 h->verinfo.vertree = NULL;
853 }
854
0525d26e
ILT
855 /* Handle the special case of a weak definition in a regular object
856 followed by a non-weak definition in a shared object. In this
456981d7
L
857 case, we prefer the definition in the shared object unless it
858 comes from a DT_NEEDED entry of a shared object, in which case,
3e932841 859 the DT_NEEDED entry may not be required at the run time. */
0525d26e 860 if (olddef
456981d7 861 && ! dt_needed
0525d26e
ILT
862 && h->root.type == bfd_link_hash_defweak
863 && newdef
864 && newdyn
865 && bind != STB_WEAK)
b4536acd
ILT
866 {
867 /* To make this work we have to frob the flags so that the rest
c44233aa
AM
868 of the code does not think we are using the regular
869 definition. */
64df8d0b
ILT
870 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
871 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
872 else if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
873 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
874 h->elf_link_hash_flags &= ~ (ELF_LINK_HASH_DEF_REGULAR
875 | ELF_LINK_HASH_DEF_DYNAMIC);
b4536acd
ILT
876
877 /* If H is the target of an indirection, we want the caller to
c44233aa
AM
878 use H rather than the indirect symbol. Otherwise if we are
879 defining a new indirect symbol we will wind up attaching it
880 to the entry we are overriding. */
b4536acd
ILT
881 *sym_hash = h;
882 }
0525d26e
ILT
883
884 /* Handle the special case of a non-weak definition in a shared
885 object followed by a weak definition in a regular object. In
886 this case we prefer to definition in the shared object. To make
887 this work we have to tell the caller to not treat the new symbol
888 as a definition. */
889 if (olddef
890 && olddyn
891 && h->root.type != bfd_link_hash_defweak
892 && newdef
893 && ! newdyn
894 && bind == STB_WEAK)
895 *override = true;
896
252b5132
RH
897 return true;
898}
899
215007a6
L
900/* This function is called to create an indirect symbol from the
901 default for the symbol with the default version if needed. The
902 symbol is described by H, NAME, SYM, SEC, VALUE, and OVERRIDE. We
903 set DYNSYM if the new indirect symbol is dynamic. DT_NEEDED
904 indicates if it comes from a DT_NEEDED entry of a shared object. */
905
906static boolean
907elf_add_default_symbol (abfd, info, h, name, sym, sec, value,
908 dynsym, override, dt_needed)
909 bfd *abfd;
910 struct bfd_link_info *info;
911 struct elf_link_hash_entry *h;
912 const char *name;
913 Elf_Internal_Sym *sym;
914 asection **sec;
915 bfd_vma *value;
916 boolean *dynsym;
917 boolean override;
918 boolean dt_needed;
919{
920 boolean type_change_ok;
921 boolean size_change_ok;
922 char *shortname;
923 struct elf_link_hash_entry *hi;
924 struct elf_backend_data *bed;
925 boolean collect;
926 boolean dynamic;
927 char *p;
d4c88bbb 928 size_t len, shortlen;
215007a6
L
929
930 /* If this symbol has a version, and it is the default version, we
931 create an indirect symbol from the default name to the fully
932 decorated name. This will cause external references which do not
933 specify a version to be bound to this version of the symbol. */
934 p = strchr (name, ELF_VER_CHR);
935 if (p == NULL || p[1] != ELF_VER_CHR)
936 return true;
937
938 if (override)
939 {
940 /* We are overridden by an old defition. We need to check if we
d4c88bbb 941 need to create the indirect symbol from the default name. */
215007a6
L
942 hi = elf_link_hash_lookup (elf_hash_table (info), name, true,
943 false, false);
944 BFD_ASSERT (hi != NULL);
945 if (hi == h)
946 return true;
947 while (hi->root.type == bfd_link_hash_indirect
948 || hi->root.type == bfd_link_hash_warning)
949 {
950 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
951 if (hi == h)
952 return true;
953 }
954 }
955
956 bed = get_elf_backend_data (abfd);
957 collect = bed->collect;
958 dynamic = (abfd->flags & DYNAMIC) != 0;
959
d4c88bbb
AM
960 shortlen = p - name;
961 shortname = bfd_hash_allocate (&info->hash->table, shortlen + 1);
215007a6
L
962 if (shortname == NULL)
963 return false;
d4c88bbb
AM
964 memcpy (shortname, name, shortlen);
965 shortname[shortlen] = '\0';
215007a6
L
966
967 /* We are going to create a new symbol. Merge it with any existing
968 symbol with this name. For the purposes of the merge, act as
969 though we were defining the symbol we just defined, although we
970 actually going to define an indirect symbol. */
971 type_change_ok = false;
972 size_change_ok = false;
973 if (! elf_merge_symbol (abfd, info, shortname, sym, sec, value,
974 &hi, &override, &type_change_ok,
975 &size_change_ok, dt_needed))
976 return false;
977
978 if (! override)
979 {
980 if (! (_bfd_generic_link_add_one_symbol
981 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
982 (bfd_vma) 0, name, false, collect,
983 (struct bfd_link_hash_entry **) &hi)))
984 return false;
985 }
986 else
987 {
988 /* In this case the symbol named SHORTNAME is overriding the
989 indirect symbol we want to add. We were planning on making
990 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
991 is the name without a version. NAME is the fully versioned
992 name, and it is the default version.
993
994 Overriding means that we already saw a definition for the
995 symbol SHORTNAME in a regular object, and it is overriding
996 the symbol defined in the dynamic object.
997
998 When this happens, we actually want to change NAME, the
999 symbol we just added, to refer to SHORTNAME. This will cause
1000 references to NAME in the shared object to become references
1001 to SHORTNAME in the regular object. This is what we expect
1002 when we override a function in a shared object: that the
1003 references in the shared object will be mapped to the
1004 definition in the regular object. */
1005
1006 while (hi->root.type == bfd_link_hash_indirect
1007 || hi->root.type == bfd_link_hash_warning)
1008 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1009
1010 h->root.type = bfd_link_hash_indirect;
1011 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1012 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
1013 {
1014 h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
1015 hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1016 if (hi->elf_link_hash_flags
1017 & (ELF_LINK_HASH_REF_REGULAR
1018 | ELF_LINK_HASH_DEF_REGULAR))
1019 {
1020 if (! _bfd_elf_link_record_dynamic_symbol (info, hi))
1021 return false;
1022 }
1023 }
1024
1025 /* Now set HI to H, so that the following code will set the
c44233aa 1026 other fields correctly. */
215007a6
L
1027 hi = h;
1028 }
1029
1030 /* If there is a duplicate definition somewhere, then HI may not
1031 point to an indirect symbol. We will have reported an error to
1032 the user in that case. */
1033
1034 if (hi->root.type == bfd_link_hash_indirect)
1035 {
1036 struct elf_link_hash_entry *ht;
1037
1038 /* If the symbol became indirect, then we assume that we have
1039 not seen a definition before. */
1040 BFD_ASSERT ((hi->elf_link_hash_flags
1041 & (ELF_LINK_HASH_DEF_DYNAMIC
1042 | ELF_LINK_HASH_DEF_REGULAR)) == 0);
1043
1044 ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1045 (*bed->elf_backend_copy_indirect_symbol) (ht, hi);
1046
1047 /* See if the new flags lead us to realize that the symbol must
1048 be dynamic. */
1049 if (! *dynsym)
1050 {
1051 if (! dynamic)
1052 {
1053 if (info->shared
1054 || ((hi->elf_link_hash_flags
1055 & ELF_LINK_HASH_REF_DYNAMIC) != 0))
1056 *dynsym = true;
1057 }
1058 else
1059 {
1060 if ((hi->elf_link_hash_flags
1061 & ELF_LINK_HASH_REF_REGULAR) != 0)
1062 *dynsym = true;
1063 }
1064 }
1065 }
1066
1067 /* We also need to define an indirection from the nondefault version
1068 of the symbol. */
1069
d4c88bbb
AM
1070 len = strlen (name);
1071 shortname = bfd_hash_allocate (&info->hash->table, len);
215007a6
L
1072 if (shortname == NULL)
1073 return false;
d4c88bbb
AM
1074 memcpy (shortname, name, shortlen);
1075 memcpy (shortname + shortlen, p + 1, len - shortlen);
215007a6
L
1076
1077 /* Once again, merge with any existing symbol. */
1078 type_change_ok = false;
1079 size_change_ok = false;
1080 if (! elf_merge_symbol (abfd, info, shortname, sym, sec, value,
1081 &hi, &override, &type_change_ok,
1082 &size_change_ok, dt_needed))
1083 return false;
1084
1085 if (override)
1086 {
1087 /* Here SHORTNAME is a versioned name, so we don't expect to see
1088 the type of override we do in the case above. */
1089 (*_bfd_error_handler)
1090 (_("%s: warning: unexpected redefinition of `%s'"),
1091 bfd_archive_filename (abfd), shortname);
1092 }
1093 else
1094 {
1095 if (! (_bfd_generic_link_add_one_symbol
1096 (info, abfd, shortname, BSF_INDIRECT,
1097 bfd_ind_section_ptr, (bfd_vma) 0, name, false,
1098 collect, (struct bfd_link_hash_entry **) &hi)))
1099 return false;
1100
1101 /* If there is a duplicate definition somewhere, then HI may not
1102 point to an indirect symbol. We will have reported an error
1103 to the user in that case. */
1104
1105 if (hi->root.type == bfd_link_hash_indirect)
1106 {
1107 /* If the symbol became indirect, then we assume that we have
1108 not seen a definition before. */
1109 BFD_ASSERT ((hi->elf_link_hash_flags
1110 & (ELF_LINK_HASH_DEF_DYNAMIC
1111 | ELF_LINK_HASH_DEF_REGULAR)) == 0);
1112
c44233aa 1113 (*bed->elf_backend_copy_indirect_symbol) (h, hi);
215007a6
L
1114
1115 /* See if the new flags lead us to realize that the symbol
1116 must be dynamic. */
1117 if (! *dynsym)
1118 {
1119 if (! dynamic)
1120 {
1121 if (info->shared
1122 || ((hi->elf_link_hash_flags
1123 & ELF_LINK_HASH_REF_DYNAMIC) != 0))
1124 *dynsym = true;
1125 }
1126 else
1127 {
1128 if ((hi->elf_link_hash_flags
1129 & ELF_LINK_HASH_REF_REGULAR) != 0)
1130 *dynsym = true;
1131 }
1132 }
1133 }
1134 }
1135
1136 return true;
1137}
1138
252b5132
RH
1139/* Add symbols from an ELF object file to the linker hash table. */
1140
1141static boolean
1142elf_link_add_object_symbols (abfd, info)
1143 bfd *abfd;
1144 struct bfd_link_info *info;
1145{
1146 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
1147 const Elf_Internal_Sym *,
1148 const char **, flagword *,
1149 asection **, bfd_vma *));
1150 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
1151 asection *, const Elf_Internal_Rela *));
1152 boolean collect;
1153 Elf_Internal_Shdr *hdr;
dc810e39
AM
1154 bfd_size_type symcount;
1155 bfd_size_type extsymcount;
1156 bfd_size_type extsymoff;
252b5132
RH
1157 struct elf_link_hash_entry **sym_hash;
1158 boolean dynamic;
252b5132
RH
1159 Elf_External_Versym *extversym = NULL;
1160 Elf_External_Versym *ever;
252b5132 1161 struct elf_link_hash_entry *weaks;
6cdc0ccc
AM
1162 Elf_Internal_Sym *isymbuf = NULL;
1163 Elf_Internal_Sym *isym;
1164 Elf_Internal_Sym *isymend;
c61b8717 1165 struct elf_backend_data *bed;
74816898 1166 boolean dt_needed;
8ea2e4bd 1167 struct elf_link_hash_table * hash_table;
dc810e39 1168 bfd_size_type amt;
8ea2e4bd
NC
1169
1170 hash_table = elf_hash_table (info);
252b5132 1171
c61b8717
RH
1172 bed = get_elf_backend_data (abfd);
1173 add_symbol_hook = bed->elf_add_symbol_hook;
1174 collect = bed->collect;
252b5132
RH
1175
1176 if ((abfd->flags & DYNAMIC) == 0)
1177 dynamic = false;
1178 else
1179 {
1180 dynamic = true;
1181
1182 /* You can't use -r against a dynamic object. Also, there's no
1183 hope of using a dynamic object which does not exactly match
1184 the format of the output file. */
1185 if (info->relocateable || info->hash->creator != abfd->xvec)
1186 {
1187 bfd_set_error (bfd_error_invalid_operation);
1188 goto error_return;
1189 }
1190 }
1191
1192 /* As a GNU extension, any input sections which are named
1193 .gnu.warning.SYMBOL are treated as warning symbols for the given
1194 symbol. This differs from .gnu.warning sections, which generate
1195 warnings when they are included in an output file. */
1196 if (! info->shared)
1197 {
1198 asection *s;
1199
1200 for (s = abfd->sections; s != NULL; s = s->next)
1201 {
1202 const char *name;
1203
1204 name = bfd_get_section_name (abfd, s);
1205 if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
1206 {
1207 char *msg;
1208 bfd_size_type sz;
1209
1210 name += sizeof ".gnu.warning." - 1;
1211
1212 /* If this is a shared object, then look up the symbol
1213 in the hash table. If it is there, and it is already
1214 been defined, then we will not be using the entry
1215 from this shared object, so we don't need to warn.
1216 FIXME: If we see the definition in a regular object
1217 later on, we will warn, but we shouldn't. The only
1218 fix is to keep track of what warnings we are supposed
1219 to emit, and then handle them all at the end of the
1220 link. */
1221 if (dynamic && abfd->xvec == info->hash->creator)
1222 {
1223 struct elf_link_hash_entry *h;
1224
8ea2e4bd 1225 h = elf_link_hash_lookup (hash_table, name,
252b5132
RH
1226 false, false, true);
1227
1228 /* FIXME: What about bfd_link_hash_common? */
1229 if (h != NULL
1230 && (h->root.type == bfd_link_hash_defined
1231 || h->root.type == bfd_link_hash_defweak))
1232 {
1233 /* We don't want to issue this warning. Clobber
c44233aa
AM
1234 the section size so that the warning does not
1235 get copied into the output file. */
252b5132
RH
1236 s->_raw_size = 0;
1237 continue;
1238 }
1239 }
1240
1241 sz = bfd_section_size (abfd, s);
1242 msg = (char *) bfd_alloc (abfd, sz + 1);
1243 if (msg == NULL)
1244 goto error_return;
1245
1246 if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
1247 goto error_return;
1248
1249 msg[sz] = '\0';
1250
1251 if (! (_bfd_generic_link_add_one_symbol
1252 (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
1253 false, collect, (struct bfd_link_hash_entry **) NULL)))
1254 goto error_return;
1255
1256 if (! info->relocateable)
1257 {
1258 /* Clobber the section size so that the warning does
c44233aa 1259 not get copied into the output file. */
252b5132
RH
1260 s->_raw_size = 0;
1261 }
1262 }
1263 }
1264 }
1265
74816898 1266 dt_needed = false;
252b5132
RH
1267 if (! dynamic)
1268 {
1269 /* If we are creating a shared library, create all the dynamic
c44233aa
AM
1270 sections immediately. We need to attach them to something,
1271 so we attach them to this BFD, provided it is the right
1272 format. FIXME: If there are no input BFD's of the same
1273 format as the output, we can't make a shared library. */
252b5132 1274 if (info->shared
8ea2e4bd
NC
1275 && is_elf_hash_table (info)
1276 && ! hash_table->dynamic_sections_created
252b5132
RH
1277 && abfd->xvec == info->hash->creator)
1278 {
1279 if (! elf_link_create_dynamic_sections (abfd, info))
1280 goto error_return;
1281 }
1282 }
8ea2e4bd
NC
1283 else if (! is_elf_hash_table (info))
1284 goto error_return;
252b5132
RH
1285 else
1286 {
1287 asection *s;
1288 boolean add_needed;
1289 const char *name;
1290 bfd_size_type oldsize;
1291 bfd_size_type strindex;
1292
1293 /* Find the name to use in a DT_NEEDED entry that refers to this
1294 object. If the object has a DT_SONAME entry, we use it.
1295 Otherwise, if the generic linker stuck something in
1296 elf_dt_name, we use that. Otherwise, we just use the file
1297 name. If the generic linker put a null string into
1298 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
1299 there is a DT_SONAME entry. */
1300 add_needed = true;
7913c838 1301 name = bfd_get_filename (abfd);
252b5132
RH
1302 if (elf_dt_name (abfd) != NULL)
1303 {
1304 name = elf_dt_name (abfd);
1305 if (*name == '\0')
74816898
L
1306 {
1307 if (elf_dt_soname (abfd) != NULL)
c44233aa 1308 dt_needed = true;
74816898
L
1309
1310 add_needed = false;
1311 }
252b5132
RH
1312 }
1313 s = bfd_get_section_by_name (abfd, ".dynamic");
1314 if (s != NULL)
1315 {
6cdc0ccc 1316 Elf_External_Dyn *dynbuf = NULL;
252b5132
RH
1317 Elf_External_Dyn *extdyn;
1318 Elf_External_Dyn *extdynend;
1319 int elfsec;
dc810e39 1320 unsigned long shlink;
a963dc6a
L
1321 int rpath;
1322 int runpath;
252b5132 1323
dc810e39 1324 dynbuf = (Elf_External_Dyn *) bfd_malloc (s->_raw_size);
252b5132
RH
1325 if (dynbuf == NULL)
1326 goto error_return;
1327
1328 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
1329 (file_ptr) 0, s->_raw_size))
6cdc0ccc 1330 goto error_free_dyn;
252b5132
RH
1331
1332 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1333 if (elfsec == -1)
6cdc0ccc 1334 goto error_free_dyn;
dc810e39 1335 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
252b5132
RH
1336
1337 extdyn = dynbuf;
1338 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
a963dc6a
L
1339 rpath = 0;
1340 runpath = 0;
252b5132
RH
1341 for (; extdyn < extdynend; extdyn++)
1342 {
1343 Elf_Internal_Dyn dyn;
1344
1345 elf_swap_dyn_in (abfd, extdyn, &dyn);
1346 if (dyn.d_tag == DT_SONAME)
1347 {
dc810e39
AM
1348 unsigned int tagv = dyn.d_un.d_val;
1349 name = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
252b5132 1350 if (name == NULL)
6cdc0ccc 1351 goto error_free_dyn;
252b5132
RH
1352 }
1353 if (dyn.d_tag == DT_NEEDED)
1354 {
1355 struct bfd_link_needed_list *n, **pn;
1356 char *fnm, *anm;
dc810e39 1357 unsigned int tagv = dyn.d_un.d_val;
252b5132 1358
dc810e39
AM
1359 amt = sizeof (struct bfd_link_needed_list);
1360 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1361 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
252b5132 1362 if (n == NULL || fnm == NULL)
6cdc0ccc 1363 goto error_free_dyn;
d4c88bbb
AM
1364 amt = strlen (fnm) + 1;
1365 anm = bfd_alloc (abfd, amt);
252b5132 1366 if (anm == NULL)
6cdc0ccc 1367 goto error_free_dyn;
d4c88bbb 1368 memcpy (anm, fnm, (size_t) amt);
252b5132
RH
1369 n->name = anm;
1370 n->by = abfd;
1371 n->next = NULL;
8ea2e4bd 1372 for (pn = & hash_table->needed;
252b5132
RH
1373 *pn != NULL;
1374 pn = &(*pn)->next)
1375 ;
1376 *pn = n;
1377 }
a963dc6a
L
1378 if (dyn.d_tag == DT_RUNPATH)
1379 {
1380 struct bfd_link_needed_list *n, **pn;
1381 char *fnm, *anm;
dc810e39 1382 unsigned int tagv = dyn.d_un.d_val;
a963dc6a
L
1383
1384 /* When we see DT_RPATH before DT_RUNPATH, we have
512a2384
AM
1385 to clear runpath. Do _NOT_ bfd_release, as that
1386 frees all more recently bfd_alloc'd blocks as
1387 well. */
8ea2e4bd
NC
1388 if (rpath && hash_table->runpath)
1389 hash_table->runpath = NULL;
a963dc6a 1390
dc810e39
AM
1391 amt = sizeof (struct bfd_link_needed_list);
1392 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1393 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
a963dc6a 1394 if (n == NULL || fnm == NULL)
6cdc0ccc 1395 goto error_free_dyn;
d4c88bbb
AM
1396 amt = strlen (fnm) + 1;
1397 anm = bfd_alloc (abfd, amt);
a963dc6a 1398 if (anm == NULL)
6cdc0ccc 1399 goto error_free_dyn;
d4c88bbb 1400 memcpy (anm, fnm, (size_t) amt);
a963dc6a
L
1401 n->name = anm;
1402 n->by = abfd;
1403 n->next = NULL;
8ea2e4bd 1404 for (pn = & hash_table->runpath;
a963dc6a
L
1405 *pn != NULL;
1406 pn = &(*pn)->next)
1407 ;
1408 *pn = n;
1409 runpath = 1;
1410 rpath = 0;
1411 }
3e932841 1412 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
a963dc6a 1413 if (!runpath && dyn.d_tag == DT_RPATH)
c44233aa 1414 {
a963dc6a
L
1415 struct bfd_link_needed_list *n, **pn;
1416 char *fnm, *anm;
dc810e39 1417 unsigned int tagv = dyn.d_un.d_val;
a963dc6a 1418
dc810e39
AM
1419 amt = sizeof (struct bfd_link_needed_list);
1420 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1421 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
a963dc6a 1422 if (n == NULL || fnm == NULL)
6cdc0ccc 1423 goto error_free_dyn;
d4c88bbb
AM
1424 amt = strlen (fnm) + 1;
1425 anm = bfd_alloc (abfd, amt);
a963dc6a 1426 if (anm == NULL)
6cdc0ccc
AM
1427 {
1428 error_free_dyn:
1429 free (dynbuf);
1430 goto error_return;
1431 }
d4c88bbb 1432 memcpy (anm, fnm, (size_t) amt);
a963dc6a
L
1433 n->name = anm;
1434 n->by = abfd;
1435 n->next = NULL;
8ea2e4bd 1436 for (pn = & hash_table->runpath;
a963dc6a
L
1437 *pn != NULL;
1438 pn = &(*pn)->next)
1439 ;
1440 *pn = n;
1441 rpath = 1;
1442 }
252b5132
RH
1443 }
1444
1445 free (dynbuf);
252b5132
RH
1446 }
1447
1448 /* We do not want to include any of the sections in a dynamic
1449 object in the output file. We hack by simply clobbering the
1450 list of sections in the BFD. This could be handled more
1451 cleanly by, say, a new section flag; the existing
1452 SEC_NEVER_LOAD flag is not the one we want, because that one
1453 still implies that the section takes up space in the output
1454 file. */
c601ffdb 1455 bfd_section_list_clear (abfd);
252b5132
RH
1456
1457 /* If this is the first dynamic object found in the link, create
1458 the special sections required for dynamic linking. */
8ea2e4bd
NC
1459 if (! hash_table->dynamic_sections_created)
1460 if (! elf_link_create_dynamic_sections (abfd, info))
1461 goto error_return;
252b5132
RH
1462
1463 if (add_needed)
1464 {
1465 /* Add a DT_NEEDED entry for this dynamic object. */
2b0f7ef9
JJ
1466 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
1467 strindex = _bfd_elf_strtab_add (hash_table->dynstr, name, false);
252b5132
RH
1468 if (strindex == (bfd_size_type) -1)
1469 goto error_return;
1470
2b0f7ef9 1471 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
252b5132
RH
1472 {
1473 asection *sdyn;
1474 Elf_External_Dyn *dyncon, *dynconend;
1475
1476 /* The hash table size did not change, which means that
1477 the dynamic object name was already entered. If we
1478 have already included this dynamic object in the
1479 link, just ignore it. There is no reason to include
1480 a particular dynamic object more than once. */
8ea2e4bd 1481 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
252b5132
RH
1482 BFD_ASSERT (sdyn != NULL);
1483
1484 dyncon = (Elf_External_Dyn *) sdyn->contents;
1485 dynconend = (Elf_External_Dyn *) (sdyn->contents +
1486 sdyn->_raw_size);
1487 for (; dyncon < dynconend; dyncon++)
1488 {
1489 Elf_Internal_Dyn dyn;
1490
8ea2e4bd 1491 elf_swap_dyn_in (hash_table->dynobj, dyncon, & dyn);
252b5132
RH
1492 if (dyn.d_tag == DT_NEEDED
1493 && dyn.d_un.d_val == strindex)
1494 {
2b0f7ef9 1495 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
252b5132
RH
1496 return true;
1497 }
1498 }
1499 }
1500
dc810e39 1501 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
252b5132
RH
1502 goto error_return;
1503 }
1504
1505 /* Save the SONAME, if there is one, because sometimes the
c44233aa 1506 linker emulation code will need to know it. */
252b5132 1507 if (*name == '\0')
210ba1e8 1508 name = basename (bfd_get_filename (abfd));
252b5132
RH
1509 elf_dt_name (abfd) = name;
1510 }
1511
6cdc0ccc
AM
1512 /* If this is a dynamic object, we always link against the .dynsym
1513 symbol table, not the .symtab symbol table. The dynamic linker
1514 will only see the .dynsym symbol table, so there is no reason to
1515 look at .symtab for a dynamic object. */
1516
1517 if (! dynamic || elf_dynsymtab (abfd) == 0)
1518 hdr = &elf_tdata (abfd)->symtab_hdr;
1519 else
1520 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1521
1522 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1523
1524 /* The sh_info field of the symtab header tells us where the
1525 external symbols start. We don't care about the local symbols at
1526 this point. */
1527 if (elf_bad_symtab (abfd))
1528 {
1529 extsymcount = symcount;
1530 extsymoff = 0;
1531 }
1532 else
1533 {
1534 extsymcount = symcount - hdr->sh_info;
1535 extsymoff = hdr->sh_info;
1536 }
252b5132 1537
6cdc0ccc
AM
1538 sym_hash = NULL;
1539 if (extsymcount != 0)
9ad5cbcf 1540 {
6cdc0ccc
AM
1541 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
1542 NULL, NULL, NULL);
1543 if (isymbuf == NULL)
9ad5cbcf 1544 goto error_return;
6cdc0ccc
AM
1545
1546 /* We store a pointer to the hash table entry for each external
1547 symbol. */
1548 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
1549 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
1550 if (sym_hash == NULL)
1551 goto error_free_sym;
1552 elf_sym_hashes (abfd) = sym_hash;
1553 }
1554
1555 if (dynamic)
1556 {
1557 /* Read in any version definitions. */
1558 if (! _bfd_elf_slurp_version_tables (abfd))
1559 goto error_free_sym;
1560
1561 /* Read in the symbol versions, but don't bother to convert them
1562 to internal format. */
1563 if (elf_dynversym (abfd) != 0)
1564 {
1565 Elf_Internal_Shdr *versymhdr;
1566
1567 versymhdr = &elf_tdata (abfd)->dynversym_hdr;
1568 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
1569 if (extversym == NULL)
1570 goto error_free_sym;
1571 amt = versymhdr->sh_size;
1572 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
1573 || bfd_bread ((PTR) extversym, amt, abfd) != amt)
1574 goto error_free_vers;
1575 }
9ad5cbcf
AM
1576 }
1577
252b5132
RH
1578 weaks = NULL;
1579
1580 ever = extversym != NULL ? extversym + extsymoff : NULL;
6cdc0ccc
AM
1581 for (isym = isymbuf, isymend = isymbuf + extsymcount;
1582 isym < isymend;
1583 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
252b5132 1584 {
252b5132
RH
1585 int bind;
1586 bfd_vma value;
1587 asection *sec;
1588 flagword flags;
1589 const char *name;
1590 struct elf_link_hash_entry *h;
1591 boolean definition;
1592 boolean size_change_ok, type_change_ok;
1593 boolean new_weakdef;
1594 unsigned int old_alignment;
215007a6
L
1595 boolean override;
1596
1597 override = false;
252b5132 1598
252b5132
RH
1599 flags = BSF_NO_FLAGS;
1600 sec = NULL;
6cdc0ccc 1601 value = isym->st_value;
252b5132
RH
1602 *sym_hash = NULL;
1603
6cdc0ccc 1604 bind = ELF_ST_BIND (isym->st_info);
252b5132
RH
1605 if (bind == STB_LOCAL)
1606 {
1607 /* This should be impossible, since ELF requires that all
1608 global symbols follow all local symbols, and that sh_info
1609 point to the first global symbol. Unfortunatealy, Irix 5
1610 screws this up. */
1611 continue;
1612 }
1613 else if (bind == STB_GLOBAL)
1614 {
6cdc0ccc
AM
1615 if (isym->st_shndx != SHN_UNDEF
1616 && isym->st_shndx != SHN_COMMON)
252b5132 1617 flags = BSF_GLOBAL;
252b5132
RH
1618 }
1619 else if (bind == STB_WEAK)
1620 flags = BSF_WEAK;
1621 else
1622 {
1623 /* Leave it up to the processor backend. */
1624 }
1625
6cdc0ccc 1626 if (isym->st_shndx == SHN_UNDEF)
252b5132 1627 sec = bfd_und_section_ptr;
6cdc0ccc 1628 else if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
252b5132 1629 {
6cdc0ccc 1630 sec = section_from_elf_index (abfd, isym->st_shndx);
252b5132
RH
1631 if (sec == NULL)
1632 sec = bfd_abs_section_ptr;
1633 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1634 value -= sec->vma;
1635 }
6cdc0ccc 1636 else if (isym->st_shndx == SHN_ABS)
252b5132 1637 sec = bfd_abs_section_ptr;
6cdc0ccc 1638 else if (isym->st_shndx == SHN_COMMON)
252b5132
RH
1639 {
1640 sec = bfd_com_section_ptr;
1641 /* What ELF calls the size we call the value. What ELF
1642 calls the value we call the alignment. */
6cdc0ccc 1643 value = isym->st_size;
252b5132
RH
1644 }
1645 else
1646 {
1647 /* Leave it up to the processor backend. */
1648 }
1649
6cdc0ccc
AM
1650 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
1651 isym->st_name);
252b5132 1652 if (name == (const char *) NULL)
6cdc0ccc 1653 goto error_free_vers;
252b5132 1654
6cdc0ccc
AM
1655 if (isym->st_shndx == SHN_COMMON
1656 && ELF_ST_TYPE (isym->st_info) == STT_TLS)
13ae64f3
JJ
1657 {
1658 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
1659
1660 if (tcomm == NULL)
1661 {
1662 tcomm = bfd_make_section (abfd, ".tcommon");
1663 if (tcomm == NULL
1664 || !bfd_set_section_flags (abfd, tcomm, (SEC_ALLOC
1665 | SEC_IS_COMMON
1666 | SEC_LINKER_CREATED
1667 | SEC_THREAD_LOCAL)))
6cdc0ccc 1668 goto error_free_vers;
13ae64f3
JJ
1669 }
1670 sec = tcomm;
1671 }
1672 else if (add_symbol_hook)
252b5132 1673 {
6cdc0ccc 1674 if (! (*add_symbol_hook) (abfd, info, isym, &name, &flags, &sec,
252b5132 1675 &value))
6cdc0ccc 1676 goto error_free_vers;
252b5132
RH
1677
1678 /* The hook function sets the name to NULL if this symbol
1679 should be skipped for some reason. */
1680 if (name == (const char *) NULL)
1681 continue;
1682 }
1683
1684 /* Sanity check that all possibilities were handled. */
1685 if (sec == (asection *) NULL)
1686 {
1687 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 1688 goto error_free_vers;
252b5132
RH
1689 }
1690
1691 if (bfd_is_und_section (sec)
1692 || bfd_is_com_section (sec))
1693 definition = false;
1694 else
1695 definition = true;
1696
1697 size_change_ok = false;
1698 type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
1699 old_alignment = 0;
1700 if (info->hash->creator->flavour == bfd_target_elf_flavour)
1701 {
1702 Elf_Internal_Versym iver;
1703 unsigned int vernum = 0;
252b5132
RH
1704
1705 if (ever != NULL)
1706 {
1707 _bfd_elf_swap_versym_in (abfd, ever, &iver);
1708 vernum = iver.vs_vers & VERSYM_VERSION;
1709
1710 /* If this is a hidden symbol, or if it is not version
c44233aa
AM
1711 1, we append the version name to the symbol name.
1712 However, we do not modify a non-hidden absolute
1713 symbol, because it might be the version symbol
1714 itself. FIXME: What if it isn't? */
252b5132
RH
1715 if ((iver.vs_vers & VERSYM_HIDDEN) != 0
1716 || (vernum > 1 && ! bfd_is_abs_section (sec)))
1717 {
1718 const char *verstr;
d4c88bbb 1719 size_t namelen, verlen, newlen;
252b5132
RH
1720 char *newname, *p;
1721
6cdc0ccc 1722 if (isym->st_shndx != SHN_UNDEF)
252b5132
RH
1723 {
1724 if (vernum > elf_tdata (abfd)->dynverdef_hdr.sh_info)
1725 {
1726 (*_bfd_error_handler)
1727 (_("%s: %s: invalid version %u (max %d)"),
8f615d07 1728 bfd_archive_filename (abfd), name, vernum,
252b5132
RH
1729 elf_tdata (abfd)->dynverdef_hdr.sh_info);
1730 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 1731 goto error_free_vers;
252b5132
RH
1732 }
1733 else if (vernum > 1)
1734 verstr =
1735 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1736 else
1737 verstr = "";
1738 }
1739 else
1740 {
1741 /* We cannot simply test for the number of
1742 entries in the VERNEED section since the
1743 numbers for the needed versions do not start
1744 at 0. */
1745 Elf_Internal_Verneed *t;
1746
1747 verstr = NULL;
1748 for (t = elf_tdata (abfd)->verref;
1749 t != NULL;
1750 t = t->vn_nextref)
1751 {
1752 Elf_Internal_Vernaux *a;
1753
1754 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1755 {
1756 if (a->vna_other == vernum)
1757 {
1758 verstr = a->vna_nodename;
1759 break;
1760 }
1761 }
1762 if (a != NULL)
1763 break;
1764 }
1765 if (verstr == NULL)
1766 {
1767 (*_bfd_error_handler)
1768 (_("%s: %s: invalid needed version %d"),
8f615d07 1769 bfd_archive_filename (abfd), name, vernum);
252b5132 1770 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 1771 goto error_free_vers;
252b5132
RH
1772 }
1773 }
1774
1775 namelen = strlen (name);
d4c88bbb
AM
1776 verlen = strlen (verstr);
1777 newlen = namelen + verlen + 2;
1778 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
6cdc0ccc 1779 && isym->st_shndx != SHN_UNDEF)
252b5132
RH
1780 ++newlen;
1781
d4c88bbb 1782 newname = (char *) bfd_alloc (abfd, (bfd_size_type) newlen);
252b5132 1783 if (newname == NULL)
6cdc0ccc 1784 goto error_free_vers;
d4c88bbb 1785 memcpy (newname, name, namelen);
252b5132
RH
1786 p = newname + namelen;
1787 *p++ = ELF_VER_CHR;
1287d1cc
ILT
1788 /* If this is a defined non-hidden version symbol,
1789 we add another @ to the name. This indicates the
1790 default version of the symbol. */
1791 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
6cdc0ccc 1792 && isym->st_shndx != SHN_UNDEF)
252b5132 1793 *p++ = ELF_VER_CHR;
d4c88bbb 1794 memcpy (p, verstr, verlen + 1);
252b5132
RH
1795
1796 name = newname;
1797 }
1798 }
1799
6cdc0ccc 1800 if (! elf_merge_symbol (abfd, info, name, isym, &sec, &value,
252b5132 1801 sym_hash, &override, &type_change_ok,
456981d7 1802 &size_change_ok, dt_needed))
6cdc0ccc 1803 goto error_free_vers;
252b5132
RH
1804
1805 if (override)
1806 definition = false;
1807
1808 h = *sym_hash;
1809 while (h->root.type == bfd_link_hash_indirect
1810 || h->root.type == bfd_link_hash_warning)
1811 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1812
1813 /* Remember the old alignment if this is a common symbol, so
c44233aa
AM
1814 that we don't reduce the alignment later on. We can't
1815 check later, because _bfd_generic_link_add_one_symbol
1816 will set a default for the alignment which we want to
1817 override. */
252b5132
RH
1818 if (h->root.type == bfd_link_hash_common)
1819 old_alignment = h->root.u.c.p->alignment_power;
1820
1821 if (elf_tdata (abfd)->verdef != NULL
1822 && ! override
1823 && vernum > 1
1824 && definition)
1825 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
1826 }
1827
1828 if (! (_bfd_generic_link_add_one_symbol
1829 (info, abfd, name, flags, sec, value, (const char *) NULL,
1830 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
6cdc0ccc 1831 goto error_free_vers;
252b5132
RH
1832
1833 h = *sym_hash;
1834 while (h->root.type == bfd_link_hash_indirect
1835 || h->root.type == bfd_link_hash_warning)
1836 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1837 *sym_hash = h;
1838
1839 new_weakdef = false;
1840 if (dynamic
1841 && definition
1842 && (flags & BSF_WEAK) != 0
6cdc0ccc 1843 && ELF_ST_TYPE (isym->st_info) != STT_FUNC
252b5132
RH
1844 && info->hash->creator->flavour == bfd_target_elf_flavour
1845 && h->weakdef == NULL)
1846 {
1847 /* Keep a list of all weak defined non function symbols from
1848 a dynamic object, using the weakdef field. Later in this
1849 function we will set the weakdef field to the correct
1850 value. We only put non-function symbols from dynamic
1851 objects on this list, because that happens to be the only
1852 time we need to know the normal symbol corresponding to a
1853 weak symbol, and the information is time consuming to
1854 figure out. If the weakdef field is not already NULL,
1855 then this symbol was already defined by some previous
1856 dynamic object, and we will be using that previous
1857 definition anyhow. */
1858
1859 h->weakdef = weaks;
1860 weaks = h;
1861 new_weakdef = true;
1862 }
1863
1864 /* Set the alignment of a common symbol. */
6cdc0ccc 1865 if (isym->st_shndx == SHN_COMMON
252b5132
RH
1866 && h->root.type == bfd_link_hash_common)
1867 {
1868 unsigned int align;
1869
6cdc0ccc 1870 align = bfd_log2 (isym->st_value);
724982f6
NC
1871 if (align > old_alignment
1872 /* Permit an alignment power of zero if an alignment of one
1873 is specified and no other alignments have been specified. */
6cdc0ccc 1874 || (isym->st_value == 1 && old_alignment == 0))
252b5132
RH
1875 h->root.u.c.p->alignment_power = align;
1876 }
1877
1878 if (info->hash->creator->flavour == bfd_target_elf_flavour)
1879 {
1880 int old_flags;
1881 boolean dynsym;
1882 int new_flag;
1883
1884 /* Remember the symbol size and type. */
6cdc0ccc 1885 if (isym->st_size != 0
252b5132
RH
1886 && (definition || h->size == 0))
1887 {
6cdc0ccc 1888 if (h->size != 0 && h->size != isym->st_size && ! size_change_ok)
252b5132
RH
1889 (*_bfd_error_handler)
1890 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
6cdc0ccc
AM
1891 name, (unsigned long) h->size,
1892 (unsigned long) isym->st_size, bfd_archive_filename (abfd));
252b5132 1893
6cdc0ccc 1894 h->size = isym->st_size;
252b5132
RH
1895 }
1896
1897 /* If this is a common symbol, then we always want H->SIZE
c44233aa
AM
1898 to be the size of the common symbol. The code just above
1899 won't fix the size if a common symbol becomes larger. We
1900 don't warn about a size change here, because that is
1901 covered by --warn-common. */
252b5132
RH
1902 if (h->root.type == bfd_link_hash_common)
1903 h->size = h->root.u.c.size;
1904
6cdc0ccc 1905 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
252b5132
RH
1906 && (definition || h->type == STT_NOTYPE))
1907 {
1908 if (h->type != STT_NOTYPE
6cdc0ccc 1909 && h->type != ELF_ST_TYPE (isym->st_info)
252b5132
RH
1910 && ! type_change_ok)
1911 (*_bfd_error_handler)
1912 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
6cdc0ccc 1913 name, h->type, ELF_ST_TYPE (isym->st_info),
8f615d07 1914 bfd_archive_filename (abfd));
252b5132 1915
6cdc0ccc 1916 h->type = ELF_ST_TYPE (isym->st_info);
252b5132
RH
1917 }
1918
7a13edea
NC
1919 /* If st_other has a processor-specific meaning, specific code
1920 might be needed here. */
6cdc0ccc 1921 if (isym->st_other != 0)
7a13edea
NC
1922 {
1923 /* Combine visibilities, using the most constraining one. */
1924 unsigned char hvis = ELF_ST_VISIBILITY (h->other);
6cdc0ccc 1925 unsigned char symvis = ELF_ST_VISIBILITY (isym->st_other);
3e932841 1926
7a13edea 1927 if (symvis && (hvis > symvis || hvis == 0))
6cdc0ccc 1928 h->other = isym->st_other;
3e932841 1929
7a13edea 1930 /* If neither has visibility, use the st_other of the
c44233aa
AM
1931 definition. This is an arbitrary choice, since the
1932 other bits have no general meaning. */
7a13edea
NC
1933 if (!symvis && !hvis
1934 && (definition || h->other == 0))
6cdc0ccc 1935 h->other = isym->st_other;
7a13edea 1936 }
252b5132
RH
1937
1938 /* Set a flag in the hash table entry indicating the type of
1939 reference or definition we just found. Keep a count of
1940 the number of dynamic symbols we find. A dynamic symbol
1941 is one which is referenced or defined by both a regular
1942 object and a shared object. */
1943 old_flags = h->elf_link_hash_flags;
1944 dynsym = false;
1945 if (! dynamic)
1946 {
1947 if (! definition)
1948 {
1949 new_flag = ELF_LINK_HASH_REF_REGULAR;
1950 if (bind != STB_WEAK)
1951 new_flag |= ELF_LINK_HASH_REF_REGULAR_NONWEAK;
1952 }
1953 else
1954 new_flag = ELF_LINK_HASH_DEF_REGULAR;
1955 if (info->shared
1956 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1957 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
1958 dynsym = true;
1959 }
1960 else
1961 {
1962 if (! definition)
1963 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
1964 else
1965 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
1966 if ((old_flags & (ELF_LINK_HASH_DEF_REGULAR
1967 | ELF_LINK_HASH_REF_REGULAR)) != 0
1968 || (h->weakdef != NULL
1969 && ! new_weakdef
1970 && h->weakdef->dynindx != -1))
1971 dynsym = true;
1972 }
1973
1974 h->elf_link_hash_flags |= new_flag;
1975
215007a6
L
1976 /* Check to see if we need to add an indirect symbol for
1977 the default name. */
051b8577 1978 if (definition || h->root.type == bfd_link_hash_common)
6cdc0ccc 1979 if (! elf_add_default_symbol (abfd, info, h, name, isym,
215007a6
L
1980 &sec, &value, &dynsym,
1981 override, dt_needed))
6cdc0ccc 1982 goto error_free_vers;
252b5132
RH
1983
1984 if (dynsym && h->dynindx == -1)
1985 {
1986 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
6cdc0ccc 1987 goto error_free_vers;
252b5132
RH
1988 if (h->weakdef != NULL
1989 && ! new_weakdef
1990 && h->weakdef->dynindx == -1)
1991 {
a7b97311 1992 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
6cdc0ccc 1993 goto error_free_vers;
252b5132
RH
1994 }
1995 }
38048eb9 1996 else if (dynsym && h->dynindx != -1)
0444bdd4
L
1997 /* If the symbol already has a dynamic index, but
1998 visibility says it should not be visible, turn it into
1999 a local symbol. */
2000 switch (ELF_ST_VISIBILITY (h->other))
2001 {
2002 case STV_INTERNAL:
3e932841 2003 case STV_HIDDEN:
e5094212 2004 (*bed->elf_backend_hide_symbol) (info, h, true);
0444bdd4
L
2005 break;
2006 }
74816898
L
2007
2008 if (dt_needed && definition
2009 && (h->elf_link_hash_flags
2010 & ELF_LINK_HASH_REF_REGULAR) != 0)
2011 {
2012 bfd_size_type oldsize;
2013 bfd_size_type strindex;
2014
8ea2e4bd 2015 if (! is_elf_hash_table (info))
6cdc0ccc 2016 goto error_free_vers;
8ea2e4bd 2017
74816898 2018 /* The symbol from a DT_NEEDED object is referenced from
c44233aa 2019 the regular object to create a dynamic executable. We
3e932841 2020 have to make sure there is a DT_NEEDED entry for it. */
74816898
L
2021
2022 dt_needed = false;
2b0f7ef9
JJ
2023 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
2024 strindex = _bfd_elf_strtab_add (hash_table->dynstr,
2025 elf_dt_soname (abfd), false);
74816898 2026 if (strindex == (bfd_size_type) -1)
6cdc0ccc 2027 goto error_free_vers;
74816898 2028
2b0f7ef9 2029 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
74816898
L
2030 {
2031 asection *sdyn;
2032 Elf_External_Dyn *dyncon, *dynconend;
2033
8ea2e4bd 2034 sdyn = bfd_get_section_by_name (hash_table->dynobj,
74816898
L
2035 ".dynamic");
2036 BFD_ASSERT (sdyn != NULL);
2037
2038 dyncon = (Elf_External_Dyn *) sdyn->contents;
2039 dynconend = (Elf_External_Dyn *) (sdyn->contents +
2040 sdyn->_raw_size);
2041 for (; dyncon < dynconend; dyncon++)
2042 {
2043 Elf_Internal_Dyn dyn;
2044
8ea2e4bd 2045 elf_swap_dyn_in (hash_table->dynobj,
74816898
L
2046 dyncon, &dyn);
2047 BFD_ASSERT (dyn.d_tag != DT_NEEDED ||
2048 dyn.d_un.d_val != strindex);
2049 }
2050 }
2051
dc810e39 2052 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
6cdc0ccc 2053 goto error_free_vers;
74816898 2054 }
252b5132
RH
2055 }
2056 }
2057
6cdc0ccc
AM
2058 if (extversym != NULL)
2059 {
2060 free (extversym);
2061 extversym = NULL;
2062 }
2063
2064 if (isymbuf != NULL)
2065 free (isymbuf);
2066 isymbuf = NULL;
2067
252b5132
RH
2068 /* Now set the weakdefs field correctly for all the weak defined
2069 symbols we found. The only way to do this is to search all the
2070 symbols. Since we only need the information for non functions in
2071 dynamic objects, that's the only time we actually put anything on
2072 the list WEAKS. We need this information so that if a regular
2073 object refers to a symbol defined weakly in a dynamic object, the
2074 real symbol in the dynamic object is also put in the dynamic
2075 symbols; we also must arrange for both symbols to point to the
2076 same memory location. We could handle the general case of symbol
2077 aliasing, but a general symbol alias can only be generated in
2078 assembler code, handling it correctly would be very time
2079 consuming, and other ELF linkers don't handle general aliasing
2080 either. */
2081 while (weaks != NULL)
2082 {
2083 struct elf_link_hash_entry *hlook;
2084 asection *slook;
2085 bfd_vma vlook;
2086 struct elf_link_hash_entry **hpp;
2087 struct elf_link_hash_entry **hppend;
2088
2089 hlook = weaks;
2090 weaks = hlook->weakdef;
2091 hlook->weakdef = NULL;
2092
2093 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
2094 || hlook->root.type == bfd_link_hash_defweak
2095 || hlook->root.type == bfd_link_hash_common
2096 || hlook->root.type == bfd_link_hash_indirect);
2097 slook = hlook->root.u.def.section;
2098 vlook = hlook->root.u.def.value;
2099
2100 hpp = elf_sym_hashes (abfd);
2101 hppend = hpp + extsymcount;
2102 for (; hpp < hppend; hpp++)
2103 {
2104 struct elf_link_hash_entry *h;
2105
2106 h = *hpp;
2107 if (h != NULL && h != hlook
2108 && h->root.type == bfd_link_hash_defined
2109 && h->root.u.def.section == slook
2110 && h->root.u.def.value == vlook)
2111 {
2112 hlook->weakdef = h;
2113
2114 /* If the weak definition is in the list of dynamic
2115 symbols, make sure the real definition is put there
2116 as well. */
2117 if (hlook->dynindx != -1
2118 && h->dynindx == -1)
2119 {
2120 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2121 goto error_return;
2122 }
2123
2124 /* If the real definition is in the list of dynamic
c44233aa
AM
2125 symbols, make sure the weak definition is put there
2126 as well. If we don't do this, then the dynamic
2127 loader might not merge the entries for the real
2128 definition and the weak definition. */
252b5132
RH
2129 if (h->dynindx != -1
2130 && hlook->dynindx == -1)
2131 {
2132 if (! _bfd_elf_link_record_dynamic_symbol (info, hlook))
2133 goto error_return;
2134 }
252b5132
RH
2135 break;
2136 }
2137 }
2138 }
2139
252b5132
RH
2140 /* If this object is the same format as the output object, and it is
2141 not a shared library, then let the backend look through the
2142 relocs.
2143
2144 This is required to build global offset table entries and to
2145 arrange for dynamic relocs. It is not required for the
2146 particular common case of linking non PIC code, even when linking
2147 against shared libraries, but unfortunately there is no way of
2148 knowing whether an object file has been compiled PIC or not.
2149 Looking through the relocs is not particularly time consuming.
2150 The problem is that we must either (1) keep the relocs in memory,
2151 which causes the linker to require additional runtime memory or
2152 (2) read the relocs twice from the input file, which wastes time.
2153 This would be a good case for using mmap.
2154
2155 I have no idea how to handle linking PIC code into a file of a
2156 different format. It probably can't be done. */
2157 check_relocs = get_elf_backend_data (abfd)->check_relocs;
2158 if (! dynamic
2159 && abfd->xvec == info->hash->creator
2160 && check_relocs != NULL)
2161 {
2162 asection *o;
2163
2164 for (o = abfd->sections; o != NULL; o = o->next)
2165 {
2166 Elf_Internal_Rela *internal_relocs;
2167 boolean ok;
2168
2169 if ((o->flags & SEC_RELOC) == 0
2170 || o->reloc_count == 0
2171 || ((info->strip == strip_all || info->strip == strip_debugger)
2172 && (o->flags & SEC_DEBUGGING) != 0)
2173 || bfd_is_abs_section (o->output_section))
2174 continue;
2175
2176 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
2177 (abfd, o, (PTR) NULL,
2178 (Elf_Internal_Rela *) NULL,
2179 info->keep_memory));
2180 if (internal_relocs == NULL)
2181 goto error_return;
2182
2183 ok = (*check_relocs) (abfd, info, o, internal_relocs);
2184
6cdc0ccc 2185 if (elf_section_data (o)->relocs != internal_relocs)
252b5132
RH
2186 free (internal_relocs);
2187
2188 if (! ok)
2189 goto error_return;
2190 }
2191 }
2192
2193 /* If this is a non-traditional, non-relocateable link, try to
2194 optimize the handling of the .stab/.stabstr sections. */
2195 if (! dynamic
2196 && ! info->relocateable
2197 && ! info->traditional_format
2198 && info->hash->creator->flavour == bfd_target_elf_flavour
8ea2e4bd 2199 && is_elf_hash_table (info)
252b5132
RH
2200 && (info->strip != strip_all && info->strip != strip_debugger))
2201 {
2202 asection *stab, *stabstr;
2203
2204 stab = bfd_get_section_by_name (abfd, ".stab");
2d653fc7
AM
2205 if (stab != NULL
2206 && (stab->flags & SEC_MERGE) == 0
2207 && !bfd_is_abs_section (stab->output_section))
252b5132
RH
2208 {
2209 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
2210
2211 if (stabstr != NULL)
2212 {
2213 struct bfd_elf_section_data *secdata;
2214
2215 secdata = elf_section_data (stab);
2216 if (! _bfd_link_section_stabs (abfd,
8ea2e4bd 2217 & hash_table->stab_info,
252b5132 2218 stab, stabstr,
65765700 2219 &secdata->sec_info))
252b5132 2220 goto error_return;
65765700
JJ
2221 if (secdata->sec_info)
2222 secdata->sec_info_type = ELF_INFO_TYPE_STABS;
252b5132
RH
2223 }
2224 }
2225 }
2226
8ea2e4bd
NC
2227 if (! info->relocateable && ! dynamic
2228 && is_elf_hash_table (info))
f5fa8ca2
JJ
2229 {
2230 asection *s;
2231
2232 for (s = abfd->sections; s != NULL; s = s->next)
2d653fc7
AM
2233 if ((s->flags & SEC_MERGE) != 0
2234 && !bfd_is_abs_section (s->output_section))
65765700
JJ
2235 {
2236 struct bfd_elf_section_data *secdata;
2237
2238 secdata = elf_section_data (s);
2239 if (! _bfd_merge_section (abfd,
2240 & hash_table->merge_info,
2241 s, &secdata->sec_info))
2242 goto error_return;
2243 else if (secdata->sec_info)
2244 secdata->sec_info_type = ELF_INFO_TYPE_MERGE;
2245 }
f5fa8ca2
JJ
2246 }
2247
f5d44ba0
AM
2248 if (is_elf_hash_table (info))
2249 {
2250 /* Add this bfd to the loaded list. */
2251 struct elf_link_loaded_list *n;
2252
2253 n = ((struct elf_link_loaded_list *)
2254 bfd_alloc (abfd, sizeof (struct elf_link_loaded_list)));
2255 if (n == NULL)
2256 goto error_return;
2257 n->abfd = abfd;
2258 n->next = hash_table->loaded;
2259 hash_table->loaded = n;
2260 }
2261
252b5132
RH
2262 return true;
2263
6cdc0ccc 2264 error_free_vers:
252b5132
RH
2265 if (extversym != NULL)
2266 free (extversym);
6cdc0ccc
AM
2267 error_free_sym:
2268 if (isymbuf != NULL)
2269 free (isymbuf);
2270 error_return:
252b5132
RH
2271 return false;
2272}
2273
2274/* Create some sections which will be filled in with dynamic linking
2275 information. ABFD is an input file which requires dynamic sections
2276 to be created. The dynamic sections take up virtual memory space
2277 when the final executable is run, so we need to create them before
2278 addresses are assigned to the output sections. We work out the
2279 actual contents and size of these sections later. */
2280
2281boolean
2282elf_link_create_dynamic_sections (abfd, info)
2283 bfd *abfd;
2284 struct bfd_link_info *info;
2285{
2286 flagword flags;
2287 register asection *s;
2288 struct elf_link_hash_entry *h;
2289 struct elf_backend_data *bed;
2290
8ea2e4bd
NC
2291 if (! is_elf_hash_table (info))
2292 return false;
2293
252b5132
RH
2294 if (elf_hash_table (info)->dynamic_sections_created)
2295 return true;
2296
2297 /* Make sure that all dynamic sections use the same input BFD. */
2298 if (elf_hash_table (info)->dynobj == NULL)
2299 elf_hash_table (info)->dynobj = abfd;
2300 else
2301 abfd = elf_hash_table (info)->dynobj;
2302
2303 /* Note that we set the SEC_IN_MEMORY flag for all of these
2304 sections. */
2305 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2306 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2307
2308 /* A dynamically linked executable has a .interp section, but a
2309 shared library does not. */
2310 if (! info->shared)
2311 {
2312 s = bfd_make_section (abfd, ".interp");
2313 if (s == NULL
2314 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2315 return false;
2316 }
2317
65765700
JJ
2318 if (! info->traditional_format
2319 && info->hash->creator->flavour == bfd_target_elf_flavour)
2320 {
2321 s = bfd_make_section (abfd, ".eh_frame_hdr");
2322 if (s == NULL
2323 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2324 || ! bfd_set_section_alignment (abfd, s, 2))
2325 return false;
2326 }
2327
252b5132
RH
2328 /* Create sections to hold version informations. These are removed
2329 if they are not needed. */
2330 s = bfd_make_section (abfd, ".gnu.version_d");
2331 if (s == NULL
2332 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2333 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2334 return false;
2335
2336 s = bfd_make_section (abfd, ".gnu.version");
2337 if (s == NULL
2338 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2339 || ! bfd_set_section_alignment (abfd, s, 1))
2340 return false;
2341
2342 s = bfd_make_section (abfd, ".gnu.version_r");
2343 if (s == NULL
2344 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2345 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2346 return false;
2347
2348 s = bfd_make_section (abfd, ".dynsym");
2349 if (s == NULL
2350 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2351 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2352 return false;
2353
2354 s = bfd_make_section (abfd, ".dynstr");
2355 if (s == NULL
2356 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2357 return false;
2358
2359 /* Create a strtab to hold the dynamic symbol names. */
2360 if (elf_hash_table (info)->dynstr == NULL)
2361 {
2b0f7ef9 2362 elf_hash_table (info)->dynstr = _bfd_elf_strtab_init ();
252b5132
RH
2363 if (elf_hash_table (info)->dynstr == NULL)
2364 return false;
2365 }
2366
2367 s = bfd_make_section (abfd, ".dynamic");
2368 if (s == NULL
2369 || ! bfd_set_section_flags (abfd, s, flags)
2370 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2371 return false;
2372
2373 /* The special symbol _DYNAMIC is always set to the start of the
2374 .dynamic section. This call occurs before we have processed the
2375 symbols for any dynamic object, so we don't have to worry about
2376 overriding a dynamic definition. We could set _DYNAMIC in a
2377 linker script, but we only want to define it if we are, in fact,
2378 creating a .dynamic section. We don't want to define it if there
2379 is no .dynamic section, since on some ELF platforms the start up
2380 code examines it to decide how to initialize the process. */
2381 h = NULL;
2382 if (! (_bfd_generic_link_add_one_symbol
2383 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
2384 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
2385 (struct bfd_link_hash_entry **) &h)))
2386 return false;
2387 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2388 h->type = STT_OBJECT;
2389
2390 if (info->shared
2391 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2392 return false;
2393
c7ac6ff8
MM
2394 bed = get_elf_backend_data (abfd);
2395
252b5132
RH
2396 s = bfd_make_section (abfd, ".hash");
2397 if (s == NULL
2398 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2399 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2400 return false;
c7ac6ff8 2401 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
252b5132
RH
2402
2403 /* Let the backend create the rest of the sections. This lets the
2404 backend set the right flags. The backend will normally create
2405 the .got and .plt sections. */
252b5132
RH
2406 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
2407 return false;
2408
2409 elf_hash_table (info)->dynamic_sections_created = true;
2410
2411 return true;
2412}
2413
2414/* Add an entry to the .dynamic table. */
2415
2416boolean
2417elf_add_dynamic_entry (info, tag, val)
2418 struct bfd_link_info *info;
2419 bfd_vma tag;
2420 bfd_vma val;
2421{
2422 Elf_Internal_Dyn dyn;
2423 bfd *dynobj;
2424 asection *s;
dc810e39 2425 bfd_size_type newsize;
252b5132
RH
2426 bfd_byte *newcontents;
2427
8ea2e4bd
NC
2428 if (! is_elf_hash_table (info))
2429 return false;
2430
252b5132
RH
2431 dynobj = elf_hash_table (info)->dynobj;
2432
2433 s = bfd_get_section_by_name (dynobj, ".dynamic");
2434 BFD_ASSERT (s != NULL);
2435
2436 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
2437 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
2438 if (newcontents == NULL)
2439 return false;
2440
2441 dyn.d_tag = tag;
2442 dyn.d_un.d_val = val;
2443 elf_swap_dyn_out (dynobj, &dyn,
2444 (Elf_External_Dyn *) (newcontents + s->_raw_size));
2445
2446 s->_raw_size = newsize;
2447 s->contents = newcontents;
2448
2449 return true;
2450}
30b30c21
RH
2451
2452/* Record a new local dynamic symbol. */
2453
2454boolean
2455elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
2456 struct bfd_link_info *info;
2457 bfd *input_bfd;
2458 long input_indx;
2459{
2460 struct elf_link_local_dynamic_entry *entry;
2461 struct elf_link_hash_table *eht;
2b0f7ef9 2462 struct elf_strtab_hash *dynstr;
30b30c21 2463 Elf_External_Sym esym;
9ad5cbcf
AM
2464 Elf_External_Sym_Shndx eshndx;
2465 Elf_External_Sym_Shndx *shndx;
30b30c21
RH
2466 unsigned long dynstr_index;
2467 char *name;
dc810e39
AM
2468 file_ptr pos;
2469 bfd_size_type amt;
30b30c21 2470
8ea2e4bd
NC
2471 if (! is_elf_hash_table (info))
2472 return false;
2473
30b30c21
RH
2474 /* See if the entry exists already. */
2475 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
2476 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
2477 return true;
2478
2479 entry = (struct elf_link_local_dynamic_entry *)
dc810e39 2480 bfd_alloc (input_bfd, (bfd_size_type) sizeof (*entry));
30b30c21
RH
2481 if (entry == NULL)
2482 return false;
2483
2484 /* Go find the symbol, so that we can find it's name. */
dc810e39
AM
2485 amt = sizeof (Elf_External_Sym);
2486 pos = elf_tdata (input_bfd)->symtab_hdr.sh_offset + input_indx * amt;
2487 if (bfd_seek (input_bfd, pos, SEEK_SET) != 0
9ad5cbcf 2488 || bfd_bread ((PTR) &esym, amt, input_bfd) != amt)
30b30c21 2489 return false;
9ad5cbcf
AM
2490 shndx = NULL;
2491 if (elf_tdata (input_bfd)->symtab_shndx_hdr.sh_size != 0)
2492 {
2493 amt = sizeof (Elf_External_Sym_Shndx);
2494 pos = elf_tdata (input_bfd)->symtab_shndx_hdr.sh_offset;
2495 pos += input_indx * amt;
2496 shndx = &eshndx;
2497 if (bfd_seek (input_bfd, pos, SEEK_SET) != 0
2498 || bfd_bread ((PTR) shndx, amt, input_bfd) != amt)
2499 return false;
2500 }
f8ecb12b 2501 elf_swap_symbol_in (input_bfd, (const PTR) &esym, (const PTR) shndx,
73ff0d56 2502 &entry->isym);
30b30c21
RH
2503
2504 name = (bfd_elf_string_from_elf_section
2505 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
2506 entry->isym.st_name));
2507
2508 dynstr = elf_hash_table (info)->dynstr;
2509 if (dynstr == NULL)
2510 {
2511 /* Create a strtab to hold the dynamic symbol names. */
2b0f7ef9 2512 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
30b30c21
RH
2513 if (dynstr == NULL)
2514 return false;
2515 }
2516
2b0f7ef9 2517 dynstr_index = _bfd_elf_strtab_add (dynstr, name, false);
30b30c21
RH
2518 if (dynstr_index == (unsigned long) -1)
2519 return false;
2520 entry->isym.st_name = dynstr_index;
2521
2522 eht = elf_hash_table (info);
2523
2524 entry->next = eht->dynlocal;
2525 eht->dynlocal = entry;
2526 entry->input_bfd = input_bfd;
2527 entry->input_indx = input_indx;
2528 eht->dynsymcount++;
2529
587ff49e
RH
2530 /* Whatever binding the symbol had before, it's now local. */
2531 entry->isym.st_info
2532 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
2533
30b30c21
RH
2534 /* The dynindx will be set at the end of size_dynamic_sections. */
2535
2536 return true;
2537}
252b5132 2538\f
6b5bd373
MM
2539/* Read and swap the relocs from the section indicated by SHDR. This
2540 may be either a REL or a RELA section. The relocations are
2541 translated into RELA relocations and stored in INTERNAL_RELOCS,
2542 which should have already been allocated to contain enough space.
2543 The EXTERNAL_RELOCS are a buffer where the external form of the
2544 relocations should be stored.
2545
2546 Returns false if something goes wrong. */
2547
2548static boolean
2549elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
2550 internal_relocs)
2551 bfd *abfd;
2552 Elf_Internal_Shdr *shdr;
2553 PTR external_relocs;
2554 Elf_Internal_Rela *internal_relocs;
2555{
c7ac6ff8 2556 struct elf_backend_data *bed;
dc810e39 2557 bfd_size_type amt;
c7ac6ff8 2558
6b5bd373
MM
2559 /* If there aren't any relocations, that's OK. */
2560 if (!shdr)
2561 return true;
2562
2563 /* Position ourselves at the start of the section. */
2564 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2565 return false;
2566
2567 /* Read the relocations. */
dc810e39 2568 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
6b5bd373
MM
2569 return false;
2570
c7ac6ff8
MM
2571 bed = get_elf_backend_data (abfd);
2572
6b5bd373
MM
2573 /* Convert the external relocations to the internal format. */
2574 if (shdr->sh_entsize == sizeof (Elf_External_Rel))
2575 {
2576 Elf_External_Rel *erel;
2577 Elf_External_Rel *erelend;
2578 Elf_Internal_Rela *irela;
c7ac6ff8 2579 Elf_Internal_Rel *irel;
6b5bd373
MM
2580
2581 erel = (Elf_External_Rel *) external_relocs;
d9bc7a44 2582 erelend = erel + NUM_SHDR_ENTRIES (shdr);
6b5bd373 2583 irela = internal_relocs;
dc810e39
AM
2584 amt = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
2585 irel = bfd_alloc (abfd, amt);
c7ac6ff8 2586 for (; erel < erelend; erel++, irela += bed->s->int_rels_per_ext_rel)
6b5bd373 2587 {
4e8a9624 2588 unsigned int i;
c7ac6ff8
MM
2589
2590 if (bed->s->swap_reloc_in)
2591 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
2592 else
2593 elf_swap_reloc_in (abfd, erel, irel);
6b5bd373 2594
c7ac6ff8
MM
2595 for (i = 0; i < bed->s->int_rels_per_ext_rel; ++i)
2596 {
2597 irela[i].r_offset = irel[i].r_offset;
2598 irela[i].r_info = irel[i].r_info;
2599 irela[i].r_addend = 0;
2600 }
6b5bd373
MM
2601 }
2602 }
2603 else
2604 {
2605 Elf_External_Rela *erela;
2606 Elf_External_Rela *erelaend;
2607 Elf_Internal_Rela *irela;
2608
2609 BFD_ASSERT (shdr->sh_entsize == sizeof (Elf_External_Rela));
2610
2611 erela = (Elf_External_Rela *) external_relocs;
d9bc7a44 2612 erelaend = erela + NUM_SHDR_ENTRIES (shdr);
6b5bd373 2613 irela = internal_relocs;
c7ac6ff8
MM
2614 for (; erela < erelaend; erela++, irela += bed->s->int_rels_per_ext_rel)
2615 {
2616 if (bed->s->swap_reloca_in)
2617 (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
2618 else
2619 elf_swap_reloca_in (abfd, erela, irela);
2620 }
6b5bd373
MM
2621 }
2622
2623 return true;
2624}
2625
23bc299b
MM
2626/* Read and swap the relocs for a section O. They may have been
2627 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2628 not NULL, they are used as buffers to read into. They are known to
2629 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2630 the return value is allocated using either malloc or bfd_alloc,
2631 according to the KEEP_MEMORY argument. If O has two relocation
2632 sections (both REL and RELA relocations), then the REL_HDR
2633 relocations will appear first in INTERNAL_RELOCS, followed by the
2634 REL_HDR2 relocations. */
252b5132
RH
2635
2636Elf_Internal_Rela *
2637NAME(_bfd_elf,link_read_relocs) (abfd, o, external_relocs, internal_relocs,
2638 keep_memory)
2639 bfd *abfd;
2640 asection *o;
2641 PTR external_relocs;
2642 Elf_Internal_Rela *internal_relocs;
2643 boolean keep_memory;
2644{
2645 Elf_Internal_Shdr *rel_hdr;
2646 PTR alloc1 = NULL;
2647 Elf_Internal_Rela *alloc2 = NULL;
c7ac6ff8 2648 struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH
2649
2650 if (elf_section_data (o)->relocs != NULL)
2651 return elf_section_data (o)->relocs;
2652
2653 if (o->reloc_count == 0)
2654 return NULL;
2655
2656 rel_hdr = &elf_section_data (o)->rel_hdr;
2657
2658 if (internal_relocs == NULL)
2659 {
dc810e39 2660 bfd_size_type size;
252b5132 2661
dc810e39
AM
2662 size = o->reloc_count;
2663 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
252b5132
RH
2664 if (keep_memory)
2665 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2666 else
2667 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2668 if (internal_relocs == NULL)
2669 goto error_return;
2670 }
2671
2672 if (external_relocs == NULL)
2673 {
dc810e39 2674 bfd_size_type size = rel_hdr->sh_size;
6b5bd373
MM
2675
2676 if (elf_section_data (o)->rel_hdr2)
dc810e39 2677 size += elf_section_data (o)->rel_hdr2->sh_size;
6b5bd373 2678 alloc1 = (PTR) bfd_malloc (size);
252b5132
RH
2679 if (alloc1 == NULL)
2680 goto error_return;
2681 external_relocs = alloc1;
2682 }
2683
6b5bd373
MM
2684 if (!elf_link_read_relocs_from_section (abfd, rel_hdr,
2685 external_relocs,
2686 internal_relocs))
2687 goto error_return;
3e932841
KH
2688 if (!elf_link_read_relocs_from_section
2689 (abfd,
6b5bd373 2690 elf_section_data (o)->rel_hdr2,
2f5116e2 2691 ((bfd_byte *) external_relocs) + rel_hdr->sh_size,
d9bc7a44 2692 internal_relocs + (NUM_SHDR_ENTRIES (rel_hdr)
c7ac6ff8 2693 * bed->s->int_rels_per_ext_rel)))
252b5132 2694 goto error_return;
252b5132
RH
2695
2696 /* Cache the results for next time, if we can. */
2697 if (keep_memory)
2698 elf_section_data (o)->relocs = internal_relocs;
2699
2700 if (alloc1 != NULL)
2701 free (alloc1);
2702
2703 /* Don't free alloc2, since if it was allocated we are passing it
2704 back (under the name of internal_relocs). */
2705
2706 return internal_relocs;
2707
2708 error_return:
2709 if (alloc1 != NULL)
2710 free (alloc1);
2711 if (alloc2 != NULL)
2712 free (alloc2);
2713 return NULL;
2714}
2715\f
252b5132
RH
2716/* Record an assignment to a symbol made by a linker script. We need
2717 this in case some dynamic object refers to this symbol. */
2718
252b5132
RH
2719boolean
2720NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
7442e600 2721 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH
2722 struct bfd_link_info *info;
2723 const char *name;
2724 boolean provide;
2725{
2726 struct elf_link_hash_entry *h;
2727
2728 if (info->hash->creator->flavour != bfd_target_elf_flavour)
2729 return true;
2730
2731 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
2732 if (h == NULL)
2733 return false;
2734
2735 if (h->root.type == bfd_link_hash_new)
a7b97311 2736 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH
2737
2738 /* If this symbol is being provided by the linker script, and it is
2739 currently defined by a dynamic object, but not by a regular
2740 object, then mark it as undefined so that the generic linker will
2741 force the correct value. */
2742 if (provide
2743 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2744 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2745 h->root.type = bfd_link_hash_undefined;
2746
2747 /* If this symbol is not being provided by the linker script, and it is
2748 currently defined by a dynamic object, but not by a regular object,
2749 then clear out any version information because the symbol will not be
2750 associated with the dynamic object any more. */
2751 if (!provide
2752 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2753 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2754 h->verinfo.verdef = NULL;
2755
2756 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
994819d2 2757
252b5132
RH
2758 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
2759 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
2760 || info->shared)
2761 && h->dynindx == -1)
2762 {
2763 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2764 return false;
2765
2766 /* If this is a weak defined symbol, and we know a corresponding
2767 real symbol from the same dynamic object, make sure the real
2768 symbol is also made into a dynamic symbol. */
2769 if (h->weakdef != NULL
2770 && h->weakdef->dynindx == -1)
2771 {
2772 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
2773 return false;
2774 }
2775 }
2776
2777 return true;
2778}
2779\f
2780/* This structure is used to pass information to
2781 elf_link_assign_sym_version. */
2782
2783struct elf_assign_sym_version_info
2784{
2785 /* Output BFD. */
2786 bfd *output_bfd;
2787 /* General link information. */
2788 struct bfd_link_info *info;
2789 /* Version tree. */
2790 struct bfd_elf_version_tree *verdefs;
252b5132
RH
2791 /* Whether we had a failure. */
2792 boolean failed;
2793};
2794
2795/* This structure is used to pass information to
2796 elf_link_find_version_dependencies. */
2797
2798struct elf_find_verdep_info
2799{
2800 /* Output BFD. */
2801 bfd *output_bfd;
2802 /* General link information. */
2803 struct bfd_link_info *info;
2804 /* The number of dependencies. */
2805 unsigned int vers;
2806 /* Whether we had a failure. */
2807 boolean failed;
2808};
2809
2810/* Array used to determine the number of hash table buckets to use
2811 based on the number of symbols there are. If there are fewer than
2812 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2813 fewer than 37 we use 17 buckets, and so forth. We never use more
2814 than 32771 buckets. */
2815
2816static const size_t elf_buckets[] =
2817{
2818 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2819 16411, 32771, 0
2820};
2821
2822/* Compute bucket count for hashing table. We do not use a static set
2823 of possible tables sizes anymore. Instead we determine for all
2824 possible reasonable sizes of the table the outcome (i.e., the
2825 number of collisions etc) and choose the best solution. The
2826 weighting functions are not too simple to allow the table to grow
2827 without bounds. Instead one of the weighting factors is the size.
2828 Therefore the result is always a good payoff between few collisions
2829 (= short chain lengths) and table size. */
2830static size_t
2831compute_bucket_count (info)
2832 struct bfd_link_info *info;
2833{
2834 size_t dynsymcount = elf_hash_table (info)->dynsymcount;
7442e600 2835 size_t best_size = 0;
252b5132
RH
2836 unsigned long int *hashcodes;
2837 unsigned long int *hashcodesp;
2838 unsigned long int i;
dc810e39 2839 bfd_size_type amt;
252b5132
RH
2840
2841 /* Compute the hash values for all exported symbols. At the same
2842 time store the values in an array so that we could use them for
2843 optimizations. */
dc810e39
AM
2844 amt = dynsymcount;
2845 amt *= sizeof (unsigned long int);
2846 hashcodes = (unsigned long int *) bfd_malloc (amt);
252b5132
RH
2847 if (hashcodes == NULL)
2848 return 0;
2849 hashcodesp = hashcodes;
2850
2851 /* Put all hash values in HASHCODES. */
2852 elf_link_hash_traverse (elf_hash_table (info),
2853 elf_collect_hash_codes, &hashcodesp);
2854
58821868
AM
2855 /* We have a problem here. The following code to optimize the table
2856 size requires an integer type with more the 32 bits. If
2857 BFD_HOST_U_64_BIT is set we know about such a type. */
252b5132 2858#ifdef BFD_HOST_U_64_BIT
82e51918 2859 if (info->optimize)
252b5132
RH
2860 {
2861 unsigned long int nsyms = hashcodesp - hashcodes;
2862 size_t minsize;
2863 size_t maxsize;
2864 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
2865 unsigned long int *counts ;
2866
2867 /* Possible optimization parameters: if we have NSYMS symbols we say
2868 that the hashing table must at least have NSYMS/4 and at most
2869 2*NSYMS buckets. */
2870 minsize = nsyms / 4;
2871 if (minsize == 0)
2872 minsize = 1;
2873 best_size = maxsize = nsyms * 2;
2874
2875 /* Create array where we count the collisions in. We must use bfd_malloc
2876 since the size could be large. */
dc810e39
AM
2877 amt = maxsize;
2878 amt *= sizeof (unsigned long int);
2879 counts = (unsigned long int *) bfd_malloc (amt);
252b5132
RH
2880 if (counts == NULL)
2881 {
2882 free (hashcodes);
2883 return 0;
2884 }
2885
2886 /* Compute the "optimal" size for the hash table. The criteria is a
2887 minimal chain length. The minor criteria is (of course) the size
2888 of the table. */
2889 for (i = minsize; i < maxsize; ++i)
2890 {
2891 /* Walk through the array of hashcodes and count the collisions. */
2892 BFD_HOST_U_64_BIT max;
2893 unsigned long int j;
2894 unsigned long int fact;
2895
2896 memset (counts, '\0', i * sizeof (unsigned long int));
2897
2898 /* Determine how often each hash bucket is used. */
2899 for (j = 0; j < nsyms; ++j)
2900 ++counts[hashcodes[j] % i];
2901
2902 /* For the weight function we need some information about the
2903 pagesize on the target. This is information need not be 100%
2904 accurate. Since this information is not available (so far) we
2905 define it here to a reasonable default value. If it is crucial
2906 to have a better value some day simply define this value. */
2907# ifndef BFD_TARGET_PAGESIZE
2908# define BFD_TARGET_PAGESIZE (4096)
2909# endif
2910
2911 /* We in any case need 2 + NSYMS entries for the size values and
2912 the chains. */
2913 max = (2 + nsyms) * (ARCH_SIZE / 8);
2914
2915# if 1
2916 /* Variant 1: optimize for short chains. We add the squares
2917 of all the chain lengths (which favous many small chain
2918 over a few long chains). */
2919 for (j = 0; j < i; ++j)
2920 max += counts[j] * counts[j];
2921
2922 /* This adds penalties for the overall size of the table. */
2923 fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2924 max *= fact * fact;
2925# else
2926 /* Variant 2: Optimize a lot more for small table. Here we
2927 also add squares of the size but we also add penalties for
2928 empty slots (the +1 term). */
2929 for (j = 0; j < i; ++j)
2930 max += (1 + counts[j]) * (1 + counts[j]);
2931
2932 /* The overall size of the table is considered, but not as
2933 strong as in variant 1, where it is squared. */
2934 fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2935 max *= fact;
2936# endif
2937
2938 /* Compare with current best results. */
2939 if (max < best_chlen)
2940 {
2941 best_chlen = max;
2942 best_size = i;
2943 }
2944 }
2945
2946 free (counts);
2947 }
2948 else
2949#endif /* defined (BFD_HOST_U_64_BIT) */
2950 {
2951 /* This is the fallback solution if no 64bit type is available or if we
2952 are not supposed to spend much time on optimizations. We select the
2953 bucket count using a fixed set of numbers. */
2954 for (i = 0; elf_buckets[i] != 0; i++)
2955 {
2956 best_size = elf_buckets[i];
2957 if (dynsymcount < elf_buckets[i + 1])
2958 break;
2959 }
2960 }
2961
2962 /* Free the arrays we needed. */
2963 free (hashcodes);
2964
2965 return best_size;
2966}
2967
2968/* Set up the sizes and contents of the ELF dynamic sections. This is
2969 called by the ELF linker emulation before_allocation routine. We
2970 must set the sizes of the sections before the linker sets the
2971 addresses of the various sections. */
2972
2973boolean
2974NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
99293407 2975 filter_shlib,
252b5132
RH
2976 auxiliary_filters, info, sinterpptr,
2977 verdefs)
2978 bfd *output_bfd;
2979 const char *soname;
2980 const char *rpath;
252b5132
RH
2981 const char *filter_shlib;
2982 const char * const *auxiliary_filters;
2983 struct bfd_link_info *info;
2984 asection **sinterpptr;
2985 struct bfd_elf_version_tree *verdefs;
2986{
2987 bfd_size_type soname_indx;
25e27870 2988 bfd *dynobj;
252b5132 2989 struct elf_backend_data *bed;
252b5132
RH
2990 struct elf_assign_sym_version_info asvinfo;
2991
2992 *sinterpptr = NULL;
2993
2994 soname_indx = (bfd_size_type) -1;
2995
2996 if (info->hash->creator->flavour != bfd_target_elf_flavour)
2997 return true;
2998
8ea2e4bd 2999 if (! is_elf_hash_table (info))
cc36acdf 3000 return true;
8ea2e4bd 3001
51b64d56
AM
3002 /* Any syms created from now on start with -1 in
3003 got.refcount/offset and plt.refcount/offset. */
3004 elf_hash_table (info)->init_refcount = -1;
3005
252b5132
RH
3006 /* The backend may have to create some sections regardless of whether
3007 we're dynamic or not. */
3008 bed = get_elf_backend_data (output_bfd);
3009 if (bed->elf_backend_always_size_sections
3010 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
3011 return false;
3012
3013 dynobj = elf_hash_table (info)->dynobj;
3014
3015 /* If there were no dynamic objects in the link, there is nothing to
3016 do here. */
3017 if (dynobj == NULL)
3018 return true;
3019
68f69152
JJ
3020 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
3021 return false;
3022
252b5132
RH
3023 if (elf_hash_table (info)->dynamic_sections_created)
3024 {
3025 struct elf_info_failed eif;
3026 struct elf_link_hash_entry *h;
fc8c40a0 3027 asection *dynstr;
252b5132
RH
3028
3029 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
3030 BFD_ASSERT (*sinterpptr != NULL || info->shared);
3031
3032 if (soname != NULL)
3033 {
2b0f7ef9
JJ
3034 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3035 soname, true);
252b5132 3036 if (soname_indx == (bfd_size_type) -1
dc810e39
AM
3037 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SONAME,
3038 soname_indx))
252b5132
RH
3039 return false;
3040 }
3041
3042 if (info->symbolic)
3043 {
dc810e39
AM
3044 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMBOLIC,
3045 (bfd_vma) 0))
252b5132 3046 return false;
d6cf2879 3047 info->flags |= DF_SYMBOLIC;
252b5132
RH
3048 }
3049
3050 if (rpath != NULL)
3051 {
3052 bfd_size_type indx;
3053
2b0f7ef9
JJ
3054 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
3055 true);
3056 if (info->new_dtags)
3057 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
252b5132 3058 if (indx == (bfd_size_type) -1
dc810e39 3059 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_RPATH, indx)
c25373b7 3060 || (info->new_dtags
dc810e39
AM
3061 && ! elf_add_dynamic_entry (info, (bfd_vma) DT_RUNPATH,
3062 indx)))
252b5132
RH
3063 return false;
3064 }
3065
3066 if (filter_shlib != NULL)
3067 {
3068 bfd_size_type indx;
3069
2b0f7ef9
JJ
3070 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3071 filter_shlib, true);
252b5132 3072 if (indx == (bfd_size_type) -1
dc810e39 3073 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_FILTER, indx))
252b5132
RH
3074 return false;
3075 }
3076
3077 if (auxiliary_filters != NULL)
3078 {
3079 const char * const *p;
3080
3081 for (p = auxiliary_filters; *p != NULL; p++)
3082 {
3083 bfd_size_type indx;
3084
2b0f7ef9
JJ
3085 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3086 *p, true);
252b5132 3087 if (indx == (bfd_size_type) -1
dc810e39
AM
3088 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_AUXILIARY,
3089 indx))
252b5132
RH
3090 return false;
3091 }
3092 }
3093
391a809a 3094 eif.info = info;
bc2b6df7 3095 eif.verdefs = verdefs;
391a809a
AM
3096 eif.failed = false;
3097
ea44b734 3098 /* If we are supposed to export all symbols into the dynamic symbol
c44233aa 3099 table (this is not the normal case), then do so. */
99293407 3100 if (info->export_dynamic)
ea44b734 3101 {
ea44b734 3102 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
c44233aa 3103 (PTR) &eif);
ea44b734
RH
3104 if (eif.failed)
3105 return false;
3106 }
3107
252b5132
RH
3108 /* Attach all the symbols to their version information. */
3109 asvinfo.output_bfd = output_bfd;
3110 asvinfo.info = info;
3111 asvinfo.verdefs = verdefs;
252b5132
RH
3112 asvinfo.failed = false;
3113
3114 elf_link_hash_traverse (elf_hash_table (info),
3115 elf_link_assign_sym_version,
3116 (PTR) &asvinfo);
3117 if (asvinfo.failed)
3118 return false;
3119
3120 /* Find all symbols which were defined in a dynamic object and make
3121 the backend pick a reasonable value for them. */
252b5132
RH
3122 elf_link_hash_traverse (elf_hash_table (info),
3123 elf_adjust_dynamic_symbol,
3124 (PTR) &eif);
3125 if (eif.failed)
3126 return false;
3127
3128 /* Add some entries to the .dynamic section. We fill in some of the
3129 values later, in elf_bfd_final_link, but we must add the entries
3130 now so that we know the final size of the .dynamic section. */
f0c2e336
MM
3131
3132 /* If there are initialization and/or finalization functions to
3133 call then add the corresponding DT_INIT/DT_FINI entries. */
3134 h = (info->init_function
3e932841 3135 ? elf_link_hash_lookup (elf_hash_table (info),
f0c2e336
MM
3136 info->init_function, false,
3137 false, false)
3138 : NULL);
252b5132
RH
3139 if (h != NULL
3140 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3141 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3142 {
dc810e39 3143 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_INIT, (bfd_vma) 0))
252b5132
RH
3144 return false;
3145 }
f0c2e336 3146 h = (info->fini_function
3e932841 3147 ? elf_link_hash_lookup (elf_hash_table (info),
f0c2e336
MM
3148 info->fini_function, false,
3149 false, false)
3150 : NULL);
252b5132
RH
3151 if (h != NULL
3152 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3153 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3154 {
dc810e39 3155 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FINI, (bfd_vma) 0))
252b5132
RH
3156 return false;
3157 }
f0c2e336 3158
fa7ea4d8
AM
3159 if (bfd_get_section_by_name (output_bfd, ".preinit_array") != NULL)
3160 {
3161 /* DT_PREINIT_ARRAY is not allowed in shared library. */
3162 if (info->shared)
3163 {
3164 bfd *sub;
3165 asection *o;
3166
3167 for (sub = info->input_bfds; sub != NULL;
3168 sub = sub->link_next)
3169 for (o = sub->sections; o != NULL; o = o->next)
3170 if (elf_section_data (o)->this_hdr.sh_type
3171 == SHT_PREINIT_ARRAY)
3172 {
3173 (*_bfd_error_handler)
3174 (_("%s: .preinit_array section is not allowed in DSO"),
58821868 3175 bfd_archive_filename (sub));
fa7ea4d8
AM
3176 break;
3177 }
60166579 3178
36b4f6e7 3179 bfd_set_error (bfd_error_nonrepresentable_section);
60166579 3180 return false;
fa7ea4d8
AM
3181 }
3182
3183 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAY,
3184 (bfd_vma) 0)
3185 || !elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAYSZ,
3186 (bfd_vma) 0))
3187 return false;
3188 }
3189 if (bfd_get_section_by_name (output_bfd, ".init_array") != NULL)
3190 {
3191 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAY,
3192 (bfd_vma) 0)
3193 || !elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAYSZ,
3194 (bfd_vma) 0))
3195 return false;
3196 }
3197 if (bfd_get_section_by_name (output_bfd, ".fini_array") != NULL)
3198 {
3199 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAY,
3200 (bfd_vma) 0)
3201 || !elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAYSZ,
3202 (bfd_vma) 0))
3203 return false;
3204 }
30831527 3205
fc8c40a0
AM
3206 dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
3207 /* If .dynstr is excluded from the link, we don't want any of
3208 these tags. Strictly, we should be checking each section
3209 individually; This quick check covers for the case where
3210 someone does a /DISCARD/ : { *(*) }. */
3211 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
3212 {
3213 bfd_size_type strsize;
3214
2b0f7ef9 3215 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
dc810e39
AM
3216 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_HASH, (bfd_vma) 0)
3217 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRTAB, (bfd_vma) 0)
3218 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMTAB, (bfd_vma) 0)
3219 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRSZ, strsize)
3220 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMENT,
3221 (bfd_vma) sizeof (Elf_External_Sym)))
fc8c40a0
AM
3222 return false;
3223 }
252b5132
RH
3224 }
3225
3226 /* The backend must work out the sizes of all the other dynamic
3227 sections. */
252b5132
RH
3228 if (bed->elf_backend_size_dynamic_sections
3229 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
3230 return false;
3231
3232 if (elf_hash_table (info)->dynamic_sections_created)
3233 {
dc810e39 3234 bfd_size_type dynsymcount;
252b5132
RH
3235 asection *s;
3236 size_t bucketcount = 0;
c7ac6ff8 3237 size_t hash_entry_size;
db6751f2 3238 unsigned int dtagcount;
252b5132
RH
3239
3240 /* Set up the version definition section. */
3241 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3242 BFD_ASSERT (s != NULL);
3243
3244 /* We may have created additional version definitions if we are
c44233aa 3245 just linking a regular application. */
252b5132
RH
3246 verdefs = asvinfo.verdefs;
3247
6b9b879a
JJ
3248 /* Skip anonymous version tag. */
3249 if (verdefs != NULL && verdefs->vernum == 0)
3250 verdefs = verdefs->next;
3251
252b5132 3252 if (verdefs == NULL)
7f8d5fc9 3253 _bfd_strip_section_from_output (info, s);
252b5132
RH
3254 else
3255 {
3256 unsigned int cdefs;
3257 bfd_size_type size;
3258 struct bfd_elf_version_tree *t;
3259 bfd_byte *p;
3260 Elf_Internal_Verdef def;
3261 Elf_Internal_Verdaux defaux;
3262
252b5132
RH
3263 cdefs = 0;
3264 size = 0;
3265
3266 /* Make space for the base version. */
3267 size += sizeof (Elf_External_Verdef);
3268 size += sizeof (Elf_External_Verdaux);
3269 ++cdefs;
3270
3271 for (t = verdefs; t != NULL; t = t->next)
3272 {
3273 struct bfd_elf_version_deps *n;
3274
3275 size += sizeof (Elf_External_Verdef);
3276 size += sizeof (Elf_External_Verdaux);
3277 ++cdefs;
3278
3279 for (n = t->deps; n != NULL; n = n->next)
3280 size += sizeof (Elf_External_Verdaux);
3281 }
3282
3283 s->_raw_size = size;
3284 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3285 if (s->contents == NULL && s->_raw_size != 0)
3286 return false;
3287
3288 /* Fill in the version definition section. */
3289
3290 p = s->contents;
3291
3292 def.vd_version = VER_DEF_CURRENT;
3293 def.vd_flags = VER_FLG_BASE;
3294 def.vd_ndx = 1;
3295 def.vd_cnt = 1;
3296 def.vd_aux = sizeof (Elf_External_Verdef);
3297 def.vd_next = (sizeof (Elf_External_Verdef)
3298 + sizeof (Elf_External_Verdaux));
3299
3300 if (soname_indx != (bfd_size_type) -1)
3301 {
2b0f7ef9
JJ
3302 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3303 soname_indx);
3a99b017 3304 def.vd_hash = bfd_elf_hash (soname);
252b5132
RH
3305 defaux.vda_name = soname_indx;
3306 }
3307 else
3308 {
3309 const char *name;
3310 bfd_size_type indx;
3311
96fd004e 3312 name = basename (output_bfd->filename);
3a99b017 3313 def.vd_hash = bfd_elf_hash (name);
2b0f7ef9
JJ
3314 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3315 name, false);
252b5132
RH
3316 if (indx == (bfd_size_type) -1)
3317 return false;
3318 defaux.vda_name = indx;
3319 }
3320 defaux.vda_next = 0;
3321
3322 _bfd_elf_swap_verdef_out (output_bfd, &def,
a7b97311 3323 (Elf_External_Verdef *) p);
252b5132
RH
3324 p += sizeof (Elf_External_Verdef);
3325 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3326 (Elf_External_Verdaux *) p);
3327 p += sizeof (Elf_External_Verdaux);
3328
3329 for (t = verdefs; t != NULL; t = t->next)
3330 {
3331 unsigned int cdeps;
3332 struct bfd_elf_version_deps *n;
3333 struct elf_link_hash_entry *h;
3334
3335 cdeps = 0;
3336 for (n = t->deps; n != NULL; n = n->next)
3337 ++cdeps;
3338
3339 /* Add a symbol representing this version. */
3340 h = NULL;
3341 if (! (_bfd_generic_link_add_one_symbol
3342 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
3343 (bfd_vma) 0, (const char *) NULL, false,
3344 get_elf_backend_data (dynobj)->collect,
3345 (struct bfd_link_hash_entry **) &h)))
3346 return false;
3347 h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
3348 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3349 h->type = STT_OBJECT;
3350 h->verinfo.vertree = t;
3351
3352 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
3353 return false;
3354
3355 def.vd_version = VER_DEF_CURRENT;
3356 def.vd_flags = 0;
3357 if (t->globals == NULL && t->locals == NULL && ! t->used)
3358 def.vd_flags |= VER_FLG_WEAK;
3359 def.vd_ndx = t->vernum + 1;
3360 def.vd_cnt = cdeps + 1;
3a99b017 3361 def.vd_hash = bfd_elf_hash (t->name);
252b5132
RH
3362 def.vd_aux = sizeof (Elf_External_Verdef);
3363 if (t->next != NULL)
3364 def.vd_next = (sizeof (Elf_External_Verdef)
3365 + (cdeps + 1) * sizeof (Elf_External_Verdaux));
3366 else
3367 def.vd_next = 0;
3368
3369 _bfd_elf_swap_verdef_out (output_bfd, &def,
3370 (Elf_External_Verdef *) p);
3371 p += sizeof (Elf_External_Verdef);
3372
3373 defaux.vda_name = h->dynstr_index;
2b0f7ef9
JJ
3374 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3375 h->dynstr_index);
252b5132
RH
3376 if (t->deps == NULL)
3377 defaux.vda_next = 0;
3378 else
3379 defaux.vda_next = sizeof (Elf_External_Verdaux);
3380 t->name_indx = defaux.vda_name;
3381
3382 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3383 (Elf_External_Verdaux *) p);
3384 p += sizeof (Elf_External_Verdaux);
3385
3386 for (n = t->deps; n != NULL; n = n->next)
3387 {
3388 if (n->version_needed == NULL)
3389 {
3390 /* This can happen if there was an error in the
3391 version script. */
3392 defaux.vda_name = 0;
3393 }
3394 else
2b0f7ef9
JJ
3395 {
3396 defaux.vda_name = n->version_needed->name_indx;
3397 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3398 defaux.vda_name);
3399 }
252b5132
RH
3400 if (n->next == NULL)
3401 defaux.vda_next = 0;
3402 else
3403 defaux.vda_next = sizeof (Elf_External_Verdaux);
3404
3405 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3406 (Elf_External_Verdaux *) p);
3407 p += sizeof (Elf_External_Verdaux);
3408 }
3409 }
3410
dc810e39
AM
3411 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEF, (bfd_vma) 0)
3412 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEFNUM,
3413 (bfd_vma) cdefs))
252b5132
RH
3414 return false;
3415
3416 elf_tdata (output_bfd)->cverdefs = cdefs;
3417 }
3418
13ae64f3 3419 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
d6cf2879 3420 {
dc810e39 3421 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS, info->flags))
d6cf2879
L
3422 return false;
3423 }
3424
4d538889 3425 if (info->flags_1)
d6cf2879
L
3426 {
3427 if (! info->shared)
3428 info->flags_1 &= ~ (DF_1_INITFIRST
3429 | DF_1_NODELETE
3430 | DF_1_NOOPEN);
dc810e39
AM
3431 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS_1,
3432 info->flags_1))
d6cf2879
L
3433 return false;
3434 }
3435
252b5132
RH
3436 /* Work out the size of the version reference section. */
3437
3438 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3439 BFD_ASSERT (s != NULL);
3440 {
3441 struct elf_find_verdep_info sinfo;
3442
3443 sinfo.output_bfd = output_bfd;
3444 sinfo.info = info;
3445 sinfo.vers = elf_tdata (output_bfd)->cverdefs;
3446 if (sinfo.vers == 0)
3447 sinfo.vers = 1;
3448 sinfo.failed = false;
3449
3450 elf_link_hash_traverse (elf_hash_table (info),
3451 elf_link_find_version_dependencies,
3452 (PTR) &sinfo);
3453
3454 if (elf_tdata (output_bfd)->verref == NULL)
7f8d5fc9 3455 _bfd_strip_section_from_output (info, s);
252b5132
RH
3456 else
3457 {
3458 Elf_Internal_Verneed *t;
3459 unsigned int size;
3460 unsigned int crefs;
3461 bfd_byte *p;
3462
3463 /* Build the version definition section. */
3464 size = 0;
3465 crefs = 0;
3466 for (t = elf_tdata (output_bfd)->verref;
3467 t != NULL;
3468 t = t->vn_nextref)
3469 {
3470 Elf_Internal_Vernaux *a;
3471
3472 size += sizeof (Elf_External_Verneed);
3473 ++crefs;
3474 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3475 size += sizeof (Elf_External_Vernaux);
3476 }
3477
3478 s->_raw_size = size;
dc810e39 3479 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
252b5132
RH
3480 if (s->contents == NULL)
3481 return false;
3482
3483 p = s->contents;
3484 for (t = elf_tdata (output_bfd)->verref;
3485 t != NULL;
3486 t = t->vn_nextref)
3487 {
3488 unsigned int caux;
3489 Elf_Internal_Vernaux *a;
3490 bfd_size_type indx;
3491
3492 caux = 0;
3493 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3494 ++caux;
3495
3496 t->vn_version = VER_NEED_CURRENT;
3497 t->vn_cnt = caux;
2b0f7ef9
JJ
3498 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3499 elf_dt_name (t->vn_bfd) != NULL
3500 ? elf_dt_name (t->vn_bfd)
3501 : basename (t->vn_bfd->filename),
3502 false);
252b5132
RH
3503 if (indx == (bfd_size_type) -1)
3504 return false;
3505 t->vn_file = indx;
3506 t->vn_aux = sizeof (Elf_External_Verneed);
3507 if (t->vn_nextref == NULL)
3508 t->vn_next = 0;
3509 else
3510 t->vn_next = (sizeof (Elf_External_Verneed)
3511 + caux * sizeof (Elf_External_Vernaux));
3512
3513 _bfd_elf_swap_verneed_out (output_bfd, t,
3514 (Elf_External_Verneed *) p);
3515 p += sizeof (Elf_External_Verneed);
3516
3517 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3518 {
3a99b017 3519 a->vna_hash = bfd_elf_hash (a->vna_nodename);
2b0f7ef9
JJ
3520 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3521 a->vna_nodename, false);
252b5132
RH
3522 if (indx == (bfd_size_type) -1)
3523 return false;
3524 a->vna_name = indx;
3525 if (a->vna_nextptr == NULL)
3526 a->vna_next = 0;
3527 else
3528 a->vna_next = sizeof (Elf_External_Vernaux);
3529
3530 _bfd_elf_swap_vernaux_out (output_bfd, a,
3531 (Elf_External_Vernaux *) p);
3532 p += sizeof (Elf_External_Vernaux);
3533 }
3534 }
3535
dc810e39
AM
3536 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEED,
3537 (bfd_vma) 0)
3538 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEEDNUM,
3539 (bfd_vma) crefs))
252b5132
RH
3540 return false;
3541
3542 elf_tdata (output_bfd)->cverrefs = crefs;
3543 }
3544 }
3545
3e932841 3546 /* Assign dynsym indicies. In a shared library we generate a
30b30c21
RH
3547 section symbol for each output section, which come first.
3548 Next come all of the back-end allocated local dynamic syms,
3549 followed by the rest of the global symbols. */
3550
3551 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
252b5132
RH
3552
3553 /* Work out the size of the symbol version section. */
3554 s = bfd_get_section_by_name (dynobj, ".gnu.version");
3555 BFD_ASSERT (s != NULL);
3556 if (dynsymcount == 0
3557 || (verdefs == NULL && elf_tdata (output_bfd)->verref == NULL))
3558 {
7f8d5fc9 3559 _bfd_strip_section_from_output (info, s);
42751cf3
MM
3560 /* The DYNSYMCOUNT might have changed if we were going to
3561 output a dynamic symbol table entry for S. */
30b30c21 3562 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
252b5132
RH
3563 }
3564 else
3565 {
3566 s->_raw_size = dynsymcount * sizeof (Elf_External_Versym);
3567 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
3568 if (s->contents == NULL)
3569 return false;
3570
dc810e39 3571 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERSYM, (bfd_vma) 0))
252b5132
RH
3572 return false;
3573 }
3574
3575 /* Set the size of the .dynsym and .hash sections. We counted
3576 the number of dynamic symbols in elf_link_add_object_symbols.
3577 We will build the contents of .dynsym and .hash when we build
3578 the final symbol table, because until then we do not know the
3579 correct value to give the symbols. We built the .dynstr
3580 section as we went along in elf_link_add_object_symbols. */
3581 s = bfd_get_section_by_name (dynobj, ".dynsym");
3582 BFD_ASSERT (s != NULL);
3583 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
3584 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3585 if (s->contents == NULL && s->_raw_size != 0)
3586 return false;
3587
fc8c40a0
AM
3588 if (dynsymcount != 0)
3589 {
3590 Elf_Internal_Sym isym;
3591
3592 /* The first entry in .dynsym is a dummy symbol. */
3593 isym.st_value = 0;
3594 isym.st_size = 0;
3595 isym.st_name = 0;
3596 isym.st_info = 0;
3597 isym.st_other = 0;
3598 isym.st_shndx = 0;
9ad5cbcf 3599 elf_swap_symbol_out (output_bfd, &isym, (PTR) s->contents, (PTR) 0);
fc8c40a0 3600 }
252b5132
RH
3601
3602 /* Compute the size of the hashing table. As a side effect this
3603 computes the hash values for all the names we export. */
3604 bucketcount = compute_bucket_count (info);
3605
3606 s = bfd_get_section_by_name (dynobj, ".hash");
3607 BFD_ASSERT (s != NULL);
c7ac6ff8
MM
3608 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
3609 s->_raw_size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
1126897b 3610 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
252b5132
RH
3611 if (s->contents == NULL)
3612 return false;
252b5132 3613
dc810e39
AM
3614 bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) bucketcount,
3615 s->contents);
3616 bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) dynsymcount,
c7ac6ff8 3617 s->contents + hash_entry_size);
252b5132
RH
3618
3619 elf_hash_table (info)->bucketcount = bucketcount;
3620
3621 s = bfd_get_section_by_name (dynobj, ".dynstr");
3622 BFD_ASSERT (s != NULL);
2b0f7ef9
JJ
3623
3624 elf_finalize_dynstr (output_bfd, info);
3625
3626 s->_raw_size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
252b5132 3627
db6751f2 3628 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
dc810e39 3629 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NULL, (bfd_vma) 0))
db6751f2 3630 return false;
252b5132
RH
3631 }
3632
3633 return true;
3634}
3635\f
2b0f7ef9
JJ
3636/* This function is used to adjust offsets into .dynstr for
3637 dynamic symbols. This is called via elf_link_hash_traverse. */
c44233aa 3638
2b0f7ef9
JJ
3639static boolean elf_adjust_dynstr_offsets
3640PARAMS ((struct elf_link_hash_entry *, PTR));
c44233aa 3641
2b0f7ef9
JJ
3642static boolean
3643elf_adjust_dynstr_offsets (h, data)
3644 struct elf_link_hash_entry *h;
3645 PTR data;
3646{
3647 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3648
e92d460e
AM
3649 if (h->root.type == bfd_link_hash_warning)
3650 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3651
2b0f7ef9
JJ
3652 if (h->dynindx != -1)
3653 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3654 return true;
3655}
3656
3657/* Assign string offsets in .dynstr, update all structures referencing
3658 them. */
3659
3660static boolean
3661elf_finalize_dynstr (output_bfd, info)
3662 bfd *output_bfd;
3663 struct bfd_link_info *info;
3664{
3665 struct elf_link_local_dynamic_entry *entry;
3666 struct elf_strtab_hash *dynstr = elf_hash_table (info)->dynstr;
3667 bfd *dynobj = elf_hash_table (info)->dynobj;
3668 asection *sdyn;
3669 bfd_size_type size;
3670 Elf_External_Dyn *dyncon, *dynconend;
3671
3672 _bfd_elf_strtab_finalize (dynstr);
3673 size = _bfd_elf_strtab_size (dynstr);
3674
3675 /* Update all .dynamic entries referencing .dynstr strings. */
3676 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3677 BFD_ASSERT (sdyn != NULL);
3678
3679 dyncon = (Elf_External_Dyn *) sdyn->contents;
3680 dynconend = (Elf_External_Dyn *) (sdyn->contents +
3681 sdyn->_raw_size);
3682 for (; dyncon < dynconend; dyncon++)
3683 {
3684 Elf_Internal_Dyn dyn;
3685
3686 elf_swap_dyn_in (dynobj, dyncon, & dyn);
3687 switch (dyn.d_tag)
3688 {
3689 case DT_STRSZ:
3690 dyn.d_un.d_val = size;
3691 elf_swap_dyn_out (dynobj, & dyn, dyncon);
3692 break;
3693 case DT_NEEDED:
3694 case DT_SONAME:
3695 case DT_RPATH:
3696 case DT_RUNPATH:
3697 case DT_FILTER:
3698 case DT_AUXILIARY:
3699 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3700 elf_swap_dyn_out (dynobj, & dyn, dyncon);
3701 break;
3702 default:
3703 break;
3704 }
3705 }
3706
3707 /* Now update local dynamic symbols. */
3708 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
3709 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3710 entry->isym.st_name);
3711
3712 /* And the rest of dynamic symbols. */
3713 elf_link_hash_traverse (elf_hash_table (info),
3714 elf_adjust_dynstr_offsets, dynstr);
3715
3716 /* Adjust version definitions. */
3717 if (elf_tdata (output_bfd)->cverdefs)
3718 {
3719 asection *s;
3720 bfd_byte *p;
3721 bfd_size_type i;
3722 Elf_Internal_Verdef def;
3723 Elf_Internal_Verdaux defaux;
c44233aa 3724
2b0f7ef9
JJ
3725 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3726 p = (bfd_byte *) s->contents;
3727 do
3728 {
3729 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3730 &def);
3731 p += sizeof (Elf_External_Verdef);
3732 for (i = 0; i < def.vd_cnt; ++i)
3733 {
3734 _bfd_elf_swap_verdaux_in (output_bfd,
3735 (Elf_External_Verdaux *) p, &defaux);
3736 defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3737 defaux.vda_name);
3738 _bfd_elf_swap_verdaux_out (output_bfd,
3739 &defaux, (Elf_External_Verdaux *) p);
3740 p += sizeof (Elf_External_Verdaux);
3741 }
3742 }
3743 while (def.vd_next);
3744 }
3745
3746 /* Adjust version references. */
3747 if (elf_tdata (output_bfd)->verref)
3748 {
3749 asection *s;
3750 bfd_byte *p;
3751 bfd_size_type i;
3752 Elf_Internal_Verneed need;
3753 Elf_Internal_Vernaux needaux;
c44233aa 3754
2b0f7ef9
JJ
3755 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3756 p = (bfd_byte *) s->contents;
3757 do
3758 {
3759 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3760 &need);
3761 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3762 _bfd_elf_swap_verneed_out (output_bfd, &need,
3763 (Elf_External_Verneed *) p);
3764 p += sizeof (Elf_External_Verneed);
3765 for (i = 0; i < need.vn_cnt; ++i)
3766 {
3767 _bfd_elf_swap_vernaux_in (output_bfd,
3768 (Elf_External_Vernaux *) p, &needaux);
3769 needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3770 needaux.vna_name);
3771 _bfd_elf_swap_vernaux_out (output_bfd,
3772 &needaux,
3773 (Elf_External_Vernaux *) p);
3774 p += sizeof (Elf_External_Vernaux);
3775 }
3776 }
3777 while (need.vn_next);
3778 }
3779
3780 return true;
3781}
3782
252b5132
RH
3783/* Fix up the flags for a symbol. This handles various cases which
3784 can only be fixed after all the input files are seen. This is
3785 currently called by both adjust_dynamic_symbol and
3786 assign_sym_version, which is unnecessary but perhaps more robust in
3787 the face of future changes. */
3788
3789static boolean
3790elf_fix_symbol_flags (h, eif)
3791 struct elf_link_hash_entry *h;
3792 struct elf_info_failed *eif;
3793{
3794 /* If this symbol was mentioned in a non-ELF file, try to set
3795 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
3796 permit a non-ELF file to correctly refer to a symbol defined in
3797 an ELF dynamic object. */
3798 if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
3799 {
94b6c40a
L
3800 while (h->root.type == bfd_link_hash_indirect)
3801 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3802
252b5132
RH
3803 if (h->root.type != bfd_link_hash_defined
3804 && h->root.type != bfd_link_hash_defweak)
3805 h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3806 | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3807 else
3808 {
3809 if (h->root.u.def.section->owner != NULL
3810 && (bfd_get_flavour (h->root.u.def.section->owner)
3811 == bfd_target_elf_flavour))
3812 h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3813 | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3814 else
3815 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3816 }
3817
3818 if (h->dynindx == -1
3819 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3820 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
3821 {
3822 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
3823 {
3824 eif->failed = true;
3825 return false;
3826 }
3827 }
3828 }
3829 else
3830 {
3831 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
c44233aa
AM
3832 was first seen in a non-ELF file. Fortunately, if the symbol
3833 was first seen in an ELF file, we're probably OK unless the
3834 symbol was defined in a non-ELF file. Catch that case here.
3835 FIXME: We're still in trouble if the symbol was first seen in
3836 a dynamic object, and then later in a non-ELF regular object. */
252b5132
RH
3837 if ((h->root.type == bfd_link_hash_defined
3838 || h->root.type == bfd_link_hash_defweak)
3839 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3840 && (h->root.u.def.section->owner != NULL
3841 ? (bfd_get_flavour (h->root.u.def.section->owner)
3842 != bfd_target_elf_flavour)
3843 : (bfd_is_abs_section (h->root.u.def.section)
3844 && (h->elf_link_hash_flags
3845 & ELF_LINK_HASH_DEF_DYNAMIC) == 0)))
3846 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3847 }
3848
3849 /* If this is a final link, and the symbol was defined as a common
3850 symbol in a regular object file, and there was no definition in
3851 any dynamic object, then the linker will have allocated space for
3852 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3853 flag will not have been set. */
3854 if (h->root.type == bfd_link_hash_defined
3855 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3856 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
3857 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3858 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
3859 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3860
3861 /* If -Bsymbolic was used (which means to bind references to global
3862 symbols to the definition within the shared object), and this
3863 symbol was defined in a regular object, then it actually doesn't
d954b040
HPN
3864 need a PLT entry, and we can accomplish that by forcing it local.
3865 Likewise, if the symbol has hidden or internal visibility.
3866 FIXME: It might be that we also do not need a PLT for other
3867 non-hidden visibilities, but we would have to tell that to the
3868 backend specifically; we can't just clear PLT-related data here. */
252b5132
RH
3869 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
3870 && eif->info->shared
8ea2e4bd 3871 && is_elf_hash_table (eif->info)
d954b040
HPN
3872 && (eif->info->symbolic
3873 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3874 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
252b5132
RH
3875 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3876 {
391a809a 3877 struct elf_backend_data *bed;
e5094212 3878 boolean force_local;
8ea2e4bd 3879
391a809a 3880 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
e5094212
AM
3881
3882 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3883 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
3884 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
252b5132
RH
3885 }
3886
fc4cc5bb
ILT
3887 /* If this is a weak defined symbol in a dynamic object, and we know
3888 the real definition in the dynamic object, copy interesting flags
3889 over to the real definition. */
3890 if (h->weakdef != NULL)
3891 {
3892 struct elf_link_hash_entry *weakdef;
3893
3894 BFD_ASSERT (h->root.type == bfd_link_hash_defined
3895 || h->root.type == bfd_link_hash_defweak);
3896 weakdef = h->weakdef;
3897 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
3898 || weakdef->root.type == bfd_link_hash_defweak);
3899 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
3900
3901 /* If the real definition is defined by a regular object file,
3902 don't do anything special. See the longer description in
3903 elf_adjust_dynamic_symbol, below. */
3904 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3905 h->weakdef = NULL;
3906 else
0a991dfe
AM
3907 {
3908 struct elf_backend_data *bed;
3909
3910 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
3911 (*bed->elf_backend_copy_indirect_symbol) (weakdef, h);
3912 }
fc4cc5bb
ILT
3913 }
3914
252b5132
RH
3915 return true;
3916}
3917
3918/* Make the backend pick a good value for a dynamic symbol. This is
3919 called via elf_link_hash_traverse, and also calls itself
3920 recursively. */
3921
3922static boolean
3923elf_adjust_dynamic_symbol (h, data)
3924 struct elf_link_hash_entry *h;
3925 PTR data;
3926{
3927 struct elf_info_failed *eif = (struct elf_info_failed *) data;
3928 bfd *dynobj;
3929 struct elf_backend_data *bed;
3930
e92d460e
AM
3931 if (h->root.type == bfd_link_hash_warning)
3932 {
3933 h->plt.offset = (bfd_vma) -1;
3934 h->got.offset = (bfd_vma) -1;
3935
3936 /* When warning symbols are created, they **replace** the "real"
3937 entry in the hash table, thus we never get to see the real
3938 symbol in a hash traversal. So look at it now. */
3939 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3940 }
3941
252b5132
RH
3942 /* Ignore indirect symbols. These are added by the versioning code. */
3943 if (h->root.type == bfd_link_hash_indirect)
3944 return true;
3945
8ea2e4bd
NC
3946 if (! is_elf_hash_table (eif->info))
3947 return false;
3948
252b5132
RH
3949 /* Fix the symbol flags. */
3950 if (! elf_fix_symbol_flags (h, eif))
3951 return false;
3952
3953 /* If this symbol does not require a PLT entry, and it is not
3954 defined by a dynamic object, or is not referenced by a regular
3955 object, ignore it. We do have to handle a weak defined symbol,
3956 even if no regular object refers to it, if we decided to add it
3957 to the dynamic symbol table. FIXME: Do we normally need to worry
3958 about symbols which are defined by one dynamic object and
3959 referenced by another one? */
3960 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
3961 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3962 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3963 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
3964 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
3965 {
3966 h->plt.offset = (bfd_vma) -1;
3967 return true;
3968 }
3969
3970 /* If we've already adjusted this symbol, don't do it again. This
3971 can happen via a recursive call. */
3972 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
3973 return true;
3974
3975 /* Don't look at this symbol again. Note that we must set this
3976 after checking the above conditions, because we may look at a
3977 symbol once, decide not to do anything, and then get called
3978 recursively later after REF_REGULAR is set below. */
3979 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
3980
3981 /* If this is a weak definition, and we know a real definition, and
3982 the real symbol is not itself defined by a regular object file,
3983 then get a good value for the real definition. We handle the
3984 real symbol first, for the convenience of the backend routine.
3985
3986 Note that there is a confusing case here. If the real definition
3987 is defined by a regular object file, we don't get the real symbol
3988 from the dynamic object, but we do get the weak symbol. If the
3989 processor backend uses a COPY reloc, then if some routine in the
3990 dynamic object changes the real symbol, we will not see that
3991 change in the corresponding weak symbol. This is the way other
3992 ELF linkers work as well, and seems to be a result of the shared
3993 library model.
3994
3995 I will clarify this issue. Most SVR4 shared libraries define the
3996 variable _timezone and define timezone as a weak synonym. The
3997 tzset call changes _timezone. If you write
3998 extern int timezone;
3999 int _timezone = 5;
4000 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4001 you might expect that, since timezone is a synonym for _timezone,
4002 the same number will print both times. However, if the processor
4003 backend uses a COPY reloc, then actually timezone will be copied
4004 into your process image, and, since you define _timezone
4005 yourself, _timezone will not. Thus timezone and _timezone will
4006 wind up at different memory locations. The tzset call will set
4007 _timezone, leaving timezone unchanged. */
4008
4009 if (h->weakdef != NULL)
4010 {
fc4cc5bb
ILT
4011 /* If we get to this point, we know there is an implicit
4012 reference by a regular object file via the weak symbol H.
4013 FIXME: Is this really true? What if the traversal finds
4014 H->WEAKDEF before it finds H? */
4015 h->weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
252b5132 4016
fc4cc5bb
ILT
4017 if (! elf_adjust_dynamic_symbol (h->weakdef, (PTR) eif))
4018 return false;
252b5132
RH
4019 }
4020
4021 /* If a symbol has no type and no size and does not require a PLT
4022 entry, then we are probably about to do the wrong thing here: we
4023 are probably going to create a COPY reloc for an empty object.
4024 This case can arise when a shared object is built with assembly
4025 code, and the assembly code fails to set the symbol type. */
4026 if (h->size == 0
4027 && h->type == STT_NOTYPE
4028 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
4029 (*_bfd_error_handler)
4030 (_("warning: type and size of dynamic symbol `%s' are not defined"),
58821868 4031 h->root.root.string);
252b5132
RH
4032
4033 dynobj = elf_hash_table (eif->info)->dynobj;
4034 bed = get_elf_backend_data (dynobj);
4035 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
4036 {
4037 eif->failed = true;
4038 return false;
4039 }
4040
4041 return true;
4042}
4043\f
4044/* This routine is used to export all defined symbols into the dynamic
4045 symbol table. It is called via elf_link_hash_traverse. */
4046
4047static boolean
4048elf_export_symbol (h, data)
4049 struct elf_link_hash_entry *h;
4050 PTR data;
4051{
4052 struct elf_info_failed *eif = (struct elf_info_failed *) data;
4053
4054 /* Ignore indirect symbols. These are added by the versioning code. */
4055 if (h->root.type == bfd_link_hash_indirect)
4056 return true;
4057
e92d460e
AM
4058 if (h->root.type == bfd_link_hash_warning)
4059 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4060
252b5132
RH
4061 if (h->dynindx == -1
4062 && (h->elf_link_hash_flags
4063 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
4064 {
bc2b6df7
L
4065 struct bfd_elf_version_tree *t;
4066 struct bfd_elf_version_expr *d;
4067
4068 for (t = eif->verdefs; t != NULL; t = t->next)
252b5132 4069 {
bc2b6df7
L
4070 if (t->globals != NULL)
4071 {
4072 for (d = t->globals; d != NULL; d = d->next)
4073 {
4074 if ((*d->match) (d, h->root.root.string))
4075 goto doit;
4076 }
4077 }
4078
4079 if (t->locals != NULL)
4080 {
4081 for (d = t->locals ; d != NULL; d = d->next)
4082 {
4083 if ((*d->match) (d, h->root.root.string))
4084 return true;
4085 }
4086 }
252b5132 4087 }
bc2b6df7
L
4088
4089 if (!eif->verdefs)
c44233aa 4090 {
58821868 4091 doit:
bc2b6df7
L
4092 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
4093 {
4094 eif->failed = true;
4095 return false;
4096 }
c44233aa 4097 }
252b5132
RH
4098 }
4099
4100 return true;
4101}
4102\f
4103/* Look through the symbols which are defined in other shared
4104 libraries and referenced here. Update the list of version
4105 dependencies. This will be put into the .gnu.version_r section.
4106 This function is called via elf_link_hash_traverse. */
4107
4108static boolean
4109elf_link_find_version_dependencies (h, data)
4110 struct elf_link_hash_entry *h;
4111 PTR data;
4112{
4113 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
4114 Elf_Internal_Verneed *t;
4115 Elf_Internal_Vernaux *a;
dc810e39 4116 bfd_size_type amt;
252b5132 4117
e92d460e
AM
4118 if (h->root.type == bfd_link_hash_warning)
4119 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4120
252b5132
RH
4121 /* We only care about symbols defined in shared objects with version
4122 information. */
4123 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
4124 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4125 || h->dynindx == -1
4126 || h->verinfo.verdef == NULL)
4127 return true;
4128
4129 /* See if we already know about this version. */
4130 for (t = elf_tdata (rinfo->output_bfd)->verref; t != NULL; t = t->vn_nextref)
4131 {
4132 if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
4133 continue;
4134
4135 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4136 if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
4137 return true;
4138
4139 break;
4140 }
4141
4142 /* This is a new version. Add it to tree we are building. */
4143
4144 if (t == NULL)
4145 {
dc810e39
AM
4146 amt = sizeof *t;
4147 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, amt);
252b5132
RH
4148 if (t == NULL)
4149 {
4150 rinfo->failed = true;
4151 return false;
4152 }
4153
4154 t->vn_bfd = h->verinfo.verdef->vd_bfd;
4155 t->vn_nextref = elf_tdata (rinfo->output_bfd)->verref;
4156 elf_tdata (rinfo->output_bfd)->verref = t;
4157 }
4158
dc810e39
AM
4159 amt = sizeof *a;
4160 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, amt);
252b5132
RH
4161
4162 /* Note that we are copying a string pointer here, and testing it
4163 above. If bfd_elf_string_from_elf_section is ever changed to
4164 discard the string data when low in memory, this will have to be
4165 fixed. */
4166 a->vna_nodename = h->verinfo.verdef->vd_nodename;
4167
4168 a->vna_flags = h->verinfo.verdef->vd_flags;
4169 a->vna_nextptr = t->vn_auxptr;
4170
4171 h->verinfo.verdef->vd_exp_refno = rinfo->vers;
4172 ++rinfo->vers;
4173
4174 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
4175
4176 t->vn_auxptr = a;
4177
4178 return true;
4179}
4180
4181/* Figure out appropriate versions for all the symbols. We may not
4182 have the version number script until we have read all of the input
4183 files, so until that point we don't know which symbols should be
4184 local. This function is called via elf_link_hash_traverse. */
4185
4186static boolean
4187elf_link_assign_sym_version (h, data)
4188 struct elf_link_hash_entry *h;
4189 PTR data;
4190{
dc810e39
AM
4191 struct elf_assign_sym_version_info *sinfo;
4192 struct bfd_link_info *info;
c61b8717 4193 struct elf_backend_data *bed;
252b5132
RH
4194 struct elf_info_failed eif;
4195 char *p;
dc810e39
AM
4196 bfd_size_type amt;
4197
4198 sinfo = (struct elf_assign_sym_version_info *) data;
4199 info = sinfo->info;
252b5132 4200
e92d460e
AM
4201 if (h->root.type == bfd_link_hash_warning)
4202 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4203
252b5132
RH
4204 /* Fix the symbol flags. */
4205 eif.failed = false;
4206 eif.info = info;
4207 if (! elf_fix_symbol_flags (h, &eif))
4208 {
4209 if (eif.failed)
4210 sinfo->failed = true;
4211 return false;
4212 }
4213
4214 /* We only need version numbers for symbols defined in regular
4215 objects. */
4216 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4217 return true;
4218
c61b8717 4219 bed = get_elf_backend_data (sinfo->output_bfd);
252b5132
RH
4220 p = strchr (h->root.root.string, ELF_VER_CHR);
4221 if (p != NULL && h->verinfo.vertree == NULL)
4222 {
4223 struct bfd_elf_version_tree *t;
4224 boolean hidden;
4225
4226 hidden = true;
4227
4228 /* There are two consecutive ELF_VER_CHR characters if this is
c44233aa 4229 not a hidden symbol. */
252b5132
RH
4230 ++p;
4231 if (*p == ELF_VER_CHR)
4232 {
4233 hidden = false;
4234 ++p;
4235 }
4236
4237 /* If there is no version string, we can just return out. */
4238 if (*p == '\0')
4239 {
4240 if (hidden)
4241 h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
4242 return true;
4243 }
4244
4245 /* Look for the version. If we find it, it is no longer weak. */
4246 for (t = sinfo->verdefs; t != NULL; t = t->next)
4247 {
4248 if (strcmp (t->name, p) == 0)
4249 {
dc810e39 4250 size_t len;
252b5132
RH
4251 char *alc;
4252 struct bfd_elf_version_expr *d;
4253
4254 len = p - h->root.root.string;
e5094212 4255 alc = bfd_malloc ((bfd_size_type) len);
252b5132 4256 if (alc == NULL)
c44233aa 4257 return false;
d4c88bbb 4258 memcpy (alc, h->root.root.string, len - 1);
252b5132
RH
4259 alc[len - 1] = '\0';
4260 if (alc[len - 2] == ELF_VER_CHR)
c44233aa 4261 alc[len - 2] = '\0';
252b5132
RH
4262
4263 h->verinfo.vertree = t;
4264 t->used = true;
4265 d = NULL;
4266
4267 if (t->globals != NULL)
4268 {
4269 for (d = t->globals; d != NULL; d = d->next)
4270 if ((*d->match) (d, alc))
4271 break;
4272 }
4273
4274 /* See if there is anything to force this symbol to
c44233aa 4275 local scope. */
252b5132
RH
4276 if (d == NULL && t->locals != NULL)
4277 {
4278 for (d = t->locals; d != NULL; d = d->next)
4279 {
4280 if ((*d->match) (d, alc))
4281 {
4282 if (h->dynindx != -1
4283 && info->shared
99293407 4284 && ! info->export_dynamic)
252b5132 4285 {
e5094212 4286 (*bed->elf_backend_hide_symbol) (info, h, true);
252b5132
RH
4287 }
4288
4289 break;
4290 }
4291 }
4292 }
4293
e5094212 4294 free (alc);
252b5132
RH
4295 break;
4296 }
4297 }
4298
4299 /* If we are building an application, we need to create a
c44233aa 4300 version node for this version. */
252b5132
RH
4301 if (t == NULL && ! info->shared)
4302 {
4303 struct bfd_elf_version_tree **pp;
4304 int version_index;
4305
4306 /* If we aren't going to export this symbol, we don't need
c44233aa 4307 to worry about it. */
252b5132
RH
4308 if (h->dynindx == -1)
4309 return true;
4310
dc810e39 4311 amt = sizeof *t;
252b5132 4312 t = ((struct bfd_elf_version_tree *)
dc810e39 4313 bfd_alloc (sinfo->output_bfd, amt));
252b5132
RH
4314 if (t == NULL)
4315 {
4316 sinfo->failed = true;
4317 return false;
4318 }
4319
4320 t->next = NULL;
4321 t->name = p;
4322 t->globals = NULL;
4323 t->locals = NULL;
4324 t->deps = NULL;
4325 t->name_indx = (unsigned int) -1;
4326 t->used = true;
4327
4328 version_index = 1;
6b9b879a
JJ
4329 /* Don't count anonymous version tag. */
4330 if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
4331 version_index = 0;
252b5132
RH
4332 for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
4333 ++version_index;
4334 t->vernum = version_index;
4335
4336 *pp = t;
4337
4338 h->verinfo.vertree = t;
4339 }
4340 else if (t == NULL)
4341 {
4342 /* We could not find the version for a symbol when
c44233aa 4343 generating a shared archive. Return an error. */
252b5132
RH
4344 (*_bfd_error_handler)
4345 (_("%s: undefined versioned symbol name %s"),
4346 bfd_get_filename (sinfo->output_bfd), h->root.root.string);
4347 bfd_set_error (bfd_error_bad_value);
58821868 4348 error_return:
252b5132
RH
4349 sinfo->failed = true;
4350 return false;
4351 }
4352
4353 if (hidden)
4354 h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
4355 }
4356
4357 /* If we don't have a version for this symbol, see if we can find
4358 something. */
4359 if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
4360 {
4361 struct bfd_elf_version_tree *t;
58821868 4362 struct bfd_elf_version_tree *local_ver;
252b5132
RH
4363 struct bfd_elf_version_expr *d;
4364
4365 /* See if can find what version this symbol is in. If the
c44233aa
AM
4366 symbol is supposed to be local, then don't actually register
4367 it. */
58821868 4368 local_ver = NULL;
252b5132
RH
4369 for (t = sinfo->verdefs; t != NULL; t = t->next)
4370 {
4371 if (t->globals != NULL)
4372 {
4373 for (d = t->globals; d != NULL; d = d->next)
4374 {
4375 if ((*d->match) (d, h->root.root.string))
4376 {
4377 h->verinfo.vertree = t;
58821868 4378 local_ver = NULL;
252b5132
RH
4379 break;
4380 }
4381 }
4382
4383 if (d != NULL)
4384 break;
4385 }
4386
4387 if (t->locals != NULL)
4388 {
4389 for (d = t->locals; d != NULL; d = d->next)
4390 {
58821868
AM
4391 /* If the match is "*", keep looking for a more
4392 explicit, perhaps even global, match. */
252b5132 4393 if (d->pattern[0] == '*' && d->pattern[1] == '\0')
58821868 4394 local_ver = t;
252b5132
RH
4395 else if ((*d->match) (d, h->root.root.string))
4396 {
58821868 4397 local_ver = t;
252b5132
RH
4398 break;
4399 }
4400 }
4401
4402 if (d != NULL)
4403 break;
4404 }
4405 }
4406
58821868 4407 if (local_ver != NULL)
252b5132 4408 {
58821868 4409 h->verinfo.vertree = local_ver;
252b5132
RH
4410 if (h->dynindx != -1
4411 && info->shared
99293407 4412 && ! info->export_dynamic)
252b5132 4413 {
e5094212 4414 (*bed->elf_backend_hide_symbol) (info, h, true);
252b5132
RH
4415 }
4416 }
96a94295
L
4417
4418 /* We need to check if a hidden versioned definition should
4419 hide the default one. */
4420 if (h->dynindx != -1 && h->verinfo.vertree != NULL)
4421 {
4422 const char *verstr, *name;
4423 size_t namelen, verlen, newlen;
4424 char *newname;
4425 struct elf_link_hash_entry *newh;
4426
4427 name = h->root.root.string;
4428 namelen = strlen (name);
4429 verstr = h->verinfo.vertree->name;
4430 verlen = strlen (verstr);
4431 newlen = namelen + verlen + 2;
4432
4433 newname = (char *) bfd_malloc ((bfd_size_type) newlen);
4434 if (newname == NULL)
4435 goto error_return;
4436 memcpy (newname, name, namelen);
4437
4438 /* Check the hidden versioned definition. */
4439 p = newname + namelen;
4440 *p++ = ELF_VER_CHR;
4441 memcpy (p, verstr, verlen + 1);
4442 newh = elf_link_hash_lookup (elf_hash_table (info), newname,
58821868 4443 false, false, false);
96a94295
L
4444
4445 if (newh
4446 && (newh->root.type == bfd_link_hash_defined
4447 || newh->root.type == bfd_link_hash_defweak))
58821868
AM
4448 /* We found a hidden versioned definition. Hide the
4449 default one. */
96a94295
L
4450 (*bed->elf_backend_hide_symbol) (info, h, true);
4451
4452 free (newname);
4453 }
252b5132
RH
4454 }
4455
4456 return true;
4457}
252b5132
RH
4458\f
4459/* Final phase of ELF linker. */
4460
4461/* A structure we use to avoid passing large numbers of arguments. */
4462
4463struct elf_final_link_info
4464{
4465 /* General link information. */
4466 struct bfd_link_info *info;
4467 /* Output BFD. */
4468 bfd *output_bfd;
4469 /* Symbol string table. */
4470 struct bfd_strtab_hash *symstrtab;
4471 /* .dynsym section. */
4472 asection *dynsym_sec;
4473 /* .hash section. */
4474 asection *hash_sec;
4475 /* symbol version section (.gnu.version). */
4476 asection *symver_sec;
13ae64f3
JJ
4477 /* first SHF_TLS section (if any). */
4478 asection *first_tls_sec;
252b5132
RH
4479 /* Buffer large enough to hold contents of any section. */
4480 bfd_byte *contents;
4481 /* Buffer large enough to hold external relocs of any section. */
4482 PTR external_relocs;
4483 /* Buffer large enough to hold internal relocs of any section. */
4484 Elf_Internal_Rela *internal_relocs;
4485 /* Buffer large enough to hold external local symbols of any input
4486 BFD. */
4487 Elf_External_Sym *external_syms;
9ad5cbcf
AM
4488 /* And a buffer for symbol section indices. */
4489 Elf_External_Sym_Shndx *locsym_shndx;
252b5132
RH
4490 /* Buffer large enough to hold internal local symbols of any input
4491 BFD. */
4492 Elf_Internal_Sym *internal_syms;
4493 /* Array large enough to hold a symbol index for each local symbol
4494 of any input BFD. */
4495 long *indices;
4496 /* Array large enough to hold a section pointer for each local
4497 symbol of any input BFD. */
4498 asection **sections;
4499 /* Buffer to hold swapped out symbols. */
4500 Elf_External_Sym *symbuf;
9ad5cbcf
AM
4501 /* And one for symbol section indices. */
4502 Elf_External_Sym_Shndx *symshndxbuf;
252b5132
RH
4503 /* Number of swapped out symbols in buffer. */
4504 size_t symbuf_count;
4505 /* Number of symbols which fit in symbuf. */
4506 size_t symbuf_size;
4507};
4508
4509static boolean elf_link_output_sym
4510 PARAMS ((struct elf_final_link_info *, const char *,
4511 Elf_Internal_Sym *, asection *));
4512static boolean elf_link_flush_output_syms
4513 PARAMS ((struct elf_final_link_info *));
4514static boolean elf_link_output_extsym
4515 PARAMS ((struct elf_link_hash_entry *, PTR));
f5fa8ca2
JJ
4516static boolean elf_link_sec_merge_syms
4517 PARAMS ((struct elf_link_hash_entry *, PTR));
f5d44ba0
AM
4518static boolean elf_link_check_versioned_symbol
4519 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
252b5132
RH
4520static boolean elf_link_input_bfd
4521 PARAMS ((struct elf_final_link_info *, bfd *));
4522static boolean elf_reloc_link_order
4523 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4524 struct bfd_link_order *));
4525
4526/* This struct is used to pass information to elf_link_output_extsym. */
4527
4528struct elf_outext_info
4529{
4530 boolean failed;
4531 boolean localsyms;
4532 struct elf_final_link_info *finfo;
4533};
4534
23bc299b
MM
4535/* Compute the size of, and allocate space for, REL_HDR which is the
4536 section header for a section containing relocations for O. */
4537
4538static boolean
4539elf_link_size_reloc_section (abfd, rel_hdr, o)
4540 bfd *abfd;
4541 Elf_Internal_Shdr *rel_hdr;
4542 asection *o;
4543{
dc810e39
AM
4544 bfd_size_type reloc_count;
4545 bfd_size_type num_rel_hashes;
23bc299b 4546
b037af20
MM
4547 /* Figure out how many relocations there will be. */
4548 if (rel_hdr == &elf_section_data (o)->rel_hdr)
4549 reloc_count = elf_section_data (o)->rel_count;
4550 else
4551 reloc_count = elf_section_data (o)->rel_count2;
4552
9317eacc
CM
4553 num_rel_hashes = o->reloc_count;
4554 if (num_rel_hashes < reloc_count)
4555 num_rel_hashes = reloc_count;
dc810e39 4556
b037af20
MM
4557 /* That allows us to calculate the size of the section. */
4558 rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count;
23bc299b
MM
4559
4560 /* The contents field must last into write_object_contents, so we
755cfd29
NC
4561 allocate it with bfd_alloc rather than malloc. Also since we
4562 cannot be sure that the contents will actually be filled in,
4563 we zero the allocated space. */
4564 rel_hdr->contents = (PTR) bfd_zalloc (abfd, rel_hdr->sh_size);
23bc299b
MM
4565 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
4566 return false;
3e932841 4567
b037af20
MM
4568 /* We only allocate one set of hash entries, so we only do it the
4569 first time we are called. */
9317eacc
CM
4570 if (elf_section_data (o)->rel_hashes == NULL
4571 && num_rel_hashes)
b037af20 4572 {
209f668e
NC
4573 struct elf_link_hash_entry **p;
4574
b037af20 4575 p = ((struct elf_link_hash_entry **)
9317eacc 4576 bfd_zmalloc (num_rel_hashes
209f668e 4577 * sizeof (struct elf_link_hash_entry *)));
9317eacc 4578 if (p == NULL)
b037af20 4579 return false;
23bc299b 4580
b037af20 4581 elf_section_data (o)->rel_hashes = p;
b037af20 4582 }
23bc299b
MM
4583
4584 return true;
4585}
4586
31367b81
MM
4587/* When performing a relocateable link, the input relocations are
4588 preserved. But, if they reference global symbols, the indices
4589 referenced must be updated. Update all the relocations in
4590 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
4591
4592static void
4593elf_link_adjust_relocs (abfd, rel_hdr, count, rel_hash)
4594 bfd *abfd;
4595 Elf_Internal_Shdr *rel_hdr;
4596 unsigned int count;
4597 struct elf_link_hash_entry **rel_hash;
4598{
4599 unsigned int i;
32f0787a 4600 struct elf_backend_data *bed = get_elf_backend_data (abfd);
209f668e
NC
4601 Elf_Internal_Rel *irel;
4602 Elf_Internal_Rela *irela;
dc810e39 4603 bfd_size_type amt = sizeof (Elf_Internal_Rel) * bed->s->int_rels_per_ext_rel;
209f668e 4604
dc810e39 4605 irel = (Elf_Internal_Rel *) bfd_zmalloc (amt);
209f668e
NC
4606 if (irel == NULL)
4607 {
4608 (*_bfd_error_handler) (_("Error: out of memory"));
4609 abort ();
4610 }
4611
dc810e39
AM
4612 amt = sizeof (Elf_Internal_Rela) * bed->s->int_rels_per_ext_rel;
4613 irela = (Elf_Internal_Rela *) bfd_zmalloc (amt);
209f668e
NC
4614 if (irela == NULL)
4615 {
4616 (*_bfd_error_handler) (_("Error: out of memory"));
4617 abort ();
4618 }
31367b81
MM
4619
4620 for (i = 0; i < count; i++, rel_hash++)
4621 {
4622 if (*rel_hash == NULL)
4623 continue;
4624
4625 BFD_ASSERT ((*rel_hash)->indx >= 0);
4626
4627 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
4628 {
4629 Elf_External_Rel *erel;
209f668e 4630 unsigned int j;
3e932841 4631
31367b81 4632 erel = (Elf_External_Rel *) rel_hdr->contents + i;
32f0787a 4633 if (bed->s->swap_reloc_in)
209f668e 4634 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
32f0787a 4635 else
209f668e
NC
4636 elf_swap_reloc_in (abfd, erel, irel);
4637
4638 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
4639 irel[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
4640 ELF_R_TYPE (irel[j].r_info));
4641
32f0787a 4642 if (bed->s->swap_reloc_out)
209f668e 4643 (*bed->s->swap_reloc_out) (abfd, irel, (bfd_byte *) erel);
32f0787a 4644 else
209f668e 4645 elf_swap_reloc_out (abfd, irel, erel);
31367b81
MM
4646 }
4647 else
4648 {
4649 Elf_External_Rela *erela;
209f668e 4650 unsigned int j;
3e932841 4651
31367b81
MM
4652 BFD_ASSERT (rel_hdr->sh_entsize
4653 == sizeof (Elf_External_Rela));
3e932841 4654
31367b81 4655 erela = (Elf_External_Rela *) rel_hdr->contents + i;
32f0787a 4656 if (bed->s->swap_reloca_in)
209f668e 4657 (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
32f0787a 4658 else
209f668e
NC
4659 elf_swap_reloca_in (abfd, erela, irela);
4660
4661 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
4662 irela[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
58821868 4663 ELF_R_TYPE (irela[j].r_info));
209f668e 4664
32f0787a 4665 if (bed->s->swap_reloca_out)
209f668e 4666 (*bed->s->swap_reloca_out) (abfd, irela, (bfd_byte *) erela);
32f0787a 4667 else
209f668e 4668 elf_swap_reloca_out (abfd, irela, erela);
31367b81
MM
4669 }
4670 }
209f668e
NC
4671
4672 free (irel);
4673 free (irela);
31367b81
MM
4674}
4675
58821868
AM
4676struct elf_link_sort_rela
4677{
db6751f2
JJ
4678 bfd_vma offset;
4679 enum elf_reloc_type_class type;
58821868
AM
4680 union
4681 {
db6751f2
JJ
4682 Elf_Internal_Rel rel;
4683 Elf_Internal_Rela rela;
4684 } u;
4685};
4686
4687static int
4688elf_link_sort_cmp1 (A, B)
4689 const PTR A;
4690 const PTR B;
4691{
f51e552e
AM
4692 struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
4693 struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
db6751f2
JJ
4694 int relativea, relativeb;
4695
4696 relativea = a->type == reloc_class_relative;
4697 relativeb = b->type == reloc_class_relative;
4698
4699 if (relativea < relativeb)
db6751f2 4700 return 1;
fcfbdf31
JJ
4701 if (relativea > relativeb)
4702 return -1;
db6751f2
JJ
4703 if (ELF_R_SYM (a->u.rel.r_info) < ELF_R_SYM (b->u.rel.r_info))
4704 return -1;
4705 if (ELF_R_SYM (a->u.rel.r_info) > ELF_R_SYM (b->u.rel.r_info))
4706 return 1;
4707 if (a->u.rel.r_offset < b->u.rel.r_offset)
4708 return -1;
4709 if (a->u.rel.r_offset > b->u.rel.r_offset)
4710 return 1;
4711 return 0;
4712}
4713
4714static int
4715elf_link_sort_cmp2 (A, B)
4716 const PTR A;
4717 const PTR B;
4718{
f51e552e
AM
4719 struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
4720 struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
db6751f2
JJ
4721 int copya, copyb;
4722
4723 if (a->offset < b->offset)
4724 return -1;
4725 if (a->offset > b->offset)
4726 return 1;
290394d6
JJ
4727 copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
4728 copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
db6751f2
JJ
4729 if (copya < copyb)
4730 return -1;
4731 if (copya > copyb)
4732 return 1;
4733 if (a->u.rel.r_offset < b->u.rel.r_offset)
4734 return -1;
4735 if (a->u.rel.r_offset > b->u.rel.r_offset)
4736 return 1;
4737 return 0;
4738}
4739
4740static size_t
4741elf_link_sort_relocs (abfd, info, psec)
4742 bfd *abfd;
4743 struct bfd_link_info *info;
4744 asection **psec;
4745{
4746 bfd *dynobj = elf_hash_table (info)->dynobj;
4747 asection *reldyn, *o;
4748 boolean rel = false;
f51e552e
AM
4749 bfd_size_type count, size;
4750 size_t i, j, ret;
db6751f2
JJ
4751 struct elf_link_sort_rela *rela;
4752 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4753
4754 reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");
4755 if (reldyn == NULL || reldyn->_raw_size == 0)
4756 {
4757 reldyn = bfd_get_section_by_name (abfd, ".rel.dyn");
4758 if (reldyn == NULL || reldyn->_raw_size == 0)
4759 return 0;
4760 rel = true;
4761 count = reldyn->_raw_size / sizeof (Elf_External_Rel);
4762 }
4763 else
4764 count = reldyn->_raw_size / sizeof (Elf_External_Rela);
4765
4766 size = 0;
4767 for (o = dynobj->sections; o != NULL; o = o->next)
4768 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4769 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4770 && o->output_section == reldyn)
4771 size += o->_raw_size;
4772
4773 if (size != reldyn->_raw_size)
4774 return 0;
4775
f51e552e 4776 rela = (struct elf_link_sort_rela *) bfd_zmalloc (sizeof (*rela) * count);
db6751f2
JJ
4777 if (rela == NULL)
4778 {
4779 (*info->callbacks->warning)
dc810e39
AM
4780 (info, _("Not enough memory to sort relocations"), 0, abfd, 0,
4781 (bfd_vma) 0);
db6751f2
JJ
4782 return 0;
4783 }
4784
4785 for (o = dynobj->sections; o != NULL; o = o->next)
4786 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4787 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4788 && o->output_section == reldyn)
4789 {
4790 if (rel)
4791 {
4792 Elf_External_Rel *erel, *erelend;
4793 struct elf_link_sort_rela *s;
4794
4795 erel = (Elf_External_Rel *) o->contents;
f51e552e 4796 erelend = (Elf_External_Rel *) (o->contents + o->_raw_size);
db6751f2
JJ
4797 s = rela + o->output_offset / sizeof (Elf_External_Rel);
4798 for (; erel < erelend; erel++, s++)
4799 {
4800 if (bed->s->swap_reloc_in)
4801 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, &s->u.rel);
4802 else
4803 elf_swap_reloc_in (abfd, erel, &s->u.rel);
4804
f51e552e 4805 s->type = (*bed->elf_backend_reloc_type_class) (&s->u.rela);
dc810e39 4806 }
db6751f2
JJ
4807 }
4808 else
4809 {
4810 Elf_External_Rela *erela, *erelaend;
4811 struct elf_link_sort_rela *s;
4812
4813 erela = (Elf_External_Rela *) o->contents;
f51e552e 4814 erelaend = (Elf_External_Rela *) (o->contents + o->_raw_size);
db6751f2
JJ
4815 s = rela + o->output_offset / sizeof (Elf_External_Rela);
4816 for (; erela < erelaend; erela++, s++)
4817 {
4818 if (bed->s->swap_reloca_in)
dc810e39
AM
4819 (*bed->s->swap_reloca_in) (dynobj, (bfd_byte *) erela,
4820 &s->u.rela);
db6751f2
JJ
4821 else
4822 elf_swap_reloca_in (dynobj, erela, &s->u.rela);
4823
f51e552e 4824 s->type = (*bed->elf_backend_reloc_type_class) (&s->u.rela);
dc810e39 4825 }
db6751f2
JJ
4826 }
4827 }
4828
973ffd63 4829 qsort (rela, (size_t) count, sizeof (*rela), elf_link_sort_cmp1);
fcfbdf31
JJ
4830 for (ret = 0; ret < count && rela[ret].type == reloc_class_relative; ret++)
4831 ;
4832 for (i = ret, j = ret; i < count; i++)
db6751f2
JJ
4833 {
4834 if (ELF_R_SYM (rela[i].u.rel.r_info) != ELF_R_SYM (rela[j].u.rel.r_info))
4835 j = i;
4836 rela[i].offset = rela[j].u.rel.r_offset;
4837 }
973ffd63 4838 qsort (rela + ret, (size_t) count - ret, sizeof (*rela), elf_link_sort_cmp2);
dc810e39 4839
db6751f2
JJ
4840 for (o = dynobj->sections; o != NULL; o = o->next)
4841 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4842 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4843 && o->output_section == reldyn)
4844 {
4845 if (rel)
4846 {
4847 Elf_External_Rel *erel, *erelend;
4848 struct elf_link_sort_rela *s;
4849
4850 erel = (Elf_External_Rel *) o->contents;
df22989b 4851 erelend = (Elf_External_Rel *) (o->contents + o->_raw_size);
db6751f2
JJ
4852 s = rela + o->output_offset / sizeof (Elf_External_Rel);
4853 for (; erel < erelend; erel++, s++)
4854 {
4855 if (bed->s->swap_reloc_out)
dc810e39
AM
4856 (*bed->s->swap_reloc_out) (abfd, &s->u.rel,
4857 (bfd_byte *) erel);
db6751f2
JJ
4858 else
4859 elf_swap_reloc_out (abfd, &s->u.rel, erel);
4860 }
4861 }
4862 else
4863 {
4864 Elf_External_Rela *erela, *erelaend;
4865 struct elf_link_sort_rela *s;
4866
4867 erela = (Elf_External_Rela *) o->contents;
df22989b 4868 erelaend = (Elf_External_Rela *) (o->contents + o->_raw_size);
db6751f2
JJ
4869 s = rela + o->output_offset / sizeof (Elf_External_Rela);
4870 for (; erela < erelaend; erela++, s++)
4871 {
4872 if (bed->s->swap_reloca_out)
dc810e39
AM
4873 (*bed->s->swap_reloca_out) (dynobj, &s->u.rela,
4874 (bfd_byte *) erela);
db6751f2
JJ
4875 else
4876 elf_swap_reloca_out (dynobj, &s->u.rela, erela);
dc810e39 4877 }
db6751f2
JJ
4878 }
4879 }
4880
4881 free (rela);
4882 *psec = reldyn;
4883 return ret;
4884}
4885
252b5132
RH
4886/* Do the final step of an ELF link. */
4887
4888boolean
4889elf_bfd_final_link (abfd, info)
4890 bfd *abfd;
4891 struct bfd_link_info *info;
4892{
4893 boolean dynamic;
9317eacc 4894 boolean emit_relocs;
252b5132
RH
4895 bfd *dynobj;
4896 struct elf_final_link_info finfo;
4897 register asection *o;
4898 register struct bfd_link_order *p;
4899 register bfd *sub;
dc810e39
AM
4900 bfd_size_type max_contents_size;
4901 bfd_size_type max_external_reloc_size;
4902 bfd_size_type max_internal_reloc_count;
4903 bfd_size_type max_sym_count;
9ad5cbcf 4904 bfd_size_type max_sym_shndx_count;
252b5132
RH
4905 file_ptr off;
4906 Elf_Internal_Sym elfsym;
4907 unsigned int i;
4908 Elf_Internal_Shdr *symtab_hdr;
4909 Elf_Internal_Shdr *symstrtab_hdr;
4910 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4911 struct elf_outext_info eoinfo;
f5fa8ca2 4912 boolean merged;
db6751f2
JJ
4913 size_t relativecount = 0;
4914 asection *reldyn = 0;
dc810e39 4915 bfd_size_type amt;
252b5132 4916
8ea2e4bd
NC
4917 if (! is_elf_hash_table (info))
4918 return false;
4919
252b5132
RH
4920 if (info->shared)
4921 abfd->flags |= DYNAMIC;
4922
4923 dynamic = elf_hash_table (info)->dynamic_sections_created;
4924 dynobj = elf_hash_table (info)->dynobj;
4925
9317eacc 4926 emit_relocs = (info->relocateable
c44233aa
AM
4927 || info->emitrelocations
4928 || bed->elf_backend_emit_relocs);
9317eacc 4929
252b5132
RH
4930 finfo.info = info;
4931 finfo.output_bfd = abfd;
4932 finfo.symstrtab = elf_stringtab_init ();
4933 if (finfo.symstrtab == NULL)
4934 return false;
4935
4936 if (! dynamic)
4937 {
4938 finfo.dynsym_sec = NULL;
4939 finfo.hash_sec = NULL;
4940 finfo.symver_sec = NULL;
4941 }
4942 else
4943 {
4944 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
4945 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
4946 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
4947 finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
4948 /* Note that it is OK if symver_sec is NULL. */
4949 }
4950
4951 finfo.contents = NULL;
4952 finfo.external_relocs = NULL;
4953 finfo.internal_relocs = NULL;
4954 finfo.external_syms = NULL;
9ad5cbcf 4955 finfo.locsym_shndx = NULL;
252b5132
RH
4956 finfo.internal_syms = NULL;
4957 finfo.indices = NULL;
4958 finfo.sections = NULL;
4959 finfo.symbuf = NULL;
9ad5cbcf 4960 finfo.symshndxbuf = NULL;
252b5132 4961 finfo.symbuf_count = 0;
13ae64f3
JJ
4962 finfo.first_tls_sec = NULL;
4963 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4964 if ((o->flags & SEC_THREAD_LOCAL) != 0
4965 && (o->flags & SEC_LOAD) != 0)
4966 {
4967 finfo.first_tls_sec = o;
4968 break;
4969 }
252b5132
RH
4970
4971 /* Count up the number of relocations we will output for each output
4972 section, so that we know the sizes of the reloc sections. We
4973 also figure out some maximum sizes. */
4974 max_contents_size = 0;
4975 max_external_reloc_size = 0;
4976 max_internal_reloc_count = 0;
4977 max_sym_count = 0;
9ad5cbcf 4978 max_sym_shndx_count = 0;
f5fa8ca2 4979 merged = false;
252b5132
RH
4980 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4981 {
4982 o->reloc_count = 0;
4983
4984 for (p = o->link_order_head; p != NULL; p = p->next)
4985 {
4986 if (p->type == bfd_section_reloc_link_order
4987 || p->type == bfd_symbol_reloc_link_order)
4988 ++o->reloc_count;
4989 else if (p->type == bfd_indirect_link_order)
4990 {
4991 asection *sec;
4992
4993 sec = p->u.indirect.section;
4994
4995 /* Mark all sections which are to be included in the
4996 link. This will normally be every section. We need
4997 to do this so that we can identify any sections which
4998 the linker has decided to not include. */
4999 sec->linker_mark = true;
5000
f5fa8ca2
JJ
5001 if (sec->flags & SEC_MERGE)
5002 merged = true;
5003
a712da20 5004 if (info->relocateable || info->emitrelocations)
252b5132 5005 o->reloc_count += sec->reloc_count;
c44233aa 5006 else if (bed->elf_backend_count_relocs)
9317eacc
CM
5007 {
5008 Elf_Internal_Rela * relocs;
5009
5010 relocs = (NAME(_bfd_elf,link_read_relocs)
5011 (abfd, sec, (PTR) NULL,
5012 (Elf_Internal_Rela *) NULL, info->keep_memory));
5013
c44233aa
AM
5014 o->reloc_count
5015 += (*bed->elf_backend_count_relocs) (sec, relocs);
9317eacc 5016
6cdc0ccc 5017 if (elf_section_data (o)->relocs != relocs)
9317eacc
CM
5018 free (relocs);
5019 }
252b5132
RH
5020
5021 if (sec->_raw_size > max_contents_size)
5022 max_contents_size = sec->_raw_size;
5023 if (sec->_cooked_size > max_contents_size)
5024 max_contents_size = sec->_cooked_size;
5025
5026 /* We are interested in just local symbols, not all
5027 symbols. */
5028 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
5029 && (sec->owner->flags & DYNAMIC) == 0)
5030 {
5031 size_t sym_count;
5032
5033 if (elf_bad_symtab (sec->owner))
5034 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
5035 / sizeof (Elf_External_Sym));
5036 else
5037 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
5038
5039 if (sym_count > max_sym_count)
5040 max_sym_count = sym_count;
5041
9ad5cbcf
AM
5042 if (sym_count > max_sym_shndx_count
5043 && elf_symtab_shndx (sec->owner) != 0)
5044 max_sym_shndx_count = sym_count;
5045
252b5132
RH
5046 if ((sec->flags & SEC_RELOC) != 0)
5047 {
5048 size_t ext_size;
5049
5050 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
5051 if (ext_size > max_external_reloc_size)
5052 max_external_reloc_size = ext_size;
5053 if (sec->reloc_count > max_internal_reloc_count)
5054 max_internal_reloc_count = sec->reloc_count;
5055 }
5056 }
5057 }
5058 }
5059
5060 if (o->reloc_count > 0)
5061 o->flags |= SEC_RELOC;
5062 else
5063 {
5064 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5065 set it (this is probably a bug) and if it is set
5066 assign_section_numbers will create a reloc section. */
5067 o->flags &=~ SEC_RELOC;
5068 }
5069
5070 /* If the SEC_ALLOC flag is not set, force the section VMA to
5071 zero. This is done in elf_fake_sections as well, but forcing
5072 the VMA to 0 here will ensure that relocs against these
5073 sections are handled correctly. */
5074 if ((o->flags & SEC_ALLOC) == 0
5075 && ! o->user_set_vma)
5076 o->vma = 0;
5077 }
5078
f5fa8ca2
JJ
5079 if (! info->relocateable && merged)
5080 elf_link_hash_traverse (elf_hash_table (info),
5081 elf_link_sec_merge_syms, (PTR) abfd);
5082
252b5132
RH
5083 /* Figure out the file positions for everything but the symbol table
5084 and the relocs. We set symcount to force assign_section_numbers
5085 to create a symbol table. */
5086 bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
5087 BFD_ASSERT (! abfd->output_has_begun);
5088 if (! _bfd_elf_compute_section_file_positions (abfd, info))
5089 goto error_return;
5090
b037af20
MM
5091 /* Figure out how many relocations we will have in each section.
5092 Just using RELOC_COUNT isn't good enough since that doesn't
5093 maintain a separate value for REL vs. RELA relocations. */
9317eacc 5094 if (emit_relocs)
b037af20
MM
5095 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5096 for (o = sub->sections; o != NULL; o = o->next)
5097 {
814fe68a 5098 asection *output_section;
b037af20 5099
814fe68a
ILT
5100 if (! o->linker_mark)
5101 {
5102 /* This section was omitted from the link. */
5103 continue;
5104 }
5105
5106 output_section = o->output_section;
5107
5108 if (output_section != NULL
5109 && (o->flags & SEC_RELOC) != 0)
b037af20 5110 {
3e932841 5111 struct bfd_elf_section_data *esdi
b037af20 5112 = elf_section_data (o);
3e932841 5113 struct bfd_elf_section_data *esdo
b037af20 5114 = elf_section_data (output_section);
ce006217
MM
5115 unsigned int *rel_count;
5116 unsigned int *rel_count2;
c119f9b8
AM
5117 bfd_size_type entsize;
5118 bfd_size_type entsize2;
b037af20 5119
c119f9b8 5120 /* We must be careful to add the relocations from the
ce006217 5121 input section to the right output count. */
c119f9b8
AM
5122 entsize = esdi->rel_hdr.sh_entsize;
5123 entsize2 = esdi->rel_hdr2 ? esdi->rel_hdr2->sh_entsize : 0;
5124 BFD_ASSERT ((entsize == sizeof (Elf_External_Rel)
5125 || entsize == sizeof (Elf_External_Rela))
5126 && entsize2 != entsize
5127 && (entsize2 == 0
5128 || entsize2 == sizeof (Elf_External_Rel)
5129 || entsize2 == sizeof (Elf_External_Rela)));
5130 if (entsize == esdo->rel_hdr.sh_entsize)
ce006217
MM
5131 {
5132 rel_count = &esdo->rel_count;
5133 rel_count2 = &esdo->rel_count2;
5134 }
5135 else
5136 {
5137 rel_count = &esdo->rel_count2;
5138 rel_count2 = &esdo->rel_count;
5139 }
3e932841 5140
d9bc7a44 5141 *rel_count += NUM_SHDR_ENTRIES (& esdi->rel_hdr);
b037af20 5142 if (esdi->rel_hdr2)
d9bc7a44 5143 *rel_count2 += NUM_SHDR_ENTRIES (esdi->rel_hdr2);
9317eacc 5144 output_section->flags |= SEC_RELOC;
b037af20
MM
5145 }
5146 }
5147
252b5132
RH
5148 /* That created the reloc sections. Set their sizes, and assign
5149 them file positions, and allocate some buffers. */
5150 for (o = abfd->sections; o != NULL; o = o->next)
5151 {
5152 if ((o->flags & SEC_RELOC) != 0)
5153 {
23bc299b
MM
5154 if (!elf_link_size_reloc_section (abfd,
5155 &elf_section_data (o)->rel_hdr,
5156 o))
252b5132
RH
5157 goto error_return;
5158
23bc299b
MM
5159 if (elf_section_data (o)->rel_hdr2
5160 && !elf_link_size_reloc_section (abfd,
5161 elf_section_data (o)->rel_hdr2,
5162 o))
252b5132 5163 goto error_return;
252b5132 5164 }
b037af20
MM
5165
5166 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
3e932841 5167 to count upwards while actually outputting the relocations. */
b037af20
MM
5168 elf_section_data (o)->rel_count = 0;
5169 elf_section_data (o)->rel_count2 = 0;
252b5132
RH
5170 }
5171
5172 _bfd_elf_assign_file_positions_for_relocs (abfd);
5173
5174 /* We have now assigned file positions for all the sections except
5175 .symtab and .strtab. We start the .symtab section at the current
5176 file position, and write directly to it. We build the .strtab
5177 section in memory. */
5178 bfd_get_symcount (abfd) = 0;
5179 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5180 /* sh_name is set in prep_headers. */
5181 symtab_hdr->sh_type = SHT_SYMTAB;
5182 symtab_hdr->sh_flags = 0;
5183 symtab_hdr->sh_addr = 0;
5184 symtab_hdr->sh_size = 0;
5185 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
5186 /* sh_link is set in assign_section_numbers. */
5187 /* sh_info is set below. */
5188 /* sh_offset is set just below. */
f0e1d18a 5189 symtab_hdr->sh_addralign = bed->s->file_align;
252b5132
RH
5190
5191 off = elf_tdata (abfd)->next_file_pos;
5192 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
5193
5194 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5195 incorrect. We do not yet know the size of the .symtab section.
5196 We correct next_file_pos below, after we do know the size. */
5197
5198 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5199 continuously seeking to the right position in the file. */
5200 if (! info->keep_memory || max_sym_count < 20)
5201 finfo.symbuf_size = 20;
5202 else
5203 finfo.symbuf_size = max_sym_count;
dc810e39
AM
5204 amt = finfo.symbuf_size;
5205 amt *= sizeof (Elf_External_Sym);
5206 finfo.symbuf = (Elf_External_Sym *) bfd_malloc (amt);
252b5132
RH
5207 if (finfo.symbuf == NULL)
5208 goto error_return;
9ad5cbcf
AM
5209 if (elf_numsections (abfd) > SHN_LORESERVE)
5210 {
5211 amt = finfo.symbuf_size;
5212 amt *= sizeof (Elf_External_Sym_Shndx);
5213 finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
5214 if (finfo.symshndxbuf == NULL)
5215 goto error_return;
5216 }
252b5132
RH
5217
5218 /* Start writing out the symbol table. The first symbol is always a
5219 dummy symbol. */
9317eacc
CM
5220 if (info->strip != strip_all
5221 || emit_relocs)
252b5132
RH
5222 {
5223 elfsym.st_value = 0;
5224 elfsym.st_size = 0;
5225 elfsym.st_info = 0;
5226 elfsym.st_other = 0;
5227 elfsym.st_shndx = SHN_UNDEF;
5228 if (! elf_link_output_sym (&finfo, (const char *) NULL,
5229 &elfsym, bfd_und_section_ptr))
5230 goto error_return;
5231 }
5232
5233#if 0
5234 /* Some standard ELF linkers do this, but we don't because it causes
5235 bootstrap comparison failures. */
5236 /* Output a file symbol for the output file as the second symbol.
5237 We output this even if we are discarding local symbols, although
5238 I'm not sure if this is correct. */
5239 elfsym.st_value = 0;
5240 elfsym.st_size = 0;
5241 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5242 elfsym.st_other = 0;
5243 elfsym.st_shndx = SHN_ABS;
5244 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
5245 &elfsym, bfd_abs_section_ptr))
5246 goto error_return;
5247#endif
5248
5249 /* Output a symbol for each section. We output these even if we are
5250 discarding local symbols, since they are used for relocs. These
5251 symbols have no names. We store the index of each one in the
5252 index field of the section, so that we can find it again when
5253 outputting relocs. */
9317eacc
CM
5254 if (info->strip != strip_all
5255 || emit_relocs)
252b5132
RH
5256 {
5257 elfsym.st_size = 0;
5258 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5259 elfsym.st_other = 0;
9ad5cbcf 5260 for (i = 1; i < elf_numsections (abfd); i++)
252b5132
RH
5261 {
5262 o = section_from_elf_index (abfd, i);
5263 if (o != NULL)
5264 o->target_index = bfd_get_symcount (abfd);
5265 elfsym.st_shndx = i;
7ad34365 5266 if (info->relocateable || o == NULL)
252b5132
RH
5267 elfsym.st_value = 0;
5268 else
5269 elfsym.st_value = o->vma;
5270 if (! elf_link_output_sym (&finfo, (const char *) NULL,
5271 &elfsym, o))
5272 goto error_return;
9ad5cbcf
AM
5273 if (i == SHN_LORESERVE)
5274 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
252b5132
RH
5275 }
5276 }
5277
5278 /* Allocate some memory to hold information read in from the input
5279 files. */
9ad5cbcf
AM
5280 if (max_contents_size != 0)
5281 {
5282 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
5283 if (finfo.contents == NULL)
5284 goto error_return;
5285 }
5286
5287 if (max_external_reloc_size != 0)
5288 {
5289 finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
5290 if (finfo.external_relocs == NULL)
5291 goto error_return;
5292 }
5293
5294 if (max_internal_reloc_count != 0)
5295 {
5296 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
5297 amt *= sizeof (Elf_Internal_Rela);
5298 finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
5299 if (finfo.internal_relocs == NULL)
5300 goto error_return;
5301 }
5302
5303 if (max_sym_count != 0)
5304 {
5305 amt = max_sym_count * sizeof (Elf_External_Sym);
5306 finfo.external_syms = (Elf_External_Sym *) bfd_malloc (amt);
5307 if (finfo.external_syms == NULL)
5308 goto error_return;
5309
5310 amt = max_sym_count * sizeof (Elf_Internal_Sym);
5311 finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
5312 if (finfo.internal_syms == NULL)
5313 goto error_return;
5314
5315 amt = max_sym_count * sizeof (long);
5316 finfo.indices = (long *) bfd_malloc (amt);
5317 if (finfo.indices == NULL)
5318 goto error_return;
5319
5320 amt = max_sym_count * sizeof (asection *);
5321 finfo.sections = (asection **) bfd_malloc (amt);
5322 if (finfo.sections == NULL)
5323 goto error_return;
5324 }
5325
5326 if (max_sym_shndx_count != 0)
5327 {
5328 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
5329 finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
5330 if (finfo.locsym_shndx == NULL)
5331 goto error_return;
5332 }
252b5132 5333
13ae64f3
JJ
5334 if (finfo.first_tls_sec)
5335 {
5336 unsigned int align = 0;
5337 bfd_vma base = finfo.first_tls_sec->vma, end = 0;
5338 asection *sec;
5339
5340 for (sec = finfo.first_tls_sec;
5341 sec && (sec->flags & SEC_THREAD_LOCAL);
5342 sec = sec->next)
5343 {
5344 bfd_vma size = sec->_raw_size;
5345
5346 if (bfd_get_section_alignment (abfd, sec) > align)
5347 align = bfd_get_section_alignment (abfd, sec);
5348 if (sec->_raw_size == 0 && (sec->flags & SEC_HAS_CONTENTS) == 0)
5349 {
5350 struct bfd_link_order *o;
5351
5352 size = 0;
5353 for (o = sec->link_order_head; o != NULL; o = o->next)
5354 if (size < o->offset + o->size)
58821868 5355 size = o->offset + o->size;
13ae64f3
JJ
5356 }
5357 end = sec->vma + size;
5358 }
5359 elf_hash_table (info)->tls_segment
5360 = bfd_zalloc (abfd, sizeof (struct elf_link_tls_segment));
5361 if (elf_hash_table (info)->tls_segment == NULL)
5362 goto error_return;
5363 elf_hash_table (info)->tls_segment->start = base;
5364 elf_hash_table (info)->tls_segment->size = end - base;
5365 elf_hash_table (info)->tls_segment->align = align;
5366 }
5367
252b5132
RH
5368 /* Since ELF permits relocations to be against local symbols, we
5369 must have the local symbols available when we do the relocations.
5370 Since we would rather only read the local symbols once, and we
5371 would rather not keep them in memory, we handle all the
5372 relocations for a single input file at the same time.
5373
5374 Unfortunately, there is no way to know the total number of local
5375 symbols until we have seen all of them, and the local symbol
5376 indices precede the global symbol indices. This means that when
5377 we are generating relocateable output, and we see a reloc against
5378 a global symbol, we can not know the symbol index until we have
5379 finished examining all the local symbols to see which ones we are
5380 going to output. To deal with this, we keep the relocations in
5381 memory, and don't output them until the end of the link. This is
5382 an unfortunate waste of memory, but I don't see a good way around
5383 it. Fortunately, it only happens when performing a relocateable
5384 link, which is not the common case. FIXME: If keep_memory is set
5385 we could write the relocs out and then read them again; I don't
5386 know how bad the memory loss will be. */
5387
5388 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5389 sub->output_has_begun = false;
5390 for (o = abfd->sections; o != NULL; o = o->next)
5391 {
5392 for (p = o->link_order_head; p != NULL; p = p->next)
5393 {
5394 if (p->type == bfd_indirect_link_order
a50c1845 5395 && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
4ddafab0 5396 == bfd_target_elf_flavour)
a50c1845 5397 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
252b5132 5398 {
252b5132
RH
5399 if (! sub->output_has_begun)
5400 {
5401 if (! elf_link_input_bfd (&finfo, sub))
5402 goto error_return;
5403 sub->output_has_begun = true;
5404 }
5405 }
5406 else if (p->type == bfd_section_reloc_link_order
5407 || p->type == bfd_symbol_reloc_link_order)
5408 {
5409 if (! elf_reloc_link_order (abfd, info, o, p))
5410 goto error_return;
5411 }
5412 else
5413 {
5414 if (! _bfd_default_link_order (abfd, info, o, p))
5415 goto error_return;
5416 }
5417 }
5418 }
5419
c44233aa
AM
5420 /* Output any global symbols that got converted to local in a
5421 version script or due to symbol visibility. We do this in a
5422 separate step since ELF requires all local symbols to appear
5423 prior to any global symbols. FIXME: We should only do this if
5424 some global symbols were, in fact, converted to become local.
5425 FIXME: Will this work correctly with the Irix 5 linker? */
5426 eoinfo.failed = false;
5427 eoinfo.finfo = &finfo;
5428 eoinfo.localsyms = true;
5429 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
5430 (PTR) &eoinfo);
5431 if (eoinfo.failed)
5432 return false;
5433
252b5132 5434 /* That wrote out all the local symbols. Finish up the symbol table
5cc7c785
L
5435 with the global symbols. Even if we want to strip everything we
5436 can, we still need to deal with those global symbols that got
3e932841 5437 converted to local in a version script. */
252b5132 5438
30b30c21 5439 /* The sh_info field records the index of the first non local symbol. */
252b5132 5440 symtab_hdr->sh_info = bfd_get_symcount (abfd);
30b30c21 5441
fc8c40a0
AM
5442 if (dynamic
5443 && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
30b30c21
RH
5444 {
5445 Elf_Internal_Sym sym;
5446 Elf_External_Sym *dynsym =
a7b97311 5447 (Elf_External_Sym *) finfo.dynsym_sec->contents;
71a40b32 5448 long last_local = 0;
30b30c21
RH
5449
5450 /* Write out the section symbols for the output sections. */
5451 if (info->shared)
5452 {
5453 asection *s;
5454
5455 sym.st_size = 0;
5456 sym.st_name = 0;
5457 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5458 sym.st_other = 0;
5459
5460 for (s = abfd->sections; s != NULL; s = s->next)
5461 {
5462 int indx;
9ad5cbcf
AM
5463 Elf_External_Sym *dest;
5464
30b30c21
RH
5465 indx = elf_section_data (s)->this_idx;
5466 BFD_ASSERT (indx > 0);
5467 sym.st_shndx = indx;
5468 sym.st_value = s->vma;
9ad5cbcf
AM
5469 dest = dynsym + elf_section_data (s)->dynindx;
5470 elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
30b30c21
RH
5471 }
5472
5473 last_local = bfd_count_sections (abfd);
5474 }
5475
5476 /* Write out the local dynsyms. */
5477 if (elf_hash_table (info)->dynlocal)
5478 {
5479 struct elf_link_local_dynamic_entry *e;
5480 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
5481 {
318da145 5482 asection *s;
9ad5cbcf 5483 Elf_External_Sym *dest;
30b30c21 5484
b037af20
MM
5485 sym.st_size = e->isym.st_size;
5486 sym.st_other = e->isym.st_other;
5487
1fa0ddb3
RH
5488 /* Copy the internal symbol as is.
5489 Note that we saved a word of storage and overwrote
c44233aa
AM
5490 the original st_name with the dynstr_index. */
5491 sym = e->isym;
30b30c21 5492
c8e5ddc8 5493 if (e->isym.st_shndx != SHN_UNDEF
58821868
AM
5494 && (e->isym.st_shndx < SHN_LORESERVE
5495 || e->isym.st_shndx > SHN_HIRESERVE))
587ff49e
RH
5496 {
5497 s = bfd_section_from_elf_index (e->input_bfd,
5498 e->isym.st_shndx);
5499
5500 sym.st_shndx =
5501 elf_section_data (s->output_section)->this_idx;
5502 sym.st_value = (s->output_section->vma
5503 + s->output_offset
5504 + e->isym.st_value);
5505 }
30b30c21
RH
5506
5507 if (last_local < e->dynindx)
5508 last_local = e->dynindx;
5509
9ad5cbcf
AM
5510 dest = dynsym + e->dynindx;
5511 elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
30b30c21
RH
5512 }
5513 }
5514
71a40b32
ILT
5515 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
5516 last_local + 1;
30b30c21 5517 }
252b5132
RH
5518
5519 /* We get the global symbols from the hash table. */
5520 eoinfo.failed = false;
5521 eoinfo.localsyms = false;
5522 eoinfo.finfo = &finfo;
5523 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
5524 (PTR) &eoinfo);
5525 if (eoinfo.failed)
5526 return false;
5527
587ff49e
RH
5528 /* If backend needs to output some symbols not present in the hash
5529 table, do it now. */
5530 if (bed->elf_backend_output_arch_syms)
5531 {
dc810e39
AM
5532 typedef boolean (*out_sym_func) PARAMS ((PTR, const char *,
5533 Elf_Internal_Sym *,
5534 asection *));
5535
5536 if (! ((*bed->elf_backend_output_arch_syms)
5537 (abfd, info, (PTR) &finfo, (out_sym_func) elf_link_output_sym)))
587ff49e 5538 return false;
3e932841 5539 }
587ff49e 5540
252b5132
RH
5541 /* Flush all symbols to the file. */
5542 if (! elf_link_flush_output_syms (&finfo))
5543 return false;
5544
5545 /* Now we know the size of the symtab section. */
5546 off += symtab_hdr->sh_size;
5547
5548 /* Finish up and write out the symbol string table (.strtab)
5549 section. */
5550 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5551 /* sh_name was set in prep_headers. */
5552 symstrtab_hdr->sh_type = SHT_STRTAB;
5553 symstrtab_hdr->sh_flags = 0;
5554 symstrtab_hdr->sh_addr = 0;
5555 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
5556 symstrtab_hdr->sh_entsize = 0;
5557 symstrtab_hdr->sh_link = 0;
5558 symstrtab_hdr->sh_info = 0;
5559 /* sh_offset is set just below. */
5560 symstrtab_hdr->sh_addralign = 1;
5561
5562 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
5563 elf_tdata (abfd)->next_file_pos = off;
5564
5565 if (bfd_get_symcount (abfd) > 0)
5566 {
5567 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
5568 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
5569 return false;
5570 }
5571
5572 /* Adjust the relocs to have the correct symbol indices. */
5573 for (o = abfd->sections; o != NULL; o = o->next)
5574 {
252b5132
RH
5575 if ((o->flags & SEC_RELOC) == 0)
5576 continue;
5577
3e932841 5578 elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr,
31367b81
MM
5579 elf_section_data (o)->rel_count,
5580 elf_section_data (o)->rel_hashes);
5581 if (elf_section_data (o)->rel_hdr2 != NULL)
5582 elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2,
5583 elf_section_data (o)->rel_count2,
3e932841 5584 (elf_section_data (o)->rel_hashes
31367b81 5585 + elf_section_data (o)->rel_count));
252b5132
RH
5586
5587 /* Set the reloc_count field to 0 to prevent write_relocs from
5588 trying to swap the relocs out itself. */
5589 o->reloc_count = 0;
5590 }
5591
db6751f2
JJ
5592 if (dynamic && info->combreloc && dynobj != NULL)
5593 relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
5594
252b5132
RH
5595 /* If we are linking against a dynamic object, or generating a
5596 shared library, finish up the dynamic linking information. */
5597 if (dynamic)
5598 {
5599 Elf_External_Dyn *dyncon, *dynconend;
5600
5601 /* Fix up .dynamic entries. */
5602 o = bfd_get_section_by_name (dynobj, ".dynamic");
5603 BFD_ASSERT (o != NULL);
5604
5605 dyncon = (Elf_External_Dyn *) o->contents;
5606 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
5607 for (; dyncon < dynconend; dyncon++)
5608 {
5609 Elf_Internal_Dyn dyn;
5610 const char *name;
5611 unsigned int type;
5612
5613 elf_swap_dyn_in (dynobj, dyncon, &dyn);
5614
5615 switch (dyn.d_tag)
5616 {
5617 default:
5618 break;
db6751f2
JJ
5619 case DT_NULL:
5620 if (relativecount > 0 && dyncon + 1 < dynconend)
5621 {
5622 switch (elf_section_data (reldyn)->this_hdr.sh_type)
5623 {
5624 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
5625 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
5626 default: break;
5627 }
5628 if (dyn.d_tag != DT_NULL)
5629 {
5630 dyn.d_un.d_val = relativecount;
5631 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5632 relativecount = 0;
5633 }
5634 }
5635 break;
252b5132 5636 case DT_INIT:
f0c2e336 5637 name = info->init_function;
252b5132
RH
5638 goto get_sym;
5639 case DT_FINI:
f0c2e336 5640 name = info->fini_function;
252b5132
RH
5641 get_sym:
5642 {
5643 struct elf_link_hash_entry *h;
5644
5645 h = elf_link_hash_lookup (elf_hash_table (info), name,
5646 false, false, true);
5647 if (h != NULL
5648 && (h->root.type == bfd_link_hash_defined
5649 || h->root.type == bfd_link_hash_defweak))
5650 {
5651 dyn.d_un.d_val = h->root.u.def.value;
5652 o = h->root.u.def.section;
5653 if (o->output_section != NULL)
5654 dyn.d_un.d_val += (o->output_section->vma
5655 + o->output_offset);
5656 else
5657 {
5658 /* The symbol is imported from another shared
5659 library and does not apply to this one. */
5660 dyn.d_un.d_val = 0;
5661 }
5662
5663 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5664 }
5665 }
5666 break;
5667
30831527
RH
5668 case DT_PREINIT_ARRAYSZ:
5669 name = ".preinit_array";
5670 goto get_size;
5671 case DT_INIT_ARRAYSZ:
5672 name = ".init_array";
5673 goto get_size;
5674 case DT_FINI_ARRAYSZ:
5675 name = ".fini_array";
5676 get_size:
5677 o = bfd_get_section_by_name (abfd, name);
2cb69dd3
JL
5678 if (o == NULL)
5679 {
5680 (*_bfd_error_handler)
5681 (_("%s: could not find output section %s"),
5682 bfd_get_filename (abfd), name);
5683 goto error_return;
5684 }
25e27870
L
5685 if (o->_raw_size == 0)
5686 (*_bfd_error_handler)
5687 (_("warning: %s section has zero size"), name);
30831527
RH
5688 dyn.d_un.d_val = o->_raw_size;
5689 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5690 break;
5691
5692 case DT_PREINIT_ARRAY:
5693 name = ".preinit_array";
5694 goto get_vma;
5695 case DT_INIT_ARRAY:
5696 name = ".init_array";
5697 goto get_vma;
5698 case DT_FINI_ARRAY:
5699 name = ".fini_array";
5700 goto get_vma;
5701
252b5132
RH
5702 case DT_HASH:
5703 name = ".hash";
5704 goto get_vma;
5705 case DT_STRTAB:
5706 name = ".dynstr";
5707 goto get_vma;
5708 case DT_SYMTAB:
5709 name = ".dynsym";
5710 goto get_vma;
5711 case DT_VERDEF:
5712 name = ".gnu.version_d";
5713 goto get_vma;
5714 case DT_VERNEED:
5715 name = ".gnu.version_r";
5716 goto get_vma;
5717 case DT_VERSYM:
5718 name = ".gnu.version";
5719 get_vma:
5720 o = bfd_get_section_by_name (abfd, name);
2cb69dd3
JL
5721 if (o == NULL)
5722 {
5723 (*_bfd_error_handler)
5724 (_("%s: could not find output section %s"),
5725 bfd_get_filename (abfd), name);
5726 goto error_return;
5727 }
252b5132
RH
5728 dyn.d_un.d_ptr = o->vma;
5729 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5730 break;
5731
5732 case DT_REL:
5733 case DT_RELA:
5734 case DT_RELSZ:
5735 case DT_RELASZ:
5736 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5737 type = SHT_REL;
5738 else
5739 type = SHT_RELA;
5740 dyn.d_un.d_val = 0;
9ad5cbcf 5741 for (i = 1; i < elf_numsections (abfd); i++)
252b5132
RH
5742 {
5743 Elf_Internal_Shdr *hdr;
5744
5745 hdr = elf_elfsections (abfd)[i];
5746 if (hdr->sh_type == type
5747 && (hdr->sh_flags & SHF_ALLOC) != 0)
5748 {
5749 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
5750 dyn.d_un.d_val += hdr->sh_size;
5751 else
5752 {
5753 if (dyn.d_un.d_val == 0
5754 || hdr->sh_addr < dyn.d_un.d_val)
5755 dyn.d_un.d_val = hdr->sh_addr;
5756 }
5757 }
5758 }
5759 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5760 break;
5761 }
5762 }
5763 }
5764
5765 /* If we have created any dynamic sections, then output them. */
5766 if (dynobj != NULL)
5767 {
5768 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
5769 goto error_return;
5770
5771 for (o = dynobj->sections; o != NULL; o = o->next)
5772 {
5773 if ((o->flags & SEC_HAS_CONTENTS) == 0
fc8c40a0
AM
5774 || o->_raw_size == 0
5775 || o->output_section == bfd_abs_section_ptr)
252b5132
RH
5776 continue;
5777 if ((o->flags & SEC_LINKER_CREATED) == 0)
5778 {
5779 /* At this point, we are only interested in sections
c44233aa 5780 created by elf_link_create_dynamic_sections. */
252b5132
RH
5781 continue;
5782 }
5783 if ((elf_section_data (o->output_section)->this_hdr.sh_type
5784 != SHT_STRTAB)
5785 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
5786 {
5787 if (! bfd_set_section_contents (abfd, o->output_section,
dc810e39
AM
5788 o->contents,
5789 (file_ptr) o->output_offset,
252b5132
RH
5790 o->_raw_size))
5791 goto error_return;
5792 }
5793 else
5794 {
252b5132 5795 /* The contents of the .dynstr section are actually in a
c44233aa 5796 stringtab. */
252b5132
RH
5797 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
5798 if (bfd_seek (abfd, off, SEEK_SET) != 0
2b0f7ef9
JJ
5799 || ! _bfd_elf_strtab_emit (abfd,
5800 elf_hash_table (info)->dynstr))
252b5132
RH
5801 goto error_return;
5802 }
5803 }
5804 }
5805
1126897b
AM
5806 if (info->relocateable)
5807 {
5808 boolean failed = false;
5809
5810 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
5811 if (failed)
5812 goto error_return;
5813 }
5814
252b5132
RH
5815 /* If we have optimized stabs strings, output them. */
5816 if (elf_hash_table (info)->stab_info != NULL)
5817 {
5818 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
5819 goto error_return;
5820 }
5821
57a72197 5822 if (info->eh_frame_hdr && elf_hash_table (info)->dynobj)
65765700
JJ
5823 {
5824 o = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
5825 ".eh_frame_hdr");
5826 if (o
5827 && (elf_section_data (o)->sec_info_type
5828 == ELF_INFO_TYPE_EH_FRAME_HDR))
5829 {
5830 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, o))
5831 goto error_return;
5832 }
5833 }
5834
252b5132
RH
5835 if (finfo.symstrtab != NULL)
5836 _bfd_stringtab_free (finfo.symstrtab);
5837 if (finfo.contents != NULL)
5838 free (finfo.contents);
5839 if (finfo.external_relocs != NULL)
5840 free (finfo.external_relocs);
5841 if (finfo.internal_relocs != NULL)
5842 free (finfo.internal_relocs);
5843 if (finfo.external_syms != NULL)
5844 free (finfo.external_syms);
9ad5cbcf
AM
5845 if (finfo.locsym_shndx != NULL)
5846 free (finfo.locsym_shndx);
252b5132
RH
5847 if (finfo.internal_syms != NULL)
5848 free (finfo.internal_syms);
5849 if (finfo.indices != NULL)
5850 free (finfo.indices);
5851 if (finfo.sections != NULL)
5852 free (finfo.sections);
5853 if (finfo.symbuf != NULL)
5854 free (finfo.symbuf);
9ad5cbcf
AM
5855 if (finfo.symshndxbuf != NULL)
5856 free (finfo.symbuf);
252b5132
RH
5857 for (o = abfd->sections; o != NULL; o = o->next)
5858 {
5859 if ((o->flags & SEC_RELOC) != 0
5860 && elf_section_data (o)->rel_hashes != NULL)
c44233aa 5861 free (elf_section_data (o)->rel_hashes);
252b5132
RH
5862 }
5863
5864 elf_tdata (abfd)->linker = true;
5865
5866 return true;
5867
5868 error_return:
5869 if (finfo.symstrtab != NULL)
5870 _bfd_stringtab_free (finfo.symstrtab);
5871 if (finfo.contents != NULL)
5872 free (finfo.contents);
5873 if (finfo.external_relocs != NULL)
5874 free (finfo.external_relocs);
5875 if (finfo.internal_relocs != NULL)
5876 free (finfo.internal_relocs);
5877 if (finfo.external_syms != NULL)
5878 free (finfo.external_syms);
9ad5cbcf
AM
5879 if (finfo.locsym_shndx != NULL)
5880 free (finfo.locsym_shndx);
252b5132
RH
5881 if (finfo.internal_syms != NULL)
5882 free (finfo.internal_syms);
5883 if (finfo.indices != NULL)
5884 free (finfo.indices);
5885 if (finfo.sections != NULL)
5886 free (finfo.sections);
5887 if (finfo.symbuf != NULL)
5888 free (finfo.symbuf);
9ad5cbcf
AM
5889 if (finfo.symshndxbuf != NULL)
5890 free (finfo.symbuf);
252b5132
RH
5891 for (o = abfd->sections; o != NULL; o = o->next)
5892 {
5893 if ((o->flags & SEC_RELOC) != 0
5894 && elf_section_data (o)->rel_hashes != NULL)
5895 free (elf_section_data (o)->rel_hashes);
5896 }
5897
5898 return false;
5899}
5900
5901/* Add a symbol to the output symbol table. */
5902
5903static boolean
5904elf_link_output_sym (finfo, name, elfsym, input_sec)
5905 struct elf_final_link_info *finfo;
5906 const char *name;
5907 Elf_Internal_Sym *elfsym;
5908 asection *input_sec;
5909{
9ad5cbcf
AM
5910 Elf_External_Sym *dest;
5911 Elf_External_Sym_Shndx *destshndx;
c44233aa 5912
252b5132
RH
5913 boolean (*output_symbol_hook) PARAMS ((bfd *,
5914 struct bfd_link_info *info,
5915 const char *,
5916 Elf_Internal_Sym *,
5917 asection *));
5918
5919 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
5920 elf_backend_link_output_symbol_hook;
5921 if (output_symbol_hook != NULL)
5922 {
5923 if (! ((*output_symbol_hook)
5924 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
5925 return false;
5926 }
5927
5928 if (name == (const char *) NULL || *name == '\0')
5929 elfsym->st_name = 0;
5930 else if (input_sec->flags & SEC_EXCLUDE)
5931 elfsym->st_name = 0;
5932 else
5933 {
5934 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
a7b97311 5935 name, true, false);
252b5132
RH
5936 if (elfsym->st_name == (unsigned long) -1)
5937 return false;
5938 }
5939
5940 if (finfo->symbuf_count >= finfo->symbuf_size)
5941 {
5942 if (! elf_link_flush_output_syms (finfo))
5943 return false;
5944 }
5945
9ad5cbcf
AM
5946 dest = finfo->symbuf + finfo->symbuf_count;
5947 destshndx = finfo->symshndxbuf;
5948 if (destshndx != NULL)
5949 destshndx += finfo->symbuf_count;
5950 elf_swap_symbol_out (finfo->output_bfd, elfsym, (PTR) dest, (PTR) destshndx);
252b5132
RH
5951 ++finfo->symbuf_count;
5952
5953 ++ bfd_get_symcount (finfo->output_bfd);
5954
5955 return true;
5956}
5957
5958/* Flush the output symbols to the file. */
5959
5960static boolean
5961elf_link_flush_output_syms (finfo)
5962 struct elf_final_link_info *finfo;
5963{
5964 if (finfo->symbuf_count > 0)
5965 {
9ad5cbcf 5966 Elf_Internal_Shdr *hdr;
dc810e39
AM
5967 file_ptr pos;
5968 bfd_size_type amt;
252b5132 5969
9ad5cbcf
AM
5970 hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
5971 pos = hdr->sh_offset + hdr->sh_size;
dc810e39
AM
5972 amt = finfo->symbuf_count * sizeof (Elf_External_Sym);
5973 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
5974 || bfd_bwrite ((PTR) finfo->symbuf, amt, finfo->output_bfd) != amt)
252b5132
RH
5975 return false;
5976
9ad5cbcf
AM
5977 hdr->sh_size += amt;
5978
5979 if (finfo->symshndxbuf != NULL)
5980 {
5981 hdr = &elf_tdata (finfo->output_bfd)->symtab_shndx_hdr;
5982 pos = hdr->sh_offset + hdr->sh_size;
5983 amt = finfo->symbuf_count * sizeof (Elf_External_Sym_Shndx);
5984 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
5985 || (bfd_bwrite ((PTR) finfo->symshndxbuf, amt, finfo->output_bfd)
5986 != amt))
5987 return false;
5988
5989 hdr->sh_size += amt;
5990 }
252b5132
RH
5991
5992 finfo->symbuf_count = 0;
5993 }
5994
5995 return true;
5996}
5997
f5fa8ca2
JJ
5998/* Adjust all external symbols pointing into SEC_MERGE sections
5999 to reflect the object merging within the sections. */
6000
6001static boolean
6002elf_link_sec_merge_syms (h, data)
6003 struct elf_link_hash_entry *h;
6004 PTR data;
6005{
6006 asection *sec;
6007
e92d460e
AM
6008 if (h->root.type == bfd_link_hash_warning)
6009 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6010
f5fa8ca2
JJ
6011 if ((h->root.type == bfd_link_hash_defined
6012 || h->root.type == bfd_link_hash_defweak)
6013 && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
65765700 6014 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
f5fa8ca2
JJ
6015 {
6016 bfd *output_bfd = (bfd *) data;
6017
6018 h->root.u.def.value =
6019 _bfd_merged_section_offset (output_bfd,
6020 &h->root.u.def.section,
65765700 6021 elf_section_data (sec)->sec_info,
f5fa8ca2
JJ
6022 h->root.u.def.value, (bfd_vma) 0);
6023 }
6024
6025 return true;
6026}
6027
f5d44ba0
AM
6028/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
6029 allowing an unsatisfied unversioned symbol in the DSO to match a
6030 versioned symbol that would normally require an explicit version. */
6031
6032static boolean
6033elf_link_check_versioned_symbol (info, h)
6034 struct bfd_link_info *info;
6035 struct elf_link_hash_entry *h;
6036{
6037 bfd *undef_bfd = h->root.u.undef.abfd;
6038 struct elf_link_loaded_list *loaded;
f5d44ba0
AM
6039
6040 if ((undef_bfd->flags & DYNAMIC) == 0
6041 || info->hash->creator->flavour != bfd_target_elf_flavour
6042 || elf_dt_soname (h->root.u.undef.abfd) == NULL)
6043 return false;
6044
6045 for (loaded = elf_hash_table (info)->loaded;
6046 loaded != NULL;
6047 loaded = loaded->next)
6048 {
6049 bfd *input;
6050 Elf_Internal_Shdr *hdr;
6051 bfd_size_type symcount;
6052 bfd_size_type extsymcount;
6053 bfd_size_type extsymoff;
6054 Elf_Internal_Shdr *versymhdr;
6cdc0ccc
AM
6055 Elf_Internal_Sym *isym;
6056 Elf_Internal_Sym *isymend;
6057 Elf_Internal_Sym *isymbuf;
f5d44ba0 6058 Elf_External_Versym *ever;
6cdc0ccc 6059 Elf_External_Versym *extversym;
f5d44ba0
AM
6060
6061 input = loaded->abfd;
6062
6063 /* We check each DSO for a possible hidden versioned definition. */
6064 if (input == undef_bfd
6065 || (input->flags & DYNAMIC) == 0
6066 || elf_dynversym (input) == 0)
6067 continue;
6068
6069 hdr = &elf_tdata (input)->dynsymtab_hdr;
6070
6071 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
6072 if (elf_bad_symtab (input))
6073 {
6074 extsymcount = symcount;
6075 extsymoff = 0;
6076 }
6077 else
6078 {
6079 extsymcount = symcount - hdr->sh_info;
6080 extsymoff = hdr->sh_info;
6081 }
6082
6083 if (extsymcount == 0)
6084 continue;
6085
6cdc0ccc
AM
6086 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
6087 NULL, NULL, NULL);
6088 if (isymbuf == NULL)
f5d44ba0
AM
6089 return false;
6090
f5d44ba0
AM
6091 /* Read in any version definitions. */
6092 versymhdr = &elf_tdata (input)->dynversym_hdr;
6093 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
6094 if (extversym == NULL)
6095 goto error_ret;
6096
6097 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
6098 || (bfd_bread ((PTR) extversym, versymhdr->sh_size, input)
6099 != versymhdr->sh_size))
6100 {
6101 free (extversym);
6102 error_ret:
6cdc0ccc 6103 free (isymbuf);
f5d44ba0
AM
6104 return false;
6105 }
6106
6107 ever = extversym + extsymoff;
6cdc0ccc
AM
6108 isymend = isymbuf + extsymcount;
6109 for (isym = isymbuf; isym < isymend; isym++, ever++)
f5d44ba0
AM
6110 {
6111 const char *name;
f5d44ba0
AM
6112 Elf_Internal_Versym iver;
6113
6cdc0ccc
AM
6114 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
6115 || isym->st_shndx == SHN_UNDEF)
f5d44ba0
AM
6116 continue;
6117
6118 name = bfd_elf_string_from_elf_section (input,
6119 hdr->sh_link,
6cdc0ccc 6120 isym->st_name);
f5d44ba0
AM
6121 if (strcmp (name, h->root.root.string) != 0)
6122 continue;
6123
6124 _bfd_elf_swap_versym_in (input, ever, &iver);
6125
6126 if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
6127 {
6128 /* If we have a non-hidden versioned sym, then it should
6129 have provided a definition for the undefined sym. */
6130 abort ();
6131 }
6132
6133 if ((iver.vs_vers & VERSYM_VERSION) == 2)
6134 {
6135 /* This is the oldest (default) sym. We can use it. */
6136 free (extversym);
6cdc0ccc 6137 free (isymbuf);
f5d44ba0
AM
6138 return true;
6139 }
6140 }
6141
6142 free (extversym);
6cdc0ccc 6143 free (isymbuf);
f5d44ba0
AM
6144 }
6145
6146 return false;
6147}
6148
252b5132
RH
6149/* Add an external symbol to the symbol table. This is called from
6150 the hash table traversal routine. When generating a shared object,
6151 we go through the symbol table twice. The first time we output
6152 anything that might have been forced to local scope in a version
6153 script. The second time we output the symbols that are still
6154 global symbols. */
6155
6156static boolean
6157elf_link_output_extsym (h, data)
6158 struct elf_link_hash_entry *h;
6159 PTR data;
6160{
6161 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
6162 struct elf_final_link_info *finfo = eoinfo->finfo;
6163 boolean strip;
6164 Elf_Internal_Sym sym;
6165 asection *input_sec;
6166
e92d460e
AM
6167 if (h->root.type == bfd_link_hash_warning)
6168 {
6169 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6170 if (h->root.type == bfd_link_hash_new)
6171 return true;
6172 }
6173
252b5132
RH
6174 /* Decide whether to output this symbol in this pass. */
6175 if (eoinfo->localsyms)
6176 {
6177 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
6178 return true;
6179 }
6180 else
6181 {
6182 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
6183 return true;
6184 }
6185
6186 /* If we are not creating a shared library, and this symbol is
6187 referenced by a shared library but is not defined anywhere, then
6188 warn that it is undefined. If we do not do this, the runtime
6189 linker will complain that the symbol is undefined when the
6190 program is run. We don't have to worry about symbols that are
6191 referenced by regular files, because we will already have issued
6192 warnings for them. */
6193 if (! finfo->info->relocateable
b79e8c78 6194 && ! finfo->info->allow_shlib_undefined
e45bf863 6195 && ! finfo->info->shared
252b5132
RH
6196 && h->root.type == bfd_link_hash_undefined
6197 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
f5d44ba0
AM
6198 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
6199 && ! elf_link_check_versioned_symbol (finfo->info, h))
252b5132
RH
6200 {
6201 if (! ((*finfo->info->callbacks->undefined_symbol)
6202 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
dc810e39 6203 (asection *) NULL, (bfd_vma) 0, true)))
252b5132
RH
6204 {
6205 eoinfo->failed = true;
6206 return false;
6207 }
6208 }
6209
6210 /* We don't want to output symbols that have never been mentioned by
6211 a regular file, or that we have been told to strip. However, if
6212 h->indx is set to -2, the symbol is used by a reloc and we must
6213 output it. */
6214 if (h->indx == -2)
6215 strip = false;
6216 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
6217 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
6218 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
6219 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
6220 strip = true;
6221 else if (finfo->info->strip == strip_all
6222 || (finfo->info->strip == strip_some
6223 && bfd_hash_lookup (finfo->info->keep_hash,
6224 h->root.root.string,
6225 false, false) == NULL))
6226 strip = true;
6227 else
6228 strip = false;
6229
6230 /* If we're stripping it, and it's not a dynamic symbol, there's
2bd171e0
ILT
6231 nothing else to do unless it is a forced local symbol. */
6232 if (strip
6233 && h->dynindx == -1
6234 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
252b5132
RH
6235 return true;
6236
6237 sym.st_value = 0;
6238 sym.st_size = h->size;
6239 sym.st_other = h->other;
6240 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
6241 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
6242 else if (h->root.type == bfd_link_hash_undefweak
6243 || h->root.type == bfd_link_hash_defweak)
6244 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
6245 else
6246 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
6247
6248 switch (h->root.type)
6249 {
6250 default:
6251 case bfd_link_hash_new:
e92d460e 6252 case bfd_link_hash_warning:
252b5132
RH
6253 abort ();
6254 return false;
6255
6256 case bfd_link_hash_undefined:
252b5132
RH
6257 case bfd_link_hash_undefweak:
6258 input_sec = bfd_und_section_ptr;
6259 sym.st_shndx = SHN_UNDEF;
6260 break;
6261
6262 case bfd_link_hash_defined:
6263 case bfd_link_hash_defweak:
6264 {
6265 input_sec = h->root.u.def.section;
6266 if (input_sec->output_section != NULL)
6267 {
6268 sym.st_shndx =
6269 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
6270 input_sec->output_section);
9ad5cbcf 6271 if (sym.st_shndx == SHN_BAD)
252b5132
RH
6272 {
6273 (*_bfd_error_handler)
6274 (_("%s: could not find output section %s for input section %s"),
6275 bfd_get_filename (finfo->output_bfd),
6276 input_sec->output_section->name,
6277 input_sec->name);
6278 eoinfo->failed = true;
6279 return false;
6280 }
6281
6282 /* ELF symbols in relocateable files are section relative,
6283 but in nonrelocateable files they are virtual
6284 addresses. */
6285 sym.st_value = h->root.u.def.value + input_sec->output_offset;
6286 if (! finfo->info->relocateable)
13ae64f3
JJ
6287 {
6288 sym.st_value += input_sec->output_section->vma;
6289 if (h->type == STT_TLS)
6290 {
6291 /* STT_TLS symbols are relative to PT_TLS segment
6292 base. */
6293 BFD_ASSERT (finfo->first_tls_sec != NULL);
6294 sym.st_value -= finfo->first_tls_sec->vma;
6295 }
6296 }
252b5132
RH
6297 }
6298 else
6299 {
6300 BFD_ASSERT (input_sec->owner == NULL
6301 || (input_sec->owner->flags & DYNAMIC) != 0);
6302 sym.st_shndx = SHN_UNDEF;
6303 input_sec = bfd_und_section_ptr;
6304 }
6305 }
6306 break;
6307
6308 case bfd_link_hash_common:
6309 input_sec = h->root.u.c.p->section;
6310 sym.st_shndx = SHN_COMMON;
6311 sym.st_value = 1 << h->root.u.c.p->alignment_power;
6312 break;
6313
6314 case bfd_link_hash_indirect:
6315 /* These symbols are created by symbol versioning. They point
c44233aa
AM
6316 to the decorated version of the name. For example, if the
6317 symbol foo@@GNU_1.2 is the default, which should be used when
6318 foo is used with no version, then we add an indirect symbol
6319 foo which points to foo@@GNU_1.2. We ignore these symbols,
6320 since the indirected symbol is already in the hash table. */
94b6c40a 6321 return true;
252b5132
RH
6322 }
6323
6324 /* Give the processor backend a chance to tweak the symbol value,
6325 and also to finish up anything that needs to be done for this
c44233aa
AM
6326 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
6327 forced local syms when non-shared is due to a historical quirk. */
252b5132
RH
6328 if ((h->dynindx != -1
6329 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
c44233aa
AM
6330 && (finfo->info->shared
6331 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
252b5132
RH
6332 && elf_hash_table (finfo->info)->dynamic_sections_created)
6333 {
6334 struct elf_backend_data *bed;
6335
6336 bed = get_elf_backend_data (finfo->output_bfd);
6337 if (! ((*bed->elf_backend_finish_dynamic_symbol)
6338 (finfo->output_bfd, finfo->info, h, &sym)))
6339 {
6340 eoinfo->failed = true;
6341 return false;
6342 }
6343 }
6344
6345 /* If we are marking the symbol as undefined, and there are no
6346 non-weak references to this symbol from a regular object, then
91d3970e
ILT
6347 mark the symbol as weak undefined; if there are non-weak
6348 references, mark the symbol as strong. We can't do this earlier,
252b5132
RH
6349 because it might not be marked as undefined until the
6350 finish_dynamic_symbol routine gets through with it. */
6351 if (sym.st_shndx == SHN_UNDEF
252b5132 6352 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
a7b97311
AM
6353 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
6354 || ELF_ST_BIND (sym.st_info) == STB_WEAK))
91d3970e
ILT
6355 {
6356 int bindtype;
6357
6358 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) != 0)
6359 bindtype = STB_GLOBAL;
6360 else
6361 bindtype = STB_WEAK;
6362 sym.st_info = ELF_ST_INFO (bindtype, ELF_ST_TYPE (sym.st_info));
6363 }
252b5132 6364
32c092c3 6365 /* If a symbol is not defined locally, we clear the visibility
3e932841 6366 field. */
2cd533b7
L
6367 if (! finfo->info->relocateable
6368 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
a7b97311 6369 sym.st_other ^= ELF_ST_VISIBILITY (sym.st_other);
32c092c3 6370
252b5132 6371 /* If this symbol should be put in the .dynsym section, then put it
f5d44ba0
AM
6372 there now. We already know the symbol index. We also fill in
6373 the entry in the .hash section. */
252b5132
RH
6374 if (h->dynindx != -1
6375 && elf_hash_table (finfo->info)->dynamic_sections_created)
6376 {
6377 size_t bucketcount;
6378 size_t bucket;
c7ac6ff8 6379 size_t hash_entry_size;
252b5132
RH
6380 bfd_byte *bucketpos;
6381 bfd_vma chain;
dc810e39 6382 Elf_External_Sym *esym;
252b5132
RH
6383
6384 sym.st_name = h->dynstr_index;
dc810e39 6385 esym = (Elf_External_Sym *) finfo->dynsym_sec->contents + h->dynindx;
9ad5cbcf 6386 elf_swap_symbol_out (finfo->output_bfd, &sym, (PTR) esym, (PTR) 0);
252b5132
RH
6387
6388 bucketcount = elf_hash_table (finfo->info)->bucketcount;
6389 bucket = h->elf_hash_value % bucketcount;
3e932841 6390 hash_entry_size
c7ac6ff8 6391 = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
252b5132 6392 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
c7ac6ff8
MM
6393 + (bucket + 2) * hash_entry_size);
6394 chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
dc810e39
AM
6395 bfd_put (8 * hash_entry_size, finfo->output_bfd, (bfd_vma) h->dynindx,
6396 bucketpos);
c7ac6ff8
MM
6397 bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
6398 ((bfd_byte *) finfo->hash_sec->contents
6399 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
252b5132
RH
6400
6401 if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
6402 {
6403 Elf_Internal_Versym iversym;
dc810e39 6404 Elf_External_Versym *eversym;
252b5132
RH
6405
6406 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6407 {
6408 if (h->verinfo.verdef == NULL)
6409 iversym.vs_vers = 0;
6410 else
6411 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
6412 }
6413 else
6414 {
6415 if (h->verinfo.vertree == NULL)
6416 iversym.vs_vers = 1;
6417 else
6418 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
6419 }
6420
6421 if ((h->elf_link_hash_flags & ELF_LINK_HIDDEN) != 0)
6422 iversym.vs_vers |= VERSYM_HIDDEN;
6423
dc810e39
AM
6424 eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
6425 eversym += h->dynindx;
6426 _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
252b5132
RH
6427 }
6428 }
6429
6430 /* If we're stripping it, then it was just a dynamic symbol, and
6431 there's nothing else to do. */
6432 if (strip)
6433 return true;
6434
6435 h->indx = bfd_get_symcount (finfo->output_bfd);
6436
6437 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
6438 {
6439 eoinfo->failed = true;
6440 return false;
6441 }
6442
6443 return true;
6444}
6445
23bc299b
MM
6446/* Copy the relocations indicated by the INTERNAL_RELOCS (which
6447 originated from the section given by INPUT_REL_HDR) to the
6448 OUTPUT_BFD. */
6449
41241523 6450static boolean
3e932841 6451elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
23bc299b
MM
6452 internal_relocs)
6453 bfd *output_bfd;
6454 asection *input_section;
6455 Elf_Internal_Shdr *input_rel_hdr;
6456 Elf_Internal_Rela *internal_relocs;
6457{
6458 Elf_Internal_Rela *irela;
6459 Elf_Internal_Rela *irelaend;
6460 Elf_Internal_Shdr *output_rel_hdr;
6461 asection *output_section;
7442e600 6462 unsigned int *rel_countp = NULL;
32f0787a 6463 struct elf_backend_data *bed;
dc810e39 6464 bfd_size_type amt;
23bc299b
MM
6465
6466 output_section = input_section->output_section;
6467 output_rel_hdr = NULL;
6468
3e932841 6469 if (elf_section_data (output_section)->rel_hdr.sh_entsize
23bc299b
MM
6470 == input_rel_hdr->sh_entsize)
6471 {
6472 output_rel_hdr = &elf_section_data (output_section)->rel_hdr;
6473 rel_countp = &elf_section_data (output_section)->rel_count;
6474 }
6475 else if (elf_section_data (output_section)->rel_hdr2
6476 && (elf_section_data (output_section)->rel_hdr2->sh_entsize
6477 == input_rel_hdr->sh_entsize))
6478 {
6479 output_rel_hdr = elf_section_data (output_section)->rel_hdr2;
6480 rel_countp = &elf_section_data (output_section)->rel_count2;
6481 }
41241523
TS
6482 else
6483 {
58821868
AM
6484 (*_bfd_error_handler)
6485 (_("%s: relocation size mismatch in %s section %s"),
6486 bfd_get_filename (output_bfd),
6487 bfd_archive_filename (input_section->owner),
6488 input_section->name);
41241523
TS
6489 bfd_set_error (bfd_error_wrong_object_format);
6490 return false;
6491 }
32f0787a
UC
6492
6493 bed = get_elf_backend_data (output_bfd);
23bc299b 6494 irela = internal_relocs;
58821868
AM
6495 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
6496 * bed->s->int_rels_per_ext_rel);
209f668e 6497
23bc299b
MM
6498 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
6499 {
6500 Elf_External_Rel *erel;
209f668e 6501 Elf_Internal_Rel *irel;
dc810e39
AM
6502
6503 amt = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
6504 irel = (Elf_Internal_Rel *) bfd_zmalloc (amt);
209f668e
NC
6505 if (irel == NULL)
6506 {
6507 (*_bfd_error_handler) (_("Error: out of memory"));
6508 abort ();
6509 }
23bc299b
MM
6510
6511 erel = ((Elf_External_Rel *) output_rel_hdr->contents + *rel_countp);
209f668e 6512 for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erel++)
23bc299b 6513 {
4e8a9624 6514 unsigned int i;
dc810e39 6515
209f668e
NC
6516 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
6517 {
6518 irel[i].r_offset = irela[i].r_offset;
6519 irel[i].r_info = irela[i].r_info;
6520 BFD_ASSERT (irela[i].r_addend == 0);
6521 }
23bc299b 6522
32f0787a 6523 if (bed->s->swap_reloc_out)
209f668e 6524 (*bed->s->swap_reloc_out) (output_bfd, irel, (PTR) erel);
32f0787a 6525 else
209f668e 6526 elf_swap_reloc_out (output_bfd, irel, erel);
23bc299b 6527 }
209f668e
NC
6528
6529 free (irel);
23bc299b
MM
6530 }
6531 else
6532 {
6533 Elf_External_Rela *erela;
6534
209f668e
NC
6535 BFD_ASSERT (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
6536
23bc299b 6537 erela = ((Elf_External_Rela *) output_rel_hdr->contents + *rel_countp);
209f668e 6538 for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erela++)
32f0787a
UC
6539 if (bed->s->swap_reloca_out)
6540 (*bed->s->swap_reloca_out) (output_bfd, irela, (PTR) erela);
6541 else
6542 elf_swap_reloca_out (output_bfd, irela, erela);
23bc299b
MM
6543 }
6544
6545 /* Bump the counter, so that we know where to add the next set of
6546 relocations. */
d9bc7a44 6547 *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr);
41241523
TS
6548
6549 return true;
23bc299b
MM
6550}
6551
252b5132
RH
6552/* Link an input file into the linker output file. This function
6553 handles all the sections and relocations of the input file at once.
6554 This is so that we only have to read the local symbols once, and
6555 don't have to keep them in memory. */
6556
6557static boolean
6558elf_link_input_bfd (finfo, input_bfd)
6559 struct elf_final_link_info *finfo;
6560 bfd *input_bfd;
6561{
6562 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
6563 bfd *, asection *, bfd_byte *,
6564 Elf_Internal_Rela *,
6565 Elf_Internal_Sym *, asection **));
6566 bfd *output_bfd;
6567 Elf_Internal_Shdr *symtab_hdr;
6568 size_t locsymcount;
6569 size_t extsymoff;
6cdc0ccc 6570 Elf_Internal_Sym *isymbuf;
252b5132 6571 Elf_Internal_Sym *isym;
6cdc0ccc 6572 Elf_Internal_Sym *isymend;
252b5132
RH
6573 long *pindex;
6574 asection **ppsection;
6575 asection *o;
c7ac6ff8 6576 struct elf_backend_data *bed;
9317eacc 6577 boolean emit_relocs;
f8deed93 6578 struct elf_link_hash_entry **sym_hashes;
252b5132
RH
6579
6580 output_bfd = finfo->output_bfd;
c7ac6ff8
MM
6581 bed = get_elf_backend_data (output_bfd);
6582 relocate_section = bed->elf_backend_relocate_section;
252b5132
RH
6583
6584 /* If this is a dynamic object, we don't want to do anything here:
6585 we don't want the local symbols, and we don't want the section
6586 contents. */
6587 if ((input_bfd->flags & DYNAMIC) != 0)
6588 return true;
6589
9317eacc 6590 emit_relocs = (finfo->info->relocateable
c44233aa
AM
6591 || finfo->info->emitrelocations
6592 || bed->elf_backend_emit_relocs);
9317eacc 6593
252b5132
RH
6594 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6595 if (elf_bad_symtab (input_bfd))
6596 {
6597 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
6598 extsymoff = 0;
6599 }
6600 else
6601 {
6602 locsymcount = symtab_hdr->sh_info;
6603 extsymoff = symtab_hdr->sh_info;
6604 }
6605
6606 /* Read the local symbols. */
6cdc0ccc
AM
6607 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6608 if (isymbuf == NULL && locsymcount != 0)
6609 {
6610 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6611 finfo->internal_syms,
6612 finfo->external_syms,
6613 finfo->locsym_shndx);
6614 if (isymbuf == NULL)
252b5132
RH
6615 return false;
6616 }
6617
6cdc0ccc
AM
6618 /* Find local symbol sections and adjust values of symbols in
6619 SEC_MERGE sections. Write out those local symbols we know are
6620 going into the output file. */
6621 isymend = isymbuf + locsymcount;
6622 for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
6623 isym < isymend;
6624 isym++, pindex++, ppsection++)
252b5132
RH
6625 {
6626 asection *isec;
6627 const char *name;
6628 Elf_Internal_Sym osym;
6629
252b5132
RH
6630 *pindex = -1;
6631
6632 if (elf_bad_symtab (input_bfd))
6633 {
6634 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
6635 {
6636 *ppsection = NULL;
6637 continue;
6638 }
6639 }
6640
6641 if (isym->st_shndx == SHN_UNDEF)
862517b6 6642 isec = bfd_und_section_ptr;
9ad5cbcf
AM
6643 else if (isym->st_shndx < SHN_LORESERVE
6644 || isym->st_shndx > SHN_HIRESERVE)
f5fa8ca2
JJ
6645 {
6646 isec = section_from_elf_index (input_bfd, isym->st_shndx);
65765700
JJ
6647 if (isec
6648 && elf_section_data (isec)->sec_info_type == ELF_INFO_TYPE_MERGE
f5fa8ca2
JJ
6649 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
6650 isym->st_value =
6651 _bfd_merged_section_offset (output_bfd, &isec,
65765700 6652 elf_section_data (isec)->sec_info,
f5fa8ca2
JJ
6653 isym->st_value, (bfd_vma) 0);
6654 }
252b5132 6655 else if (isym->st_shndx == SHN_ABS)
862517b6 6656 isec = bfd_abs_section_ptr;
252b5132 6657 else if (isym->st_shndx == SHN_COMMON)
862517b6 6658 isec = bfd_com_section_ptr;
252b5132
RH
6659 else
6660 {
6661 /* Who knows? */
6662 isec = NULL;
6663 }
6664
6665 *ppsection = isec;
6666
6667 /* Don't output the first, undefined, symbol. */
6cdc0ccc 6668 if (ppsection == finfo->sections)
252b5132
RH
6669 continue;
6670
24376d1b
AM
6671 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
6672 {
24376d1b
AM
6673 /* We never output section symbols. Instead, we use the
6674 section symbol of the corresponding section in the output
6675 file. */
6676 continue;
6677 }
6678
252b5132
RH
6679 /* If we are stripping all symbols, we don't want to output this
6680 one. */
6681 if (finfo->info->strip == strip_all)
6682 continue;
6683
252b5132
RH
6684 /* If we are discarding all local symbols, we don't want to
6685 output this one. If we are generating a relocateable output
6686 file, then some of the local symbols may be required by
6687 relocs; we output them below as we discover that they are
6688 needed. */
6689 if (finfo->info->discard == discard_all)
6690 continue;
6691
6692 /* If this symbol is defined in a section which we are
c44233aa
AM
6693 discarding, we don't need to keep it, but note that
6694 linker_mark is only reliable for sections that have contents.
6695 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
6696 as well as linker_mark. */
9ad5cbcf 6697 if ((isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
252b5132
RH
6698 && isec != NULL
6699 && ((! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
6700 || (! finfo->info->relocateable
6701 && (isec->flags & SEC_EXCLUDE) != 0)))
6702 continue;
6703
6704 /* Get the name of the symbol. */
6705 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
6706 isym->st_name);
6707 if (name == NULL)
6708 return false;
6709
6710 /* See if we are discarding symbols with this name. */
6711 if ((finfo->info->strip == strip_some
6712 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
6713 == NULL))
f5fa8ca2
JJ
6714 || (((finfo->info->discard == discard_sec_merge
6715 && (isec->flags & SEC_MERGE) && ! finfo->info->relocateable)
6716 || finfo->info->discard == discard_l)
252b5132
RH
6717 && bfd_is_local_label_name (input_bfd, name)))
6718 continue;
6719
6720 /* If we get here, we are going to output this symbol. */
6721
6722 osym = *isym;
6723
6724 /* Adjust the section index for the output file. */
6725 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
6726 isec->output_section);
9ad5cbcf 6727 if (osym.st_shndx == SHN_BAD)
252b5132
RH
6728 return false;
6729
6730 *pindex = bfd_get_symcount (output_bfd);
6731
6732 /* ELF symbols in relocateable files are section relative, but
6733 in executable files they are virtual addresses. Note that
6734 this code assumes that all ELF sections have an associated
6735 BFD section with a reasonable value for output_offset; below
6736 we assume that they also have a reasonable value for
6737 output_section. Any special sections must be set up to meet
6738 these requirements. */
6739 osym.st_value += isec->output_offset;
6740 if (! finfo->info->relocateable)
13ae64f3
JJ
6741 {
6742 osym.st_value += isec->output_section->vma;
6743 if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
6744 {
6745 /* STT_TLS symbols are relative to PT_TLS segment base. */
6746 BFD_ASSERT (finfo->first_tls_sec != NULL);
6747 osym.st_value -= finfo->first_tls_sec->vma;
6748 }
6749 }
252b5132
RH
6750
6751 if (! elf_link_output_sym (finfo, name, &osym, isec))
6752 return false;
6753 }
6754
6755 /* Relocate the contents of each section. */
f8deed93 6756 sym_hashes = elf_sym_hashes (input_bfd);
252b5132
RH
6757 for (o = input_bfd->sections; o != NULL; o = o->next)
6758 {
6759 bfd_byte *contents;
6760
6761 if (! o->linker_mark)
6762 {
6763 /* This section was omitted from the link. */
6764 continue;
6765 }
6766
6767 if ((o->flags & SEC_HAS_CONTENTS) == 0
6768 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
6769 continue;
6770
6771 if ((o->flags & SEC_LINKER_CREATED) != 0)
6772 {
6773 /* Section was created by elf_link_create_dynamic_sections
6774 or somesuch. */
6775 continue;
6776 }
6777
6778 /* Get the contents of the section. They have been cached by a
c44233aa
AM
6779 relaxation routine. Note that o is a section in an input
6780 file, so the contents field will not have been set by any of
6781 the routines which work on output files. */
252b5132
RH
6782 if (elf_section_data (o)->this_hdr.contents != NULL)
6783 contents = elf_section_data (o)->this_hdr.contents;
6784 else
6785 {
6786 contents = finfo->contents;
6787 if (! bfd_get_section_contents (input_bfd, o, contents,
6788 (file_ptr) 0, o->_raw_size))
6789 return false;
6790 }
6791
6792 if ((o->flags & SEC_RELOC) != 0)
6793 {
6794 Elf_Internal_Rela *internal_relocs;
6795
6796 /* Get the swapped relocs. */
6797 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
6798 (input_bfd, o, finfo->external_relocs,
6799 finfo->internal_relocs, false));
6800 if (internal_relocs == NULL
6801 && o->reloc_count > 0)
6802 return false;
6803
ec338859
AM
6804 /* Run through the relocs looking for any against symbols
6805 from discarded sections and section symbols from
6806 removed link-once sections. Complain about relocs
6807 against discarded sections. Zero relocs against removed
6808 link-once sections. We should really complain if
6809 anything in the final link tries to use it, but
6810 DWARF-based exception handling might have an entry in
6811 .eh_frame to describe a routine in the linkonce section,
6812 and it turns out to be hard to remove the .eh_frame
6813 entry too. FIXME. */
73d074b4
DJ
6814 if (!finfo->info->relocateable
6815 && !elf_section_ignore_discarded_relocs (o))
ec338859
AM
6816 {
6817 Elf_Internal_Rela *rel, *relend;
50b4d486 6818
ec338859
AM
6819 rel = internal_relocs;
6820 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
6821 for ( ; rel < relend; rel++)
6822 {
6823 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
6824
6825 if (r_symndx >= locsymcount
6826 || (elf_bad_symtab (input_bfd)
6827 && finfo->sections[r_symndx] == NULL))
6828 {
6829 struct elf_link_hash_entry *h;
6830
6831 h = sym_hashes[r_symndx - extsymoff];
6832 while (h->root.type == bfd_link_hash_indirect
6833 || h->root.type == bfd_link_hash_warning)
6834 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6835
6836 /* Complain if the definition comes from a
6837 discarded section. */
6838 if ((h->root.type == bfd_link_hash_defined
6839 || h->root.type == bfd_link_hash_defweak)
ed4de5e2 6840 && elf_discarded_section (h->root.u.def.section))
ec338859 6841 {
f8deed93 6842#if BFD_VERSION_DATE < 20031005
ec338859
AM
6843 if ((o->flags & SEC_DEBUGGING) != 0)
6844 {
f8deed93 6845#if BFD_VERSION_DATE > 20021005
ec338859
AM
6846 (*finfo->info->callbacks->warning)
6847 (finfo->info,
6848 _("warning: relocation against removed section; zeroing"),
6849 NULL, input_bfd, o, rel->r_offset);
f8deed93 6850#endif
45e9217a 6851 BFD_ASSERT (r_symndx != 0);
f8deed93 6852 memset (rel, 0, sizeof (*rel));
ec338859
AM
6853 }
6854 else
f8deed93 6855#endif
ec338859
AM
6856 {
6857 if (! ((*finfo->info->callbacks->undefined_symbol)
6858 (finfo->info, h->root.root.string,
6859 input_bfd, o, rel->r_offset,
6860 true)))
6861 return false;
6862 }
6863 }
6864 }
6865 else
6866 {
f9f32305 6867 asection *sec = finfo->sections[r_symndx];
50b4d486 6868
ed4de5e2 6869 if (sec != NULL && elf_discarded_section (sec))
f9f32305 6870 {
f8deed93 6871#if BFD_VERSION_DATE < 20031005
ad43ed4c
L
6872 if ((o->flags & SEC_DEBUGGING) != 0
6873 || (sec->flags & SEC_LINK_ONCE) != 0)
f9f32305 6874 {
50b4d486 6875#if BFD_VERSION_DATE > 20021005
f9f32305
AM
6876 (*finfo->info->callbacks->warning)
6877 (finfo->info,
6878 _("warning: relocation against removed section"),
6879 NULL, input_bfd, o, rel->r_offset);
50b4d486 6880#endif
45e9217a 6881 BFD_ASSERT (r_symndx != 0);
f9f32305
AM
6882 rel->r_info
6883 = ELF_R_INFO (0, ELF_R_TYPE (rel->r_info));
6884 rel->r_addend = 0;
6885 }
6886 else
f8deed93 6887#endif
f9f32305
AM
6888 {
6889 boolean ok;
6890 const char *msg
6891 = _("local symbols in discarded section %s");
6892 bfd_size_type amt
6893 = strlen (sec->name) + strlen (msg) - 1;
6894 char *buf = (char *) bfd_malloc (amt);
6895
6896 if (buf != NULL)
6897 sprintf (buf, msg, sec->name);
6898 else
6899 buf = (char *) sec->name;
6900 ok = (*finfo->info->callbacks
6901 ->undefined_symbol) (finfo->info, buf,
6902 input_bfd, o,
6903 rel->r_offset,
6904 true);
6905 if (buf != sec->name)
6906 free (buf);
6907 if (!ok)
6908 return false;
ec338859
AM
6909 }
6910 }
6911 }
6912 }
6913 }
50b4d486 6914
252b5132
RH
6915 /* Relocate the section by invoking a back end routine.
6916
6917 The back end routine is responsible for adjusting the
6918 section contents as necessary, and (if using Rela relocs
6919 and generating a relocateable output file) adjusting the
6920 reloc addend as necessary.
6921
6922 The back end routine does not have to worry about setting
6923 the reloc address or the reloc symbol index.
6924
6925 The back end routine is given a pointer to the swapped in
6926 internal symbols, and can access the hash table entries
6927 for the external symbols via elf_sym_hashes (input_bfd).
6928
6929 When generating relocateable output, the back end routine
6930 must handle STB_LOCAL/STT_SECTION symbols specially. The
6931 output symbol is going to be a section symbol
6932 corresponding to the output section, which will require
6933 the addend to be adjusted. */
6934
6935 if (! (*relocate_section) (output_bfd, finfo->info,
6936 input_bfd, o, contents,
6937 internal_relocs,
6cdc0ccc 6938 isymbuf,
252b5132
RH
6939 finfo->sections))
6940 return false;
6941
9317eacc 6942 if (emit_relocs)
252b5132
RH
6943 {
6944 Elf_Internal_Rela *irela;
6945 Elf_Internal_Rela *irelaend;
6946 struct elf_link_hash_entry **rel_hash;
c89583f8 6947 Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
4e8a9624 6948 unsigned int next_erel;
41241523
TS
6949 boolean (*reloc_emitter) PARAMS ((bfd *, asection *,
6950 Elf_Internal_Shdr *,
6951 Elf_Internal_Rela *));
b491616a
AM
6952 boolean rela_normal;
6953
6954 input_rel_hdr = &elf_section_data (o)->rel_hdr;
6955 rela_normal = (bed->rela_normal
6956 && (input_rel_hdr->sh_entsize
6957 == sizeof (Elf_External_Rela)));
252b5132
RH
6958
6959 /* Adjust the reloc addresses and symbol indices. */
6960
6961 irela = internal_relocs;
dc810e39 6962 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
252b5132 6963 rel_hash = (elf_section_data (o->output_section)->rel_hashes
31367b81
MM
6964 + elf_section_data (o->output_section)->rel_count
6965 + elf_section_data (o->output_section)->rel_count2);
209f668e 6966 for (next_erel = 0; irela < irelaend; irela++, next_erel++)
252b5132
RH
6967 {
6968 unsigned long r_symndx;
252b5132
RH
6969 asection *sec;
6970
209f668e
NC
6971 if (next_erel == bed->s->int_rels_per_ext_rel)
6972 {
6973 rel_hash++;
6974 next_erel = 0;
6975 }
6976
252b5132
RH
6977 irela->r_offset += o->output_offset;
6978
7ad34365 6979 /* Relocs in an executable have to be virtual addresses. */
fd984e46 6980 if (!finfo->info->relocateable)
7ad34365
NC
6981 irela->r_offset += o->output_section->vma;
6982
252b5132
RH
6983 r_symndx = ELF_R_SYM (irela->r_info);
6984
6985 if (r_symndx == 0)
6986 continue;
6987
6988 if (r_symndx >= locsymcount
6989 || (elf_bad_symtab (input_bfd)
6990 && finfo->sections[r_symndx] == NULL))
6991 {
6992 struct elf_link_hash_entry *rh;
209f668e 6993 unsigned long indx;
252b5132
RH
6994
6995 /* This is a reloc against a global symbol. We
6996 have not yet output all the local symbols, so
6997 we do not know the symbol index of any global
6998 symbol. We set the rel_hash entry for this
6999 reloc to point to the global hash table entry
7000 for this symbol. The symbol index is then
7001 set at the end of elf_bfd_final_link. */
7002 indx = r_symndx - extsymoff;
7003 rh = elf_sym_hashes (input_bfd)[indx];
7004 while (rh->root.type == bfd_link_hash_indirect
7005 || rh->root.type == bfd_link_hash_warning)
7006 rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
7007
7008 /* Setting the index to -2 tells
7009 elf_link_output_extsym that this symbol is
7010 used by a reloc. */
7011 BFD_ASSERT (rh->indx < 0);
7012 rh->indx = -2;
7013
7014 *rel_hash = rh;
7015
7016 continue;
7017 }
7018
3e932841 7019 /* This is a reloc against a local symbol. */
252b5132
RH
7020
7021 *rel_hash = NULL;
6cdc0ccc 7022 isym = isymbuf + r_symndx;
252b5132
RH
7023 sec = finfo->sections[r_symndx];
7024 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
7025 {
7026 /* I suppose the backend ought to fill in the
7027 section of any STT_SECTION symbol against a
7028 processor specific section. If we have
7029 discarded a section, the output_section will
7030 be the absolute section. */
b491616a
AM
7031 if (bfd_is_abs_section (sec)
7032 || (sec != NULL
7033 && bfd_is_abs_section (sec->output_section)))
252b5132
RH
7034 r_symndx = 0;
7035 else if (sec == NULL || sec->owner == NULL)
7036 {
7037 bfd_set_error (bfd_error_bad_value);
7038 return false;
7039 }
7040 else
7041 {
7042 r_symndx = sec->output_section->target_index;
7043 BFD_ASSERT (r_symndx != 0);
7044 }
b491616a
AM
7045
7046 /* Adjust the addend according to where the
f5d44ba0 7047 section winds up in the output section. */
b491616a
AM
7048 if (rela_normal)
7049 irela->r_addend += sec->output_offset;
252b5132
RH
7050 }
7051 else
7052 {
7053 if (finfo->indices[r_symndx] == -1)
7054 {
dc810e39 7055 unsigned long shlink;
252b5132
RH
7056 const char *name;
7057 asection *osec;
7058
7059 if (finfo->info->strip == strip_all)
7060 {
7061 /* You can't do ld -r -s. */
7062 bfd_set_error (bfd_error_invalid_operation);
7063 return false;
7064 }
7065
7066 /* This symbol was skipped earlier, but
7067 since it is needed by a reloc, we
7068 must output it now. */
dc810e39 7069 shlink = symtab_hdr->sh_link;
a7b97311 7070 name = (bfd_elf_string_from_elf_section
dc810e39 7071 (input_bfd, shlink, isym->st_name));
252b5132
RH
7072 if (name == NULL)
7073 return false;
7074
7075 osec = sec->output_section;
7076 isym->st_shndx =
7077 _bfd_elf_section_from_bfd_section (output_bfd,
7078 osec);
9ad5cbcf 7079 if (isym->st_shndx == SHN_BAD)
252b5132
RH
7080 return false;
7081
7082 isym->st_value += sec->output_offset;
7083 if (! finfo->info->relocateable)
13ae64f3
JJ
7084 {
7085 isym->st_value += osec->vma;
7086 if (ELF_ST_TYPE (isym->st_info) == STT_TLS)
7087 {
7088 /* STT_TLS symbols are relative to PT_TLS
7089 segment base. */
7090 BFD_ASSERT (finfo->first_tls_sec != NULL);
7091 isym->st_value -= finfo->first_tls_sec->vma;
7092 }
7093 }
252b5132 7094
a7b97311
AM
7095 finfo->indices[r_symndx]
7096 = bfd_get_symcount (output_bfd);
252b5132
RH
7097
7098 if (! elf_link_output_sym (finfo, name, isym, sec))
7099 return false;
7100 }
7101
7102 r_symndx = finfo->indices[r_symndx];
7103 }
7104
7105 irela->r_info = ELF_R_INFO (r_symndx,
7106 ELF_R_TYPE (irela->r_info));
7107 }
7108
7109 /* Swap out the relocs. */
c44233aa
AM
7110 if (bed->elf_backend_emit_relocs
7111 && !(finfo->info->relocateable
a7b97311 7112 || finfo->info->emitrelocations))
c44233aa
AM
7113 reloc_emitter = bed->elf_backend_emit_relocs;
7114 else
7115 reloc_emitter = elf_link_output_relocs;
9317eacc 7116
c89583f8
AM
7117 if (input_rel_hdr->sh_size != 0
7118 && ! (*reloc_emitter) (output_bfd, o, input_rel_hdr,
7119 internal_relocs))
41241523 7120 return false;
9317eacc 7121
c89583f8
AM
7122 input_rel_hdr2 = elf_section_data (o)->rel_hdr2;
7123 if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0)
c44233aa
AM
7124 {
7125 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
dc810e39 7126 * bed->s->int_rels_per_ext_rel);
c89583f8 7127 if (! (*reloc_emitter) (output_bfd, o, input_rel_hdr2,
41241523
TS
7128 internal_relocs))
7129 return false;
c44233aa 7130 }
252b5132
RH
7131 }
7132 }
7133
7134 /* Write out the modified section contents. */
73d074b4 7135 if (bed->elf_backend_write_section
f9f32305 7136 && (*bed->elf_backend_write_section) (output_bfd, o, contents))
73d074b4
DJ
7137 {
7138 /* Section written out. */
7139 }
65765700 7140 else switch (elf_section_data (o)->sec_info_type)
f5fa8ca2 7141 {
65765700 7142 case ELF_INFO_TYPE_STABS:
f5fa8ca2 7143 if (! (_bfd_write_section_stabs
65765700
JJ
7144 (output_bfd,
7145 &elf_hash_table (finfo->info)->stab_info,
7146 o, &elf_section_data (o)->sec_info, contents)))
f5fa8ca2 7147 return false;
65765700
JJ
7148 break;
7149 case ELF_INFO_TYPE_MERGE:
f5fa8ca2 7150 if (! (_bfd_write_merged_section
65765700 7151 (output_bfd, o, elf_section_data (o)->sec_info)))
252b5132 7152 return false;
65765700
JJ
7153 break;
7154 case ELF_INFO_TYPE_EH_FRAME:
7155 {
7156 asection *ehdrsec;
7157
7158 ehdrsec
7159 = bfd_get_section_by_name (elf_hash_table (finfo->info)->dynobj,
7160 ".eh_frame_hdr");
7161 if (! (_bfd_elf_write_section_eh_frame (output_bfd, o, ehdrsec,
7162 contents)))
7163 return false;
7164 }
7165 break;
7166 default:
7167 {
7168 bfd_size_type sec_size;
7169
7170 sec_size = (o->_cooked_size != 0 ? o->_cooked_size : o->_raw_size);
7171 if (! (o->flags & SEC_EXCLUDE)
7172 && ! bfd_set_section_contents (output_bfd, o->output_section,
7173 contents,
7174 (file_ptr) o->output_offset,
7175 sec_size))
7176 return false;
7177 }
7178 break;
252b5132
RH
7179 }
7180 }
7181
7182 return true;
7183}
7184
7185/* Generate a reloc when linking an ELF file. This is a reloc
7186 requested by the linker, and does come from any input file. This
7187 is used to build constructor and destructor tables when linking
7188 with -Ur. */
7189
7190static boolean
7191elf_reloc_link_order (output_bfd, info, output_section, link_order)
7192 bfd *output_bfd;
7193 struct bfd_link_info *info;
7194 asection *output_section;
7195 struct bfd_link_order *link_order;
7196{
7197 reloc_howto_type *howto;
7198 long indx;
7199 bfd_vma offset;
7200 bfd_vma addend;
7201 struct elf_link_hash_entry **rel_hash_ptr;
7202 Elf_Internal_Shdr *rel_hdr;
32f0787a 7203 struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
252b5132
RH
7204
7205 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
7206 if (howto == NULL)
7207 {
7208 bfd_set_error (bfd_error_bad_value);
7209 return false;
7210 }
7211
7212 addend = link_order->u.reloc.p->addend;
7213
7214 /* Figure out the symbol index. */
7215 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
31367b81
MM
7216 + elf_section_data (output_section)->rel_count
7217 + elf_section_data (output_section)->rel_count2);
252b5132
RH
7218 if (link_order->type == bfd_section_reloc_link_order)
7219 {
7220 indx = link_order->u.reloc.p->u.section->target_index;
7221 BFD_ASSERT (indx != 0);
7222 *rel_hash_ptr = NULL;
7223 }
7224 else
7225 {
7226 struct elf_link_hash_entry *h;
7227
7228 /* Treat a reloc against a defined symbol as though it were
c44233aa 7229 actually against the section. */
252b5132
RH
7230 h = ((struct elf_link_hash_entry *)
7231 bfd_wrapped_link_hash_lookup (output_bfd, info,
7232 link_order->u.reloc.p->u.name,
7233 false, false, true));
7234 if (h != NULL
7235 && (h->root.type == bfd_link_hash_defined
7236 || h->root.type == bfd_link_hash_defweak))
7237 {
7238 asection *section;
7239
7240 section = h->root.u.def.section;
7241 indx = section->output_section->target_index;
7242 *rel_hash_ptr = NULL;
7243 /* It seems that we ought to add the symbol value to the
c44233aa
AM
7244 addend here, but in practice it has already been added
7245 because it was passed to constructor_callback. */
252b5132
RH
7246 addend += section->output_section->vma + section->output_offset;
7247 }
7248 else if (h != NULL)
7249 {
7250 /* Setting the index to -2 tells elf_link_output_extsym that
7251 this symbol is used by a reloc. */
7252 h->indx = -2;
7253 *rel_hash_ptr = h;
7254 indx = 0;
7255 }
7256 else
7257 {
7258 if (! ((*info->callbacks->unattached_reloc)
7259 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
7260 (asection *) NULL, (bfd_vma) 0)))
7261 return false;
7262 indx = 0;
7263 }
7264 }
7265
7266 /* If this is an inplace reloc, we must write the addend into the
7267 object file. */
7268 if (howto->partial_inplace && addend != 0)
7269 {
7270 bfd_size_type size;
7271 bfd_reloc_status_type rstat;
7272 bfd_byte *buf;
7273 boolean ok;
dc810e39 7274 const char *sym_name;
252b5132
RH
7275
7276 size = bfd_get_reloc_size (howto);
7277 buf = (bfd_byte *) bfd_zmalloc (size);
7278 if (buf == (bfd_byte *) NULL)
7279 return false;
dc810e39 7280 rstat = _bfd_relocate_contents (howto, output_bfd, (bfd_vma) addend, buf);
252b5132
RH
7281 switch (rstat)
7282 {
7283 case bfd_reloc_ok:
7284 break;
dc810e39 7285
252b5132
RH
7286 default:
7287 case bfd_reloc_outofrange:
7288 abort ();
dc810e39 7289
252b5132 7290 case bfd_reloc_overflow:
dc810e39
AM
7291 if (link_order->type == bfd_section_reloc_link_order)
7292 sym_name = bfd_section_name (output_bfd,
7293 link_order->u.reloc.p->u.section);
7294 else
7295 sym_name = link_order->u.reloc.p->u.name;
252b5132 7296 if (! ((*info->callbacks->reloc_overflow)
dc810e39
AM
7297 (info, sym_name, howto->name, addend,
7298 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
252b5132
RH
7299 {
7300 free (buf);
7301 return false;
7302 }
7303 break;
7304 }
7305 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
7306 (file_ptr) link_order->offset, size);
7307 free (buf);
7308 if (! ok)
7309 return false;
7310 }
7311
7312 /* The address of a reloc is relative to the section in a
7313 relocateable file, and is a virtual address in an executable
7314 file. */
7315 offset = link_order->offset;
7316 if (! info->relocateable)
7317 offset += output_section->vma;
7318
7319 rel_hdr = &elf_section_data (output_section)->rel_hdr;
7320
7321 if (rel_hdr->sh_type == SHT_REL)
7322 {
dc810e39 7323 bfd_size_type size;
209f668e 7324 Elf_Internal_Rel *irel;
252b5132 7325 Elf_External_Rel *erel;
4e8a9624 7326 unsigned int i;
dc810e39
AM
7327
7328 size = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
7329 irel = (Elf_Internal_Rel *) bfd_zmalloc (size);
209f668e
NC
7330 if (irel == NULL)
7331 return false;
dc810e39 7332
209f668e
NC
7333 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7334 irel[i].r_offset = offset;
7335 irel[0].r_info = ELF_R_INFO (indx, howto->type);
252b5132 7336
252b5132 7337 erel = ((Elf_External_Rel *) rel_hdr->contents
0525d26e 7338 + elf_section_data (output_section)->rel_count);
209f668e 7339
32f0787a 7340 if (bed->s->swap_reloc_out)
209f668e 7341 (*bed->s->swap_reloc_out) (output_bfd, irel, (bfd_byte *) erel);
32f0787a 7342 else
209f668e
NC
7343 elf_swap_reloc_out (output_bfd, irel, erel);
7344
7345 free (irel);
252b5132
RH
7346 }
7347 else
7348 {
dc810e39 7349 bfd_size_type size;
209f668e 7350 Elf_Internal_Rela *irela;
252b5132 7351 Elf_External_Rela *erela;
4e8a9624 7352 unsigned int i;
dc810e39
AM
7353
7354 size = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
7355 irela = (Elf_Internal_Rela *) bfd_zmalloc (size);
209f668e
NC
7356 if (irela == NULL)
7357 return false;
7358
7359 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7360 irela[i].r_offset = offset;
7361 irela[0].r_info = ELF_R_INFO (indx, howto->type);
7362 irela[0].r_addend = addend;
252b5132 7363
252b5132 7364 erela = ((Elf_External_Rela *) rel_hdr->contents
0525d26e 7365 + elf_section_data (output_section)->rel_count);
209f668e 7366
32f0787a 7367 if (bed->s->swap_reloca_out)
209f668e 7368 (*bed->s->swap_reloca_out) (output_bfd, irela, (bfd_byte *) erela);
32f0787a 7369 else
209f668e 7370 elf_swap_reloca_out (output_bfd, irela, erela);
252b5132
RH
7371 }
7372
0525d26e 7373 ++elf_section_data (output_section)->rel_count;
252b5132
RH
7374
7375 return true;
7376}
252b5132
RH
7377\f
7378/* Allocate a pointer to live in a linker created section. */
7379
7380boolean
7381elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
7382 bfd *abfd;
7383 struct bfd_link_info *info;
7384 elf_linker_section_t *lsect;
7385 struct elf_link_hash_entry *h;
7386 const Elf_Internal_Rela *rel;
7387{
7388 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
7389 elf_linker_section_pointers_t *linker_section_ptr;
dc810e39
AM
7390 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
7391 bfd_size_type amt;
252b5132
RH
7392
7393 BFD_ASSERT (lsect != NULL);
7394
a7b97311 7395 /* Is this a global symbol? */
252b5132
RH
7396 if (h != NULL)
7397 {
a7b97311 7398 /* Has this symbol already been allocated? If so, our work is done. */
252b5132
RH
7399 if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
7400 rel->r_addend,
7401 lsect->which))
7402 return true;
7403
7404 ptr_linker_section_ptr = &h->linker_section_pointer;
7405 /* Make sure this symbol is output as a dynamic symbol. */
7406 if (h->dynindx == -1)
7407 {
7408 if (! elf_link_record_dynamic_symbol (info, h))
7409 return false;
7410 }
7411
7412 if (lsect->rel_section)
7413 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
7414 }
a7b97311 7415 else
252b5132 7416 {
a7b97311 7417 /* Allocation of a pointer to a local symbol. */
252b5132
RH
7418 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
7419
a7b97311 7420 /* Allocate a table to hold the local symbols if first time. */
252b5132
RH
7421 if (!ptr)
7422 {
7423 unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
7424 register unsigned int i;
7425
dc810e39
AM
7426 amt = num_symbols;
7427 amt *= sizeof (elf_linker_section_pointers_t *);
7428 ptr = (elf_linker_section_pointers_t **) bfd_alloc (abfd, amt);
252b5132
RH
7429
7430 if (!ptr)
7431 return false;
7432
7433 elf_local_ptr_offsets (abfd) = ptr;
7434 for (i = 0; i < num_symbols; i++)
a7b97311 7435 ptr[i] = (elf_linker_section_pointers_t *) 0;
252b5132
RH
7436 }
7437
a7b97311 7438 /* Has this symbol already been allocated? If so, our work is done. */
252b5132
RH
7439 if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
7440 rel->r_addend,
7441 lsect->which))
7442 return true;
7443
7444 ptr_linker_section_ptr = &ptr[r_symndx];
7445
7446 if (info->shared)
7447 {
7448 /* If we are generating a shared object, we need to
7449 output a R_<xxx>_RELATIVE reloc so that the
7450 dynamic linker can adjust this GOT entry. */
7451 BFD_ASSERT (lsect->rel_section != NULL);
7452 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
7453 }
7454 }
7455
a7b97311
AM
7456 /* Allocate space for a pointer in the linker section, and allocate
7457 a new pointer record from internal memory. */
252b5132 7458 BFD_ASSERT (ptr_linker_section_ptr != NULL);
dc810e39
AM
7459 amt = sizeof (elf_linker_section_pointers_t);
7460 linker_section_ptr = (elf_linker_section_pointers_t *) bfd_alloc (abfd, amt);
252b5132
RH
7461
7462 if (!linker_section_ptr)
7463 return false;
7464
7465 linker_section_ptr->next = *ptr_linker_section_ptr;
7466 linker_section_ptr->addend = rel->r_addend;
7467 linker_section_ptr->which = lsect->which;
7468 linker_section_ptr->written_address_p = false;
7469 *ptr_linker_section_ptr = linker_section_ptr;
7470
7471#if 0
7472 if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
7473 {
a7b97311
AM
7474 linker_section_ptr->offset = (lsect->section->_raw_size
7475 - lsect->hole_size + (ARCH_SIZE / 8));
252b5132
RH
7476 lsect->hole_offset += ARCH_SIZE / 8;
7477 lsect->sym_offset += ARCH_SIZE / 8;
a7b97311 7478 if (lsect->sym_hash)
252b5132 7479 {
a7b97311 7480 /* Bump up symbol value if needed. */
252b5132
RH
7481 lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
7482#ifdef DEBUG
7483 fprintf (stderr, "Bump up %s by %ld, current value = %ld\n",
7484 lsect->sym_hash->root.root.string,
a7b97311
AM
7485 (long) ARCH_SIZE / 8,
7486 (long) lsect->sym_hash->root.u.def.value);
252b5132
RH
7487#endif
7488 }
7489 }
7490 else
7491#endif
7492 linker_section_ptr->offset = lsect->section->_raw_size;
7493
7494 lsect->section->_raw_size += ARCH_SIZE / 8;
7495
7496#ifdef DEBUG
a7b97311
AM
7497 fprintf (stderr,
7498 "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
7499 lsect->name, (long) linker_section_ptr->offset,
7500 (long) lsect->section->_raw_size);
252b5132
RH
7501#endif
7502
7503 return true;
7504}
252b5132
RH
7505\f
7506#if ARCH_SIZE==64
7507#define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
7508#endif
7509#if ARCH_SIZE==32
7510#define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
7511#endif
7512
209f668e 7513/* Fill in the address for a pointer generated in a linker section. */
252b5132
RH
7514
7515bfd_vma
a7b97311
AM
7516elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h,
7517 relocation, rel, relative_reloc)
252b5132
RH
7518 bfd *output_bfd;
7519 bfd *input_bfd;
7520 struct bfd_link_info *info;
7521 elf_linker_section_t *lsect;
7522 struct elf_link_hash_entry *h;
7523 bfd_vma relocation;
7524 const Elf_Internal_Rela *rel;
7525 int relative_reloc;
7526{
7527 elf_linker_section_pointers_t *linker_section_ptr;
7528
7529 BFD_ASSERT (lsect != NULL);
7530
a7b97311 7531 if (h != NULL)
252b5132 7532 {
a7b97311
AM
7533 /* Handle global symbol. */
7534 linker_section_ptr = (_bfd_elf_find_pointer_linker_section
7535 (h->linker_section_pointer,
7536 rel->r_addend,
7537 lsect->which));
252b5132
RH
7538
7539 BFD_ASSERT (linker_section_ptr != NULL);
7540
7541 if (! elf_hash_table (info)->dynamic_sections_created
7542 || (info->shared
7543 && info->symbolic
7544 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
7545 {
7546 /* This is actually a static link, or it is a
7547 -Bsymbolic link and the symbol is defined
7548 locally. We must initialize this entry in the
7549 global section.
7550
7551 When doing a dynamic link, we create a .rela.<xxx>
7552 relocation entry to initialize the value. This
7553 is done in the finish_dynamic_symbol routine. */
7554 if (!linker_section_ptr->written_address_p)
7555 {
7556 linker_section_ptr->written_address_p = true;
a7b97311
AM
7557 bfd_put_ptr (output_bfd,
7558 relocation + linker_section_ptr->addend,
7559 (lsect->section->contents
7560 + linker_section_ptr->offset));
252b5132
RH
7561 }
7562 }
7563 }
a7b97311 7564 else
252b5132 7565 {
a7b97311 7566 /* Handle local symbol. */
252b5132
RH
7567 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
7568 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
7569 BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
a7b97311
AM
7570 linker_section_ptr = (_bfd_elf_find_pointer_linker_section
7571 (elf_local_ptr_offsets (input_bfd)[r_symndx],
7572 rel->r_addend,
7573 lsect->which));
252b5132
RH
7574
7575 BFD_ASSERT (linker_section_ptr != NULL);
7576
a7b97311 7577 /* Write out pointer if it hasn't been rewritten out before. */
252b5132
RH
7578 if (!linker_section_ptr->written_address_p)
7579 {
7580 linker_section_ptr->written_address_p = true;
7581 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
7582 lsect->section->contents + linker_section_ptr->offset);
7583
7584 if (info->shared)
7585 {
7586 asection *srel = lsect->rel_section;
209f668e 7587 Elf_Internal_Rela *outrel;
dc810e39 7588 Elf_External_Rela *erel;
209f668e
NC
7589 struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
7590 unsigned int i;
dc810e39 7591 bfd_size_type amt;
209f668e 7592
dc810e39
AM
7593 amt = sizeof (Elf_Internal_Rela) * bed->s->int_rels_per_ext_rel;
7594 outrel = (Elf_Internal_Rela *) bfd_zmalloc (amt);
209f668e
NC
7595 if (outrel == NULL)
7596 {
7597 (*_bfd_error_handler) (_("Error: out of memory"));
7598 return 0;
7599 }
252b5132 7600
a7b97311
AM
7601 /* We need to generate a relative reloc for the dynamic
7602 linker. */
252b5132 7603 if (!srel)
a7b97311
AM
7604 {
7605 srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
7606 lsect->rel_name);
7607 lsect->rel_section = srel;
7608 }
252b5132
RH
7609
7610 BFD_ASSERT (srel != NULL);
7611
209f668e
NC
7612 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7613 outrel[i].r_offset = (lsect->section->output_section->vma
7614 + lsect->section->output_offset
7615 + linker_section_ptr->offset);
7616 outrel[0].r_info = ELF_R_INFO (0, relative_reloc);
7617 outrel[0].r_addend = 0;
dc810e39
AM
7618 erel = (Elf_External_Rela *) lsect->section->contents;
7619 erel += elf_section_data (lsect->section)->rel_count;
7620 elf_swap_reloca_out (output_bfd, outrel, erel);
0525d26e 7621 ++elf_section_data (lsect->section)->rel_count;
dc810e39 7622
209f668e 7623 free (outrel);
252b5132
RH
7624 }
7625 }
7626 }
7627
7628 relocation = (lsect->section->output_offset
7629 + linker_section_ptr->offset
7630 - lsect->hole_offset
7631 - lsect->sym_offset);
7632
7633#ifdef DEBUG
a7b97311
AM
7634 fprintf (stderr,
7635 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
7636 lsect->name, (long) relocation, (long) relocation);
252b5132
RH
7637#endif
7638
7639 /* Subtract out the addend, because it will get added back in by the normal
7640 processing. */
7641 return relocation - linker_section_ptr->addend;
7642}
7643\f
7644/* Garbage collect unused sections. */
7645
7646static boolean elf_gc_mark
58821868
AM
7647 PARAMS ((struct bfd_link_info *, asection *,
7648 asection * (*) (asection *, struct bfd_link_info *,
7649 Elf_Internal_Rela *, struct elf_link_hash_entry *,
7650 Elf_Internal_Sym *)));
252b5132
RH
7651
7652static boolean elf_gc_sweep
58821868
AM
7653 PARAMS ((struct bfd_link_info *,
7654 boolean (*) (bfd *, struct bfd_link_info *, asection *,
7655 const Elf_Internal_Rela *)));
252b5132
RH
7656
7657static boolean elf_gc_sweep_symbol
58821868 7658 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
7659
7660static boolean elf_gc_allocate_got_offsets
58821868 7661 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
7662
7663static boolean elf_gc_propagate_vtable_entries_used
58821868 7664 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
7665
7666static boolean elf_gc_smash_unused_vtentry_relocs
58821868 7667 PARAMS ((struct elf_link_hash_entry *, PTR));
252b5132
RH
7668
7669/* The mark phase of garbage collection. For a given section, mark
dbb410c3
AM
7670 it and any sections in this section's group, and all the sections
7671 which define symbols to which it refers. */
252b5132
RH
7672
7673static boolean
7674elf_gc_mark (info, sec, gc_mark_hook)
7675 struct bfd_link_info *info;
7676 asection *sec;
58821868
AM
7677 asection * (*gc_mark_hook) PARAMS ((asection *, struct bfd_link_info *,
7678 Elf_Internal_Rela *,
7679 struct elf_link_hash_entry *,
7680 Elf_Internal_Sym *));
252b5132 7681{
dbb410c3
AM
7682 boolean ret;
7683 asection *group_sec;
252b5132
RH
7684
7685 sec->gc_mark = 1;
7686
dbb410c3
AM
7687 /* Mark all the sections in the group. */
7688 group_sec = elf_section_data (sec)->next_in_group;
7689 if (group_sec && !group_sec->gc_mark)
7690 if (!elf_gc_mark (info, group_sec, gc_mark_hook))
7691 return false;
252b5132 7692
dbb410c3
AM
7693 /* Look through the section relocs. */
7694 ret = true;
252b5132
RH
7695 if ((sec->flags & SEC_RELOC) != 0 && sec->reloc_count > 0)
7696 {
7697 Elf_Internal_Rela *relstart, *rel, *relend;
7698 Elf_Internal_Shdr *symtab_hdr;
7699 struct elf_link_hash_entry **sym_hashes;
7700 size_t nlocsyms;
7701 size_t extsymoff;
252b5132 7702 bfd *input_bfd = sec->owner;
c7ac6ff8 7703 struct elf_backend_data *bed = get_elf_backend_data (input_bfd);
6cdc0ccc 7704 Elf_Internal_Sym *isym = NULL;
252b5132
RH
7705
7706 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
7707 sym_hashes = elf_sym_hashes (input_bfd);
7708
7709 /* Read the local symbols. */
7710 if (elf_bad_symtab (input_bfd))
7711 {
7712 nlocsyms = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
c44233aa 7713 extsymoff = 0;
252b5132
RH
7714 }
7715 else
7716 extsymoff = nlocsyms = symtab_hdr->sh_info;
9ad5cbcf 7717
6cdc0ccc
AM
7718 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
7719 if (isym == NULL && nlocsyms != 0)
9ad5cbcf 7720 {
6cdc0ccc
AM
7721 isym = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, nlocsyms, 0,
7722 NULL, NULL, NULL);
7723 if (isym == NULL)
9ad5cbcf
AM
7724 return false;
7725 }
7726
252b5132
RH
7727 /* Read the relocations. */
7728 relstart = (NAME(_bfd_elf,link_read_relocs)
6cdc0ccc 7729 (input_bfd, sec, NULL, (Elf_Internal_Rela *) NULL,
252b5132
RH
7730 info->keep_memory));
7731 if (relstart == NULL)
7732 {
7733 ret = false;
7734 goto out1;
7735 }
c7ac6ff8 7736 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
252b5132
RH
7737
7738 for (rel = relstart; rel < relend; rel++)
7739 {
7740 unsigned long r_symndx;
7741 asection *rsec;
7742 struct elf_link_hash_entry *h;
252b5132
RH
7743
7744 r_symndx = ELF_R_SYM (rel->r_info);
7745 if (r_symndx == 0)
7746 continue;
7747
6cdc0ccc
AM
7748 if (r_symndx >= nlocsyms
7749 || ELF_ST_BIND (isym[r_symndx].st_info) != STB_LOCAL)
252b5132
RH
7750 {
7751 h = sym_hashes[r_symndx - extsymoff];
1e2f5b6e 7752 rsec = (*gc_mark_hook) (sec, info, rel, h, NULL);
252b5132
RH
7753 }
7754 else
7755 {
6cdc0ccc 7756 rsec = (*gc_mark_hook) (sec, info, rel, NULL, &isym[r_symndx]);
252b5132
RH
7757 }
7758
7759 if (rsec && !rsec->gc_mark)
b91afed7
AM
7760 {
7761 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
7762 rsec->gc_mark = 1;
7763 else if (!elf_gc_mark (info, rsec, gc_mark_hook))
7764 {
7765 ret = false;
7766 goto out2;
7767 }
7768 }
252b5132
RH
7769 }
7770
7771 out2:
6cdc0ccc 7772 if (elf_section_data (sec)->relocs != relstart)
252b5132
RH
7773 free (relstart);
7774 out1:
6cdc0ccc
AM
7775 if (isym != NULL && symtab_hdr->contents != (unsigned char *) isym)
7776 {
7777 if (! info->keep_memory)
7778 free (isym);
7779 else
7780 symtab_hdr->contents = (unsigned char *) isym;
7781 }
252b5132
RH
7782 }
7783
7784 return ret;
7785}
7786
7787/* The sweep phase of garbage collection. Remove all garbage sections. */
7788
7789static boolean
7790elf_gc_sweep (info, gc_sweep_hook)
7791 struct bfd_link_info *info;
58821868
AM
7792 boolean (*gc_sweep_hook) PARAMS ((bfd *, struct bfd_link_info *,
7793 asection *, const Elf_Internal_Rela *));
252b5132
RH
7794{
7795 bfd *sub;
7796
7797 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
7798 {
7799 asection *o;
7800
f6af82bd
AM
7801 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
7802 continue;
7803
252b5132
RH
7804 for (o = sub->sections; o != NULL; o = o->next)
7805 {
7806 /* Keep special sections. Keep .debug sections. */
7807 if ((o->flags & SEC_LINKER_CREATED)
7808 || (o->flags & SEC_DEBUGGING))
7809 o->gc_mark = 1;
7810
7811 if (o->gc_mark)
7812 continue;
7813
7814 /* Skip sweeping sections already excluded. */
7815 if (o->flags & SEC_EXCLUDE)
7816 continue;
7817
7818 /* Since this is early in the link process, it is simple
7819 to remove a section from the output. */
7820 o->flags |= SEC_EXCLUDE;
7821
7822 /* But we also have to update some of the relocation
7823 info we collected before. */
7824 if (gc_sweep_hook
7825 && (o->flags & SEC_RELOC) && o->reloc_count > 0)
7826 {
7827 Elf_Internal_Rela *internal_relocs;
7828 boolean r;
7829
7830 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
7831 (o->owner, o, NULL, NULL, info->keep_memory));
7832 if (internal_relocs == NULL)
7833 return false;
7834
3e932841 7835 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
252b5132 7836
6cdc0ccc 7837 if (elf_section_data (o)->relocs != internal_relocs)
252b5132
RH
7838 free (internal_relocs);
7839
7840 if (!r)
7841 return false;
7842 }
7843 }
7844 }
7845
7846 /* Remove the symbols that were in the swept sections from the dynamic
7847 symbol table. GCFIXME: Anyone know how to get them out of the
7848 static symbol table as well? */
7849 {
7850 int i = 0;
7851
7852 elf_link_hash_traverse (elf_hash_table (info),
7853 elf_gc_sweep_symbol,
7854 (PTR) &i);
7855
7856 elf_hash_table (info)->dynsymcount = i;
7857 }
7858
7859 return true;
7860}
7861
7862/* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
7863
7864static boolean
7865elf_gc_sweep_symbol (h, idxptr)
7866 struct elf_link_hash_entry *h;
7867 PTR idxptr;
7868{
7869 int *idx = (int *) idxptr;
7870
e92d460e
AM
7871 if (h->root.type == bfd_link_hash_warning)
7872 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7873
252b5132
RH
7874 if (h->dynindx != -1
7875 && ((h->root.type != bfd_link_hash_defined
7876 && h->root.type != bfd_link_hash_defweak)
7877 || h->root.u.def.section->gc_mark))
7878 h->dynindx = (*idx)++;
7879
7880 return true;
7881}
7882
7883/* Propogate collected vtable information. This is called through
7884 elf_link_hash_traverse. */
7885
7886static boolean
7887elf_gc_propagate_vtable_entries_used (h, okp)
7888 struct elf_link_hash_entry *h;
7889 PTR okp;
7890{
e92d460e
AM
7891 if (h->root.type == bfd_link_hash_warning)
7892 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7893
3e932841 7894 /* Those that are not vtables. */
252b5132
RH
7895 if (h->vtable_parent == NULL)
7896 return true;
7897
7898 /* Those vtables that do not have parents, we cannot merge. */
7899 if (h->vtable_parent == (struct elf_link_hash_entry *) -1)
7900 return true;
7901
7902 /* If we've already been done, exit. */
7903 if (h->vtable_entries_used && h->vtable_entries_used[-1])
7904 return true;
7905
7906 /* Make sure the parent's table is up to date. */
7907 elf_gc_propagate_vtable_entries_used (h->vtable_parent, okp);
7908
7909 if (h->vtable_entries_used == NULL)
7910 {
7911 /* None of this table's entries were referenced. Re-use the
7912 parent's table. */
7913 h->vtable_entries_used = h->vtable_parent->vtable_entries_used;
7914 h->vtable_entries_size = h->vtable_parent->vtable_entries_size;
7915 }
7916 else
7917 {
7918 size_t n;
7919 boolean *cu, *pu;
7920
7921 /* Or the parent's entries into ours. */
7922 cu = h->vtable_entries_used;
7923 cu[-1] = true;
7924 pu = h->vtable_parent->vtable_entries_used;
7925 if (pu != NULL)
7926 {
c44233aa
AM
7927 asection *sec = h->root.u.def.section;
7928 struct elf_backend_data *bed = get_elf_backend_data (sec->owner);
7929 int file_align = bed->s->file_align;
0d1ea5c0
CM
7930
7931 n = h->vtable_parent->vtable_entries_size / file_align;
374b596d 7932 while (n--)
252b5132 7933 {
374b596d
NC
7934 if (*pu)
7935 *cu = true;
7936 pu++;
7937 cu++;
252b5132
RH
7938 }
7939 }
7940 }
7941
7942 return true;
7943}
7944
7945static boolean
7946elf_gc_smash_unused_vtentry_relocs (h, okp)
7947 struct elf_link_hash_entry *h;
7948 PTR okp;
7949{
7950 asection *sec;
7951 bfd_vma hstart, hend;
7952 Elf_Internal_Rela *relstart, *relend, *rel;
c7ac6ff8 7953 struct elf_backend_data *bed;
0d1ea5c0 7954 int file_align;
252b5132 7955
e92d460e
AM
7956 if (h->root.type == bfd_link_hash_warning)
7957 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7958
252b5132
RH
7959 /* Take care of both those symbols that do not describe vtables as
7960 well as those that are not loaded. */
7961 if (h->vtable_parent == NULL)
7962 return true;
7963
7964 BFD_ASSERT (h->root.type == bfd_link_hash_defined
7965 || h->root.type == bfd_link_hash_defweak);
7966
7967 sec = h->root.u.def.section;
7968 hstart = h->root.u.def.value;
7969 hend = hstart + h->size;
7970
7971 relstart = (NAME(_bfd_elf,link_read_relocs)
7972 (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL, true));
7973 if (!relstart)
a7b97311 7974 return *(boolean *) okp = false;
c7ac6ff8 7975 bed = get_elf_backend_data (sec->owner);
0d1ea5c0
CM
7976 file_align = bed->s->file_align;
7977
c7ac6ff8 7978 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
252b5132
RH
7979
7980 for (rel = relstart; rel < relend; ++rel)
7981 if (rel->r_offset >= hstart && rel->r_offset < hend)
7982 {
7983 /* If the entry is in use, do nothing. */
7984 if (h->vtable_entries_used
7985 && (rel->r_offset - hstart) < h->vtable_entries_size)
7986 {
0d1ea5c0 7987 bfd_vma entry = (rel->r_offset - hstart) / file_align;
252b5132
RH
7988 if (h->vtable_entries_used[entry])
7989 continue;
7990 }
7991 /* Otherwise, kill it. */
7992 rel->r_offset = rel->r_info = rel->r_addend = 0;
7993 }
7994
7995 return true;
7996}
7997
7998/* Do mark and sweep of unused sections. */
7999
8000boolean
8001elf_gc_sections (abfd, info)
8002 bfd *abfd;
8003 struct bfd_link_info *info;
8004{
8005 boolean ok = true;
8006 bfd *sub;
8007 asection * (*gc_mark_hook)
1e2f5b6e 8008 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
c44233aa 8009 struct elf_link_hash_entry *h, Elf_Internal_Sym *));
252b5132
RH
8010
8011 if (!get_elf_backend_data (abfd)->can_gc_sections
6d3e950b 8012 || info->relocateable || info->emitrelocations
252b5132
RH
8013 || elf_hash_table (info)->dynamic_sections_created)
8014 return true;
8015
8016 /* Apply transitive closure to the vtable entry usage info. */
8017 elf_link_hash_traverse (elf_hash_table (info),
8018 elf_gc_propagate_vtable_entries_used,
8019 (PTR) &ok);
8020 if (!ok)
8021 return false;
8022
8023 /* Kill the vtable relocations that were not used. */
8024 elf_link_hash_traverse (elf_hash_table (info),
8025 elf_gc_smash_unused_vtentry_relocs,
8026 (PTR) &ok);
8027 if (!ok)
8028 return false;
8029
8030 /* Grovel through relocs to find out who stays ... */
8031
8032 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
8033 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8034 {
8035 asection *o;
f6af82bd
AM
8036
8037 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
8038 continue;
8039
252b5132
RH
8040 for (o = sub->sections; o != NULL; o = o->next)
8041 {
8042 if (o->flags & SEC_KEEP)
c44233aa 8043 if (!elf_gc_mark (info, o, gc_mark_hook))
252b5132
RH
8044 return false;
8045 }
8046 }
8047
8048 /* ... and mark SEC_EXCLUDE for those that go. */
a7b97311 8049 if (!elf_gc_sweep (info, get_elf_backend_data (abfd)->gc_sweep_hook))
252b5132
RH
8050 return false;
8051
8052 return true;
8053}
8054\f
8055/* Called from check_relocs to record the existance of a VTINHERIT reloc. */
8056
8057boolean
8058elf_gc_record_vtinherit (abfd, sec, h, offset)
8059 bfd *abfd;
8060 asection *sec;
8061 struct elf_link_hash_entry *h;
8062 bfd_vma offset;
8063{
8064 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
8065 struct elf_link_hash_entry **search, *child;
8066 bfd_size_type extsymcount;
8067
8068 /* The sh_info field of the symtab header tells us where the
8069 external symbols start. We don't care about the local symbols at
8070 this point. */
8071 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size/sizeof (Elf_External_Sym);
8072 if (!elf_bad_symtab (abfd))
8073 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
8074
8075 sym_hashes = elf_sym_hashes (abfd);
8076 sym_hashes_end = sym_hashes + extsymcount;
8077
8078 /* Hunt down the child symbol, which is in this section at the same
8079 offset as the relocation. */
8080 for (search = sym_hashes; search != sym_hashes_end; ++search)
8081 {
8082 if ((child = *search) != NULL
8083 && (child->root.type == bfd_link_hash_defined
8084 || child->root.type == bfd_link_hash_defweak)
8085 && child->root.u.def.section == sec
8086 && child->root.u.def.value == offset)
8087 goto win;
8088 }
8089
8090 (*_bfd_error_handler) ("%s: %s+%lu: No symbol found for INHERIT",
8f615d07 8091 bfd_archive_filename (abfd), sec->name,
a7b97311 8092 (unsigned long) offset);
252b5132
RH
8093 bfd_set_error (bfd_error_invalid_operation);
8094 return false;
8095
dc810e39 8096 win:
252b5132
RH
8097 if (!h)
8098 {
8099 /* This *should* only be the absolute section. It could potentially
8100 be that someone has defined a non-global vtable though, which
8101 would be bad. It isn't worth paging in the local symbols to be
8102 sure though; that case should simply be handled by the assembler. */
8103
8104 child->vtable_parent = (struct elf_link_hash_entry *) -1;
8105 }
8106 else
8107 child->vtable_parent = h;
8108
8109 return true;
8110}
8111
8112/* Called from check_relocs to record the existance of a VTENTRY reloc. */
8113
8114boolean
8115elf_gc_record_vtentry (abfd, sec, h, addend)
7442e600
ILT
8116 bfd *abfd ATTRIBUTE_UNUSED;
8117 asection *sec ATTRIBUTE_UNUSED;
252b5132
RH
8118 struct elf_link_hash_entry *h;
8119 bfd_vma addend;
8120{
0d1ea5c0
CM
8121 struct elf_backend_data *bed = get_elf_backend_data (abfd);
8122 int file_align = bed->s->file_align;
8123
252b5132
RH
8124 if (addend >= h->vtable_entries_size)
8125 {
8126 size_t size, bytes;
8127 boolean *ptr = h->vtable_entries_used;
8128
8129 /* While the symbol is undefined, we have to be prepared to handle
8130 a zero size. */
8131 if (h->root.type == bfd_link_hash_undefined)
8132 size = addend;
8133 else
8134 {
8135 size = h->size;
8136 if (size < addend)
8137 {
8138 /* Oops! We've got a reference past the defined end of
8139 the table. This is probably a bug -- shall we warn? */
8140 size = addend;
8141 }
8142 }
8143
8144 /* Allocate one extra entry for use as a "done" flag for the
8145 consolidation pass. */
0d1ea5c0 8146 bytes = (size / file_align + 1) * sizeof (boolean);
252b5132
RH
8147
8148 if (ptr)
8149 {
dc810e39 8150 ptr = bfd_realloc (ptr - 1, (bfd_size_type) bytes);
3e932841 8151
fed79cc6
NC
8152 if (ptr != NULL)
8153 {
8154 size_t oldbytes;
252b5132 8155
a7b97311
AM
8156 oldbytes = ((h->vtable_entries_size / file_align + 1)
8157 * sizeof (boolean));
8158 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
fed79cc6 8159 }
252b5132
RH
8160 }
8161 else
dc810e39 8162 ptr = bfd_zmalloc ((bfd_size_type) bytes);
252b5132 8163
fed79cc6
NC
8164 if (ptr == NULL)
8165 return false;
3e932841 8166
252b5132 8167 /* And arrange for that done flag to be at index -1. */
fed79cc6 8168 h->vtable_entries_used = ptr + 1;
252b5132
RH
8169 h->vtable_entries_size = size;
8170 }
3e932841 8171
0d1ea5c0 8172 h->vtable_entries_used[addend / file_align] = true;
252b5132
RH
8173
8174 return true;
8175}
8176
8177/* And an accompanying bit to work out final got entry offsets once
8178 we're done. Should be called from final_link. */
8179
8180boolean
8181elf_gc_common_finalize_got_offsets (abfd, info)
8182 bfd *abfd;
8183 struct bfd_link_info *info;
8184{
8185 bfd *i;
8186 struct elf_backend_data *bed = get_elf_backend_data (abfd);
8187 bfd_vma gotoff;
8188
8189 /* The GOT offset is relative to the .got section, but the GOT header is
8190 put into the .got.plt section, if the backend uses it. */
8191 if (bed->want_got_plt)
8192 gotoff = 0;
8193 else
8194 gotoff = bed->got_header_size;
8195
8196 /* Do the local .got entries first. */
8197 for (i = info->input_bfds; i; i = i->link_next)
8198 {
f6af82bd 8199 bfd_signed_vma *local_got;
252b5132
RH
8200 bfd_size_type j, locsymcount;
8201 Elf_Internal_Shdr *symtab_hdr;
8202
f6af82bd
AM
8203 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
8204 continue;
8205
8206 local_got = elf_local_got_refcounts (i);
252b5132
RH
8207 if (!local_got)
8208 continue;
8209
8210 symtab_hdr = &elf_tdata (i)->symtab_hdr;
8211 if (elf_bad_symtab (i))
8212 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
8213 else
8214 locsymcount = symtab_hdr->sh_info;
8215
8216 for (j = 0; j < locsymcount; ++j)
8217 {
8218 if (local_got[j] > 0)
8219 {
8220 local_got[j] = gotoff;
8221 gotoff += ARCH_SIZE / 8;
8222 }
8223 else
8224 local_got[j] = (bfd_vma) -1;
8225 }
8226 }
8227
dd5724d5
AM
8228 /* Then the global .got entries. .plt refcounts are handled by
8229 adjust_dynamic_symbol */
252b5132
RH
8230 elf_link_hash_traverse (elf_hash_table (info),
8231 elf_gc_allocate_got_offsets,
8232 (PTR) &gotoff);
8233 return true;
8234}
8235
8236/* We need a special top-level link routine to convert got reference counts
8237 to real got offsets. */
8238
8239static boolean
8240elf_gc_allocate_got_offsets (h, offarg)
8241 struct elf_link_hash_entry *h;
8242 PTR offarg;
8243{
8244 bfd_vma *off = (bfd_vma *) offarg;
8245
e92d460e
AM
8246 if (h->root.type == bfd_link_hash_warning)
8247 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8248
252b5132
RH
8249 if (h->got.refcount > 0)
8250 {
8251 h->got.offset = off[0];
8252 off[0] += ARCH_SIZE / 8;
8253 }
8254 else
8255 h->got.offset = (bfd_vma) -1;
8256
8257 return true;
8258}
8259
8260/* Many folk need no more in the way of final link than this, once
8261 got entry reference counting is enabled. */
8262
8263boolean
8264elf_gc_common_final_link (abfd, info)
8265 bfd *abfd;
8266 struct bfd_link_info *info;
8267{
8268 if (!elf_gc_common_finalize_got_offsets (abfd, info))
8269 return false;
8270
8271 /* Invoke the regular ELF backend linker to do all the work. */
8272 return elf_bfd_final_link (abfd, info);
8273}
8274
8275/* This function will be called though elf_link_hash_traverse to store
8276 all hash value of the exported symbols in an array. */
8277
8278static boolean
8279elf_collect_hash_codes (h, data)
8280 struct elf_link_hash_entry *h;
8281 PTR data;
8282{
8283 unsigned long **valuep = (unsigned long **) data;
8284 const char *name;
8285 char *p;
8286 unsigned long ha;
8287 char *alc = NULL;
8288
e92d460e
AM
8289 if (h->root.type == bfd_link_hash_warning)
8290 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8291
252b5132
RH
8292 /* Ignore indirect symbols. These are added by the versioning code. */
8293 if (h->dynindx == -1)
8294 return true;
8295
8296 name = h->root.root.string;
8297 p = strchr (name, ELF_VER_CHR);
8298 if (p != NULL)
8299 {
dc810e39
AM
8300 alc = bfd_malloc ((bfd_size_type) (p - name + 1));
8301 memcpy (alc, name, (size_t) (p - name));
252b5132
RH
8302 alc[p - name] = '\0';
8303 name = alc;
8304 }
8305
8306 /* Compute the hash value. */
8307 ha = bfd_elf_hash (name);
8308
8309 /* Store the found hash value in the array given as the argument. */
8310 *(*valuep)++ = ha;
8311
8312 /* And store it in the struct so that we can put it in the hash table
8313 later. */
8314 h->elf_hash_value = ha;
8315
8316 if (alc != NULL)
8317 free (alc);
8318
8319 return true;
8320}
73d074b4
DJ
8321
8322boolean
8323elf_reloc_symbol_deleted_p (offset, cookie)
8324 bfd_vma offset;
8325 PTR cookie;
8326{
9ad5cbcf 8327 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
73d074b4
DJ
8328
8329 if (rcookie->bad_symtab)
8330 rcookie->rel = rcookie->rels;
8331
8332 for (; rcookie->rel < rcookie->relend; rcookie->rel++)
8333 {
8334 unsigned long r_symndx = ELF_R_SYM (rcookie->rel->r_info);
73d074b4
DJ
8335
8336 if (! rcookie->bad_symtab)
8337 if (rcookie->rel->r_offset > offset)
8338 return false;
8339 if (rcookie->rel->r_offset != offset)
8340 continue;
8341
73d074b4 8342 if (r_symndx >= rcookie->locsymcount
6cdc0ccc 8343 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
73d074b4
DJ
8344 {
8345 struct elf_link_hash_entry *h;
8346
8347 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
8348
8349 while (h->root.type == bfd_link_hash_indirect
8350 || h->root.type == bfd_link_hash_warning)
8351 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8352
8353 if ((h->root.type == bfd_link_hash_defined
8354 || h->root.type == bfd_link_hash_defweak)
ed4de5e2 8355 && elf_discarded_section (h->root.u.def.section))
73d074b4
DJ
8356 return true;
8357 else
8358 return false;
8359 }
6cdc0ccc 8360 else
73d074b4
DJ
8361 {
8362 /* It's not a relocation against a global symbol,
44421011 8363 but it could be a relocation against a local
73d074b4
DJ
8364 symbol for a discarded section. */
8365 asection *isec;
6cdc0ccc 8366 Elf_Internal_Sym *isym;
73d074b4
DJ
8367
8368 /* Need to: get the symbol; get the section. */
6cdc0ccc
AM
8369 isym = &rcookie->locsyms[r_symndx];
8370 if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
73d074b4 8371 {
6cdc0ccc 8372 isec = section_from_elf_index (rcookie->abfd, isym->st_shndx);
ed4de5e2 8373 if (isec != NULL && elf_discarded_section (isec))
73d074b4
DJ
8374 return true;
8375 }
8376 }
8377 return false;
8378 }
8379 return false;
8380}
8381
8382/* Discard unneeded references to discarded sections.
8383 Returns true if any section's size was changed. */
8384/* This function assumes that the relocations are in sorted order,
8385 which is true for all known assemblers. */
8386
8387boolean
65765700
JJ
8388elf_bfd_discard_info (output_bfd, info)
8389 bfd *output_bfd;
73d074b4
DJ
8390 struct bfd_link_info *info;
8391{
8392 struct elf_reloc_cookie cookie;
65765700 8393 asection *stab, *eh, *ehdr;
73d074b4 8394 Elf_Internal_Shdr *symtab_hdr;
73d074b4
DJ
8395 struct elf_backend_data *bed;
8396 bfd *abfd;
8397 boolean ret = false;
65765700 8398 boolean strip = info->strip == strip_all || info->strip == strip_debugger;
73d074b4
DJ
8399
8400 if (info->relocateable
8401 || info->traditional_format
8402 || info->hash->creator->flavour != bfd_target_elf_flavour
65765700 8403 || ! is_elf_hash_table (info))
73d074b4 8404 return false;
65765700 8405
72dd6331
AM
8406 ehdr = NULL;
8407 if (elf_hash_table (info)->dynobj != NULL)
8408 ehdr = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
8409 ".eh_frame_hdr");
65765700 8410
73d074b4
DJ
8411 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
8412 {
163c1c30
L
8413 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
8414 continue;
8415
73d074b4
DJ
8416 bed = get_elf_backend_data (abfd);
8417
8418 if ((abfd->flags & DYNAMIC) != 0)
8419 continue;
8420
65765700
JJ
8421 eh = NULL;
8422 if (ehdr)
8423 {
8424 eh = bfd_get_section_by_name (abfd, ".eh_frame");
2d653fc7
AM
8425 if (eh && (eh->_raw_size == 0
8426 || bfd_is_abs_section (eh->output_section)))
65765700
JJ
8427 eh = NULL;
8428 }
8429
2d653fc7
AM
8430 stab = NULL;
8431 if (!strip)
8432 {
8433 stab = bfd_get_section_by_name (abfd, ".stab");
8434 if (stab && (stab->_raw_size == 0
8435 || bfd_is_abs_section (stab->output_section)))
8436 stab = NULL;
8437 }
40b829d4
AM
8438 if ((! stab
8439 || elf_section_data(stab)->sec_info_type != ELF_INFO_TYPE_STABS)
65765700
JJ
8440 && ! eh
8441 && (strip || ! bed->elf_backend_discard_info))
73d074b4
DJ
8442 continue;
8443
8444 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
73d074b4
DJ
8445 cookie.abfd = abfd;
8446 cookie.sym_hashes = elf_sym_hashes (abfd);
8447 cookie.bad_symtab = elf_bad_symtab (abfd);
8448 if (cookie.bad_symtab)
8449 {
8450 cookie.locsymcount =
8451 symtab_hdr->sh_size / sizeof (Elf_External_Sym);
8452 cookie.extsymoff = 0;
8453 }
8454 else
8455 {
8456 cookie.locsymcount = symtab_hdr->sh_info;
8457 cookie.extsymoff = symtab_hdr->sh_info;
8458 }
8459
6cdc0ccc
AM
8460 cookie.locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
8461 if (cookie.locsyms == NULL && cookie.locsymcount != 0)
c44233aa 8462 {
6cdc0ccc
AM
8463 cookie.locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8464 cookie.locsymcount, 0,
8465 NULL, NULL, NULL);
c44233aa 8466 if (cookie.locsyms == NULL)
9ad5cbcf 8467 return false;
9ad5cbcf 8468 }
73d074b4 8469
65765700 8470 if (stab)
73d074b4
DJ
8471 {
8472 cookie.rels = (NAME(_bfd_elf,link_read_relocs)
6cdc0ccc 8473 (abfd, stab, (PTR) NULL, (Elf_Internal_Rela *) NULL,
73d074b4
DJ
8474 info->keep_memory));
8475 if (cookie.rels)
8476 {
8477 cookie.rel = cookie.rels;
8478 cookie.relend =
65765700
JJ
8479 cookie.rels + stab->reloc_count * bed->s->int_rels_per_ext_rel;
8480 if (_bfd_discard_section_stabs (abfd, stab,
8481 elf_section_data (stab)->sec_info,
73d074b4
DJ
8482 elf_reloc_symbol_deleted_p,
8483 &cookie))
8484 ret = true;
6cdc0ccc 8485 if (elf_section_data (stab)->relocs != cookie.rels)
73d074b4
DJ
8486 free (cookie.rels);
8487 }
8488 }
8489
65765700
JJ
8490 if (eh)
8491 {
8492 cookie.rels = NULL;
8493 cookie.rel = NULL;
8494 cookie.relend = NULL;
8495 if (eh->reloc_count)
8496 cookie.rels = (NAME(_bfd_elf,link_read_relocs)
40b829d4 8497 (abfd, eh, (PTR) NULL, (Elf_Internal_Rela *) NULL,
65765700
JJ
8498 info->keep_memory));
8499 if (cookie.rels)
8500 {
8501 cookie.rel = cookie.rels;
8502 cookie.relend =
8503 cookie.rels + eh->reloc_count * bed->s->int_rels_per_ext_rel;
8504 }
8505 if (_bfd_elf_discard_section_eh_frame (abfd, info, eh, ehdr,
8506 elf_reloc_symbol_deleted_p,
8507 &cookie))
8508 ret = true;
6cdc0ccc 8509 if (cookie.rels && elf_section_data (eh)->relocs != cookie.rels)
65765700
JJ
8510 free (cookie.rels);
8511 }
8512
73d074b4
DJ
8513 if (bed->elf_backend_discard_info)
8514 {
8515 if (bed->elf_backend_discard_info (abfd, &cookie, info))
8516 ret = true;
8517 }
8518
6cdc0ccc
AM
8519 if (cookie.locsyms != NULL
8520 && symtab_hdr->contents != (unsigned char *) cookie.locsyms)
8521 {
8522 if (! info->keep_memory)
8523 free (cookie.locsyms);
8524 else
8525 symtab_hdr->contents = (unsigned char *) cookie.locsyms;
8526 }
73d074b4 8527 }
65765700 8528
40b829d4 8529 if (ehdr && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info, ehdr))
65765700 8530 ret = true;
73d074b4
DJ
8531 return ret;
8532}
8533
8534static boolean
8535elf_section_ignore_discarded_relocs (sec)
8536 asection *sec;
8537{
40b829d4
AM
8538 struct elf_backend_data *bed;
8539
65765700
JJ
8540 switch (elf_section_data (sec)->sec_info_type)
8541 {
8542 case ELF_INFO_TYPE_STABS:
8543 case ELF_INFO_TYPE_EH_FRAME:
8544 return true;
8545 default:
8546 break;
8547 }
40b829d4
AM
8548
8549 bed = get_elf_backend_data (sec->owner);
8550 if (bed->elf_backend_ignore_discarded_relocs != NULL
8551 && (*bed->elf_backend_ignore_discarded_relocs) (sec))
73d074b4 8552 return true;
65765700
JJ
8553
8554 return false;
73d074b4 8555}
This page took 0.629593 seconds and 4 git commands to generate.