projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* opncls.c (bfd_alloc_by_size_t): Set bfd_error_no_memory if
[deliverable/binutils-gdb.git] / bfd / elflink.h
CommitLineData
8afe83be
KR		 1/* ELF linker support.
2 Copyright 1995 Free Software Foundation, Inc.
3
4This file is part of BFD, the Binary File Descriptor library.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
943fbd5b 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
452a5efb 19
ede4eed4
KR		 20/* ELF linker code. */
21
22static boolean elf_link_add_object_symbols
23 PARAMS ((bfd *, struct bfd_link_info *));
24static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd *, struct bfd_link_info *));
26static Elf_Internal_Rela *elf_link_read_relocs
27 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean));
28static boolean elf_export_symbol
29 PARAMS ((struct elf_link_hash_entry *, PTR));
30static boolean elf_adjust_dynamic_symbol
31 PARAMS ((struct elf_link_hash_entry *, PTR));
32
33/* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
35
36struct elf_info_failed
37{
38 boolean failed;
39 struct bfd_link_info *info;
40};
41
42/* Given an ELF BFD, add symbols to the global hash table as
43 appropriate. */
44
45boolean
46elf_bfd_link_add_symbols (abfd, info)
47 bfd *abfd;
48 struct bfd_link_info *info;
49{
ede4eed4
KR		 50 switch (bfd_get_format (abfd))
51 {
52 case bfd_object:
53 return elf_link_add_object_symbols (abfd, info);
54 case bfd_archive:
ede4eed4
KR		 55 return elf_link_add_archive_symbols (abfd, info);
56 default:
57 bfd_set_error (bfd_error_wrong_format);
58 return false;
59 }
60}
61
62/* Add symbols from an ELF archive file to the linker hash table. We
63 don't use _bfd_generic_link_add_archive_symbols because of a
64 problem which arises on UnixWare. The UnixWare libc.so is an
65 archive which includes an entry libc.so.1 which defines a bunch of
66 symbols. The libc.so archive also includes a number of other
67 object files, which also define symbols, some of which are the same
68 as those defined in libc.so.1. Correct linking requires that we
69 consider each object file in turn, and include it if it defines any
70 symbols we need. _bfd_generic_link_add_archive_symbols does not do
71 this; it looks through the list of undefined symbols, and includes
72 any object file which defines them. When this algorithm is used on
73 UnixWare, it winds up pulling in libc.so.1 early and defining a
74 bunch of symbols. This means that some of the other objects in the
75 archive are not included in the link, which is incorrect since they
76 precede libc.so.1 in the archive.
77
78 Fortunately, ELF archive handling is simpler than that done by
79 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
80 oddities. In ELF, if we find a symbol in the archive map, and the
81 symbol is currently undefined, we know that we must pull in that
82 object file.
83
84 Unfortunately, we do have to make multiple passes over the symbol
85 table until nothing further is resolved. */
86
87static boolean
88elf_link_add_archive_symbols (abfd, info)
89 bfd *abfd;
90 struct bfd_link_info *info;
91{
92 symindex c;
93 boolean *defined = NULL;
94 boolean *included = NULL;
95 carsym *symdefs;
96 boolean loop;
97
98 if (! bfd_has_map (abfd))
99 {
100 /* An empty archive is a special case. */
101 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
102 return true;
103 bfd_set_error (bfd_error_no_armap);
104 return false;
105 }
106
107 /* Keep track of all symbols we know to be already defined, and all
108 files we know to be already included. This is to speed up the
109 second and subsequent passes. */
110 c = bfd_ardata (abfd)->symdef_count;
111 if (c == 0)
112 return true;
113 defined = (boolean *) malloc (c * sizeof (boolean));
114 included = (boolean *) malloc (c * sizeof (boolean));
115 if (defined == (boolean *) NULL || included == (boolean *) NULL)
116 {
117 bfd_set_error (bfd_error_no_memory);
118 goto error_return;
119 }
120 memset (defined, 0, c * sizeof (boolean));
121 memset (included, 0, c * sizeof (boolean));
122
123 symdefs = bfd_ardata (abfd)->symdefs;
124
125 do
126 {
127 file_ptr last;
128 symindex i;
129 carsym *symdef;
130 carsym *symdefend;
131
132 loop = false;
133 last = -1;
134
135 symdef = symdefs;
136 symdefend = symdef + c;
137 for (i = 0; symdef < symdefend; symdef++, i++)
138 {
139 struct elf_link_hash_entry *h;
140 bfd *element;
141 struct bfd_link_hash_entry *undefs_tail;
142 symindex mark;
143
144 if (defined[i] || included[i])
145 continue;
146 if (symdef->file_offset == last)
147 {
148 included[i] = true;
149 continue;
150 }
151
152 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
153 false, false, false);
154 if (h == (struct elf_link_hash_entry *) NULL)
155 continue;
156 if (h->root.type != bfd_link_hash_undefined)
157 {
68807a39
ILT		 158 if (h->root.type != bfd_link_hash_undefweak)
159 defined[i] = true;
ede4eed4
KR		 160 continue;
161 }
162
163 /* We need to include this archive member. */
164
165 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
166 if (element == (bfd *) NULL)
167 goto error_return;
168
169 if (! bfd_check_format (element, bfd_object))
170 goto error_return;
171
172 /* Doublecheck that we have not included this object
173 already--it should be impossible, but there may be
174 something wrong with the archive. */
175 if (element->archive_pass != 0)
176 {
177 bfd_set_error (bfd_error_bad_value);
178 goto error_return;
179 }
180 element->archive_pass = 1;
181
182 undefs_tail = info->hash->undefs_tail;
183
184 if (! (*info->callbacks->add_archive_element) (info, element,
185 symdef->name))
186 goto error_return;
187 if (! elf_link_add_object_symbols (element, info))
188 goto error_return;
189
190 /* If there are any new undefined symbols, we need to make
191 another pass through the archive in order to see whether
192 they can be defined. FIXME: This isn't perfect, because
193 common symbols wind up on undefs_tail and because an
194 undefined symbol which is defined later on in this pass
195 does not require another pass. This isn't a bug, but it
196 does make the code less efficient than it could be. */
197 if (undefs_tail != info->hash->undefs_tail)
198 loop = true;
199
200 /* Look backward to mark all symbols from this object file
201 which we have already seen in this pass. */
202 mark = i;
203 do
204 {
205 included[mark] = true;
206 if (mark == 0)
207 break;
208 --mark;
209 }
210 while (symdefs[mark].file_offset == symdef->file_offset);
211
212 /* We mark subsequent symbols from this object file as we go
213 on through the loop. */
214 last = symdef->file_offset;
215 }
216 }
217 while (loop);
218
219 free (defined);
220 free (included);
221
222 return true;
223
224 error_return:
225 if (defined != (boolean *) NULL)
226 free (defined);
227 if (included != (boolean *) NULL)
228 free (included);
229 return false;
230}
231
232/* Add symbols from an ELF object file to the linker hash table. */
233
234static boolean
235elf_link_add_object_symbols (abfd, info)
236 bfd *abfd;
237 struct bfd_link_info *info;
238{
239 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
240 const Elf_Internal_Sym *,
241 const char **, flagword *,
242 asection **, bfd_vma *));
243 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
244 asection *, const Elf_Internal_Rela *));
245 boolean collect;
246 Elf_Internal_Shdr *hdr;
247 size_t symcount;
248 size_t extsymcount;
249 size_t extsymoff;
250 Elf_External_Sym *buf = NULL;
251 struct elf_link_hash_entry **sym_hash;
252 boolean dynamic;
253 Elf_External_Dyn *dynbuf = NULL;
254 struct elf_link_hash_entry *weaks;
255 Elf_External_Sym *esym;
256 Elf_External_Sym *esymend;
257
258 add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
259 collect = get_elf_backend_data (abfd)->collect;
260
0cb70568
ILT		 261 /* As a GNU extension, any input sections which are named
262 .gnu.warning.SYMBOL are treated as warning symbols for the given
263 symbol. This differs from .gnu.warning sections, which generate
264 warnings when they are included in an output file. */
265 if (! info->shared)
266 {
267 asection *s;
268
269 for (s = abfd->sections; s != NULL; s = s->next)
270 {
271 const char *name;
272
273 name = bfd_get_section_name (abfd, s);
274 if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
275 {
276 char *msg;
277 bfd_size_type sz;
278
279 sz = bfd_section_size (abfd, s);
280 msg = (char *) bfd_alloc (abfd, sz);
281 if (msg == NULL)
a9713b91 282 goto error_return;
0cb70568
ILT		 283
284 if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
285 goto error_return;
286
287 if (! (_bfd_generic_link_add_one_symbol
288 (info, abfd,
289 name + sizeof ".gnu.warning." - 1,
290 BSF_WARNING, s, (bfd_vma) 0, msg, false, collect,
291 (struct bfd_link_hash_entry **) NULL)))
292 goto error_return;
293
294 if (! info->relocateable)
295 {
296 /* Clobber the section size so that the warning does
297 not get copied into the output file. */
298 s->_raw_size = 0;
299 }
300 }
301 }
302 }
303
ede4eed4
KR		 304 /* A stripped shared library might only have a dynamic symbol table,
305 not a regular symbol table. In that case we can still go ahead
306 and link using the dynamic symbol table. */
307 if (elf_onesymtab (abfd) == 0
308 && elf_dynsymtab (abfd) != 0)
309 {
310 elf_onesymtab (abfd) = elf_dynsymtab (abfd);
311 elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
312 }
313
314 hdr = &elf_tdata (abfd)->symtab_hdr;
315 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
316
317 /* The sh_info field of the symtab header tells us where the
318 external symbols start. We don't care about the local symbols at
319 this point. */
320 if (elf_bad_symtab (abfd))
321 {
322 extsymcount = symcount;
323 extsymoff = 0;
324 }
325 else
326 {
327 extsymcount = symcount - hdr->sh_info;
328 extsymoff = hdr->sh_info;
329 }
330
331 buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
332 if (buf == NULL && extsymcount != 0)
333 {
334 bfd_set_error (bfd_error_no_memory);
335 goto error_return;
336 }
337
338 /* We store a pointer to the hash table entry for each external
339 symbol. */
340 sym_hash = ((struct elf_link_hash_entry **)
341 bfd_alloc (abfd,
342 extsymcount * sizeof (struct elf_link_hash_entry *)));
343 if (sym_hash == NULL)
a9713b91 344 goto error_return;
ede4eed4
KR		 345 elf_sym_hashes (abfd) = sym_hash;
346
347 if (elf_elfheader (abfd)->e_type != ET_DYN)
348 {
349 dynamic = false;
350
351 /* If we are creating a shared library, create all the dynamic
352 sections immediately. We need to attach them to something,
353 so we attach them to this BFD, provided it is the right
354 format. FIXME: If there are no input BFD's of the same
355 format as the output, we can't make a shared library. */
356 if (info->shared
357 && ! elf_hash_table (info)->dynamic_sections_created
358 && abfd->xvec == info->hash->creator)
359 {
360 if (! elf_link_create_dynamic_sections (abfd, info))
361 goto error_return;
362 }
363 }
364 else
365 {
366 asection *s;
367 boolean add_needed;
368 const char *name;
369 bfd_size_type oldsize;
370 bfd_size_type strindex;
371
372 dynamic = true;
373
374 /* You can't use -r against a dynamic object. Also, there's no
375 hope of using a dynamic object which does not exactly match
376 the format of the output file. */
377 if (info->relocateable
378 || info->hash->creator != abfd->xvec)
379 {
380 bfd_set_error (bfd_error_invalid_operation);
381 goto error_return;
382 }
383
384 /* Find the name to use in a DT_NEEDED entry that refers to this
385 object. If the object has a DT_SONAME entry, we use it.
386 Otherwise, if the generic linker stuck something in
387 elf_dt_needed_name, we use that. Otherwise, we just use the
388 file name. If the generic linker put a null string into
389 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
390 even if there is a DT_SONAME entry. */
391 add_needed = true;
392 name = bfd_get_filename (abfd);
393 if (elf_dt_needed_name (abfd) != NULL)
394 {
395 name = elf_dt_needed_name (abfd);
396 if (*name == '\0')
397 add_needed = false;
398 }
399 s = bfd_get_section_by_name (abfd, ".dynamic");
400 if (s != NULL)
401 {
402 Elf_External_Dyn *extdyn;
403 Elf_External_Dyn *extdynend;
404 int elfsec;
405 unsigned long link;
406
3fe22b98 407 dynbuf = (Elf_External_Dyn *) malloc ((size_t) s->_raw_size);
ede4eed4
KR		 408 if (dynbuf == NULL)
409 {
410 bfd_set_error (bfd_error_no_memory);
411 goto error_return;
412 }
413
414 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
415 (file_ptr) 0, s->_raw_size))
416 goto error_return;
417
418 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
419 if (elfsec == -1)
420 goto error_return;
421 link = elf_elfsections (abfd)[elfsec]->sh_link;
422
423 extdyn = dynbuf;
424 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
425 for (; extdyn < extdynend; extdyn++)
426 {
427 Elf_Internal_Dyn dyn;
428
429 elf_swap_dyn_in (abfd, extdyn, &dyn);
430 if (add_needed && dyn.d_tag == DT_SONAME)
431 {
432 name = bfd_elf_string_from_elf_section (abfd, link,
433 dyn.d_un.d_val);
434 if (name == NULL)
435 goto error_return;
436 }
437 if (dyn.d_tag == DT_NEEDED)
438 {
54406786 439 struct bfd_link_needed_list *n, **pn;
ede4eed4
KR		 440 char *fnm, *anm;
441
54406786
ILT		 442 n = ((struct bfd_link_needed_list *)
443 bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
ede4eed4
KR		 444 fnm = bfd_elf_string_from_elf_section (abfd, link,
445 dyn.d_un.d_val);
446 if (n == NULL || fnm == NULL)
447 goto error_return;
448 anm = bfd_alloc (abfd, strlen (fnm) + 1);
449 if (anm == NULL)
450 goto error_return;
451 strcpy (anm, fnm);
452 n->name = anm;
453 n->by = abfd;
454 n->next = NULL;
455 for (pn = &elf_hash_table (info)->needed;
456 *pn != NULL;
457 pn = &(*pn)->next)
458 ;
459 *pn = n;
460 }
461 }
462
463 free (dynbuf);
464 dynbuf = NULL;
465 }
466
467 /* We do not want to include any of the sections in a dynamic
468 object in the output file. We hack by simply clobbering the
469 list of sections in the BFD. This could be handled more
470 cleanly by, say, a new section flag; the existing
471 SEC_NEVER_LOAD flag is not the one we want, because that one
472 still implies that the section takes up space in the output
473 file. */
474 abfd->sections = NULL;
475
476 /* If this is the first dynamic object found in the link, create
477 the special sections required for dynamic linking. */
478 if (! elf_hash_table (info)->dynamic_sections_created)
479 {
480 if (! elf_link_create_dynamic_sections (abfd, info))
481 goto error_return;
482 }
483
484 if (add_needed)
485 {
486 /* Add a DT_NEEDED entry for this dynamic object. */
487 oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
488 strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
489 true, false);
490 if (strindex == (bfd_size_type) -1)
491 goto error_return;
492
493 if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
494 {
495 asection *sdyn;
496 Elf_External_Dyn *dyncon, *dynconend;
497
498 /* The hash table size did not change, which means that
499 the dynamic object name was already entered. If we
500 have already included this dynamic object in the
501 link, just ignore it. There is no reason to include
502 a particular dynamic object more than once. */
503 sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
504 ".dynamic");
505 BFD_ASSERT (sdyn != NULL);
506
507 dyncon = (Elf_External_Dyn *) sdyn->contents;
508 dynconend = (Elf_External_Dyn *) (sdyn->contents +
509 sdyn->_raw_size);
510 for (; dyncon < dynconend; dyncon++)
511 {
512 Elf_Internal_Dyn dyn;
513
514 elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
515 &dyn);
516 if (dyn.d_tag == DT_NEEDED
517 && dyn.d_un.d_val == strindex)
518 {
519 if (buf != NULL)
520 free (buf);
521 return true;
522 }
523 }
524 }
525
526 if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
527 goto error_return;
528 }
529 }
530
531 if (bfd_seek (abfd,
532 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
533 SEEK_SET) != 0
534 || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
535 != extsymcount * sizeof (Elf_External_Sym)))
536 goto error_return;
537
538 weaks = NULL;
539
540 esymend = buf + extsymcount;
541 for (esym = buf; esym < esymend; esym++, sym_hash++)
542 {
543 Elf_Internal_Sym sym;
544 int bind;
545 bfd_vma value;
546 asection *sec;
547 flagword flags;
548 const char *name;
0cb70568 549 struct elf_link_hash_entry *h;
ede4eed4 550 boolean definition;
ee9f09cd 551 boolean size_change_ok, type_change_ok;
452a5efb 552 boolean new_weakdef;
ede4eed4
KR		 553
554 elf_swap_symbol_in (abfd, esym, &sym);
555
556 flags = BSF_NO_FLAGS;
557 sec = NULL;
558 value = sym.st_value;
559 *sym_hash = NULL;
560
561 bind = ELF_ST_BIND (sym.st_info);
562 if (bind == STB_LOCAL)
563 {
564 /* This should be impossible, since ELF requires that all
565 global symbols follow all local symbols, and that sh_info
566 point to the first global symbol. Unfortunatealy, Irix 5
567 screws this up. */
568 continue;
569 }
570 else if (bind == STB_GLOBAL)
571 {
572 if (sym.st_shndx != SHN_UNDEF
573 && sym.st_shndx != SHN_COMMON)
574 flags = BSF_GLOBAL;
575 else
576 flags = 0;
577 }
578 else if (bind == STB_WEAK)
579 flags = BSF_WEAK;
580 else
581 {
582 /* Leave it up to the processor backend. */
583 }
584
585 if (sym.st_shndx == SHN_UNDEF)
586 sec = bfd_und_section_ptr;
587 else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
588 {
589 sec = section_from_elf_index (abfd, sym.st_shndx);
590 if (sec != NULL)
591 value -= sec->vma;
592 else
593 sec = bfd_abs_section_ptr;
594 }
595 else if (sym.st_shndx == SHN_ABS)
596 sec = bfd_abs_section_ptr;
597 else if (sym.st_shndx == SHN_COMMON)
598 {
599 sec = bfd_com_section_ptr;
600 /* What ELF calls the size we call the value. What ELF
601 calls the value we call the alignment. */
602 value = sym.st_size;
603 }
604 else
605 {
606 /* Leave it up to the processor backend. */
607 }
608
609 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
610 if (name == (const char *) NULL)
611 goto error_return;
612
613 if (add_symbol_hook)
614 {
615 if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
616 &value))
617 goto error_return;
618
619 /* The hook function sets the name to NULL if this symbol
620 should be skipped for some reason. */
621 if (name == (const char *) NULL)
622 continue;
623 }
624
625 /* Sanity check that all possibilities were handled. */
626 if (sec == (asection *) NULL)
627 {
628 bfd_set_error (bfd_error_bad_value);
629 goto error_return;
630 }
631
632 if (bfd_is_und_section (sec)
633 || bfd_is_com_section (sec))
634 definition = false;
635 else
636 definition = true;
637
ee9f09cd
ILT		 638 size_change_ok = false;
639 type_change_ok = false;
ede4eed4
KR		 640 if (info->hash->creator->flavour == bfd_target_elf_flavour)
641 {
642 /* We need to look up the symbol now in order to get some of
643 the dynamic object handling right. We pass the hash
644 table entry in to _bfd_generic_link_add_one_symbol so
645 that it does not have to look it up again. */
646 h = elf_link_hash_lookup (elf_hash_table (info), name,
647 true, false, false);
648 if (h == NULL)
649 goto error_return;
650 *sym_hash = h;
651
0cb70568
ILT		 652 while (h->root.type == bfd_link_hash_indirect
653 || h->root.type == bfd_link_hash_warning)
654 h = (struct elf_link_hash_entry *) h->root.u.i.link;
655
ee9f09cd
ILT		 656 /* It's OK to change the type if it used to be a weak
657 definition. */
658 type_change_ok = (h->root.type == bfd_link_hash_defweak
659 || h->root.type == bfd_link_hash_undefweak);
660
661 /* It's OK to change the size if it used to be a weak
662 definition, or if it used to be undefined, or if we will
663 be overriding an old definition.
664 */
665 size_change_ok = (type_change_ok
666 || h->root.type == bfd_link_hash_undefined);
8235c112 667
ede4eed4
KR		 668 /* If we are looking at a dynamic object, and this is a
669 definition, we need to see if it has already been defined
670 by some other object. If it has, we want to use the
671 existing definition, and we do not want to report a
672 multiple symbol definition error; we do this by
673 clobbering sec to be bfd_und_section_ptr. */
674 if (dynamic && definition)
675 {
676 if (h->root.type == bfd_link_hash_defined
3d7c42c9
ILT		 677 || h->root.type == bfd_link_hash_defweak
678 || (h->root.type == bfd_link_hash_common
679 && bind == STB_WEAK))
680 {
681 sec = bfd_und_section_ptr;
682 definition = false;
ee9f09cd 683 size_change_ok = true;
3d7c42c9 684 }
ede4eed4
KR		 685 }
686
687 /* Similarly, if we are not looking at a dynamic object, and
688 we have a definition, we want to override any definition
689 we may have from a dynamic object. Symbols from regular
690 files always take precedence over symbols from dynamic
691 objects, even if they are defined after the dynamic
692 object in the link. */
693 if (! dynamic
694 && definition
695 && (h->root.type == bfd_link_hash_defined
696 || h->root.type == bfd_link_hash_defweak)
697 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
698 && (bfd_get_flavour (h->root.u.def.section->owner)
699 == bfd_target_elf_flavour)
700 && (elf_elfheader (h->root.u.def.section->owner)->e_type
701 == ET_DYN))
702 {
703 /* Change the hash table entry to undefined, and let
704 _bfd_generic_link_add_one_symbol do the right thing
705 with the new definition. */
706 h->root.type = bfd_link_hash_undefined;
707 h->root.u.undef.abfd = h->root.u.def.section->owner;
ee9f09cd 708 size_change_ok = true;
ede4eed4
KR		 709 }
710 }
711
712 if (! (_bfd_generic_link_add_one_symbol
713 (info, abfd, name, flags, sec, value, (const char *) NULL,
714 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
715 goto error_return;
716
0cb70568
ILT		 717 h = *sym_hash;
718 while (h->root.type == bfd_link_hash_indirect
719 || h->root.type == bfd_link_hash_warning)
720 h = (struct elf_link_hash_entry *) h->root.u.i.link;
721 *sym_hash = h;
722
452a5efb 723 new_weakdef = false;
ede4eed4
KR		 724 if (dynamic
725 && definition
726 && (flags & BSF_WEAK) != 0
727 && ELF_ST_TYPE (sym.st_info) != STT_FUNC
728 && info->hash->creator->flavour == bfd_target_elf_flavour
0cb70568 729 && h->weakdef == NULL)
ede4eed4
KR		 730 {
731 /* Keep a list of all weak defined non function symbols from
732 a dynamic object, using the weakdef field. Later in this
733 function we will set the weakdef field to the correct
734 value. We only put non-function symbols from dynamic
735 objects on this list, because that happens to be the only
736 time we need to know the normal symbol corresponding to a
737 weak symbol, and the information is time consuming to
738 figure out. If the weakdef field is not already NULL,
739 then this symbol was already defined by some previous
740 dynamic object, and we will be using that previous
741 definition anyhow. */
742
0cb70568
ILT		 743 h->weakdef = weaks;
744 weaks = h;
452a5efb 745 new_weakdef = true;
ede4eed4
KR		 746 }
747
748 /* Get the alignment of a common symbol. */
749 if (sym.st_shndx == SHN_COMMON
0cb70568
ILT		 750 && h->root.type == bfd_link_hash_common)
751 h->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
ede4eed4
KR		 752
753 if (info->hash->creator->flavour == bfd_target_elf_flavour)
754 {
755 int old_flags;
756 boolean dynsym;
757 int new_flag;
758
759 /* Remember the symbol size and type. */
3d7c42c9
ILT		 760 if (sym.st_size != 0
761 && (definition || h->size == 0))
ede4eed4 762 {
ee9f09cd 763 if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
3d7c42c9
ILT		 764 (*_bfd_error_handler)
765 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
766 name, (unsigned long) h->size, (unsigned long) sym.st_size,
767 bfd_get_filename (abfd));
768
ede4eed4
KR		 769 h->size = sym.st_size;
770 }
3d7c42c9
ILT		 771 if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
772 && (definition || h->type == STT_NOTYPE))
ede4eed4 773 {
3d7c42c9 774 if (h->type != STT_NOTYPE
8235c112 775 && h->type != ELF_ST_TYPE (sym.st_info)
ee9f09cd 776 && ! type_change_ok)
3d7c42c9
ILT		 777 (*_bfd_error_handler)
778 ("Warning: type of symbol `%s' changed from %d to %d in %s",
779 name, h->type, ELF_ST_TYPE (sym.st_info),
780 bfd_get_filename (abfd));
781
ede4eed4
KR		 782 h->type = ELF_ST_TYPE (sym.st_info);
783 }
784
785 /* Set a flag in the hash table entry indicating the type of
786 reference or definition we just found. Keep a count of
787 the number of dynamic symbols we find. A dynamic symbol
788 is one which is referenced or defined by both a regular
789 object and a shared object, or one which is referenced or
790 defined by more than one shared object. */
791 old_flags = h->elf_link_hash_flags;
792 dynsym = false;
793 if (! dynamic)
794 {
795 if (! definition)
796 new_flag = ELF_LINK_HASH_REF_REGULAR;
797 else
798 new_flag = ELF_LINK_HASH_DEF_REGULAR;
799 if (info->shared
800 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
801 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
802 dynsym = true;
803 }
804 else
805 {
806 if (! definition)
807 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
808 else
809 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
810 if ((old_flags & new_flag) != 0
811 || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
452a5efb
ILT		 812 | ELF_LINK_HASH_REF_REGULAR)) != 0
813 || (h->weakdef != NULL
814 && (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
815 | ELF_LINK_HASH_REF_DYNAMIC)) != 0))
ede4eed4
KR		 816 dynsym = true;
817 }
818
819 h->elf_link_hash_flags |= new_flag;
820 if (dynsym && h->dynindx == -1)
821 {
822 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
823 goto error_return;
452a5efb
ILT		 824 if (h->weakdef != NULL
825 && ! new_weakdef
826 && h->weakdef->dynindx == -1)
827 {
828 if (! _bfd_elf_link_record_dynamic_symbol (info,
829 h->weakdef))
830 goto error_return;
831 }
ede4eed4
KR		 832 }
833 }
834 }
835
836 /* Now set the weakdefs field correctly for all the weak defined
837 symbols we found. The only way to do this is to search all the
838 symbols. Since we only need the information for non functions in
839 dynamic objects, that's the only time we actually put anything on
840 the list WEAKS. We need this information so that if a regular
841 object refers to a symbol defined weakly in a dynamic object, the
842 real symbol in the dynamic object is also put in the dynamic
843 symbols; we also must arrange for both symbols to point to the
844 same memory location. We could handle the general case of symbol
845 aliasing, but a general symbol alias can only be generated in
846 assembler code, handling it correctly would be very time
847 consuming, and other ELF linkers don't handle general aliasing
848 either. */
849 while (weaks != NULL)
850 {
851 struct elf_link_hash_entry *hlook;
852 asection *slook;
853 bfd_vma vlook;
854 struct elf_link_hash_entry **hpp;
855 struct elf_link_hash_entry **hppend;
856
857 hlook = weaks;
858 weaks = hlook->weakdef;
859 hlook->weakdef = NULL;
860
861 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
862 || hlook->root.type == bfd_link_hash_defweak
863 || hlook->root.type == bfd_link_hash_common
864 || hlook->root.type == bfd_link_hash_indirect);
865 slook = hlook->root.u.def.section;
866 vlook = hlook->root.u.def.value;
867
868 hpp = elf_sym_hashes (abfd);
869 hppend = hpp + extsymcount;
870 for (; hpp < hppend; hpp++)
871 {
872 struct elf_link_hash_entry *h;
873
874 h = *hpp;
875 if (h != NULL && h != hlook
876 && (h->root.type == bfd_link_hash_defined
877 || h->root.type == bfd_link_hash_defweak)
878 && h->root.u.def.section == slook
879 && h->root.u.def.value == vlook)
880 {
881 hlook->weakdef = h;
882
883 /* If the weak definition is in the list of dynamic
884 symbols, make sure the real definition is put there
885 as well. */
886 if (hlook->dynindx != -1
887 && h->dynindx == -1)
888 {
889 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
890 goto error_return;
891 }
892
893 break;
894 }
895 }
896 }
897
898 if (buf != NULL)
899 {
900 free (buf);
901 buf = NULL;
902 }
903
904 /* If this object is the same format as the output object, and it is
905 not a shared library, then let the backend look through the
906 relocs.
907
908 This is required to build global offset table entries and to
909 arrange for dynamic relocs. It is not required for the
910 particular common case of linking non PIC code, even when linking
911 against shared libraries, but unfortunately there is no way of
912 knowing whether an object file has been compiled PIC or not.
913 Looking through the relocs is not particularly time consuming.
914 The problem is that we must either (1) keep the relocs in memory,
915 which causes the linker to require additional runtime memory or
916 (2) read the relocs twice from the input file, which wastes time.
917 This would be a good case for using mmap.
918
919 I have no idea how to handle linking PIC code into a file of a
920 different format. It probably can't be done. */
921 check_relocs = get_elf_backend_data (abfd)->check_relocs;
922 if (! dynamic
923 && abfd->xvec == info->hash->creator
924 && check_relocs != NULL)
925 {
926 asection *o;
927
928 for (o = abfd->sections; o != NULL; o = o->next)
929 {
930 Elf_Internal_Rela *internal_relocs;
931 boolean ok;
932
933 if ((o->flags & SEC_RELOC) == 0
934 || o->reloc_count == 0)
935 continue;
936
937 /* I believe we can ignore the relocs for any section which
938 does not form part of the final process image, such as a
939 debugging section. */
940 if ((o->flags & SEC_ALLOC) == 0)
941 continue;
942
943 internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
944 (Elf_Internal_Rela *) NULL,
945 info->keep_memory);
946 if (internal_relocs == NULL)
947 goto error_return;
948
949 ok = (*check_relocs) (abfd, info, o, internal_relocs);
950
951 if (! info->keep_memory)
952 free (internal_relocs);
953
954 if (! ok)
955 goto error_return;
956 }
957 }
958
959 return true;
960
961 error_return:
962 if (buf != NULL)
963 free (buf);
964 if (dynbuf != NULL)
965 free (dynbuf);
966 return false;
967}
968
969/* Create some sections which will be filled in with dynamic linking
970 information. ABFD is an input file which requires dynamic sections
971 to be created. The dynamic sections take up virtual memory space
972 when the final executable is run, so we need to create them before
973 addresses are assigned to the output sections. We work out the
974 actual contents and size of these sections later. */
975
976boolean
977elf_link_create_dynamic_sections (abfd, info)
978 bfd *abfd;
979 struct bfd_link_info *info;
980{
981 flagword flags;
982 register asection *s;
983 struct elf_link_hash_entry *h;
984 struct elf_backend_data *bed;
985
986 if (elf_hash_table (info)->dynamic_sections_created)
987 return true;
988
989 /* Make sure that all dynamic sections use the same input BFD. */
990 if (elf_hash_table (info)->dynobj == NULL)
991 elf_hash_table (info)->dynobj = abfd;
992 else
993 abfd = elf_hash_table (info)->dynobj;
994
995 /* Note that we set the SEC_IN_MEMORY flag for all of these
996 sections. */
997 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
998
999 /* A dynamically linked executable has a .interp section, but a
1000 shared library does not. */
1001 if (! info->shared)
1002 {
1003 s = bfd_make_section (abfd, ".interp");
1004 if (s == NULL
1005 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1006 return false;
1007 }
1008
1009 s = bfd_make_section (abfd, ".dynsym");
1010 if (s == NULL
1011 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1012 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1013 return false;
1014
1015 s = bfd_make_section (abfd, ".dynstr");
1016 if (s == NULL
1017 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1018 return false;
1019
1020 /* Create a strtab to hold the dynamic symbol names. */
1021 if (elf_hash_table (info)->dynstr == NULL)
1022 {
1023 elf_hash_table (info)->dynstr = elf_stringtab_init ();
1024 if (elf_hash_table (info)->dynstr == NULL)
1025 return false;
1026 }
1027
1028 s = bfd_make_section (abfd, ".dynamic");
1029 if (s == NULL
1030 || ! bfd_set_section_flags (abfd, s, flags)
1031 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1032 return false;
1033
1034 /* The special symbol _DYNAMIC is always set to the start of the
1035 .dynamic section. This call occurs before we have processed the
1036 symbols for any dynamic object, so we don't have to worry about
1037 overriding a dynamic definition. We could set _DYNAMIC in a
1038 linker script, but we only want to define it if we are, in fact,
1039 creating a .dynamic section. We don't want to define it if there
1040 is no .dynamic section, since on some ELF platforms the start up
1041 code examines it to decide how to initialize the process. */
1042 h = NULL;
1043 if (! (_bfd_generic_link_add_one_symbol
1044 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1045 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1046 (struct bfd_link_hash_entry **) &h)))
1047 return false;
1048 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1049 h->type = STT_OBJECT;
1050
1051 if (info->shared
1052 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1053 return false;
1054
1055 s = bfd_make_section (abfd, ".hash");
1056 if (s == NULL
1057 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1058 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1059 return false;
1060
1061 /* Let the backend create the rest of the sections. This lets the
1062 backend set the right flags. The backend will normally create
1063 the .got and .plt sections. */
1064 bed = get_elf_backend_data (abfd);
1065 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1066 return false;
1067
1068 elf_hash_table (info)->dynamic_sections_created = true;
1069
1070 return true;
1071}
1072
1073/* Add an entry to the .dynamic table. */
1074
1075boolean
1076elf_add_dynamic_entry (info, tag, val)
1077 struct bfd_link_info *info;
1078 bfd_vma tag;
1079 bfd_vma val;
1080{
1081 Elf_Internal_Dyn dyn;
1082 bfd *dynobj;
1083 asection *s;
1084 size_t newsize;
1085 bfd_byte *newcontents;
1086
1087 dynobj = elf_hash_table (info)->dynobj;
1088
1089 s = bfd_get_section_by_name (dynobj, ".dynamic");
1090 BFD_ASSERT (s != NULL);
1091
1092 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1093 if (s->contents == NULL)
1094 newcontents = (bfd_byte *) malloc (newsize);
1095 else
1096 newcontents = (bfd_byte *) realloc (s->contents, newsize);
1097 if (newcontents == NULL)
1098 {
1099 bfd_set_error (bfd_error_no_memory);
1100 return false;
1101 }
1102
1103 dyn.d_tag = tag;
1104 dyn.d_un.d_val = val;
1105 elf_swap_dyn_out (dynobj, &dyn,
1106 (Elf_External_Dyn *) (newcontents + s->_raw_size));
1107
1108 s->_raw_size = newsize;
1109 s->contents = newcontents;
1110
1111 return true;
1112}
1113
1114/* Read and swap the relocs for a section. They may have been cached.
1115 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1116 they are used as buffers to read into. They are known to be large
1117 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1118 value is allocated using either malloc or bfd_alloc, according to
1119 the KEEP_MEMORY argument. */
1120
1121static Elf_Internal_Rela *
1122elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1123 bfd *abfd;
1124 asection *o;
1125 PTR external_relocs;
1126 Elf_Internal_Rela *internal_relocs;
1127 boolean keep_memory;
1128{
1129 Elf_Internal_Shdr *rel_hdr;
1130 PTR alloc1 = NULL;
1131 Elf_Internal_Rela *alloc2 = NULL;
1132
1133 if (elf_section_data (o)->relocs != NULL)
1134 return elf_section_data (o)->relocs;
1135
1136 if (o->reloc_count == 0)
1137 return NULL;
1138
1139 rel_hdr = &elf_section_data (o)->rel_hdr;
1140
1141 if (internal_relocs == NULL)
1142 {
1143 size_t size;
1144
1145 size = o->reloc_count * sizeof (Elf_Internal_Rela);
1146 if (keep_memory)
1147 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1148 else
1149 internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
1150 if (internal_relocs == NULL)
1151 {
1152 bfd_set_error (bfd_error_no_memory);
1153 goto error_return;
1154 }
1155 }
1156
1157 if (external_relocs == NULL)
1158 {
3fe22b98 1159 alloc1 = (PTR) malloc ((size_t) rel_hdr->sh_size);
ede4eed4
KR		 1160 if (alloc1 == NULL)
1161 {
1162 bfd_set_error (bfd_error_no_memory);
1163 goto error_return;
1164 }
1165 external_relocs = alloc1;
1166 }
1167
1168 if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1169 || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1170 != rel_hdr->sh_size))
1171 goto error_return;
1172
1173 /* Swap in the relocs. For convenience, we always produce an
1174 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1175 to 0. */
1176 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1177 {
1178 Elf_External_Rel *erel;
1179 Elf_External_Rel *erelend;
1180 Elf_Internal_Rela *irela;
1181
1182 erel = (Elf_External_Rel *) external_relocs;
1183 erelend = erel + o->reloc_count;
1184 irela = internal_relocs;
1185 for (; erel < erelend; erel++, irela++)
1186 {
1187 Elf_Internal_Rel irel;
1188
1189 elf_swap_reloc_in (abfd, erel, &irel);
1190 irela->r_offset = irel.r_offset;
1191 irela->r_info = irel.r_info;
1192 irela->r_addend = 0;
1193 }
1194 }
1195 else
1196 {
1197 Elf_External_Rela *erela;
1198 Elf_External_Rela *erelaend;
1199 Elf_Internal_Rela *irela;
1200
1201 BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1202
1203 erela = (Elf_External_Rela *) external_relocs;
1204 erelaend = erela + o->reloc_count;
1205 irela = internal_relocs;
1206 for (; erela < erelaend; erela++, irela++)
1207 elf_swap_reloca_in (abfd, erela, irela);
1208 }
1209
1210 /* Cache the results for next time, if we can. */
1211 if (keep_memory)
1212 elf_section_data (o)->relocs = internal_relocs;
1213
1214 if (alloc1 != NULL)
1215 free (alloc1);
1216
1217 /* Don't free alloc2, since if it was allocated we are passing it
1218 back (under the name of internal_relocs). */
1219
1220 return internal_relocs;
1221
1222 error_return:
1223 if (alloc1 != NULL)
1224 free (alloc1);
1225 if (alloc2 != NULL)
1226 free (alloc2);
1227 return NULL;
1228}
1229
1230/* Record an assignment to a symbol made by a linker script. We need
1231 this in case some dynamic object refers to this symbol. */
1232
1233/*ARGSUSED*/
1234boolean
1235NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1236 bfd *output_bfd;
1237 struct bfd_link_info *info;
1238 const char *name;
1239 boolean provide;
1240{
1241 struct elf_link_hash_entry *h;
1242
1243 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1244 return true;
1245
1246 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1247 if (h == NULL)
1248 return false;
1249
1250 /* If this symbol is being provided by the linker script, and it is
1251 currently defined by a dynamic object, but not by a regular
1252 object, then mark it as undefined so that the generic linker will
1253 force the correct value. */
1254 if (provide
1255 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1256 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1257 h->root.type = bfd_link_hash_undefined;
1258
1259 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1260 h->type = STT_OBJECT;
1261
1262 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1263 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1264 || info->shared)
1265 && h->dynindx == -1)
1266 {
1267 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1268 return false;
1269
1270 /* If this is a weak defined symbol, and we know a corresponding
1271 real symbol from the same dynamic object, make sure the real
1272 symbol is also made into a dynamic symbol. */
1273 if (h->weakdef != NULL
1274 && h->weakdef->dynindx == -1)
1275 {
1276 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1277 return false;
1278 }
1279 }
1280
1281 return true;
1282}
1283
1284/* Array used to determine the number of hash table buckets to use
1285 based on the number of symbols there are. If there are fewer than
1286 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1287 fewer than 37 we use 17 buckets, and so forth. We never use more
1288 than 521 buckets. */
1289
1290static const size_t elf_buckets[] =
1291{
1292 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1293};
1294
1295/* Set up the sizes and contents of the ELF dynamic sections. This is
1296 called by the ELF linker emulation before_allocation routine. We
1297 must set the sizes of the sections before the linker sets the
1298 addresses of the various sections. */
1299
1300boolean
1301NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1302 export_dynamic, info, sinterpptr)
1303 bfd *output_bfd;
1304 const char *soname;
1305 const char *rpath;
1306 boolean export_dynamic;
1307 struct bfd_link_info *info;
1308 asection **sinterpptr;
1309{
1310 bfd *dynobj;
1311 struct elf_backend_data *bed;
1312
1313 *sinterpptr = NULL;
1314
1315 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1316 return true;
1317
1318 dynobj = elf_hash_table (info)->dynobj;
1319
1320 /* If there were no dynamic objects in the link, there is nothing to
1321 do here. */
1322 if (dynobj == NULL)
1323 return true;
1324
1325 /* If we are supposed to export all symbols into the dynamic symbol
1326 table (this is not the normal case), then do so. */
1327 if (export_dynamic)
1328 {
1329 struct elf_info_failed eif;
1330
1331 eif.failed = false;
1332 eif.info = info;
1333 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1334 (PTR) &eif);
1335 if (eif.failed)
1336 return false;
1337 }
1338
1339 if (elf_hash_table (info)->dynamic_sections_created)
1340 {
1341 struct elf_info_failed eif;
73a68447 1342 struct elf_link_hash_entry *h;
ede4eed4
KR		 1343 bfd_size_type strsize;
1344
1345 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1346 BFD_ASSERT (*sinterpptr != NULL || info->shared);
1347
1348 if (soname != NULL)
1349 {
1350 bfd_size_type indx;
1351
1352 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1353 true, true);
1354 if (indx == (bfd_size_type) -1
1355 || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1356 return false;
1357 }
1358
951fe66d
ILT		 1359 if (info->symbolic)
1360 {
1361 if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
1362 return false;
1363 }
1364
ede4eed4
KR		 1365 if (rpath != NULL)
1366 {
1367 bfd_size_type indx;
1368
1369 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1370 true, true);
1371 if (indx == (bfd_size_type) -1
1372 || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1373 return false;
1374 }
1375
1376 /* Find all symbols which were defined in a dynamic object and make
1377 the backend pick a reasonable value for them. */
1378 eif.failed = false;
1379 eif.info = info;
1380 elf_link_hash_traverse (elf_hash_table (info),
1381 elf_adjust_dynamic_symbol,
1382 (PTR) &eif);
1383 if (eif.failed)
1384 return false;
1385
1386 /* Add some entries to the .dynamic section. We fill in some of the
1387 values later, in elf_bfd_final_link, but we must add the entries
1388 now so that we know the final size of the .dynamic section. */
73a68447
ILT		 1389 h = elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1390 false, false);
1391 if (h != NULL
1392 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1393 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
ede4eed4
KR		 1394 {
1395 if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1396 return false;
1397 }
73a68447
ILT		 1398 h = elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1399 false, false);
1400 if (h != NULL
1401 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1402 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
ede4eed4
KR		 1403 {
1404 if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1405 return false;
1406 }
1407 strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1408 if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1409 || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1410 || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1411 || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1412 || ! elf_add_dynamic_entry (info, DT_SYMENT,
1413 sizeof (Elf_External_Sym)))
1414 return false;
1415 }
1416
1417 /* The backend must work out the sizes of all the other dynamic
1418 sections. */
1419 bed = get_elf_backend_data (output_bfd);
1420 if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1421 return false;
1422
1423 if (elf_hash_table (info)->dynamic_sections_created)
1424 {
1425 size_t dynsymcount;
1426 asection *s;
1427 size_t i;
1428 size_t bucketcount = 0;
1429 Elf_Internal_Sym isym;
1430
1431 /* Set the size of the .dynsym and .hash sections. We counted
1432 the number of dynamic symbols in elf_link_add_object_symbols.
1433 We will build the contents of .dynsym and .hash when we build
1434 the final symbol table, because until then we do not know the
1435 correct value to give the symbols. We built the .dynstr
1436 section as we went along in elf_link_add_object_symbols. */
1437 dynsymcount = elf_hash_table (info)->dynsymcount;
1438 s = bfd_get_section_by_name (dynobj, ".dynsym");
1439 BFD_ASSERT (s != NULL);
1440 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1441 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1442 if (s->contents == NULL && s->_raw_size != 0)
a9713b91 1443 return false;
ede4eed4
KR		 1444
1445 /* The first entry in .dynsym is a dummy symbol. */
1446 isym.st_value = 0;
1447 isym.st_size = 0;
1448 isym.st_name = 0;
1449 isym.st_info = 0;
1450 isym.st_other = 0;
1451 isym.st_shndx = 0;
1452 elf_swap_symbol_out (output_bfd, &isym,
cf9fb9f2 1453 (PTR) (Elf_External_Sym *) s->contents);
ede4eed4
KR		 1454
1455 for (i = 0; elf_buckets[i] != 0; i++)
1456 {
1457 bucketcount = elf_buckets[i];
1458 if (dynsymcount < elf_buckets[i + 1])
1459 break;
1460 }
1461
1462 s = bfd_get_section_by_name (dynobj, ".hash");
1463 BFD_ASSERT (s != NULL);
1464 s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1465 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1466 if (s->contents == NULL)
a9713b91 1467 return false;
3fe22b98 1468 memset (s->contents, 0, (size_t) s->_raw_size);
ede4eed4
KR		 1469
1470 put_word (output_bfd, bucketcount, s->contents);
1471 put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1472
1473 elf_hash_table (info)->bucketcount = bucketcount;
1474
1475 s = bfd_get_section_by_name (dynobj, ".dynstr");
1476 BFD_ASSERT (s != NULL);
1477 s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1478
1479 if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1480 return false;
1481 }
1482
1483 return true;
1484}
1485
1486/* This routine is used to export all defined symbols into the dynamic
1487 symbol table. It is called via elf_link_hash_traverse. */
1488
1489static boolean
1490elf_export_symbol (h, data)
1491 struct elf_link_hash_entry *h;
1492 PTR data;
1493{
1494 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1495
1496 if (h->dynindx == -1
1497 && (h->elf_link_hash_flags
1498 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1499 {
1500 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1501 {
1502 eif->failed = true;
1503 return false;
1504 }
1505 }
1506
1507 return true;
1508}
1509
1510/* Make the backend pick a good value for a dynamic symbol. This is
1511 called via elf_link_hash_traverse, and also calls itself
1512 recursively. */
1513
1514static boolean
1515elf_adjust_dynamic_symbol (h, data)
1516 struct elf_link_hash_entry *h;
1517 PTR data;
1518{
1519 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1520 bfd *dynobj;
1521 struct elf_backend_data *bed;
1522
951fe66d
ILT		 1523 /* If -Bsymbolic was used (which means to bind references to global
1524 symbols to the definition within the shared object), and this
1525 symbol was defined in a regular object, then it actually doesn't
1526 need a PLT entry. */
1527 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1528 && eif->info->shared
1529 && eif->info->symbolic
1530 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1531 h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
1532
ede4eed4
KR		 1533 /* If this symbol does not require a PLT entry, and it is not
1534 defined by a dynamic object, or is not referenced by a regular
452a5efb
ILT		 1535 object, ignore it. We do have to handle a weak defined symbol,
1536 even if no regular object refers to it, if we decided to add it
1537 to the dynamic symbol table. FIXME: Do we normally need to worry
1538 about symbols which are defined by one dynamic object and
1539 referenced by another one? */
ede4eed4
KR		 1540 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1541 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1542 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
452a5efb
ILT		 1543 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1544 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
ede4eed4
KR		 1545 return true;
1546
1547 /* If we've already adjusted this symbol, don't do it again. This
1548 can happen via a recursive call. */
1549 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1550 return true;
1551
1552 /* Don't look at this symbol again. Note that we must set this
1553 after checking the above conditions, because we may look at a
1554 symbol once, decide not to do anything, and then get called
1555 recursively later after REF_REGULAR is set below. */
1556 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1557
1558 /* If this is a weak definition, and we know a real definition, and
1559 the real symbol is not itself defined by a regular object file,
1560 then get a good value for the real definition. We handle the
1561 real symbol first, for the convenience of the backend routine.
1562
1563 Note that there is a confusing case here. If the real definition
1564 is defined by a regular object file, we don't get the real symbol
1565 from the dynamic object, but we do get the weak symbol. If the
1566 processor backend uses a COPY reloc, then if some routine in the
1567 dynamic object changes the real symbol, we will not see that
1568 change in the corresponding weak symbol. This is the way other
1569 ELF linkers work as well, and seems to be a result of the shared
1570 library model.
1571
1572 I will clarify this issue. Most SVR4 shared libraries define the
1573 variable _timezone and define timezone as a weak synonym. The
1574 tzset call changes _timezone. If you write
1575 extern int timezone;
1576 int _timezone = 5;
1577 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1578 you might expect that, since timezone is a synonym for _timezone,
1579 the same number will print both times. However, if the processor
1580 backend uses a COPY reloc, then actually timezone will be copied
1581 into your process image, and, since you define _timezone
1582 yourself, _timezone will not. Thus timezone and _timezone will
1583 wind up at different memory locations. The tzset call will set
1584 _timezone, leaving timezone unchanged. */
1585
1586 if (h->weakdef != NULL)
1587 {
1588 struct elf_link_hash_entry *weakdef;
1589
1590 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1591 || h->root.type == bfd_link_hash_defweak);
1592 weakdef = h->weakdef;
1593 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1594 || weakdef->root.type == bfd_link_hash_defweak);
1595 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1596 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1597 {
1598 /* This symbol is defined by a regular object file, so we
1599 will not do anything special. Clear weakdef for the
1600 convenience of the processor backend. */
1601 h->weakdef = NULL;
1602 }
1603 else
1604 {
1605 /* There is an implicit reference by a regular object file
1606 via the weak symbol. */
1607 weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1608 if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1609 return false;
1610 }
1611 }
1612
1613 dynobj = elf_hash_table (eif->info)->dynobj;
1614 bed = get_elf_backend_data (dynobj);
1615 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1616 {
1617 eif->failed = true;
1618 return false;
1619 }
1620
1621 return true;
1622}
1623\f
1624/* Final phase of ELF linker. */
1625
1626/* A structure we use to avoid passing large numbers of arguments. */
1627
1628struct elf_final_link_info
1629{
1630 /* General link information. */
1631 struct bfd_link_info *info;
1632 /* Output BFD. */
1633 bfd *output_bfd;
1634 /* Symbol string table. */
1635 struct bfd_strtab_hash *symstrtab;
1636 /* .dynsym section. */
1637 asection *dynsym_sec;
1638 /* .hash section. */
1639 asection *hash_sec;
1640 /* Buffer large enough to hold contents of any section. */
1641 bfd_byte *contents;
1642 /* Buffer large enough to hold external relocs of any section. */
1643 PTR external_relocs;
1644 /* Buffer large enough to hold internal relocs of any section. */
1645 Elf_Internal_Rela *internal_relocs;
1646 /* Buffer large enough to hold external local symbols of any input
1647 BFD. */
1648 Elf_External_Sym *external_syms;
1649 /* Buffer large enough to hold internal local symbols of any input
1650 BFD. */
1651 Elf_Internal_Sym *internal_syms;
1652 /* Array large enough to hold a symbol index for each local symbol
1653 of any input BFD. */
1654 long *indices;
1655 /* Array large enough to hold a section pointer for each local
1656 symbol of any input BFD. */
1657 asection **sections;
1658 /* Buffer to hold swapped out symbols. */
1659 Elf_External_Sym *symbuf;
1660 /* Number of swapped out symbols in buffer. */
1661 size_t symbuf_count;
1662 /* Number of symbols which fit in symbuf. */
1663 size_t symbuf_size;
1664};
1665
1666static boolean elf_link_output_sym
1667 PARAMS ((struct elf_final_link_info *, const char *,
1668 Elf_Internal_Sym *, asection *));
1669static boolean elf_link_flush_output_syms
1670 PARAMS ((struct elf_final_link_info *));
1671static boolean elf_link_output_extsym
1672 PARAMS ((struct elf_link_hash_entry *, PTR));
1673static boolean elf_link_input_bfd
1674 PARAMS ((struct elf_final_link_info *, bfd *));
1675static boolean elf_reloc_link_order
1676 PARAMS ((bfd *, struct bfd_link_info *, asection *,
1677 struct bfd_link_order *));
1678
1679/* This struct is used to pass information to routines called via
1680 elf_link_hash_traverse which must return failure. */
1681
1682struct elf_finfo_failed
1683{
1684 boolean failed;
1685 struct elf_final_link_info *finfo;
1686};
1687
1688/* Do the final step of an ELF link. */
1689
1690boolean
1691elf_bfd_final_link (abfd, info)
1692 bfd *abfd;
1693 struct bfd_link_info *info;
1694{
1695 boolean dynamic;
1696 bfd *dynobj;
1697 struct elf_final_link_info finfo;
1698 register asection *o;
1699 register struct bfd_link_order *p;
1700 register bfd *sub;
1701 size_t max_contents_size;
1702 size_t max_external_reloc_size;
1703 size_t max_internal_reloc_count;
1704 size_t max_sym_count;
1705 file_ptr off;
1706 Elf_Internal_Sym elfsym;
1707 unsigned int i;
1708 Elf_Internal_Shdr *symtab_hdr;
1709 Elf_Internal_Shdr *symstrtab_hdr;
1710 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1711 struct elf_finfo_failed eif;
1712
1713 if (info->shared)
1714 abfd->flags |= DYNAMIC;
1715
1716 dynamic = elf_hash_table (info)->dynamic_sections_created;
1717 dynobj = elf_hash_table (info)->dynobj;
1718
1719 finfo.info = info;
1720 finfo.output_bfd = abfd;
1721 finfo.symstrtab = elf_stringtab_init ();
1722 if (finfo.symstrtab == NULL)
1723 return false;
1724 if (! dynamic)
1725 {
1726 finfo.dynsym_sec = NULL;
1727 finfo.hash_sec = NULL;
1728 }
1729 else
1730 {
1731 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1732 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1733 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1734 }
1735 finfo.contents = NULL;
1736 finfo.external_relocs = NULL;
1737 finfo.internal_relocs = NULL;
1738 finfo.external_syms = NULL;
1739 finfo.internal_syms = NULL;
1740 finfo.indices = NULL;
1741 finfo.sections = NULL;
1742 finfo.symbuf = NULL;
1743 finfo.symbuf_count = 0;
1744
1745 /* Count up the number of relocations we will output for each output
1746 section, so that we know the sizes of the reloc sections. We
1747 also figure out some maximum sizes. */
1748 max_contents_size = 0;
1749 max_external_reloc_size = 0;
1750 max_internal_reloc_count = 0;
1751 max_sym_count = 0;
1752 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1753 {
1754 o->reloc_count = 0;
1755
1756 for (p = o->link_order_head; p != NULL; p = p->next)
1757 {
1758 if (p->type == bfd_section_reloc_link_order
1759 || p->type == bfd_symbol_reloc_link_order)
1760 ++o->reloc_count;
1761 else if (p->type == bfd_indirect_link_order)
1762 {
1763 asection *sec;
1764
1765 sec = p->u.indirect.section;
1766
1767 if (info->relocateable)
1768 o->reloc_count += sec->reloc_count;
1769
1770 if (sec->_raw_size > max_contents_size)
1771 max_contents_size = sec->_raw_size;
1772 if (sec->_cooked_size > max_contents_size)
1773 max_contents_size = sec->_cooked_size;
1774
1775 /* We are interested in just local symbols, not all
1776 symbols. */
1777 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1778 {
1779 size_t sym_count;
1780
1781 if (elf_bad_symtab (sec->owner))
1782 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1783 / sizeof (Elf_External_Sym));
1784 else
1785 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1786
1787 if (sym_count > max_sym_count)
1788 max_sym_count = sym_count;
1789
1790 if ((sec->flags & SEC_RELOC) != 0)
1791 {
1792 size_t ext_size;
1793
1794 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1795 if (ext_size > max_external_reloc_size)
1796 max_external_reloc_size = ext_size;
1797 if (sec->reloc_count > max_internal_reloc_count)
1798 max_internal_reloc_count = sec->reloc_count;
1799 }
1800 }
1801 }
1802 }
1803
1804 if (o->reloc_count > 0)
1805 o->flags |= SEC_RELOC;
1806 else
1807 {
1808 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1809 set it (this is probably a bug) and if it is set
1810 assign_section_numbers will create a reloc section. */
1811 o->flags &=~ SEC_RELOC;
1812 }
1813
1814 /* If the SEC_ALLOC flag is not set, force the section VMA to
1815 zero. This is done in elf_fake_sections as well, but forcing
1816 the VMA to 0 here will ensure that relocs against these
1817 sections are handled correctly. */
1818 if ((o->flags & SEC_ALLOC) == 0)
1819 o->vma = 0;
1820 }
1821
1822 /* Figure out the file positions for everything but the symbol table
1823 and the relocs. We set symcount to force assign_section_numbers
1824 to create a symbol table. */
1825 abfd->symcount = info->strip == strip_all ? 0 : 1;
1826 BFD_ASSERT (! abfd->output_has_begun);
1827 if (! _bfd_elf_compute_section_file_positions (abfd, info))
1828 goto error_return;
1829
1830 /* That created the reloc sections. Set their sizes, and assign
1831 them file positions, and allocate some buffers. */
1832 for (o = abfd->sections; o != NULL; o = o->next)
1833 {
1834 if ((o->flags & SEC_RELOC) != 0)
1835 {
1836 Elf_Internal_Shdr *rel_hdr;
1837 register struct elf_link_hash_entry **p, **pend;
1838
1839 rel_hdr = &elf_section_data (o)->rel_hdr;
1840
1841 rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1842
1843 /* The contents field must last into write_object_contents,
1844 so we allocate it with bfd_alloc rather than malloc. */
1845 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1846 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
a9713b91 1847 goto error_return;
ede4eed4
KR		 1848
1849 p = ((struct elf_link_hash_entry **)
1850 malloc (o->reloc_count
1851 * sizeof (struct elf_link_hash_entry *)));
1852 if (p == NULL && o->reloc_count != 0)
1853 {
1854 bfd_set_error (bfd_error_no_memory);
1855 goto error_return;
1856 }
1857 elf_section_data (o)->rel_hashes = p;
1858 pend = p + o->reloc_count;
1859 for (; p < pend; p++)
1860 *p = NULL;
1861
1862 /* Use the reloc_count field as an index when outputting the
1863 relocs. */
1864 o->reloc_count = 0;
1865 }
1866 }
1867
1868 _bfd_elf_assign_file_positions_for_relocs (abfd);
1869
1870 /* We have now assigned file positions for all the sections except
1871 .symtab and .strtab. We start the .symtab section at the current
1872 file position, and write directly to it. We build the .strtab
ab276dfa 1873 section in memory. */
ede4eed4
KR		 1874 abfd->symcount = 0;
1875 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1876 /* sh_name is set in prep_headers. */
1877 symtab_hdr->sh_type = SHT_SYMTAB;
1878 symtab_hdr->sh_flags = 0;
1879 symtab_hdr->sh_addr = 0;
1880 symtab_hdr->sh_size = 0;
1881 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1882 /* sh_link is set in assign_section_numbers. */
1883 /* sh_info is set below. */
1884 /* sh_offset is set just below. */
1885 symtab_hdr->sh_addralign = 4; /* FIXME: system dependent? */
1886
1887 off = elf_tdata (abfd)->next_file_pos;
1888 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1889
1890 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1891 incorrect. We do not yet know the size of the .symtab section.
1892 We correct next_file_pos below, after we do know the size. */
1893
1894 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1895 continuously seeking to the right position in the file. */
1896 if (! info->keep_memory || max_sym_count < 20)
1897 finfo.symbuf_size = 20;
1898 else
1899 finfo.symbuf_size = max_sym_count;
1900 finfo.symbuf = ((Elf_External_Sym *)
1901 malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1902 if (finfo.symbuf == NULL)
1903 {
1904 bfd_set_error (bfd_error_no_memory);
1905 goto error_return;
1906 }
1907
1908 /* Start writing out the symbol table. The first symbol is always a
1909 dummy symbol. */
1910 elfsym.st_value = 0;
1911 elfsym.st_size = 0;
1912 elfsym.st_info = 0;
1913 elfsym.st_other = 0;
1914 elfsym.st_shndx = SHN_UNDEF;
1915 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1916 &elfsym, bfd_und_section_ptr))
1917 goto error_return;
1918
1919#if 0
1920 /* Some standard ELF linkers do this, but we don't because it causes
1921 bootstrap comparison failures. */
1922 /* Output a file symbol for the output file as the second symbol.
1923 We output this even if we are discarding local symbols, although
1924 I'm not sure if this is correct. */
1925 elfsym.st_value = 0;
1926 elfsym.st_size = 0;
1927 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
1928 elfsym.st_other = 0;
1929 elfsym.st_shndx = SHN_ABS;
1930 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
1931 &elfsym, bfd_abs_section_ptr))
1932 goto error_return;
1933#endif
1934
1935 /* Output a symbol for each section. We output these even if we are
1936 discarding local symbols, since they are used for relocs. These
1937 symbols have no names. We store the index of each one in the
1938 index field of the section, so that we can find it again when
1939 outputting relocs. */
1940 elfsym.st_value = 0;
1941 elfsym.st_size = 0;
1942 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1943 elfsym.st_other = 0;
1944 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1945 {
1946 o = section_from_elf_index (abfd, i);
1947 if (o != NULL)
1948 o->target_index = abfd->symcount;
1949 elfsym.st_shndx = i;
1950 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1951 &elfsym, o))
1952 goto error_return;
1953 }
1954
1955 /* Allocate some memory to hold information read in from the input
1956 files. */
1957 finfo.contents = (bfd_byte *) malloc (max_contents_size);
1958 finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
1959 finfo.internal_relocs = ((Elf_Internal_Rela *)
1960 malloc (max_internal_reloc_count
1961 * sizeof (Elf_Internal_Rela)));
1962 finfo.external_syms = ((Elf_External_Sym *)
1963 malloc (max_sym_count * sizeof (Elf_External_Sym)));
1964 finfo.internal_syms = ((Elf_Internal_Sym *)
1965 malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
1966 finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
1967 finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
1968 if ((finfo.contents == NULL && max_contents_size != 0)
1969 || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
1970 || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
1971 || (finfo.external_syms == NULL && max_sym_count != 0)
1972 || (finfo.internal_syms == NULL && max_sym_count != 0)
1973 || (finfo.indices == NULL && max_sym_count != 0)
1974 || (finfo.sections == NULL && max_sym_count != 0))
1975 {
1976 bfd_set_error (bfd_error_no_memory);
1977 goto error_return;
1978 }
1979
1980 /* Since ELF permits relocations to be against local symbols, we
1981 must have the local symbols available when we do the relocations.
1982 Since we would rather only read the local symbols once, and we
1983 would rather not keep them in memory, we handle all the
1984 relocations for a single input file at the same time.
1985
1986 Unfortunately, there is no way to know the total number of local
1987 symbols until we have seen all of them, and the local symbol
1988 indices precede the global symbol indices. This means that when
1989 we are generating relocateable output, and we see a reloc against
1990 a global symbol, we can not know the symbol index until we have
1991 finished examining all the local symbols to see which ones we are
1992 going to output. To deal with this, we keep the relocations in
1993 memory, and don't output them until the end of the link. This is
1994 an unfortunate waste of memory, but I don't see a good way around
1995 it. Fortunately, it only happens when performing a relocateable
1996 link, which is not the common case. FIXME: If keep_memory is set
1997 we could write the relocs out and then read them again; I don't
1998 know how bad the memory loss will be. */
1999
2000 for (sub = info->input_bfds; sub != NULL; sub = sub->next)
2001 sub->output_has_begun = false;
2002 for (o = abfd->sections; o != NULL; o = o->next)
2003 {
2004 for (p = o->link_order_head; p != NULL; p = p->next)
2005 {
2006 if (p->type == bfd_indirect_link_order
2007 && (bfd_get_flavour (p->u.indirect.section->owner)
2008 == bfd_target_elf_flavour))
2009 {
2010 sub = p->u.indirect.section->owner;
2011 if (! sub->output_has_begun)
2012 {
2013 if (! elf_link_input_bfd (&finfo, sub))
2014 goto error_return;
2015 sub->output_has_begun = true;
2016 }
2017 }
2018 else if (p->type == bfd_section_reloc_link_order
2019 || p->type == bfd_symbol_reloc_link_order)
2020 {
2021 if (! elf_reloc_link_order (abfd, info, o, p))
2022 goto error_return;
2023 }
2024 else
2025 {
2026 if (! _bfd_default_link_order (abfd, info, o, p))
2027 goto error_return;
2028 }
2029 }
2030 }
2031
2032 /* That wrote out all the local symbols. Finish up the symbol table
2033 with the global symbols. */
2034
2035 /* The sh_info field records the index of the first non local
2036 symbol. */
2037 symtab_hdr->sh_info = abfd->symcount;
2038 if (dynamic)
2039 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
2040
2041 /* We get the global symbols from the hash table. */
2042 eif.failed = false;
2043 eif.finfo = &finfo;
2044 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
2045 (PTR) &eif);
2046 if (eif.failed)
2047 return false;
2048
2049 /* Flush all symbols to the file. */
2050 if (! elf_link_flush_output_syms (&finfo))
2051 return false;
2052
2053 /* Now we know the size of the symtab section. */
2054 off += symtab_hdr->sh_size;
2055
2056 /* Finish up and write out the symbol string table (.strtab)
2057 section. */
2058 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2059 /* sh_name was set in prep_headers. */
2060 symstrtab_hdr->sh_type = SHT_STRTAB;
2061 symstrtab_hdr->sh_flags = 0;
2062 symstrtab_hdr->sh_addr = 0;
2063 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
2064 symstrtab_hdr->sh_entsize = 0;
2065 symstrtab_hdr->sh_link = 0;
2066 symstrtab_hdr->sh_info = 0;
2067 /* sh_offset is set just below. */
2068 symstrtab_hdr->sh_addralign = 1;
2069
2070 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
2071 elf_tdata (abfd)->next_file_pos = off;
2072
2073 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
2074 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
2075 return false;
2076
2077 /* Adjust the relocs to have the correct symbol indices. */
2078 for (o = abfd->sections; o != NULL; o = o->next)
2079 {
2080 struct elf_link_hash_entry **rel_hash;
2081 Elf_Internal_Shdr *rel_hdr;
2082
2083 if ((o->flags & SEC_RELOC) == 0)
2084 continue;
2085
2086 rel_hash = elf_section_data (o)->rel_hashes;
2087 rel_hdr = &elf_section_data (o)->rel_hdr;
2088 for (i = 0; i < o->reloc_count; i++, rel_hash++)
2089 {
2090 if (*rel_hash == NULL)
2091 continue;
2092
2093 BFD_ASSERT ((*rel_hash)->indx >= 0);
2094
2095 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2096 {
2097 Elf_External_Rel *erel;
2098 Elf_Internal_Rel irel;
2099
2100 erel = (Elf_External_Rel *) rel_hdr->contents + i;
2101 elf_swap_reloc_in (abfd, erel, &irel);
2102 irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2103 ELF_R_TYPE (irel.r_info));
2104 elf_swap_reloc_out (abfd, &irel, erel);
2105 }
2106 else
2107 {
2108 Elf_External_Rela *erela;
2109 Elf_Internal_Rela irela;
2110
2111 BFD_ASSERT (rel_hdr->sh_entsize
2112 == sizeof (Elf_External_Rela));
2113
2114 erela = (Elf_External_Rela *) rel_hdr->contents + i;
2115 elf_swap_reloca_in (abfd, erela, &irela);
2116 irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2117 ELF_R_TYPE (irela.r_info));
2118 elf_swap_reloca_out (abfd, &irela, erela);
2119 }
2120 }
2121
2122 /* Set the reloc_count field to 0 to prevent write_relocs from
2123 trying to swap the relocs out itself. */
2124 o->reloc_count = 0;
2125 }
2126
2127 /* If we are linking against a dynamic object, or generating a
2128 shared library, finish up the dynamic linking information. */
2129 if (dynamic)
2130 {
2131 Elf_External_Dyn *dyncon, *dynconend;
2132
2133 /* Fix up .dynamic entries. */
2134 o = bfd_get_section_by_name (dynobj, ".dynamic");
2135 BFD_ASSERT (o != NULL);
2136
2137 dyncon = (Elf_External_Dyn *) o->contents;
2138 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2139 for (; dyncon < dynconend; dyncon++)
2140 {
2141 Elf_Internal_Dyn dyn;
2142 const char *name;
2143 unsigned int type;
2144
2145 elf_swap_dyn_in (dynobj, dyncon, &dyn);
2146
2147 switch (dyn.d_tag)
2148 {
2149 default:
2150 break;
2151
2152 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2153 magic _init and _fini symbols. This is pretty ugly,
2154 but we are compatible. */
2155 case DT_INIT:
2156 name = "_init";
2157 goto get_sym;
2158 case DT_FINI:
2159 name = "_fini";
2160 get_sym:
2161 {
2162 struct elf_link_hash_entry *h;
2163
2164 h = elf_link_hash_lookup (elf_hash_table (info), name,
2165 false, false, true);
d6f672b8
ILT		 2166 if (h != NULL
2167 && (h->root.type == bfd_link_hash_defined
2168 || h->root.type == bfd_link_hash_defweak))
ede4eed4
KR		 2169 {
2170 dyn.d_un.d_val = h->root.u.def.value;
2171 o = h->root.u.def.section;
2172 if (o->output_section != NULL)
2173 dyn.d_un.d_val += (o->output_section->vma
2174 + o->output_offset);
2175 else
d6f672b8
ILT		 2176 {
2177 /* The symbol is imported from another shared
2178 library and does not apply to this one. */
2179 dyn.d_un.d_val = 0;
2180 }
2181
2182 elf_swap_dyn_out (dynobj, &dyn, dyncon);
ede4eed4 2183 }
ede4eed4
KR		 2184 }
2185 break;
2186
2187 case DT_HASH:
2188 name = ".hash";
2189 goto get_vma;
2190 case DT_STRTAB:
2191 name = ".dynstr";
2192 goto get_vma;
2193 case DT_SYMTAB:
2194 name = ".dynsym";
2195 get_vma:
2196 o = bfd_get_section_by_name (abfd, name);
2197 BFD_ASSERT (o != NULL);
2198 dyn.d_un.d_ptr = o->vma;
2199 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2200 break;
2201
2202 case DT_REL:
2203 case DT_RELA:
2204 case DT_RELSZ:
2205 case DT_RELASZ:
2206 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2207 type = SHT_REL;
2208 else
2209 type = SHT_RELA;
2210 dyn.d_un.d_val = 0;
2211 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2212 {
2213 Elf_Internal_Shdr *hdr;
2214
2215 hdr = elf_elfsections (abfd)[i];
2216 if (hdr->sh_type == type
2217 && (hdr->sh_flags & SHF_ALLOC) != 0)
2218 {
2219 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2220 dyn.d_un.d_val += hdr->sh_size;
2221 else
2222 {
2223 if (dyn.d_un.d_val == 0
2224 || hdr->sh_addr < dyn.d_un.d_val)
2225 dyn.d_un.d_val = hdr->sh_addr;
2226 }
2227 }
2228 }
2229 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2230 break;
2231 }
2232 }
2233 }
2234
2235 /* If we have created any dynamic sections, then output them. */
2236 if (dynobj != NULL)
2237 {
2238 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2239 goto error_return;
2240
2241 for (o = dynobj->sections; o != NULL; o = o->next)
2242 {
2243 if ((o->flags & SEC_HAS_CONTENTS) == 0
2244 || o->_raw_size == 0)
2245 continue;
2246 if ((o->flags & SEC_IN_MEMORY) == 0)
2247 {
2248 /* At this point, we are only interested in sections
2249 created by elf_link_create_dynamic_sections. FIXME:
2250 This test is fragile. */
2251 continue;
2252 }
2253 if ((elf_section_data (o->output_section)->this_hdr.sh_type
2254 != SHT_STRTAB)
2255 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2256 {
2257 if (! bfd_set_section_contents (abfd, o->output_section,
2258 o->contents, o->output_offset,
2259 o->_raw_size))
2260 goto error_return;
2261 }
2262 else
2263 {
2264 file_ptr off;
2265
2266 /* The contents of the .dynstr section are actually in a
2267 stringtab. */
2268 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2269 if (bfd_seek (abfd, off, SEEK_SET) != 0
2270 || ! _bfd_stringtab_emit (abfd,
2271 elf_hash_table (info)->dynstr))
2272 goto error_return;
2273 }
2274 }
2275 }
2276
2277 if (finfo.symstrtab != NULL)
2278 _bfd_stringtab_free (finfo.symstrtab);
2279 if (finfo.contents != NULL)
2280 free (finfo.contents);
2281 if (finfo.external_relocs != NULL)
2282 free (finfo.external_relocs);
2283 if (finfo.internal_relocs != NULL)
2284 free (finfo.internal_relocs);
2285 if (finfo.external_syms != NULL)
2286 free (finfo.external_syms);
2287 if (finfo.internal_syms != NULL)
2288 free (finfo.internal_syms);
2289 if (finfo.indices != NULL)
2290 free (finfo.indices);
2291 if (finfo.sections != NULL)
2292 free (finfo.sections);
2293 if (finfo.symbuf != NULL)
2294 free (finfo.symbuf);
2295 for (o = abfd->sections; o != NULL; o = o->next)
2296 {
2297 if ((o->flags & SEC_RELOC) != 0
2298 && elf_section_data (o)->rel_hashes != NULL)
2299 free (elf_section_data (o)->rel_hashes);
2300 }
2301
2302 elf_tdata (abfd)->linker = true;
2303
2304 return true;
2305
2306 error_return:
2307 if (finfo.symstrtab != NULL)
2308 _bfd_stringtab_free (finfo.symstrtab);
2309 if (finfo.contents != NULL)
2310 free (finfo.contents);
2311 if (finfo.external_relocs != NULL)
2312 free (finfo.external_relocs);
2313 if (finfo.internal_relocs != NULL)
2314 free (finfo.internal_relocs);
2315 if (finfo.external_syms != NULL)
2316 free (finfo.external_syms);
2317 if (finfo.internal_syms != NULL)
2318 free (finfo.internal_syms);
2319 if (finfo.indices != NULL)
2320 free (finfo.indices);
2321 if (finfo.sections != NULL)
2322 free (finfo.sections);
2323 if (finfo.symbuf != NULL)
2324 free (finfo.symbuf);
2325 for (o = abfd->sections; o != NULL; o = o->next)
2326 {
2327 if ((o->flags & SEC_RELOC) != 0
2328 && elf_section_data (o)->rel_hashes != NULL)
2329 free (elf_section_data (o)->rel_hashes);
2330 }
2331
2332 return false;
2333}
2334
2335/* Add a symbol to the output symbol table. */
2336
2337static boolean
2338elf_link_output_sym (finfo, name, elfsym, input_sec)
2339 struct elf_final_link_info *finfo;
2340 const char *name;
2341 Elf_Internal_Sym *elfsym;
2342 asection *input_sec;
2343{
2344 boolean (*output_symbol_hook) PARAMS ((bfd *,
2345 struct bfd_link_info *info,
2346 const char *,
2347 Elf_Internal_Sym *,
2348 asection *));
2349
2350 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2351 elf_backend_link_output_symbol_hook;
2352 if (output_symbol_hook != NULL)
2353 {
2354 if (! ((*output_symbol_hook)
2355 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2356 return false;
2357 }
2358
2359 if (name == (const char *) NULL || *name == '\0')
2360 elfsym->st_name = 0;
2361 else
2362 {
2363 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2364 name, true,
2365 false);
2366 if (elfsym->st_name == (unsigned long) -1)
2367 return false;
2368 }
2369
2370 if (finfo->symbuf_count >= finfo->symbuf_size)
2371 {
2372 if (! elf_link_flush_output_syms (finfo))
2373 return false;
2374 }
2375
2376 elf_swap_symbol_out (finfo->output_bfd, elfsym,
cf9fb9f2 2377 (PTR) (finfo->symbuf + finfo->symbuf_count));
ede4eed4
KR		 2378 ++finfo->symbuf_count;
2379
2380 ++finfo->output_bfd->symcount;
2381
2382 return true;
2383}
2384
2385/* Flush the output symbols to the file. */
2386
2387static boolean
2388elf_link_flush_output_syms (finfo)
2389 struct elf_final_link_info *finfo;
2390{
2391 Elf_Internal_Shdr *symtab;
2392
2393 symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2394
2395 if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2396 SEEK_SET) != 0
2397 || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2398 sizeof (Elf_External_Sym), finfo->output_bfd)
2399 != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2400 return false;
2401
2402 symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2403
2404 finfo->symbuf_count = 0;
2405
2406 return true;
2407}
2408
2409/* Add an external symbol to the symbol table. This is called from
2410 the hash table traversal routine. */
2411
2412static boolean
2413elf_link_output_extsym (h, data)
2414 struct elf_link_hash_entry *h;
2415 PTR data;
2416{
2417 struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2418 struct elf_final_link_info *finfo = eif->finfo;
2419 boolean strip;
2420 Elf_Internal_Sym sym;
2421 asection *input_sec;
2422
2423 /* If we are not creating a shared library, and this symbol is
2424 referenced by a shared library but is not defined anywhere, then
2425 warn that it is undefined. If we do not do this, the runtime
2426 linker will complain that the symbol is undefined when the
2427 program is run. We don't have to worry about symbols that are
2428 referenced by regular files, because we will already have issued
2429 warnings for them. */
2430 if (! finfo->info->relocateable
2431 && ! finfo->info->shared
2432 && h->root.type == bfd_link_hash_undefined
2433 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2434 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2435 {
2436 if (! ((*finfo->info->callbacks->undefined_symbol)
2437 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2438 (asection *) NULL, 0)))
2439 {
2440 eif->failed = true;
2441 return false;
2442 }
2443 }
2444
2445 /* We don't want to output symbols that have never been mentioned by
2446 a regular file, or that we have been told to strip. However, if
2447 h->indx is set to -2, the symbol is used by a reloc and we must
2448 output it. */
2449 if (h->indx == -2)
2450 strip = false;
2451 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2452 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2453 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2454 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2455 strip = true;
2456 else if (finfo->info->strip == strip_all
2457 || (finfo->info->strip == strip_some
2458 && bfd_hash_lookup (finfo->info->keep_hash,
2459 h->root.root.string,
2460 false, false) == NULL))
2461 strip = true;
2462 else
2463 strip = false;
2464
2465 /* If we're stripping it, and it's not a dynamic symbol, there's
2466 nothing else to do. */
2467 if (strip && h->dynindx == -1)
2468 return true;
2469
2470 sym.st_value = 0;
2471 sym.st_size = h->size;
2472 sym.st_other = 0;
2473 if (h->root.type == bfd_link_hash_undefweak
2474 || h->root.type == bfd_link_hash_defweak)
2475 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2476 else
2477 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2478
2479 switch (h->root.type)
2480 {
2481 default:
2482 case bfd_link_hash_new:
2483 abort ();
2484 return false;
2485
2486 case bfd_link_hash_undefined:
2487 input_sec = bfd_und_section_ptr;
2488 sym.st_shndx = SHN_UNDEF;
2489 break;
2490
2491 case bfd_link_hash_undefweak:
2492 input_sec = bfd_und_section_ptr;
2493 sym.st_shndx = SHN_UNDEF;
2494 break;
2495
2496 case bfd_link_hash_defined:
2497 case bfd_link_hash_defweak:
2498 {
2499 input_sec = h->root.u.def.section;
2500 if (input_sec->output_section != NULL)
2501 {
2502 sym.st_shndx =
2503 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2504 input_sec->output_section);
2505 if (sym.st_shndx == (unsigned short) -1)
2506 {
2507 eif->failed = true;
2508 return false;
2509 }
2510
2511 /* ELF symbols in relocateable files are section relative,
2512 but in nonrelocateable files they are virtual
2513 addresses. */
2514 sym.st_value = h->root.u.def.value + input_sec->output_offset;
2515 if (! finfo->info->relocateable)
2516 sym.st_value += input_sec->output_section->vma;
2517 }
2518 else
2519 {
2520 BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2521 == bfd_target_elf_flavour)
2522 && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2523 sym.st_shndx = SHN_UNDEF;
2524 input_sec = bfd_und_section_ptr;
2525 }
2526 }
2527 break;
2528
2529 case bfd_link_hash_common:
2530 input_sec = bfd_com_section_ptr;
2531 sym.st_shndx = SHN_COMMON;
2532 sym.st_value = 1 << h->root.u.c.p->alignment_power;
2533 break;
2534
2535 case bfd_link_hash_indirect:
2536 case bfd_link_hash_warning:
0cb70568
ILT		 2537 return (elf_link_output_extsym
2538 ((struct elf_link_hash_entry *) h->root.u.i.link, data));
ede4eed4
KR		 2539 }
2540
2541 /* If this symbol should be put in the .dynsym section, then put it
2542 there now. We have already know the symbol index. We also fill
2543 in the entry in the .hash section. */
2544 if (h->dynindx != -1
2545 && elf_hash_table (finfo->info)->dynamic_sections_created)
2546 {
2547 struct elf_backend_data *bed;
2548 size_t bucketcount;
2549 size_t bucket;
2550 bfd_byte *bucketpos;
2551 bfd_vma chain;
2552
2553 sym.st_name = h->dynstr_index;
2554
2555 /* Give the processor backend a chance to tweak the symbol
2556 value, and also to finish up anything that needs to be done
2557 for this symbol. */
2558 bed = get_elf_backend_data (finfo->output_bfd);
2559 if (! ((*bed->elf_backend_finish_dynamic_symbol)
2560 (finfo->output_bfd, finfo->info, h, &sym)))
2561 {
2562 eif->failed = true;
2563 return false;
2564 }
2565
2566 elf_swap_symbol_out (finfo->output_bfd, &sym,
cf9fb9f2
ILT		 2567 (PTR) (((Elf_External_Sym *)
2568 finfo->dynsym_sec->contents)
2569 + h->dynindx));
ede4eed4
KR		 2570
2571 bucketcount = elf_hash_table (finfo->info)->bucketcount;
2572 bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2573 % bucketcount);
2574 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2575 + (bucket + 2) * (ARCH_SIZE / 8));
2576 chain = get_word (finfo->output_bfd, bucketpos);
2577 put_word (finfo->output_bfd, h->dynindx, bucketpos);
2578 put_word (finfo->output_bfd, chain,
2579 ((bfd_byte *) finfo->hash_sec->contents
2580 + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2581 }
2582
2583 /* If we're stripping it, then it was just a dynamic symbol, and
2584 there's nothing else to do. */
2585 if (strip)
2586 return true;
2587
2588 h->indx = finfo->output_bfd->symcount;
2589
2590 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2591 {
2592 eif->failed = true;
2593 return false;
2594 }
2595
2596 return true;
2597}
2598
2599/* Link an input file into the linker output file. This function
2600 handles all the sections and relocations of the input file at once.
2601 This is so that we only have to read the local symbols once, and
2602 don't have to keep them in memory. */
2603
2604static boolean
2605elf_link_input_bfd (finfo, input_bfd)
2606 struct elf_final_link_info *finfo;
2607 bfd *input_bfd;
2608{
2609 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2610 bfd *, asection *, bfd_byte *,
2611 Elf_Internal_Rela *,
2612 Elf_Internal_Sym *, asection **));
2613 bfd *output_bfd;
2614 Elf_Internal_Shdr *symtab_hdr;
2615 size_t locsymcount;
2616 size_t extsymoff;
2617 Elf_External_Sym *esym;
2618 Elf_External_Sym *esymend;
2619 Elf_Internal_Sym *isym;
2620 long *pindex;
2621 asection **ppsection;
2622 asection *o;
2623
2624 output_bfd = finfo->output_bfd;
2625 relocate_section =
2626 get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2627
2628 /* If this is a dynamic object, we don't want to do anything here:
2629 we don't want the local symbols, and we don't want the section
2630 contents. */
2631 if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2632 return true;
2633
2634 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2635 if (elf_bad_symtab (input_bfd))
2636 {
2637 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2638 extsymoff = 0;
2639 }
2640 else
2641 {
2642 locsymcount = symtab_hdr->sh_info;
2643 extsymoff = symtab_hdr->sh_info;
2644 }
2645
2646 /* Read the local symbols. */
2647 if (locsymcount > 0
2648 && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2649 || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2650 locsymcount, input_bfd)
2651 != locsymcount * sizeof (Elf_External_Sym))))
2652 return false;
2653
2654 /* Swap in the local symbols and write out the ones which we know
2655 are going into the output file. */
2656 esym = finfo->external_syms;
2657 esymend = esym + locsymcount;
2658 isym = finfo->internal_syms;
2659 pindex = finfo->indices;
2660 ppsection = finfo->sections;
2661 for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2662 {
2663 asection *isec;
2664 const char *name;
2665 Elf_Internal_Sym osym;
2666
2667 elf_swap_symbol_in (input_bfd, esym, isym);
2668 *pindex = -1;
2669
2670 if (elf_bad_symtab (input_bfd))
2671 {
2672 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2673 {
2674 *ppsection = NULL;
2675 continue;
2676 }
2677 }
2678
2679 if (isym->st_shndx == SHN_UNDEF)
2680 isec = bfd_und_section_ptr;
2681 else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2682 isec = section_from_elf_index (input_bfd, isym->st_shndx);
2683 else if (isym->st_shndx == SHN_ABS)
2684 isec = bfd_abs_section_ptr;
2685 else if (isym->st_shndx == SHN_COMMON)
2686 isec = bfd_com_section_ptr;
2687 else
2688 {
2689 /* Who knows? */
2690 isec = NULL;
2691 }
2692
2693 *ppsection = isec;
2694
2695 /* Don't output the first, undefined, symbol. */
2696 if (esym == finfo->external_syms)
2697 continue;
2698
2699 /* If we are stripping all symbols, we don't want to output this
2700 one. */
2701 if (finfo->info->strip == strip_all)
2702 continue;
2703
2704 /* We never output section symbols. Instead, we use the section
2705 symbol of the corresponding section in the output file. */
2706 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2707 continue;
2708
2709 /* If we are discarding all local symbols, we don't want to
2710 output this one. If we are generating a relocateable output
2711 file, then some of the local symbols may be required by
2712 relocs; we output them below as we discover that they are
2713 needed. */
2714 if (finfo->info->discard == discard_all)
2715 continue;
2716
2717 /* Get the name of the symbol. */
2718 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2719 isym->st_name);
2720 if (name == NULL)
2721 return false;
2722
2723 /* See if we are discarding symbols with this name. */
2724 if ((finfo->info->strip == strip_some
2725 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2726 == NULL))
2727 || (finfo->info->discard == discard_l
2728 && strncmp (name, finfo->info->lprefix,
2729 finfo->info->lprefix_len) == 0))
2730 continue;
2731
2732 /* If we get here, we are going to output this symbol. */
2733
2734 osym = *isym;
2735
2736 /* Adjust the section index for the output file. */
2737 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2738 isec->output_section);
2739 if (osym.st_shndx == (unsigned short) -1)
2740 return false;
2741
2742 *pindex = output_bfd->symcount;
2743
2744 /* ELF symbols in relocateable files are section relative, but
2745 in executable files they are virtual addresses. Note that
2746 this code assumes that all ELF sections have an associated
2747 BFD section with a reasonable value for output_offset; below
2748 we assume that they also have a reasonable value for
2749 output_section. Any special sections must be set up to meet
2750 these requirements. */
2751 osym.st_value += isec->output_offset;
2752 if (! finfo->info->relocateable)
2753 osym.st_value += isec->output_section->vma;
2754
2755 if (! elf_link_output_sym (finfo, name, &osym, isec))
2756 return false;
2757 }
2758
2759 /* Relocate the contents of each section. */
2760 for (o = input_bfd->sections; o != NULL; o = o->next)
2761 {
2762 if ((o->flags & SEC_HAS_CONTENTS) == 0)
2763 continue;
2764
2765 if ((o->flags & SEC_IN_MEMORY) != 0
2766 && input_bfd == elf_hash_table (finfo->info)->dynobj)
2767 {
2768 /* Section was created by elf_link_create_dynamic_sections.
2769 FIXME: This test is fragile. */
2770 continue;
2771 }
2772
2773 /* Read the contents of the section. */
2774 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2775 (file_ptr) 0, o->_raw_size))
2776 return false;
2777
2778 if ((o->flags & SEC_RELOC) != 0)
2779 {
2780 Elf_Internal_Rela *internal_relocs;
2781
2782 /* Get the swapped relocs. */
2783 internal_relocs = elf_link_read_relocs (input_bfd, o,
2784 finfo->external_relocs,
2785 finfo->internal_relocs,
2786 false);
2787 if (internal_relocs == NULL
2788 && o->reloc_count > 0)
2789 return false;
2790
2791 /* Relocate the section by invoking a back end routine.
2792
2793 The back end routine is responsible for adjusting the
2794 section contents as necessary, and (if using Rela relocs
2795 and generating a relocateable output file) adjusting the
2796 reloc addend as necessary.
2797
2798 The back end routine does not have to worry about setting
2799 the reloc address or the reloc symbol index.
2800
2801 The back end routine is given a pointer to the swapped in
2802 internal symbols, and can access the hash table entries
2803 for the external symbols via elf_sym_hashes (input_bfd).
2804
2805 When generating relocateable output, the back end routine
2806 must handle STB_LOCAL/STT_SECTION symbols specially. The
2807 output symbol is going to be a section symbol
2808 corresponding to the output section, which will require
2809 the addend to be adjusted. */
2810
2811 if (! (*relocate_section) (output_bfd, finfo->info,
2812 input_bfd, o,
2813 finfo->contents,
2814 internal_relocs,
2815 finfo->internal_syms,
2816 finfo->sections))
2817 return false;
2818
2819 if (finfo->info->relocateable)
2820 {
2821 Elf_Internal_Rela *irela;
2822 Elf_Internal_Rela *irelaend;
2823 struct elf_link_hash_entry **rel_hash;
2824 Elf_Internal_Shdr *input_rel_hdr;
2825 Elf_Internal_Shdr *output_rel_hdr;
2826
2827 /* Adjust the reloc addresses and symbol indices. */
2828
2829 irela = internal_relocs;
2830 irelaend = irela + o->reloc_count;
2831 rel_hash = (elf_section_data (o->output_section)->rel_hashes
2832 + o->output_section->reloc_count);
2833 for (; irela < irelaend; irela++, rel_hash++)
2834 {
ae115e51 2835 unsigned long r_symndx;
ede4eed4
KR		 2836 Elf_Internal_Sym *isym;
2837 asection *sec;
2838
2839 irela->r_offset += o->output_offset;
2840
2841 r_symndx = ELF_R_SYM (irela->r_info);
2842
2843 if (r_symndx == 0)
2844 continue;
2845
2846 if (r_symndx >= locsymcount
2847 || (elf_bad_symtab (input_bfd)
2848 && finfo->sections[r_symndx] == NULL))
2849 {
2850 long indx;
2851
2852 /* This is a reloc against a global symbol. We
2853 have not yet output all the local symbols, so
2854 we do not know the symbol index of any global
2855 symbol. We set the rel_hash entry for this
2856 reloc to point to the global hash table entry
2857 for this symbol. The symbol index is then
2858 set at the end of elf_bfd_final_link. */
2859 indx = r_symndx - extsymoff;
2860 *rel_hash = elf_sym_hashes (input_bfd)[indx];
2861
2862 /* Setting the index to -2 tells
2863 elf_link_output_extsym that this symbol is
2864 used by a reloc. */
2865 BFD_ASSERT ((*rel_hash)->indx < 0);
2866 (*rel_hash)->indx = -2;
2867
2868 continue;
2869 }
2870
2871 /* This is a reloc against a local symbol. */
2872
2873 *rel_hash = NULL;
2874 isym = finfo->internal_syms + r_symndx;
2875 sec = finfo->sections[r_symndx];
2876 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2877 {
2878 /* I suppose the backend ought to fill in the
2879 section of any STT_SECTION symbol against a
2880 processor specific section. */
2881 if (sec != NULL && bfd_is_abs_section (sec))
2882 r_symndx = 0;
2883 else if (sec == NULL || sec->owner == NULL)
2884 {
2885 bfd_set_error (bfd_error_bad_value);
2886 return false;
2887 }
2888 else
2889 {
2890 r_symndx = sec->output_section->target_index;
2891 BFD_ASSERT (r_symndx != 0);
2892 }
2893 }
2894 else
2895 {
2896 if (finfo->indices[r_symndx] == -1)
2897 {
2898 unsigned long link;
2899 const char *name;
2900 asection *osec;
2901
2902 if (finfo->info->strip == strip_all)
2903 {
2904 /* You can't do ld -r -s. */
2905 bfd_set_error (bfd_error_invalid_operation);
2906 return false;
2907 }
2908
2909 /* This symbol was skipped earlier, but
2910 since it is needed by a reloc, we
2911 must output it now. */
2912 link = symtab_hdr->sh_link;
2913 name = bfd_elf_string_from_elf_section (input_bfd,
2914 link,
2915 isym->st_name);
2916 if (name == NULL)
2917 return false;
2918
2919 osec = sec->output_section;
2920 isym->st_shndx =
2921 _bfd_elf_section_from_bfd_section (output_bfd,
2922 osec);
2923 if (isym->st_shndx == (unsigned short) -1)
2924 return false;
2925
2926 isym->st_value += sec->output_offset;
2927 if (! finfo->info->relocateable)
2928 isym->st_value += osec->vma;
2929
2930 finfo->indices[r_symndx] = output_bfd->symcount;
2931
2932 if (! elf_link_output_sym (finfo, name, isym, sec))
2933 return false;
2934 }
2935
2936 r_symndx = finfo->indices[r_symndx];
2937 }
2938
2939 irela->r_info = ELF_R_INFO (r_symndx,
2940 ELF_R_TYPE (irela->r_info));
2941 }
2942
2943 /* Swap out the relocs. */
2944 input_rel_hdr = &elf_section_data (o)->rel_hdr;
2945 output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
2946 BFD_ASSERT (output_rel_hdr->sh_entsize
2947 == input_rel_hdr->sh_entsize);
2948 irela = internal_relocs;
2949 irelaend = irela + o->reloc_count;
2950 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2951 {
2952 Elf_External_Rel *erel;
2953
2954 erel = ((Elf_External_Rel *) output_rel_hdr->contents
2955 + o->output_section->reloc_count);
2956 for (; irela < irelaend; irela++, erel++)
2957 {
2958 Elf_Internal_Rel irel;
2959
2960 irel.r_offset = irela->r_offset;
2961 irel.r_info = irela->r_info;
2962 BFD_ASSERT (irela->r_addend == 0);
2963 elf_swap_reloc_out (output_bfd, &irel, erel);
2964 }
2965 }
2966 else
2967 {
2968 Elf_External_Rela *erela;
2969
2970 BFD_ASSERT (input_rel_hdr->sh_entsize
2971 == sizeof (Elf_External_Rela));
2972 erela = ((Elf_External_Rela *) output_rel_hdr->contents
2973 + o->output_section->reloc_count);
2974 for (; irela < irelaend; irela++, erela++)
2975 elf_swap_reloca_out (output_bfd, irela, erela);
2976 }
2977
2978 o->output_section->reloc_count += o->reloc_count;
2979 }
2980 }
2981
2982 /* Write out the modified section contents. */
2983 if (! bfd_set_section_contents (output_bfd, o->output_section,
2984 finfo->contents, o->output_offset,
2985 (o->_cooked_size != 0
2986 ? o->_cooked_size
2987 : o->_raw_size)))
2988 return false;
2989 }
2990
2991 return true;
2992}
2993
2994/* Generate a reloc when linking an ELF file. This is a reloc
2995 requested by the linker, and does come from any input file. This
2996 is used to build constructor and destructor tables when linking
2997 with -Ur. */
2998
2999static boolean
3000elf_reloc_link_order (output_bfd, info, output_section, link_order)
3001 bfd *output_bfd;
3002 struct bfd_link_info *info;
3003 asection *output_section;
3004 struct bfd_link_order *link_order;
3005{
3006 reloc_howto_type *howto;
3007 long indx;
3008 bfd_vma offset;
3009 struct elf_link_hash_entry **rel_hash_ptr;
3010 Elf_Internal_Shdr *rel_hdr;
3011
3012 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3013 if (howto == NULL)
3014 {
3015 bfd_set_error (bfd_error_bad_value);
3016 return false;
3017 }
3018
3019 /* If this is an inplace reloc, we must write the addend into the
3020 object file. */
3021 if (howto->partial_inplace
3022 && link_order->u.reloc.p->addend != 0)
3023 {
3024 bfd_size_type size;
3025 bfd_reloc_status_type rstat;
3026 bfd_byte *buf;
3027 boolean ok;
3028
3029 size = bfd_get_reloc_size (howto);
3030 buf = (bfd_byte *) bfd_zmalloc (size);
3031 if (buf == (bfd_byte *) NULL)
a9713b91 3032 return false;
ede4eed4
KR		 3033 rstat = _bfd_relocate_contents (howto, output_bfd,
3034 link_order->u.reloc.p->addend, buf);
3035 switch (rstat)
3036 {
3037 case bfd_reloc_ok:
3038 break;
3039 default:
3040 case bfd_reloc_outofrange:
3041 abort ();
3042 case bfd_reloc_overflow:
3043 if (! ((*info->callbacks->reloc_overflow)
3044 (info,
3045 (link_order->type == bfd_section_reloc_link_order
3046 ? bfd_section_name (output_bfd,
3047 link_order->u.reloc.p->u.section)
3048 : link_order->u.reloc.p->u.name),
3049 howto->name, link_order->u.reloc.p->addend,
3050 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
3051 {
3052 free (buf);
3053 return false;
3054 }
3055 break;
3056 }
3057 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
3058 (file_ptr) link_order->offset, size);
3059 free (buf);
3060 if (! ok)
3061 return false;
3062 }
3063
3064 /* Figure out the symbol index. */
3065 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
3066 + output_section->reloc_count);
3067 if (link_order->type == bfd_section_reloc_link_order)
3068 {
3069 indx = link_order->u.reloc.p->u.section->target_index;
3070 BFD_ASSERT (indx != 0);
3071 *rel_hash_ptr = NULL;
3072 }
3073 else
3074 {
3075 struct elf_link_hash_entry *h;
3076
3077 h = elf_link_hash_lookup (elf_hash_table (info),
3078 link_order->u.reloc.p->u.name,
3079 false, false, true);
3080 if (h != NULL)
3081 {
3082 /* Setting the index to -2 tells elf_link_output_extsym that
3083 this symbol is used by a reloc. */
3084 h->indx = -2;
3085 *rel_hash_ptr = h;
3086 indx = 0;
3087 }
3088 else
3089 {
3090 if (! ((*info->callbacks->unattached_reloc)
3091 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
3092 (asection *) NULL, (bfd_vma) 0)))
3093 return false;
3094 indx = 0;
3095 }
3096 }
3097
3098 /* The address of a reloc is relative to the section in a
3099 relocateable file, and is a virtual address in an executable
3100 file. */
3101 offset = link_order->offset;
3102 if (! info->relocateable)
3103 offset += output_section->vma;
3104
3105 rel_hdr = &elf_section_data (output_section)->rel_hdr;
3106
3107 if (rel_hdr->sh_type == SHT_REL)
3108 {
3109 Elf_Internal_Rel irel;
3110 Elf_External_Rel *erel;
3111
3112 irel.r_offset = offset;
3113 irel.r_info = ELF_R_INFO (indx, howto->type);
3114 erel = ((Elf_External_Rel *) rel_hdr->contents
3115 + output_section->reloc_count);
3116 elf_swap_reloc_out (output_bfd, &irel, erel);
3117 }
3118 else
3119 {
3120 Elf_Internal_Rela irela;
3121 Elf_External_Rela *erela;
3122
3123 irela.r_offset = offset;
3124 irela.r_info = ELF_R_INFO (indx, howto->type);
3125 irela.r_addend = link_order->u.reloc.p->addend;
3126 erela = ((Elf_External_Rela *) rel_hdr->contents
3127 + output_section->reloc_count);
3128 elf_swap_reloca_out (output_bfd, &irela, erela);
3129 }
3130
3131 ++output_section->reloc_count;
3132
3133 return true;
3134}
3135
GDB Binutils - Deliverables
This page took 0.165123 seconds and 4 git commands to generate.