]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix typo.
[thirdparty/binutils-gdb.git] / bfd / elf.c
CommitLineData
252b5132
RH		 1/* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 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
18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20/*
21
22SECTION
23 ELF backends
24
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
28
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
31 haven't bothered yet.
32 */
33
34#include "bfd.h"
35#include "sysdep.h"
36#include "bfdlink.h"
37#include "libbfd.h"
38#define ARCH_SIZE 0
39#include "elf-bfd.h"
40
41static INLINE struct elf_segment_map *make_mapping
42 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
43static boolean map_sections_to_segments PARAMS ((bfd *));
44static int elf_sort_sections PARAMS ((const PTR, const PTR));
45static boolean assign_file_positions_for_segments PARAMS ((bfd *));
46static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
47static boolean prep_headers PARAMS ((bfd *));
48static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
49static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
50static char *elf_read PARAMS ((bfd *, long, unsigned int));
51static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
52static boolean assign_section_numbers PARAMS ((bfd *));
53static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
54static boolean elf_map_symbols PARAMS ((bfd *));
55static bfd_size_type get_program_header_size PARAMS ((bfd *));
56
57/* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
60
61/* Swap in a Verdef structure. */
62
63void
64_bfd_elf_swap_verdef_in (abfd, src, dst)
65 bfd *abfd;
66 const Elf_External_Verdef *src;
67 Elf_Internal_Verdef *dst;
68{
69 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
70 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags);
71 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx);
72 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt);
73 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash);
74 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux);
75 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next);
76}
77
78/* Swap out a Verdef structure. */
79
80void
81_bfd_elf_swap_verdef_out (abfd, src, dst)
82 bfd *abfd;
83 const Elf_Internal_Verdef *src;
84 Elf_External_Verdef *dst;
85{
86 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
87 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
88 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
89 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
90 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
91 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
92 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
93}
94
95/* Swap in a Verdaux structure. */
96
97void
98_bfd_elf_swap_verdaux_in (abfd, src, dst)
99 bfd *abfd;
100 const Elf_External_Verdaux *src;
101 Elf_Internal_Verdaux *dst;
102{
103 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
104 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
105}
106
107/* Swap out a Verdaux structure. */
108
109void
110_bfd_elf_swap_verdaux_out (abfd, src, dst)
111 bfd *abfd;
112 const Elf_Internal_Verdaux *src;
113 Elf_External_Verdaux *dst;
114{
115 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
116 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
117}
118
119/* Swap in a Verneed structure. */
120
121void
122_bfd_elf_swap_verneed_in (abfd, src, dst)
123 bfd *abfd;
124 const Elf_External_Verneed *src;
125 Elf_Internal_Verneed *dst;
126{
127 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
128 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt);
129 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file);
130 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux);
131 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next);
132}
133
134/* Swap out a Verneed structure. */
135
136void
137_bfd_elf_swap_verneed_out (abfd, src, dst)
138 bfd *abfd;
139 const Elf_Internal_Verneed *src;
140 Elf_External_Verneed *dst;
141{
142 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
143 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
144 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
145 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
146 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
147}
148
149/* Swap in a Vernaux structure. */
150
151void
152_bfd_elf_swap_vernaux_in (abfd, src, dst)
153 bfd *abfd;
154 const Elf_External_Vernaux *src;
155 Elf_Internal_Vernaux *dst;
156{
157 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash);
158 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
159 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
160 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name);
161 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next);
162}
163
164/* Swap out a Vernaux structure. */
165
166void
167_bfd_elf_swap_vernaux_out (abfd, src, dst)
168 bfd *abfd;
169 const Elf_Internal_Vernaux *src;
170 Elf_External_Vernaux *dst;
171{
172 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
173 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
174 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
175 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
176 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
177}
178
179/* Swap in a Versym structure. */
180
181void
182_bfd_elf_swap_versym_in (abfd, src, dst)
183 bfd *abfd;
184 const Elf_External_Versym *src;
185 Elf_Internal_Versym *dst;
186{
187 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
188}
189
190/* Swap out a Versym structure. */
191
192void
193_bfd_elf_swap_versym_out (abfd, src, dst)
194 bfd *abfd;
195 const Elf_Internal_Versym *src;
196 Elf_External_Versym *dst;
197{
198 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
199}
200
201/* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. */
203unsigned long
204bfd_elf_hash (name)
205 CONST unsigned char *name;
206{
207 unsigned long h = 0;
208 unsigned long g;
209 int ch;
210
211 while ((ch = *name++) != '\0')
212 {
213 h = (h << 4) + ch;
214 if ((g = (h & 0xf0000000)) != 0)
215 {
216 h ^= g >> 24;
217 /* The ELF ABI says `h &= ~g', but this is equivalent in
218 this case and on some machines one insn instead of two. */
219 h ^= g;
220 }
221 }
222 return h;
223}
224
225/* Read a specified number of bytes at a specified offset in an ELF
226 file, into a newly allocated buffer, and return a pointer to the
227 buffer. */
228
229static char *
230elf_read (abfd, offset, size)
231 bfd * abfd;
232 long offset;
233 unsigned int size;
234{
235 char *buf;
236
237 if ((buf = bfd_alloc (abfd, size)) == NULL)
238 return NULL;
239 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
240 return NULL;
241 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
242 {
243 if (bfd_get_error () != bfd_error_system_call)
244 bfd_set_error (bfd_error_file_truncated);
245 return NULL;
246 }
247 return buf;
248}
249
250boolean
251bfd_elf_mkobject (abfd)
252 bfd * abfd;
253{
254 /* this just does initialization */
255 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
256 elf_tdata (abfd) = (struct elf_obj_tdata *)
257 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
258 if (elf_tdata (abfd) == 0)
259 return false;
260 /* since everything is done at close time, do we need any
261 initialization? */
262
263 return true;
264}
265
266boolean
267bfd_elf_mkcorefile (abfd)
268 bfd * abfd;
269{
270 /* I think this can be done just like an object file. */
271 return bfd_elf_mkobject (abfd);
272}
273
274char *
275bfd_elf_get_str_section (abfd, shindex)
276 bfd * abfd;
277 unsigned int shindex;
278{
279 Elf_Internal_Shdr **i_shdrp;
280 char *shstrtab = NULL;
281 unsigned int offset;
282 unsigned int shstrtabsize;
283
284 i_shdrp = elf_elfsections (abfd);
285 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
286 return 0;
287
288 shstrtab = (char *) i_shdrp[shindex]->contents;
289 if (shstrtab == NULL)
290 {
291 /* No cached one, attempt to read, and cache what we read. */
292 offset = i_shdrp[shindex]->sh_offset;
293 shstrtabsize = i_shdrp[shindex]->sh_size;
294 shstrtab = elf_read (abfd, offset, shstrtabsize);
295 i_shdrp[shindex]->contents = (PTR) shstrtab;
296 }
297 return shstrtab;
298}
299
300char *
301bfd_elf_string_from_elf_section (abfd, shindex, strindex)
302 bfd * abfd;
303 unsigned int shindex;
304 unsigned int strindex;
305{
306 Elf_Internal_Shdr *hdr;
307
308 if (strindex == 0)
309 return "";
310
311 hdr = elf_elfsections (abfd)[shindex];
312
313 if (hdr->contents == NULL
314 && bfd_elf_get_str_section (abfd, shindex) == NULL)
315 return NULL;
316
317 if (strindex >= hdr->sh_size)
318 {
319 (*_bfd_error_handler)
320 (_("%s: invalid string offset %u >= %lu for section `%s'"),
321 bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
322 ((shindex == elf_elfheader(abfd)->e_shstrndx
323 && strindex == hdr->sh_name)
324 ? ".shstrtab"
325 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
326 return "";
327 }
328
329 return ((char *) hdr->contents) + strindex;
330}
331
332/* Make a BFD section from an ELF section. We store a pointer to the
333 BFD section in the bfd_section field of the header. */
334
335boolean
336_bfd_elf_make_section_from_shdr (abfd, hdr, name)
337 bfd *abfd;
338 Elf_Internal_Shdr *hdr;
339 const char *name;
340{
341 asection *newsect;
342 flagword flags;
343
344 if (hdr->bfd_section != NULL)
345 {
346 BFD_ASSERT (strcmp (name,
347 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
348 return true;
349 }
350
351 newsect = bfd_make_section_anyway (abfd, name);
352 if (newsect == NULL)
353 return false;
354
355 newsect->filepos = hdr->sh_offset;
356
357 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
358 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
359 || ! bfd_set_section_alignment (abfd, newsect,
360 bfd_log2 (hdr->sh_addralign)))
361 return false;
362
363 flags = SEC_NO_FLAGS;
364 if (hdr->sh_type != SHT_NOBITS)
365 flags |= SEC_HAS_CONTENTS;
366 if ((hdr->sh_flags & SHF_ALLOC) != 0)
367 {
368 flags |= SEC_ALLOC;
369 if (hdr->sh_type != SHT_NOBITS)
370 flags |= SEC_LOAD;
371 }
372 if ((hdr->sh_flags & SHF_WRITE) == 0)
373 flags |= SEC_READONLY;
374 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
375 flags |= SEC_CODE;
376 else if ((flags & SEC_LOAD) != 0)
377 flags |= SEC_DATA;
378
379 /* The debugging sections appear to be recognized only by name, not
380 any sort of flag. */
381 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
382 || strncmp (name, ".line", sizeof ".line" - 1) == 0
383 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
384 flags |= SEC_DEBUGGING;
385
386 /* As a GNU extension, if the name begins with .gnu.linkonce, we
387 only link a single copy of the section. This is used to support
388 g++. g++ will emit each template expansion in its own section.
389 The symbols will be defined as weak, so that multiple definitions
390 are permitted. The GNU linker extension is to actually discard
391 all but one of the sections. */
392 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
393 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
394
395 if (! bfd_set_section_flags (abfd, newsect, flags))
396 return false;
397
398 if ((flags & SEC_ALLOC) != 0)
399 {
400 Elf_Internal_Phdr *phdr;
401 unsigned int i;
402
403 /* Look through the phdrs to see if we need to adjust the lma.
404 If all the p_paddr fields are zero, we ignore them, since
405 some ELF linkers produce such output. */
406 phdr = elf_tdata (abfd)->phdr;
407 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
408 {
409 if (phdr->p_paddr != 0)
410 break;
411 }
412 if (i < elf_elfheader (abfd)->e_phnum)
413 {
414 phdr = elf_tdata (abfd)->phdr;
415 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
416 {
417 if (phdr->p_type == PT_LOAD
418 && phdr->p_vaddr != phdr->p_paddr
419 && phdr->p_vaddr <= hdr->sh_addr
420 && (phdr->p_vaddr + phdr->p_memsz
421 >= hdr->sh_addr + hdr->sh_size)
422 && ((flags & SEC_LOAD) == 0
423 || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
424 && (phdr->p_offset + phdr->p_filesz
425 >= hdr->sh_offset + hdr->sh_size))))
426 {
427 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
428 break;
429 }
430 }
431 }
432 }
433
434 hdr->bfd_section = newsect;
435 elf_section_data (newsect)->this_hdr = *hdr;
436
437 return true;
438}
439
440/*
441INTERNAL_FUNCTION
442 bfd_elf_find_section
443
444SYNOPSIS
445 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
446
447DESCRIPTION
448 Helper functions for GDB to locate the string tables.
449 Since BFD hides string tables from callers, GDB needs to use an
450 internal hook to find them. Sun's .stabstr, in particular,
451 isn't even pointed to by the .stab section, so ordinary
452 mechanisms wouldn't work to find it, even if we had some.
453*/
454
455struct elf_internal_shdr *
456bfd_elf_find_section (abfd, name)
457 bfd * abfd;
458 char *name;
459{
460 Elf_Internal_Shdr **i_shdrp;
461 char *shstrtab;
462 unsigned int max;
463 unsigned int i;
464
465 i_shdrp = elf_elfsections (abfd);
466 if (i_shdrp != NULL)
467 {
468 shstrtab = bfd_elf_get_str_section
469 (abfd, elf_elfheader (abfd)->e_shstrndx);
470 if (shstrtab != NULL)
471 {
472 max = elf_elfheader (abfd)->e_shnum;
473 for (i = 1; i < max; i++)
474 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
475 return i_shdrp[i];
476 }
477 }
478 return 0;
479}
480
481const char *const bfd_elf_section_type_names[] = {
482 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
483 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
484 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
485};
486
487/* ELF relocs are against symbols. If we are producing relocateable
488 output, and the reloc is against an external symbol, and nothing
489 has given us any additional addend, the resulting reloc will also
490 be against the same symbol. In such a case, we don't want to
491 change anything about the way the reloc is handled, since it will
492 all be done at final link time. Rather than put special case code
493 into bfd_perform_relocation, all the reloc types use this howto
494 function. It just short circuits the reloc if producing
495 relocateable output against an external symbol. */
496
497/*ARGSUSED*/
498bfd_reloc_status_type
499bfd_elf_generic_reloc (abfd,
500 reloc_entry,
501 symbol,
502 data,
503 input_section,
504 output_bfd,
505 error_message)
506 bfd *abfd;
507 arelent *reloc_entry;
508 asymbol *symbol;
509 PTR data;
510 asection *input_section;
511 bfd *output_bfd;
512 char **error_message;
513{
514 if (output_bfd != (bfd *) NULL
515 && (symbol->flags & BSF_SECTION_SYM) == 0
516 && (! reloc_entry->howto->partial_inplace
517 || reloc_entry->addend == 0))
518 {
519 reloc_entry->address += input_section->output_offset;
520 return bfd_reloc_ok;
521 }
522
523 return bfd_reloc_continue;
524}
525\f
526/* Print out the program headers. */
527
528boolean
529_bfd_elf_print_private_bfd_data (abfd, farg)
530 bfd *abfd;
531 PTR farg;
532{
533 FILE *f = (FILE *) farg;
534 Elf_Internal_Phdr *p;
535 asection *s;
536 bfd_byte *dynbuf = NULL;
537
538 p = elf_tdata (abfd)->phdr;
539 if (p != NULL)
540 {
541 unsigned int i, c;
542
543 fprintf (f, _("\nProgram Header:\n"));
544 c = elf_elfheader (abfd)->e_phnum;
545 for (i = 0; i < c; i++, p++)
546 {
547 const char *s;
548 char buf[20];
549
550 switch (p->p_type)
551 {
552 case PT_NULL: s = "NULL"; break;
553 case PT_LOAD: s = "LOAD"; break;
554 case PT_DYNAMIC: s = "DYNAMIC"; break;
555 case PT_INTERP: s = "INTERP"; break;
556 case PT_NOTE: s = "NOTE"; break;
557 case PT_SHLIB: s = "SHLIB"; break;
558 case PT_PHDR: s = "PHDR"; break;
559 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
560 }
561 fprintf (f, "%8s off 0x", s);
562 fprintf_vma (f, p->p_offset);
563 fprintf (f, " vaddr 0x");
564 fprintf_vma (f, p->p_vaddr);
565 fprintf (f, " paddr 0x");
566 fprintf_vma (f, p->p_paddr);
567 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
568 fprintf (f, " filesz 0x");
569 fprintf_vma (f, p->p_filesz);
570 fprintf (f, " memsz 0x");
571 fprintf_vma (f, p->p_memsz);
572 fprintf (f, " flags %c%c%c",
573 (p->p_flags & PF_R) != 0 ? 'r' : '-',
574 (p->p_flags & PF_W) != 0 ? 'w' : '-',
575 (p->p_flags & PF_X) != 0 ? 'x' : '-');
576 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
577 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
578 fprintf (f, "\n");
579 }
580 }
581
582 s = bfd_get_section_by_name (abfd, ".dynamic");
583 if (s != NULL)
584 {
585 int elfsec;
586 unsigned long link;
587 bfd_byte *extdyn, *extdynend;
588 size_t extdynsize;
589 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
590
591 fprintf (f, _("\nDynamic Section:\n"));
592
593 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
594 if (dynbuf == NULL)
595 goto error_return;
596 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
597 s->_raw_size))
598 goto error_return;
599
600 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
601 if (elfsec == -1)
602 goto error_return;
603 link = elf_elfsections (abfd)[elfsec]->sh_link;
604
605 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
606 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
607
608 extdyn = dynbuf;
609 extdynend = extdyn + s->_raw_size;
610 for (; extdyn < extdynend; extdyn += extdynsize)
611 {
612 Elf_Internal_Dyn dyn;
613 const char *name;
614 char ab[20];
615 boolean stringp;
616
617 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
618
619 if (dyn.d_tag == DT_NULL)
620 break;
621
622 stringp = false;
623 switch (dyn.d_tag)
624 {
625 default:
626 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
627 name = ab;
628 break;
629
630 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
631 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
632 case DT_PLTGOT: name = "PLTGOT"; break;
633 case DT_HASH: name = "HASH"; break;
634 case DT_STRTAB: name = "STRTAB"; break;
635 case DT_SYMTAB: name = "SYMTAB"; break;
636 case DT_RELA: name = "RELA"; break;
637 case DT_RELASZ: name = "RELASZ"; break;
638 case DT_RELAENT: name = "RELAENT"; break;
639 case DT_STRSZ: name = "STRSZ"; break;
640 case DT_SYMENT: name = "SYMENT"; break;
641 case DT_INIT: name = "INIT"; break;
642 case DT_FINI: name = "FINI"; break;
643 case DT_SONAME: name = "SONAME"; stringp = true; break;
644 case DT_RPATH: name = "RPATH"; stringp = true; break;
645 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
646 case DT_REL: name = "REL"; break;
647 case DT_RELSZ: name = "RELSZ"; break;
648 case DT_RELENT: name = "RELENT"; break;
649 case DT_PLTREL: name = "PLTREL"; break;
650 case DT_DEBUG: name = "DEBUG"; break;
651 case DT_TEXTREL: name = "TEXTREL"; break;
652 case DT_JMPREL: name = "JMPREL"; break;
653 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
654 case DT_FILTER: name = "FILTER"; stringp = true; break;
655 case DT_VERSYM: name = "VERSYM"; break;
656 case DT_VERDEF: name = "VERDEF"; break;
657 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
658 case DT_VERNEED: name = "VERNEED"; break;
659 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
660 }
661
662 fprintf (f, " %-11s ", name);
663 if (! stringp)
664 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
665 else
666 {
667 const char *string;
668
669 string = bfd_elf_string_from_elf_section (abfd, link,
670 dyn.d_un.d_val);
671 if (string == NULL)
672 goto error_return;
673 fprintf (f, "%s", string);
674 }
675 fprintf (f, "\n");
676 }
677
678 free (dynbuf);
679 dynbuf = NULL;
680 }
681
682 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
683 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
684 {
685 if (! _bfd_elf_slurp_version_tables (abfd))
686 return false;
687 }
688
689 if (elf_dynverdef (abfd) != 0)
690 {
691 Elf_Internal_Verdef *t;
692
693 fprintf (f, _("\nVersion definitions:\n"));
694 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
695 {
696 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
697 t->vd_flags, t->vd_hash, t->vd_nodename);
698 if (t->vd_auxptr->vda_nextptr != NULL)
699 {
700 Elf_Internal_Verdaux *a;
701
702 fprintf (f, "\t");
703 for (a = t->vd_auxptr->vda_nextptr;
704 a != NULL;
705 a = a->vda_nextptr)
706 fprintf (f, "%s ", a->vda_nodename);
707 fprintf (f, "\n");
708 }
709 }
710 }
711
712 if (elf_dynverref (abfd) != 0)
713 {
714 Elf_Internal_Verneed *t;
715
716 fprintf (f, _("\nVersion References:\n"));
717 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
718 {
719 Elf_Internal_Vernaux *a;
720
721 fprintf (f, _(" required from %s:\n"), t->vn_filename);
722 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
723 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
724 a->vna_flags, a->vna_other, a->vna_nodename);
725 }
726 }
727
728 return true;
729
730 error_return:
731 if (dynbuf != NULL)
732 free (dynbuf);
733 return false;
734}
735
736/* Display ELF-specific fields of a symbol. */
737
738void
739bfd_elf_print_symbol (abfd, filep, symbol, how)
740 bfd *abfd;
741 PTR filep;
742 asymbol *symbol;
743 bfd_print_symbol_type how;
744{
745 FILE *file = (FILE *) filep;
746 switch (how)
747 {
748 case bfd_print_symbol_name:
749 fprintf (file, "%s", symbol->name);
750 break;
751 case bfd_print_symbol_more:
752 fprintf (file, "elf ");
753 fprintf_vma (file, symbol->value);
754 fprintf (file, " %lx", (long) symbol->flags);
755 break;
756 case bfd_print_symbol_all:
757 {
758 CONST char *section_name;
759 section_name = symbol->section ? symbol->section->name : "(*none*)";
760 bfd_print_symbol_vandf ((PTR) file, symbol);
761 fprintf (file, " %s\t", section_name);
762 /* Print the "other" value for a symbol. For common symbols,
763 we've already printed the size; now print the alignment.
764 For other symbols, we have no specified alignment, and
765 we've printed the address; now print the size. */
766 fprintf_vma (file,
767 (bfd_is_com_section (symbol->section)
768 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
769 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
770
771 /* If we have version information, print it. */
772 if (elf_tdata (abfd)->dynversym_section != 0
773 && (elf_tdata (abfd)->dynverdef_section != 0
774 || elf_tdata (abfd)->dynverref_section != 0))
775 {
776 unsigned int vernum;
777 const char *version_string;
778
779 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
780
781 if (vernum == 0)
782 version_string = "";
783 else if (vernum == 1)
784 version_string = "Base";
785 else if (vernum <= elf_tdata (abfd)->cverdefs)
786 version_string =
787 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
788 else
789 {
790 Elf_Internal_Verneed *t;
791
792 version_string = "";
793 for (t = elf_tdata (abfd)->verref;
794 t != NULL;
795 t = t->vn_nextref)
796 {
797 Elf_Internal_Vernaux *a;
798
799 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
800 {
801 if (a->vna_other == vernum)
802 {
803 version_string = a->vna_nodename;
804 break;
805 }
806 }
807 }
808 }
809
810 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
811 fprintf (file, " %-11s", version_string);
812 else
813 {
814 int i;
815
816 fprintf (file, " (%s)", version_string);
817 for (i = 10 - strlen (version_string); i > 0; --i)
818 putc (' ', file);
819 }
820 }
821
822 /* If the st_other field is not zero, print it. */
823 if (((elf_symbol_type *) symbol)->internal_elf_sym.st_other != 0)
824 fprintf (file, " 0x%02x",
825 ((unsigned int)
826 ((elf_symbol_type *) symbol)->internal_elf_sym.st_other));
827
828 fprintf (file, " %s", symbol->name);
829 }
830 break;
831 }
832}
833\f
834/* Create an entry in an ELF linker hash table. */
835
836struct bfd_hash_entry *
837_bfd_elf_link_hash_newfunc (entry, table, string)
838 struct bfd_hash_entry *entry;
839 struct bfd_hash_table *table;
840 const char *string;
841{
842 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
843
844 /* Allocate the structure if it has not already been allocated by a
845 subclass. */
846 if (ret == (struct elf_link_hash_entry *) NULL)
847 ret = ((struct elf_link_hash_entry *)
848 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
849 if (ret == (struct elf_link_hash_entry *) NULL)
850 return (struct bfd_hash_entry *) ret;
851
852 /* Call the allocation method of the superclass. */
853 ret = ((struct elf_link_hash_entry *)
854 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
855 table, string));
856 if (ret != (struct elf_link_hash_entry *) NULL)
857 {
858 /* Set local fields. */
859 ret->indx = -1;
860 ret->size = 0;
861 ret->dynindx = -1;
862 ret->dynstr_index = 0;
863 ret->weakdef = NULL;
864 ret->got.offset = (bfd_vma) -1;
865 ret->plt.offset = (bfd_vma) -1;
866 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
867 ret->verinfo.verdef = NULL;
868 ret->vtable_entries_used = NULL;
869 ret->vtable_entries_size = 0;
870 ret->vtable_parent = NULL;
871 ret->type = STT_NOTYPE;
872 ret->other = 0;
873 /* Assume that we have been called by a non-ELF symbol reader.
874 This flag is then reset by the code which reads an ELF input
875 file. This ensures that a symbol created by a non-ELF symbol
876 reader will have the flag set correctly. */
877 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
878 }
879
880 return (struct bfd_hash_entry *) ret;
881}
882
883/* Initialize an ELF linker hash table. */
884
885boolean
886_bfd_elf_link_hash_table_init (table, abfd, newfunc)
887 struct elf_link_hash_table *table;
888 bfd *abfd;
889 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
890 struct bfd_hash_table *,
891 const char *));
892{
893 table->dynamic_sections_created = false;
894 table->dynobj = NULL;
895 /* The first dynamic symbol is a dummy. */
896 table->dynsymcount = 1;
897 table->dynstr = NULL;
898 table->bucketcount = 0;
899 table->needed = NULL;
900 table->hgot = NULL;
901 table->stab_info = NULL;
902 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
903}
904
905/* Create an ELF linker hash table. */
906
907struct bfd_link_hash_table *
908_bfd_elf_link_hash_table_create (abfd)
909 bfd *abfd;
910{
911 struct elf_link_hash_table *ret;
912
913 ret = ((struct elf_link_hash_table *)
914 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
915 if (ret == (struct elf_link_hash_table *) NULL)
916 return NULL;
917
918 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
919 {
920 bfd_release (abfd, ret);
921 return NULL;
922 }
923
924 return &ret->root;
925}
926
927/* This is a hook for the ELF emulation code in the generic linker to
928 tell the backend linker what file name to use for the DT_NEEDED
929 entry for a dynamic object. The generic linker passes name as an
930 empty string to indicate that no DT_NEEDED entry should be made. */
931
932void
933bfd_elf_set_dt_needed_name (abfd, name)
934 bfd *abfd;
935 const char *name;
936{
937 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
938 && bfd_get_format (abfd) == bfd_object)
939 elf_dt_name (abfd) = name;
940}
941
942/* Get the list of DT_NEEDED entries for a link. This is a hook for
943 the linker ELF emulation code. */
944
945struct bfd_link_needed_list *
946bfd_elf_get_needed_list (abfd, info)
947 bfd *abfd;
948 struct bfd_link_info *info;
949{
950 if (info->hash->creator->flavour != bfd_target_elf_flavour)
951 return NULL;
952 return elf_hash_table (info)->needed;
953}
954
955/* Get the name actually used for a dynamic object for a link. This
956 is the SONAME entry if there is one. Otherwise, it is the string
957 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
958
959const char *
960bfd_elf_get_dt_soname (abfd)
961 bfd *abfd;
962{
963 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
964 && bfd_get_format (abfd) == bfd_object)
965 return elf_dt_name (abfd);
966 return NULL;
967}
968
969/* Get the list of DT_NEEDED entries from a BFD. This is a hook for
970 the ELF linker emulation code. */
971
972boolean
973bfd_elf_get_bfd_needed_list (abfd, pneeded)
974 bfd *abfd;
975 struct bfd_link_needed_list **pneeded;
976{
977 asection *s;
978 bfd_byte *dynbuf = NULL;
979 int elfsec;
980 unsigned long link;
981 bfd_byte *extdyn, *extdynend;
982 size_t extdynsize;
983 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
984
985 *pneeded = NULL;
986
987 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
988 || bfd_get_format (abfd) != bfd_object)
989 return true;
990
991 s = bfd_get_section_by_name (abfd, ".dynamic");
992 if (s == NULL || s->_raw_size == 0)
993 return true;
994
995 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
996 if (dynbuf == NULL)
997 goto error_return;
998
999 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1000 s->_raw_size))
1001 goto error_return;
1002
1003 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1004 if (elfsec == -1)
1005 goto error_return;
1006
1007 link = elf_elfsections (abfd)[elfsec]->sh_link;
1008
1009 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1010 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1011
1012 extdyn = dynbuf;
1013 extdynend = extdyn + s->_raw_size;
1014 for (; extdyn < extdynend; extdyn += extdynsize)
1015 {
1016 Elf_Internal_Dyn dyn;
1017
1018 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1019
1020 if (dyn.d_tag == DT_NULL)
1021 break;
1022
1023 if (dyn.d_tag == DT_NEEDED)
1024 {
1025 const char *string;
1026 struct bfd_link_needed_list *l;
1027
1028 string = bfd_elf_string_from_elf_section (abfd, link,
1029 dyn.d_un.d_val);
1030 if (string == NULL)
1031 goto error_return;
1032
1033 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1034 if (l == NULL)
1035 goto error_return;
1036
1037 l->by = abfd;
1038 l->name = string;
1039 l->next = *pneeded;
1040 *pneeded = l;
1041 }
1042 }
1043
1044 free (dynbuf);
1045
1046 return true;
1047
1048 error_return:
1049 if (dynbuf != NULL)
1050 free (dynbuf);
1051 return false;
1052}
1053\f
1054/* Allocate an ELF string table--force the first byte to be zero. */
1055
1056struct bfd_strtab_hash *
1057_bfd_elf_stringtab_init ()
1058{
1059 struct bfd_strtab_hash *ret;
1060
1061 ret = _bfd_stringtab_init ();
1062 if (ret != NULL)
1063 {
1064 bfd_size_type loc;
1065
1066 loc = _bfd_stringtab_add (ret, "", true, false);
1067 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1068 if (loc == (bfd_size_type) -1)
1069 {
1070 _bfd_stringtab_free (ret);
1071 ret = NULL;
1072 }
1073 }
1074 return ret;
1075}
1076\f
1077/* ELF .o/exec file reading */
1078
1079/* Create a new bfd section from an ELF section header. */
1080
1081boolean
1082bfd_section_from_shdr (abfd, shindex)
1083 bfd *abfd;
1084 unsigned int shindex;
1085{
1086 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1087 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1088 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1089 char *name;
1090
1091 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1092
1093 switch (hdr->sh_type)
1094 {
1095 case SHT_NULL:
1096 /* Inactive section. Throw it away. */
1097 return true;
1098
1099 case SHT_PROGBITS: /* Normal section with contents. */
1100 case SHT_DYNAMIC: /* Dynamic linking information. */
1101 case SHT_NOBITS: /* .bss section. */
1102 case SHT_HASH: /* .hash section. */
1103 case SHT_NOTE: /* .note section. */
1104 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1105
1106 case SHT_SYMTAB: /* A symbol table */
1107 if (elf_onesymtab (abfd) == shindex)
1108 return true;
1109
1110 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1111 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1112 elf_onesymtab (abfd) = shindex;
1113 elf_tdata (abfd)->symtab_hdr = *hdr;
1114 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1115 abfd->flags |= HAS_SYMS;
1116
1117 /* Sometimes a shared object will map in the symbol table. If
1118 SHF_ALLOC is set, and this is a shared object, then we also
1119 treat this section as a BFD section. We can not base the
1120 decision purely on SHF_ALLOC, because that flag is sometimes
1121 set in a relocateable object file, which would confuse the
1122 linker. */
1123 if ((hdr->sh_flags & SHF_ALLOC) != 0
1124 && (abfd->flags & DYNAMIC) != 0
1125 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1126 return false;
1127
1128 return true;
1129
1130 case SHT_DYNSYM: /* A dynamic symbol table */
1131 if (elf_dynsymtab (abfd) == shindex)
1132 return true;
1133
1134 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1135 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1136 elf_dynsymtab (abfd) = shindex;
1137 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1138 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1139 abfd->flags |= HAS_SYMS;
1140
1141 /* Besides being a symbol table, we also treat this as a regular
1142 section, so that objcopy can handle it. */
1143 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1144
1145 case SHT_STRTAB: /* A string table */
1146 if (hdr->bfd_section != NULL)
1147 return true;
1148 if (ehdr->e_shstrndx == shindex)
1149 {
1150 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1151 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1152 return true;
1153 }
1154 {
1155 unsigned int i;
1156
1157 for (i = 1; i < ehdr->e_shnum; i++)
1158 {
1159 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1160 if (hdr2->sh_link == shindex)
1161 {
1162 if (! bfd_section_from_shdr (abfd, i))
1163 return false;
1164 if (elf_onesymtab (abfd) == i)
1165 {
1166 elf_tdata (abfd)->strtab_hdr = *hdr;
1167 elf_elfsections (abfd)[shindex] =
1168 &elf_tdata (abfd)->strtab_hdr;
1169 return true;
1170 }
1171 if (elf_dynsymtab (abfd) == i)
1172 {
1173 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1174 elf_elfsections (abfd)[shindex] = hdr =
1175 &elf_tdata (abfd)->dynstrtab_hdr;
1176 /* We also treat this as a regular section, so
1177 that objcopy can handle it. */
1178 break;
1179 }
1180#if 0 /* Not handling other string tables specially right now. */
1181 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1182 /* We have a strtab for some random other section. */
1183 newsect = (asection *) hdr2->bfd_section;
1184 if (!newsect)
1185 break;
1186 hdr->bfd_section = newsect;
1187 hdr2 = &elf_section_data (newsect)->str_hdr;
1188 *hdr2 = *hdr;
1189 elf_elfsections (abfd)[shindex] = hdr2;
1190#endif
1191 }
1192 }
1193 }
1194
1195 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1196
1197 case SHT_REL:
1198 case SHT_RELA:
1199 /* *These* do a lot of work -- but build no sections! */
1200 {
1201 asection *target_sect;
1202 Elf_Internal_Shdr *hdr2;
1203
1204 /* For some incomprehensible reason Oracle distributes
1205 libraries for Solaris in which some of the objects have
1206 bogus sh_link fields. It would be nice if we could just
1207 reject them, but, unfortunately, some people need to use
1208 them. We scan through the section headers; if we find only
1209 one suitable symbol table, we clobber the sh_link to point
1210 to it. I hope this doesn't break anything. */
1211 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1212 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1213 {
1214 int scan;
1215 int found;
1216
1217 found = 0;
1218 for (scan = 1; scan < ehdr->e_shnum; scan++)
1219 {
1220 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1221 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1222 {
1223 if (found != 0)
1224 {
1225 found = 0;
1226 break;
1227 }
1228 found = scan;
1229 }
1230 }
1231 if (found != 0)
1232 hdr->sh_link = found;
1233 }
1234
1235 /* Get the symbol table. */
1236 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1237 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1238 return false;
1239
1240 /* If this reloc section does not use the main symbol table we
1241 don't treat it as a reloc section. BFD can't adequately
1242 represent such a section, so at least for now, we don't
1243 try. We just present it as a normal section. */
1244 if (hdr->sh_link != elf_onesymtab (abfd))
1245 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1246
1247 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1248 return false;
1249 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1250 if (target_sect == NULL)
1251 return false;
1252
1253 if ((target_sect->flags & SEC_RELOC) == 0
1254 || target_sect->reloc_count == 0)
1255 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1256 else
1257 {
1258 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1259 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1260 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1261 }
1262 *hdr2 = *hdr;
1263 elf_elfsections (abfd)[shindex] = hdr2;
1264 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
1265 target_sect->flags |= SEC_RELOC;
1266 target_sect->relocation = NULL;
1267 target_sect->rel_filepos = hdr->sh_offset;
1268 abfd->flags |= HAS_RELOC;
1269 return true;
1270 }
1271 break;
1272
1273 case SHT_GNU_verdef:
1274 elf_dynverdef (abfd) = shindex;
1275 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1276 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1277 break;
1278
1279 case SHT_GNU_versym:
1280 elf_dynversym (abfd) = shindex;
1281 elf_tdata (abfd)->dynversym_hdr = *hdr;
1282 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1283 break;
1284
1285 case SHT_GNU_verneed:
1286 elf_dynverref (abfd) = shindex;
1287 elf_tdata (abfd)->dynverref_hdr = *hdr;
1288 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1289 break;
1290
1291 case SHT_SHLIB:
1292 return true;
1293
1294 default:
1295 /* Check for any processor-specific section types. */
1296 {
1297 if (bed->elf_backend_section_from_shdr)
1298 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1299 }
1300 break;
1301 }
1302
1303 return true;
1304}
1305
1306/* Given an ELF section number, retrieve the corresponding BFD
1307 section. */
1308
1309asection *
1310bfd_section_from_elf_index (abfd, index)
1311 bfd *abfd;
1312 unsigned int index;
1313{
1314 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1315 if (index >= elf_elfheader (abfd)->e_shnum)
1316 return NULL;
1317 return elf_elfsections (abfd)[index]->bfd_section;
1318}
1319
1320boolean
1321_bfd_elf_new_section_hook (abfd, sec)
1322 bfd *abfd;
1323 asection *sec;
1324{
1325 struct bfd_elf_section_data *sdata;
1326
1327 sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
1328 if (!sdata)
1329 return false;
1330 sec->used_by_bfd = (PTR) sdata;
1331 memset (sdata, 0, sizeof (*sdata));
1332 return true;
1333}
1334
1335/* Create a new bfd section from an ELF program header.
1336
1337 Since program segments have no names, we generate a synthetic name
1338 of the form segment<NUM>, where NUM is generally the index in the
1339 program header table. For segments that are split (see below) we
1340 generate the names segment<NUM>a and segment<NUM>b.
1341
1342 Note that some program segments may have a file size that is different than
1343 (less than) the memory size. All this means is that at execution the
1344 system must allocate the amount of memory specified by the memory size,
1345 but only initialize it with the first "file size" bytes read from the
1346 file. This would occur for example, with program segments consisting
1347 of combined data+bss.
1348
1349 To handle the above situation, this routine generates TWO bfd sections
1350 for the single program segment. The first has the length specified by
1351 the file size of the segment, and the second has the length specified
1352 by the difference between the two sizes. In effect, the segment is split
1353 into it's initialized and uninitialized parts.
1354
1355 */
1356
1357boolean
1358bfd_section_from_phdr (abfd, hdr, index)
1359 bfd *abfd;
1360 Elf_Internal_Phdr *hdr;
1361 int index;
1362{
1363 asection *newsect;
1364 char *name;
1365 char namebuf[64];
1366 int split;
1367
1368 split = ((hdr->p_memsz > 0)
1369 && (hdr->p_filesz > 0)
1370 && (hdr->p_memsz > hdr->p_filesz));
1371 sprintf (namebuf, split ? "segment%da" : "segment%d", index);
1372 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1373 if (!name)
1374 return false;
1375 strcpy (name, namebuf);
1376 newsect = bfd_make_section (abfd, name);
1377 if (newsect == NULL)
1378 return false;
1379 newsect->vma = hdr->p_vaddr;
1380 newsect->lma = hdr->p_paddr;
1381 newsect->_raw_size = hdr->p_filesz;
1382 newsect->filepos = hdr->p_offset;
1383 newsect->flags |= SEC_HAS_CONTENTS;
1384 if (hdr->p_type == PT_LOAD)
1385 {
1386 newsect->flags |= SEC_ALLOC;
1387 newsect->flags |= SEC_LOAD;
1388 if (hdr->p_flags & PF_X)
1389 {
1390 /* FIXME: all we known is that it has execute PERMISSION,
1391 may be data. */
1392 newsect->flags |= SEC_CODE;
1393 }
1394 }
1395 if (!(hdr->p_flags & PF_W))
1396 {
1397 newsect->flags |= SEC_READONLY;
1398 }
1399
1400 if (split)
1401 {
1402 sprintf (namebuf, "segment%db", index);
1403 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1404 if (!name)
1405 return false;
1406 strcpy (name, namebuf);
1407 newsect = bfd_make_section (abfd, name);
1408 if (newsect == NULL)
1409 return false;
1410 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1411 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1412 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1413 if (hdr->p_type == PT_LOAD)
1414 {
1415 newsect->flags |= SEC_ALLOC;
1416 if (hdr->p_flags & PF_X)
1417 newsect->flags |= SEC_CODE;
1418 }
1419 if (!(hdr->p_flags & PF_W))
1420 newsect->flags |= SEC_READONLY;
1421 }
1422
1423 return true;
1424}
1425
1426/* Set up an ELF internal section header for a section. */
1427
1428/*ARGSUSED*/
1429static void
1430elf_fake_sections (abfd, asect, failedptrarg)
1431 bfd *abfd;
1432 asection *asect;
1433 PTR failedptrarg;
1434{
1435 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1436 boolean *failedptr = (boolean *) failedptrarg;
1437 Elf_Internal_Shdr *this_hdr;
1438
1439 if (*failedptr)
1440 {
1441 /* We already failed; just get out of the bfd_map_over_sections
1442 loop. */
1443 return;
1444 }
1445
1446 this_hdr = &elf_section_data (asect)->this_hdr;
1447
1448 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1449 asect->name,
1450 true, false);
1451 if (this_hdr->sh_name == (unsigned long) -1)
1452 {
1453 *failedptr = true;
1454 return;
1455 }
1456
1457 this_hdr->sh_flags = 0;
1458
1459 if ((asect->flags & SEC_ALLOC) != 0
1460 || asect->user_set_vma)
1461 this_hdr->sh_addr = asect->vma;
1462 else
1463 this_hdr->sh_addr = 0;
1464
1465 this_hdr->sh_offset = 0;
1466 this_hdr->sh_size = asect->_raw_size;
1467 this_hdr->sh_link = 0;
1468 this_hdr->sh_addralign = 1 << asect->alignment_power;
1469 /* The sh_entsize and sh_info fields may have been set already by
1470 copy_private_section_data. */
1471
1472 this_hdr->bfd_section = asect;
1473 this_hdr->contents = NULL;
1474
1475 /* FIXME: This should not be based on section names. */
1476 if (strcmp (asect->name, ".dynstr") == 0)
1477 this_hdr->sh_type = SHT_STRTAB;
1478 else if (strcmp (asect->name, ".hash") == 0)
1479 {
1480 this_hdr->sh_type = SHT_HASH;
1481 this_hdr->sh_entsize = bed->s->arch_size / 8;
1482 }
1483 else if (strcmp (asect->name, ".dynsym") == 0)
1484 {
1485 this_hdr->sh_type = SHT_DYNSYM;
1486 this_hdr->sh_entsize = bed->s->sizeof_sym;
1487 }
1488 else if (strcmp (asect->name, ".dynamic") == 0)
1489 {
1490 this_hdr->sh_type = SHT_DYNAMIC;
1491 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1492 }
c1f6bc03 1493 else if (strncmp (asect->name, ".rela.", 6) == 0
252b5132
RH		 1494 && get_elf_backend_data (abfd)->use_rela_p)
1495 {
1496 this_hdr->sh_type = SHT_RELA;
1497 this_hdr->sh_entsize = bed->s->sizeof_rela;
1498 }
c1f6bc03 1499 else if (strncmp (asect->name, ".rel.", 5) == 0
252b5132
RH		 1500 && ! get_elf_backend_data (abfd)->use_rela_p)
1501 {
1502 this_hdr->sh_type = SHT_REL;
1503 this_hdr->sh_entsize = bed->s->sizeof_rel;
1504 }
1505 else if (strncmp (asect->name, ".note", 5) == 0)
1506 this_hdr->sh_type = SHT_NOTE;
1507 else if (strncmp (asect->name, ".stab", 5) == 0
1508 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1509 this_hdr->sh_type = SHT_STRTAB;
1510 else if (strcmp (asect->name, ".gnu.version") == 0)
1511 {
1512 this_hdr->sh_type = SHT_GNU_versym;
1513 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1514 }
1515 else if (strcmp (asect->name, ".gnu.version_d") == 0)
1516 {
1517 this_hdr->sh_type = SHT_GNU_verdef;
1518 this_hdr->sh_entsize = 0;
1519 /* objcopy or strip will copy over sh_info, but may not set
1520 cverdefs. The linker will set cverdefs, but sh_info will be
1521 zero. */
1522 if (this_hdr->sh_info == 0)
1523 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1524 else
1525 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1526 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1527 }
1528 else if (strcmp (asect->name, ".gnu.version_r") == 0)
1529 {
1530 this_hdr->sh_type = SHT_GNU_verneed;
1531 this_hdr->sh_entsize = 0;
1532 /* objcopy or strip will copy over sh_info, but may not set
1533 cverrefs. The linker will set cverrefs, but sh_info will be
1534 zero. */
1535 if (this_hdr->sh_info == 0)
1536 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1537 else
1538 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1539 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1540 }
1541 else if ((asect->flags & SEC_ALLOC) != 0
1542 && (asect->flags & SEC_LOAD) != 0)
1543 this_hdr->sh_type = SHT_PROGBITS;
1544 else if ((asect->flags & SEC_ALLOC) != 0
1545 && ((asect->flags & SEC_LOAD) == 0))
1546 this_hdr->sh_type = SHT_NOBITS;
1547 else
1548 {
1549 /* Who knows? */
1550 this_hdr->sh_type = SHT_PROGBITS;
1551 }
1552
1553 if ((asect->flags & SEC_ALLOC) != 0)
1554 this_hdr->sh_flags |= SHF_ALLOC;
1555 if ((asect->flags & SEC_READONLY) == 0)
1556 this_hdr->sh_flags |= SHF_WRITE;
1557 if ((asect->flags & SEC_CODE) != 0)
1558 this_hdr->sh_flags |= SHF_EXECINSTR;
1559
1560 /* Check for processor-specific section types. */
1561 {
1562 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1563
1564 if (bed->elf_backend_fake_sections)
1565 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1566 }
1567
1568 /* If the section has relocs, set up a section header for the
1569 SHT_REL[A] section. */
1570 if ((asect->flags & SEC_RELOC) != 0)
1571 {
1572 Elf_Internal_Shdr *rela_hdr;
1573 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1574 char *name;
1575
1576 rela_hdr = &elf_section_data (asect)->rel_hdr;
1577 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1578 if (name == NULL)
1579 {
1580 *failedptr = true;
1581 return;
1582 }
1583 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1584 rela_hdr->sh_name =
1585 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1586 true, false);
1587 if (rela_hdr->sh_name == (unsigned int) -1)
1588 {
1589 *failedptr = true;
1590 return;
1591 }
1592 rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1593 rela_hdr->sh_entsize = (use_rela_p
1594 ? bed->s->sizeof_rela
1595 : bed->s->sizeof_rel);
1596 rela_hdr->sh_addralign = bed->s->file_align;
1597 rela_hdr->sh_flags = 0;
1598 rela_hdr->sh_addr = 0;
1599 rela_hdr->sh_size = 0;
1600 rela_hdr->sh_offset = 0;
1601 }
1602}
1603
1604/* Assign all ELF section numbers. The dummy first section is handled here
1605 too. The link/info pointers for the standard section types are filled
1606 in here too, while we're at it. */
1607
1608static boolean
1609assign_section_numbers (abfd)
1610 bfd *abfd;
1611{
1612 struct elf_obj_tdata *t = elf_tdata (abfd);
1613 asection *sec;
1614 unsigned int section_number;
1615 Elf_Internal_Shdr **i_shdrp;
1616 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1617
1618 section_number = 1;
1619
1620 for (sec = abfd->sections; sec; sec = sec->next)
1621 {
1622 struct bfd_elf_section_data *d = elf_section_data (sec);
1623
1624 d->this_idx = section_number++;
1625 if ((sec->flags & SEC_RELOC) == 0)
1626 d->rel_idx = 0;
1627 else
1628 d->rel_idx = section_number++;
1629 }
1630
1631 t->shstrtab_section = section_number++;
1632 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1633 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1634
1635 if (bfd_get_symcount (abfd) > 0)
1636 {
1637 t->symtab_section = section_number++;
1638 t->strtab_section = section_number++;
1639 }
1640
1641 elf_elfheader (abfd)->e_shnum = section_number;
1642
1643 /* Set up the list of section header pointers, in agreement with the
1644 indices. */
1645 i_shdrp = ((Elf_Internal_Shdr **)
1646 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1647 if (i_shdrp == NULL)
1648 return false;
1649
1650 i_shdrp[0] = ((Elf_Internal_Shdr *)
1651 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1652 if (i_shdrp[0] == NULL)
1653 {
1654 bfd_release (abfd, i_shdrp);
1655 return false;
1656 }
1657 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1658
1659 elf_elfsections (abfd) = i_shdrp;
1660
1661 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1662 if (bfd_get_symcount (abfd) > 0)
1663 {
1664 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1665 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1666 t->symtab_hdr.sh_link = t->strtab_section;
1667 }
1668 for (sec = abfd->sections; sec; sec = sec->next)
1669 {
1670 struct bfd_elf_section_data *d = elf_section_data (sec);
1671 asection *s;
1672 const char *name;
1673
1674 i_shdrp[d->this_idx] = &d->this_hdr;
1675 if (d->rel_idx != 0)
1676 i_shdrp[d->rel_idx] = &d->rel_hdr;
1677
1678 /* Fill in the sh_link and sh_info fields while we're at it. */
1679
1680 /* sh_link of a reloc section is the section index of the symbol
1681 table. sh_info is the section index of the section to which
1682 the relocation entries apply. */
1683 if (d->rel_idx != 0)
1684 {
1685 d->rel_hdr.sh_link = t->symtab_section;
1686 d->rel_hdr.sh_info = d->this_idx;
1687 }
1688
1689 switch (d->this_hdr.sh_type)
1690 {
1691 case SHT_REL:
1692 case SHT_RELA:
1693 /* A reloc section which we are treating as a normal BFD
1694 section. sh_link is the section index of the symbol
1695 table. sh_info is the section index of the section to
1696 which the relocation entries apply. We assume that an
1697 allocated reloc section uses the dynamic symbol table.
1698 FIXME: How can we be sure? */
1699 s = bfd_get_section_by_name (abfd, ".dynsym");
1700 if (s != NULL)
1701 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1702
1703 /* We look up the section the relocs apply to by name. */
1704 name = sec->name;
1705 if (d->this_hdr.sh_type == SHT_REL)
1706 name += 4;
1707 else
1708 name += 5;
1709 s = bfd_get_section_by_name (abfd, name);
1710 if (s != NULL)
1711 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1712 break;
1713
1714 case SHT_STRTAB:
1715 /* We assume that a section named .stab*str is a stabs
1716 string section. We look for a section with the same name
1717 but without the trailing ``str'', and set its sh_link
1718 field to point to this section. */
1719 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1720 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1721 {
1722 size_t len;
1723 char *alc;
1724
1725 len = strlen (sec->name);
1726 alc = (char *) bfd_malloc (len - 2);
1727 if (alc == NULL)
1728 return false;
1729 strncpy (alc, sec->name, len - 3);
1730 alc[len - 3] = '\0';
1731 s = bfd_get_section_by_name (abfd, alc);
1732 free (alc);
1733 if (s != NULL)
1734 {
1735 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1736
1737 /* This is a .stab section. */
1738 elf_section_data (s)->this_hdr.sh_entsize =
1739 4 + 2 * (bed->s->arch_size / 8);
1740 }
1741 }
1742 break;
1743
1744 case SHT_DYNAMIC:
1745 case SHT_DYNSYM:
1746 case SHT_GNU_verneed:
1747 case SHT_GNU_verdef:
1748 /* sh_link is the section header index of the string table
1749 used for the dynamic entries, or the symbol table, or the
1750 version strings. */
1751 s = bfd_get_section_by_name (abfd, ".dynstr");
1752 if (s != NULL)
1753 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1754 break;
1755
1756 case SHT_HASH:
1757 case SHT_GNU_versym:
1758 /* sh_link is the section header index of the symbol table
1759 this hash table or version table is for. */
1760 s = bfd_get_section_by_name (abfd, ".dynsym");
1761 if (s != NULL)
1762 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1763 break;
1764 }
1765 }
1766
1767 return true;
1768}
1769
1770/* Map symbol from it's internal number to the external number, moving
1771 all local symbols to be at the head of the list. */
1772
1773static INLINE int
1774sym_is_global (abfd, sym)
1775 bfd *abfd;
1776 asymbol *sym;
1777{
1778 /* If the backend has a special mapping, use it. */
1779 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1780 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1781 (abfd, sym));
1782
1783 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1784 || bfd_is_und_section (bfd_get_section (sym))
1785 || bfd_is_com_section (bfd_get_section (sym)));
1786}
1787
1788static boolean
1789elf_map_symbols (abfd)
1790 bfd *abfd;
1791{
1792 int symcount = bfd_get_symcount (abfd);
1793 asymbol **syms = bfd_get_outsymbols (abfd);
1794 asymbol **sect_syms;
1795 int num_locals = 0;
1796 int num_globals = 0;
1797 int num_locals2 = 0;
1798 int num_globals2 = 0;
1799 int max_index = 0;
1800 int num_sections = 0;
1801 int idx;
1802 asection *asect;
1803 asymbol **new_syms;
1804 asymbol *sym;
1805
1806#ifdef DEBUG
1807 fprintf (stderr, "elf_map_symbols\n");
1808 fflush (stderr);
1809#endif
1810
1811 /* Add a section symbol for each BFD section. FIXME: Is this really
1812 necessary? */
1813 for (asect = abfd->sections; asect; asect = asect->next)
1814 {
1815 if (max_index < asect->index)
1816 max_index = asect->index;
1817 }
1818
1819 max_index++;
1820 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1821 if (sect_syms == NULL)
1822 return false;
1823 elf_section_syms (abfd) = sect_syms;
1824
1825 for (idx = 0; idx < symcount; idx++)
1826 {
1827 sym = syms[idx];
1828
1829 if ((sym->flags & BSF_SECTION_SYM) != 0
1830 && sym->value == 0)
1831 {
1832 asection *sec;
1833
1834 sec = sym->section;
1835
1836 if (sec->owner != NULL)
1837 {
1838 if (sec->owner != abfd)
1839 {
1840 if (sec->output_offset != 0)
1841 continue;
1842
1843 sec = sec->output_section;
1844
1845 /* Empty sections in the input files may have had a section
1846 symbol created for them. (See the comment near the end of
1847 _bfd_generic_link_output_symbols in linker.c). If the linker
1848 script discards such sections then we will reach this point.
1849 Since we know that we cannot avoid this case, we detect it
1850 and skip the abort and the assignment to the sect_syms array.
1851 To reproduce this particular case try running the linker
1852 testsuite test ld-scripts/weak.exp for an ELF port that uses
1853 the generic linker. */
1854 if (sec->owner == NULL)
1855 continue;
1856
1857 BFD_ASSERT (sec->owner == abfd);
1858 }
1859 sect_syms[sec->index] = syms[idx];
1860 }
1861 }
1862 }
1863
1864 for (asect = abfd->sections; asect; asect = asect->next)
1865 {
1866 if (sect_syms[asect->index] != NULL)
1867 continue;
1868
1869 sym = bfd_make_empty_symbol (abfd);
1870 if (sym == NULL)
1871 return false;
1872 sym->the_bfd = abfd;
1873 sym->name = asect->name;
1874 sym->value = 0;
1875 /* Set the flags to 0 to indicate that this one was newly added. */
1876 sym->flags = 0;
1877 sym->section = asect;
1878 sect_syms[asect->index] = sym;
1879 num_sections++;
1880#ifdef DEBUG
1881 fprintf (stderr,
1882 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1883 asect->name, (long) asect->vma, asect->index, (long) asect);
1884#endif
1885 }
1886
1887 /* Classify all of the symbols. */
1888 for (idx = 0; idx < symcount; idx++)
1889 {
1890 if (!sym_is_global (abfd, syms[idx]))
1891 num_locals++;
1892 else
1893 num_globals++;
1894 }
1895 for (asect = abfd->sections; asect; asect = asect->next)
1896 {
1897 if (sect_syms[asect->index] != NULL
1898 && sect_syms[asect->index]->flags == 0)
1899 {
1900 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
1901 if (!sym_is_global (abfd, sect_syms[asect->index]))
1902 num_locals++;
1903 else
1904 num_globals++;
1905 sect_syms[asect->index]->flags = 0;
1906 }
1907 }
1908
1909 /* Now sort the symbols so the local symbols are first. */
1910 new_syms = ((asymbol **)
1911 bfd_alloc (abfd,
1912 (num_locals + num_globals) * sizeof (asymbol *)));
1913 if (new_syms == NULL)
1914 return false;
1915
1916 for (idx = 0; idx < symcount; idx++)
1917 {
1918 asymbol *sym = syms[idx];
1919 int i;
1920
1921 if (!sym_is_global (abfd, sym))
1922 i = num_locals2++;
1923 else
1924 i = num_locals + num_globals2++;
1925 new_syms[i] = sym;
1926 sym->udata.i = i + 1;
1927 }
1928 for (asect = abfd->sections; asect; asect = asect->next)
1929 {
1930 if (sect_syms[asect->index] != NULL
1931 && sect_syms[asect->index]->flags == 0)
1932 {
1933 asymbol *sym = sect_syms[asect->index];
1934 int i;
1935
1936 sym->flags = BSF_SECTION_SYM;
1937 if (!sym_is_global (abfd, sym))
1938 i = num_locals2++;
1939 else
1940 i = num_locals + num_globals2++;
1941 new_syms[i] = sym;
1942 sym->udata.i = i + 1;
1943 }
1944 }
1945
1946 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
1947
1948 elf_num_locals (abfd) = num_locals;
1949 elf_num_globals (abfd) = num_globals;
1950 return true;
1951}
1952
1953/* Align to the maximum file alignment that could be required for any
1954 ELF data structure. */
1955
1956static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
1957static INLINE file_ptr
1958align_file_position (off, align)
1959 file_ptr off;
1960 int align;
1961{
1962 return (off + align - 1) & ~(align - 1);
1963}
1964
1965/* Assign a file position to a section, optionally aligning to the
1966 required section alignment. */
1967
1968INLINE file_ptr
1969_bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
1970 Elf_Internal_Shdr *i_shdrp;
1971 file_ptr offset;
1972 boolean align;
1973{
1974 if (align)
1975 {
1976 unsigned int al;
1977
1978 al = i_shdrp->sh_addralign;
1979 if (al > 1)
1980 offset = BFD_ALIGN (offset, al);
1981 }
1982 i_shdrp->sh_offset = offset;
1983 if (i_shdrp->bfd_section != NULL)
1984 i_shdrp->bfd_section->filepos = offset;
1985 if (i_shdrp->sh_type != SHT_NOBITS)
1986 offset += i_shdrp->sh_size;
1987 return offset;
1988}
1989
1990/* Compute the file positions we are going to put the sections at, and
1991 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1992 is not NULL, this is being called by the ELF backend linker. */
1993
1994boolean
1995_bfd_elf_compute_section_file_positions (abfd, link_info)
1996 bfd *abfd;
1997 struct bfd_link_info *link_info;
1998{
1999 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2000 boolean failed;
2001 struct bfd_strtab_hash *strtab;
2002 Elf_Internal_Shdr *shstrtab_hdr;
2003
2004 if (abfd->output_has_begun)
2005 return true;
2006
2007 /* Do any elf backend specific processing first. */
2008 if (bed->elf_backend_begin_write_processing)
2009 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2010
2011 if (! prep_headers (abfd))
2012 return false;
2013
2014 failed = false;
2015 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2016 if (failed)
2017 return false;
2018
2019 if (!assign_section_numbers (abfd))
2020 return false;
2021
2022 /* The backend linker builds symbol table information itself. */
2023 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2024 {
2025 /* Non-zero if doing a relocatable link. */
2026 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2027
2028 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2029 return false;
2030 }
2031
2032 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2033 /* sh_name was set in prep_headers. */
2034 shstrtab_hdr->sh_type = SHT_STRTAB;
2035 shstrtab_hdr->sh_flags = 0;
2036 shstrtab_hdr->sh_addr = 0;
2037 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2038 shstrtab_hdr->sh_entsize = 0;
2039 shstrtab_hdr->sh_link = 0;
2040 shstrtab_hdr->sh_info = 0;
2041 /* sh_offset is set in assign_file_positions_except_relocs. */
2042 shstrtab_hdr->sh_addralign = 1;
2043
2044 if (!assign_file_positions_except_relocs (abfd))
2045 return false;
2046
2047 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2048 {
2049 file_ptr off;
2050 Elf_Internal_Shdr *hdr;
2051
2052 off = elf_tdata (abfd)->next_file_pos;
2053
2054 hdr = &elf_tdata (abfd)->symtab_hdr;
2055 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2056
2057 hdr = &elf_tdata (abfd)->strtab_hdr;
2058 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2059
2060 elf_tdata (abfd)->next_file_pos = off;
2061
2062 /* Now that we know where the .strtab section goes, write it
2063 out. */
2064 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2065 || ! _bfd_stringtab_emit (abfd, strtab))
2066 return false;
2067 _bfd_stringtab_free (strtab);
2068 }
2069
2070 abfd->output_has_begun = true;
2071
2072 return true;
2073}
2074
2075/* Create a mapping from a set of sections to a program segment. */
2076
2077static INLINE struct elf_segment_map *
2078make_mapping (abfd, sections, from, to, phdr)
2079 bfd *abfd;
2080 asection **sections;
2081 unsigned int from;
2082 unsigned int to;
2083 boolean phdr;
2084{
2085 struct elf_segment_map *m;
2086 unsigned int i;
2087 asection **hdrpp;
2088
2089 m = ((struct elf_segment_map *)
2090 bfd_zalloc (abfd,
2091 (sizeof (struct elf_segment_map)
2092 + (to - from - 1) * sizeof (asection *))));
2093 if (m == NULL)
2094 return NULL;
2095 m->next = NULL;
2096 m->p_type = PT_LOAD;
2097 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2098 m->sections[i - from] = *hdrpp;
2099 m->count = to - from;
2100
2101 if (from == 0 && phdr)
2102 {
2103 /* Include the headers in the first PT_LOAD segment. */
2104 m->includes_filehdr = 1;
2105 m->includes_phdrs = 1;
2106 }
2107
2108 return m;
2109}
2110
2111/* Set up a mapping from BFD sections to program segments. */
2112
2113static boolean
2114map_sections_to_segments (abfd)
2115 bfd *abfd;
2116{
2117 asection **sections = NULL;
2118 asection *s;
2119 unsigned int i;
2120 unsigned int count;
2121 struct elf_segment_map *mfirst;
2122 struct elf_segment_map **pm;
2123 struct elf_segment_map *m;
2124 asection *last_hdr;
2125 unsigned int phdr_index;
2126 bfd_vma maxpagesize;
2127 asection **hdrpp;
2128 boolean phdr_in_segment = true;
2129 boolean writable;
2130 asection *dynsec;
2131
2132 if (elf_tdata (abfd)->segment_map != NULL)
2133 return true;
2134
2135 if (bfd_count_sections (abfd) == 0)
2136 return true;
2137
2138 /* Select the allocated sections, and sort them. */
2139
2140 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2141 * sizeof (asection *));
2142 if (sections == NULL)
2143 goto error_return;
2144
2145 i = 0;
2146 for (s = abfd->sections; s != NULL; s = s->next)
2147 {
2148 if ((s->flags & SEC_ALLOC) != 0)
2149 {
2150 sections[i] = s;
2151 ++i;
2152 }
2153 }
2154 BFD_ASSERT (i <= bfd_count_sections (abfd));
2155 count = i;
2156
2157 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2158
2159 /* Build the mapping. */
2160
2161 mfirst = NULL;
2162 pm = &mfirst;
2163
2164 /* If we have a .interp section, then create a PT_PHDR segment for
2165 the program headers and a PT_INTERP segment for the .interp
2166 section. */
2167 s = bfd_get_section_by_name (abfd, ".interp");
2168 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2169 {
2170 m = ((struct elf_segment_map *)
2171 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2172 if (m == NULL)
2173 goto error_return;
2174 m->next = NULL;
2175 m->p_type = PT_PHDR;
2176 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2177 m->p_flags = PF_R | PF_X;
2178 m->p_flags_valid = 1;
2179 m->includes_phdrs = 1;
2180
2181 *pm = m;
2182 pm = &m->next;
2183
2184 m = ((struct elf_segment_map *)
2185 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2186 if (m == NULL)
2187 goto error_return;
2188 m->next = NULL;
2189 m->p_type = PT_INTERP;
2190 m->count = 1;
2191 m->sections[0] = s;
2192
2193 *pm = m;
2194 pm = &m->next;
2195 }
2196
2197 /* Look through the sections. We put sections in the same program
2198 segment when the start of the second section can be placed within
2199 a few bytes of the end of the first section. */
2200 last_hdr = NULL;
2201 phdr_index = 0;
2202 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2203 writable = false;
2204 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2205 if (dynsec != NULL
2206 && (dynsec->flags & SEC_LOAD) == 0)
2207 dynsec = NULL;
2208
2209 /* Deal with -Ttext or something similar such that the first section
2210 is not adjacent to the program headers. This is an
2211 approximation, since at this point we don't know exactly how many
2212 program headers we will need. */
2213 if (count > 0)
2214 {
2215 bfd_size_type phdr_size;
2216
2217 phdr_size = elf_tdata (abfd)->program_header_size;
2218 if (phdr_size == 0)
2219 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2220 if ((abfd->flags & D_PAGED) == 0
2221 || sections[0]->lma < phdr_size
2222 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2223 phdr_in_segment = false;
2224 }
2225
2226 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2227 {
2228 asection *hdr;
2229 boolean new_segment;
2230
2231 hdr = *hdrpp;
2232
2233 /* See if this section and the last one will fit in the same
2234 segment. */
2235
2236 if (last_hdr == NULL)
2237 {
2238 /* If we don't have a segment yet, then we don't need a new
2239 one (we build the last one after this loop). */
2240 new_segment = false;
2241 }
2242 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2243 {
2244 /* If this section has a different relation between the
2245 virtual address and the load address, then we need a new
2246 segment. */
2247 new_segment = true;
2248 }
2249 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2250 < BFD_ALIGN (hdr->lma, maxpagesize))
2251 {
2252 /* If putting this section in this segment would force us to
2253 skip a page in the segment, then we need a new segment. */
2254 new_segment = true;
2255 }
2256 else if ((last_hdr->flags & SEC_LOAD) == 0
2257 && (hdr->flags & SEC_LOAD) != 0)
2258 {
2259 /* We don't want to put a loadable section after a
2260 nonloadable section in the same segment. */
2261 new_segment = true;
2262 }
2263 else if ((abfd->flags & D_PAGED) == 0)
2264 {
2265 /* If the file is not demand paged, which means that we
2266 don't require the sections to be correctly aligned in the
2267 file, then there is no other reason for a new segment. */
2268 new_segment = false;
2269 }
2270 else if (! writable
2271 && (hdr->flags & SEC_READONLY) == 0
2272 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2273 == hdr->lma))
2274 {
2275 /* We don't want to put a writable section in a read only
2276 segment, unless they are on the same page in memory
2277 anyhow. We already know that the last section does not
2278 bring us past the current section on the page, so the
2279 only case in which the new section is not on the same
2280 page as the previous section is when the previous section
2281 ends precisely on a page boundary. */
2282 new_segment = true;
2283 }
2284 else
2285 {
2286 /* Otherwise, we can use the same segment. */
2287 new_segment = false;
2288 }
2289
2290 if (! new_segment)
2291 {
2292 if ((hdr->flags & SEC_READONLY) == 0)
2293 writable = true;
2294 last_hdr = hdr;
2295 continue;
2296 }
2297
2298 /* We need a new program segment. We must create a new program
2299 header holding all the sections from phdr_index until hdr. */
2300
2301 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2302 if (m == NULL)
2303 goto error_return;
2304
2305 *pm = m;
2306 pm = &m->next;
2307
2308 if ((hdr->flags & SEC_READONLY) == 0)
2309 writable = true;
2310 else
2311 writable = false;
2312
2313 last_hdr = hdr;
2314 phdr_index = i;
2315 phdr_in_segment = false;
2316 }
2317
2318 /* Create a final PT_LOAD program segment. */
2319 if (last_hdr != NULL)
2320 {
2321 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2322 if (m == NULL)
2323 goto error_return;
2324
2325 *pm = m;
2326 pm = &m->next;
2327 }
2328
2329 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2330 if (dynsec != NULL)
2331 {
2332 m = ((struct elf_segment_map *)
2333 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2334 if (m == NULL)
2335 goto error_return;
2336 m->next = NULL;
2337 m->p_type = PT_DYNAMIC;
2338 m->count = 1;
2339 m->sections[0] = dynsec;
2340
2341 *pm = m;
2342 pm = &m->next;
2343 }
2344
2345 /* For each loadable .note section, add a PT_NOTE segment. We don't
2346 use bfd_get_section_by_name, because if we link together
2347 nonloadable .note sections and loadable .note sections, we will
2348 generate two .note sections in the output file. FIXME: Using
2349 names for section types is bogus anyhow. */
2350 for (s = abfd->sections; s != NULL; s = s->next)
2351 {
2352 if ((s->flags & SEC_LOAD) != 0
2353 && strncmp (s->name, ".note", 5) == 0)
2354 {
2355 m = ((struct elf_segment_map *)
2356 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2357 if (m == NULL)
2358 goto error_return;
2359 m->next = NULL;
2360 m->p_type = PT_NOTE;
2361 m->count = 1;
2362 m->sections[0] = s;
2363
2364 *pm = m;
2365 pm = &m->next;
2366 }
2367 }
2368
2369 free (sections);
2370 sections = NULL;
2371
2372 elf_tdata (abfd)->segment_map = mfirst;
2373 return true;
2374
2375 error_return:
2376 if (sections != NULL)
2377 free (sections);
2378 return false;
2379}
2380
2381/* Sort sections by address. */
2382
2383static int
2384elf_sort_sections (arg1, arg2)
2385 const PTR arg1;
2386 const PTR arg2;
2387{
2388 const asection *sec1 = *(const asection **) arg1;
2389 const asection *sec2 = *(const asection **) arg2;
2390
2391 /* Sort by LMA first, since this is the address used to
2392 place the section into a segment. */
2393 if (sec1->lma < sec2->lma)
2394 return -1;
2395 else if (sec1->lma > sec2->lma)
2396 return 1;
2397
2398 /* Then sort by VMA. Normally the LMA and the VMA will be
2399 the same, and this will do nothing. */
2400 if (sec1->vma < sec2->vma)
2401 return -1;
2402 else if (sec1->vma > sec2->vma)
2403 return 1;
2404
2405 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2406
2407#define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2408
2409 if (TOEND (sec1))
2410 {
2411 if (TOEND (sec2))
2412 return sec1->target_index - sec2->target_index;
2413 else
2414 return 1;
2415 }
2416
2417 if (TOEND (sec2))
2418 return -1;
2419
2420#undef TOEND
2421
2422 /* Sort by size, to put zero sized sections before others at the
2423 same address. */
2424
2425 if (sec1->_raw_size < sec2->_raw_size)
2426 return -1;
2427 if (sec1->_raw_size > sec2->_raw_size)
2428 return 1;
2429
2430 return sec1->target_index - sec2->target_index;
2431}
2432
2433/* Assign file positions to the sections based on the mapping from
2434 sections to segments. This function also sets up some fields in
2435 the file header, and writes out the program headers. */
2436
2437static boolean
2438assign_file_positions_for_segments (abfd)
2439 bfd *abfd;
2440{
2441 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2442 unsigned int count;
2443 struct elf_segment_map *m;
2444 unsigned int alloc;
2445 Elf_Internal_Phdr *phdrs;
2446 file_ptr off, voff;
2447 bfd_vma filehdr_vaddr, filehdr_paddr;
2448 bfd_vma phdrs_vaddr, phdrs_paddr;
2449 Elf_Internal_Phdr *p;
2450
2451 if (elf_tdata (abfd)->segment_map == NULL)
2452 {
2453 if (! map_sections_to_segments (abfd))
2454 return false;
2455 }
2456
2457 if (bed->elf_backend_modify_segment_map)
2458 {
2459 if (! (*bed->elf_backend_modify_segment_map) (abfd))
2460 return false;
2461 }
2462
2463 count = 0;
2464 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2465 ++count;
2466
2467 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2468 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2469 elf_elfheader (abfd)->e_phnum = count;
2470
2471 if (count == 0)
2472 return true;
2473
2474 /* If we already counted the number of program segments, make sure
2475 that we allocated enough space. This happens when SIZEOF_HEADERS
2476 is used in a linker script. */
2477 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2478 if (alloc != 0 && count > alloc)
2479 {
2480 ((*_bfd_error_handler)
2481 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2482 bfd_get_filename (abfd), alloc, count));
2483 bfd_set_error (bfd_error_bad_value);
2484 return false;
2485 }
2486
2487 if (alloc == 0)
2488 alloc = count;
2489
2490 phdrs = ((Elf_Internal_Phdr *)
2491 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2492 if (phdrs == NULL)
2493 return false;
2494
2495 off = bed->s->sizeof_ehdr;
2496 off += alloc * bed->s->sizeof_phdr;
2497
2498 filehdr_vaddr = 0;
2499 filehdr_paddr = 0;
2500 phdrs_vaddr = 0;
2501 phdrs_paddr = 0;
2502
2503 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2504 m != NULL;
2505 m = m->next, p++)
2506 {
2507 unsigned int i;
2508 asection **secpp;
2509
2510 /* If elf_segment_map is not from map_sections_to_segments, the
2511 sections may not be correctly ordered. */
2512 if (m->count > 0)
2513 qsort (m->sections, (size_t) m->count, sizeof (asection *),
2514 elf_sort_sections);
2515
2516 p->p_type = m->p_type;
2517
2518 if (m->p_flags_valid)
2519 p->p_flags = m->p_flags;
2520 else
2521 p->p_flags = 0;
2522
2523 if (p->p_type == PT_LOAD
2524 && m->count > 0
2525 && (m->sections[0]->flags & SEC_ALLOC) != 0)
2526 {
2527 if ((abfd->flags & D_PAGED) != 0)
2528 off += (m->sections[0]->vma - off) % bed->maxpagesize;
2529 else
2530 {
2531 bfd_size_type align;
2532
2533 align = 0;
2534 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2535 {
2536 bfd_size_type secalign;
2537
2538 secalign = bfd_get_section_alignment (abfd, *secpp);
2539 if (secalign > align)
2540 align = secalign;
2541 }
2542
2543 off += (m->sections[0]->vma - off) % (1 << align);
2544 }
2545 }
2546
2547 if (m->count == 0)
2548 p->p_vaddr = 0;
2549 else
2550 p->p_vaddr = m->sections[0]->vma;
2551
2552 if (m->p_paddr_valid)
2553 p->p_paddr = m->p_paddr;
2554 else if (m->count == 0)
2555 p->p_paddr = 0;
2556 else
2557 p->p_paddr = m->sections[0]->lma;
2558
2559 if (p->p_type == PT_LOAD
2560 && (abfd->flags & D_PAGED) != 0)
2561 p->p_align = bed->maxpagesize;
2562 else if (m->count == 0)
2563 p->p_align = bed->s->file_align;
2564 else
2565 p->p_align = 0;
2566
2567 p->p_offset = 0;
2568 p->p_filesz = 0;
2569 p->p_memsz = 0;
2570
2571 if (m->includes_filehdr)
2572 {
2573 if (! m->p_flags_valid)
2574 p->p_flags |= PF_R;
2575 p->p_offset = 0;
2576 p->p_filesz = bed->s->sizeof_ehdr;
2577 p->p_memsz = bed->s->sizeof_ehdr;
2578 if (m->count > 0)
2579 {
2580 BFD_ASSERT (p->p_type == PT_LOAD);
2581
2582 if (p->p_vaddr < (bfd_vma) off)
2583 {
2584 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2585 bfd_get_filename (abfd));
2586 bfd_set_error (bfd_error_bad_value);
2587 return false;
2588 }
2589
2590 p->p_vaddr -= off;
2591 if (! m->p_paddr_valid)
2592 p->p_paddr -= off;
2593 }
2594 if (p->p_type == PT_LOAD)
2595 {
2596 filehdr_vaddr = p->p_vaddr;
2597 filehdr_paddr = p->p_paddr;
2598 }
2599 }
2600
2601 if (m->includes_phdrs)
2602 {
2603 if (! m->p_flags_valid)
2604 p->p_flags |= PF_R;
2605
2606 if (m->includes_filehdr)
2607 {
2608 if (p->p_type == PT_LOAD)
2609 {
2610 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2611 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2612 }
2613 }
2614 else
2615 {
2616 p->p_offset = bed->s->sizeof_ehdr;
2617
2618 if (m->count > 0)
2619 {
2620 BFD_ASSERT (p->p_type == PT_LOAD);
2621 p->p_vaddr -= off - p->p_offset;
2622 if (! m->p_paddr_valid)
2623 p->p_paddr -= off - p->p_offset;
2624 }
2625
2626 if (p->p_type == PT_LOAD)
2627 {
2628 phdrs_vaddr = p->p_vaddr;
2629 phdrs_paddr = p->p_paddr;
2630 }
2631 else
2632 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2633 }
2634
2635 p->p_filesz += alloc * bed->s->sizeof_phdr;
2636 p->p_memsz += alloc * bed->s->sizeof_phdr;
2637 }
2638
2639 if (p->p_type == PT_LOAD
2640 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2641 {
2642 if (! m->includes_filehdr && ! m->includes_phdrs)
2643 p->p_offset = off;
2644 else
2645 {
2646 file_ptr adjust;
2647
2648 adjust = off - (p->p_offset + p->p_filesz);
2649 p->p_filesz += adjust;
2650 p->p_memsz += adjust;
2651 }
2652 }
2653
2654 voff = off;
2655
2656 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2657 {
2658 asection *sec;
2659 flagword flags;
2660 bfd_size_type align;
2661
2662 sec = *secpp;
2663 flags = sec->flags;
2664 align = 1 << bfd_get_section_alignment (abfd, sec);
2665
2666 /* The section may have artificial alignment forced by a
2667 link script. Notice this case by the gap between the
2668 cumulative phdr vma and the section's vma. */
2669 if (p->p_vaddr + p->p_memsz < sec->vma)
2670 {
2671 bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2672
2673 p->p_memsz += adjust;
2674 off += adjust;
2675 voff += adjust;
2676 if ((flags & SEC_LOAD) != 0)
2677 p->p_filesz += adjust;
2678 }
2679
2680 if (p->p_type == PT_LOAD)
2681 {
2682 bfd_signed_vma adjust;
2683
2684 if ((flags & SEC_LOAD) != 0)
2685 {
2686 adjust = sec->lma - (p->p_paddr + p->p_memsz);
2687 if (adjust < 0)
2688 adjust = 0;
2689 }
2690 else if ((flags & SEC_ALLOC) != 0)
2691 {
2692 /* The section VMA must equal the file position
2693 modulo the page size. FIXME: I'm not sure if
2694 this adjustment is really necessary. We used to
2695 not have the SEC_LOAD case just above, and then
2696 this was necessary, but now I'm not sure. */
2697 if ((abfd->flags & D_PAGED) != 0)
2698 adjust = (sec->vma - voff) % bed->maxpagesize;
2699 else
2700 adjust = (sec->vma - voff) % align;
2701 }
2702 else
2703 adjust = 0;
2704
2705 if (adjust != 0)
2706 {
2707 if (i == 0)
2708 {
2709 (* _bfd_error_handler)
2710 (_("Error: First section in segment (%s) starts at 0x%x"),
2711 bfd_section_name (abfd, sec), sec->lma);
2712 (* _bfd_error_handler)
2713 (_(" whereas segment starts at 0x%x"),
2714 p->p_paddr);
2715
2716 return false;
2717 }
2718 p->p_memsz += adjust;
2719 off += adjust;
2720 voff += adjust;
2721 if ((flags & SEC_LOAD) != 0)
2722 p->p_filesz += adjust;
2723 }
2724
2725 sec->filepos = off;
2726
2727 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2728 used in a linker script we may have a section with
2729 SEC_LOAD clear but which is supposed to have
2730 contents. */
2731 if ((flags & SEC_LOAD) != 0
2732 || (flags & SEC_HAS_CONTENTS) != 0)
2733 off += sec->_raw_size;
2734
2735 if ((flags & SEC_ALLOC) != 0)
2736 voff += sec->_raw_size;
2737 }
2738
2739 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
2740 {
2741 if (i == 0) /* the actual "note" segment */
2742 { /* this one actually contains everything. */
2743 sec->filepos = off;
2744 p->p_filesz = sec->_raw_size;
2745 off += sec->_raw_size;
2746 voff = off;
2747 }
2748 else /* fake sections -- don't need to be written */
2749 {
2750 sec->filepos = 0;
2751 sec->_raw_size = 0;
2752 flags = sec->flags = 0; /* no contents */
2753 }
2754 p->p_memsz = 0;
2755 p->p_align = 1;
2756 }
2757 else
2758 {
2759 p->p_memsz += sec->_raw_size;
2760
2761 if ((flags & SEC_LOAD) != 0)
2762 p->p_filesz += sec->_raw_size;
2763
2764 if (align > p->p_align
2765 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
2766 p->p_align = align;
2767 }
2768
2769 if (! m->p_flags_valid)
2770 {
2771 p->p_flags |= PF_R;
2772 if ((flags & SEC_CODE) != 0)
2773 p->p_flags |= PF_X;
2774 if ((flags & SEC_READONLY) == 0)
2775 p->p_flags |= PF_W;
2776 }
2777 }
2778 }
2779
2780 /* Now that we have set the section file positions, we can set up
2781 the file positions for the non PT_LOAD segments. */
2782 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2783 m != NULL;
2784 m = m->next, p++)
2785 {
2786 if (p->p_type != PT_LOAD && m->count > 0)
2787 {
2788 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
2789 p->p_offset = m->sections[0]->filepos;
2790 }
2791 if (m->count == 0)
2792 {
2793 if (m->includes_filehdr)
2794 {
2795 p->p_vaddr = filehdr_vaddr;
2796 if (! m->p_paddr_valid)
2797 p->p_paddr = filehdr_paddr;
2798 }
2799 else if (m->includes_phdrs)
2800 {
2801 p->p_vaddr = phdrs_vaddr;
2802 if (! m->p_paddr_valid)
2803 p->p_paddr = phdrs_paddr;
2804 }
2805 }
2806 }
2807
2808 /* Clear out any program headers we allocated but did not use. */
2809 for (; count < alloc; count++, p++)
2810 {
2811 memset (p, 0, sizeof *p);
2812 p->p_type = PT_NULL;
2813 }
2814
2815 elf_tdata (abfd)->phdr = phdrs;
2816
2817 elf_tdata (abfd)->next_file_pos = off;
2818
2819 /* Write out the program headers. */
2820 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
2821 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
2822 return false;
2823
2824 return true;
2825}
2826
2827/* Get the size of the program header.
2828
2829 If this is called by the linker before any of the section VMA's are set, it
2830 can't calculate the correct value for a strange memory layout. This only
2831 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2832 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2833 data segment (exclusive of .interp and .dynamic).
2834
2835 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2836 will be two segments. */
2837
2838static bfd_size_type
2839get_program_header_size (abfd)
2840 bfd *abfd;
2841{
2842 size_t segs;
2843 asection *s;
2844 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2845
2846 /* We can't return a different result each time we're called. */
2847 if (elf_tdata (abfd)->program_header_size != 0)
2848 return elf_tdata (abfd)->program_header_size;
2849
2850 if (elf_tdata (abfd)->segment_map != NULL)
2851 {
2852 struct elf_segment_map *m;
2853
2854 segs = 0;
2855 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2856 ++segs;
2857 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2858 return elf_tdata (abfd)->program_header_size;
2859 }
2860
2861 /* Assume we will need exactly two PT_LOAD segments: one for text
2862 and one for data. */
2863 segs = 2;
2864
2865 s = bfd_get_section_by_name (abfd, ".interp");
2866 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2867 {
2868 /* If we have a loadable interpreter section, we need a
2869 PT_INTERP segment. In this case, assume we also need a
2870 PT_PHDR segment, although that may not be true for all
2871 targets. */
2872 segs += 2;
2873 }
2874
2875 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
2876 {
2877 /* We need a PT_DYNAMIC segment. */
2878 ++segs;
2879 }
2880
2881 for (s = abfd->sections; s != NULL; s = s->next)
2882 {
2883 if ((s->flags & SEC_LOAD) != 0
2884 && strncmp (s->name, ".note", 5) == 0)
2885 {
2886 /* We need a PT_NOTE segment. */
2887 ++segs;
2888 }
2889 }
2890
2891 /* Let the backend count up any program headers it might need. */
2892 if (bed->elf_backend_additional_program_headers)
2893 {
2894 int a;
2895
2896 a = (*bed->elf_backend_additional_program_headers) (abfd);
2897 if (a == -1)
2898 abort ();
2899 segs += a;
2900 }
2901
2902 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2903 return elf_tdata (abfd)->program_header_size;
2904}
2905
2906/* Work out the file positions of all the sections. This is called by
2907 _bfd_elf_compute_section_file_positions. All the section sizes and
2908 VMAs must be known before this is called.
2909
2910 We do not consider reloc sections at this point, unless they form
2911 part of the loadable image. Reloc sections are assigned file
2912 positions in assign_file_positions_for_relocs, which is called by
2913 write_object_contents and final_link.
2914
2915 We also don't set the positions of the .symtab and .strtab here. */
2916
2917static boolean
2918assign_file_positions_except_relocs (abfd)
2919 bfd *abfd;
2920{
2921 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
2922 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
2923 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
2924 file_ptr off;
2925 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2926
2927 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
2928 && bfd_get_format (abfd) != bfd_core)
2929 {
2930 Elf_Internal_Shdr **hdrpp;
2931 unsigned int i;
2932
2933 /* Start after the ELF header. */
2934 off = i_ehdrp->e_ehsize;
2935
2936 /* We are not creating an executable, which means that we are
2937 not creating a program header, and that the actual order of
2938 the sections in the file is unimportant. */
2939 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2940 {
2941 Elf_Internal_Shdr *hdr;
2942
2943 hdr = *hdrpp;
2944 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
2945 {
2946 hdr->sh_offset = -1;
2947 continue;
2948 }
2949 if (i == tdata->symtab_section
2950 || i == tdata->strtab_section)
2951 {
2952 hdr->sh_offset = -1;
2953 continue;
2954 }
2955
2956 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2957 }
2958 }
2959 else
2960 {
2961 unsigned int i;
2962 Elf_Internal_Shdr **hdrpp;
2963
2964 /* Assign file positions for the loaded sections based on the
2965 assignment of sections to segments. */
2966 if (! assign_file_positions_for_segments (abfd))
2967 return false;
2968
2969 /* Assign file positions for the other sections. */
2970
2971 off = elf_tdata (abfd)->next_file_pos;
2972 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2973 {
2974 Elf_Internal_Shdr *hdr;
2975
2976 hdr = *hdrpp;
2977 if (hdr->bfd_section != NULL
2978 && hdr->bfd_section->filepos != 0)
2979 hdr->sh_offset = hdr->bfd_section->filepos;
2980 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
2981 {
2982 ((*_bfd_error_handler)
2983 (_("%s: warning: allocated section `%s' not in segment"),
2984 bfd_get_filename (abfd),
2985 (hdr->bfd_section == NULL
2986 ? "*unknown*"
2987 : hdr->bfd_section->name)));
2988 if ((abfd->flags & D_PAGED) != 0)
2989 off += (hdr->sh_addr - off) % bed->maxpagesize;
2990 else
2991 off += (hdr->sh_addr - off) % hdr->sh_addralign;
2992 off = _bfd_elf_assign_file_position_for_section (hdr, off,
2993 false);
2994 }
2995 else if (hdr->sh_type == SHT_REL
2996 || hdr->sh_type == SHT_RELA
2997 || hdr == i_shdrpp[tdata->symtab_section]
2998 || hdr == i_shdrpp[tdata->strtab_section])
2999 hdr->sh_offset = -1;
3000 else
3001 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3002 }
3003 }
3004
3005 /* Place the section headers. */
3006 off = align_file_position (off, bed->s->file_align);
3007 i_ehdrp->e_shoff = off;
3008 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3009
3010 elf_tdata (abfd)->next_file_pos = off;
3011
3012 return true;
3013}
3014
3015static boolean
3016prep_headers (abfd)
3017 bfd *abfd;
3018{
3019 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3020 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3021 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3022 int count;
3023 struct bfd_strtab_hash *shstrtab;
3024 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3025
3026 i_ehdrp = elf_elfheader (abfd);
3027 i_shdrp = elf_elfsections (abfd);
3028
3029 shstrtab = _bfd_elf_stringtab_init ();
3030 if (shstrtab == NULL)
3031 return false;
3032
3033 elf_shstrtab (abfd) = shstrtab;
3034
3035 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3036 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3037 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3038 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3039
3040 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3041 i_ehdrp->e_ident[EI_DATA] =
3042 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3043 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3044
3045 for (count = EI_PAD; count < EI_NIDENT; count++)
3046 i_ehdrp->e_ident[count] = 0;
3047
3048 if ((abfd->flags & DYNAMIC) != 0)
3049 i_ehdrp->e_type = ET_DYN;
3050 else if ((abfd->flags & EXEC_P) != 0)
3051 i_ehdrp->e_type = ET_EXEC;
3052 else if (bfd_get_format (abfd) == bfd_core)
3053 i_ehdrp->e_type = ET_CORE;
3054 else
3055 i_ehdrp->e_type = ET_REL;
3056
3057 switch (bfd_get_arch (abfd))
3058 {
3059 case bfd_arch_unknown:
3060 i_ehdrp->e_machine = EM_NONE;
3061 break;
3062 case bfd_arch_sparc:
3063 if (bed->s->arch_size == 64)
3064 i_ehdrp->e_machine = EM_SPARCV9;
3065 else
3066 i_ehdrp->e_machine = EM_SPARC;
3067 break;
3068 case bfd_arch_i386:
3069 i_ehdrp->e_machine = EM_386;
3070 break;
3071 case bfd_arch_m68k:
3072 i_ehdrp->e_machine = EM_68K;
3073 break;
3074 case bfd_arch_m88k:
3075 i_ehdrp->e_machine = EM_88K;
3076 break;
3077 case bfd_arch_i860:
3078 i_ehdrp->e_machine = EM_860;
3079 break;
b2ef150d
ILT		 3080 case bfd_arch_i960:
3081 i_ehdrp->e_machine = EM_960;
3082 break;
252b5132
RH		 3083 case bfd_arch_mips: /* MIPS Rxxxx */
3084 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
3085 break;
3086 case bfd_arch_hppa:
3087 i_ehdrp->e_machine = EM_PARISC;
3088 break;
3089 case bfd_arch_powerpc:
3090 i_ehdrp->e_machine = EM_PPC;
3091 break;
3092 case bfd_arch_alpha:
3093 i_ehdrp->e_machine = EM_ALPHA;
3094 break;
3095 case bfd_arch_sh:
3096 i_ehdrp->e_machine = EM_SH;
3097 break;
3098 case bfd_arch_d10v:
3099 i_ehdrp->e_machine = EM_CYGNUS_D10V;
3100 break;
3101 case bfd_arch_d30v:
3102 i_ehdrp->e_machine = EM_CYGNUS_D30V;
3103 break;
3104 case bfd_arch_fr30:
3105 i_ehdrp->e_machine = EM_CYGNUS_FR30;
3106 break;
3107 case bfd_arch_mcore:
3108 i_ehdrp->e_machine = EM_MCORE;
3109 break;
3110 case bfd_arch_v850:
3111 switch (bfd_get_mach (abfd))
3112 {
3113 default:
3114 case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3115 }
3116 break;
3117 case bfd_arch_arc:
3118 i_ehdrp->e_machine = EM_CYGNUS_ARC;
3119 break;
3120 case bfd_arch_arm:
3121 i_ehdrp->e_machine = EM_ARM;
3122 break;
3123 case bfd_arch_m32r:
3124 i_ehdrp->e_machine = EM_CYGNUS_M32R;
3125 break;
3126 case bfd_arch_mn10200:
3127 i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3128 break;
3129 case bfd_arch_mn10300:
3130 i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3131 break;
3132 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3133 default:
3134 i_ehdrp->e_machine = EM_NONE;
3135 }
3136 i_ehdrp->e_version = bed->s->ev_current;
3137 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3138
3139 /* no program header, for now. */
3140 i_ehdrp->e_phoff = 0;
3141 i_ehdrp->e_phentsize = 0;
3142 i_ehdrp->e_phnum = 0;
3143
3144 /* each bfd section is section header entry */
3145 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3146 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3147
3148 /* if we're building an executable, we'll need a program header table */
3149 if (abfd->flags & EXEC_P)
3150 {
3151 /* it all happens later */
3152#if 0
3153 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3154
3155 /* elf_build_phdrs() returns a (NULL-terminated) array of
3156 Elf_Internal_Phdrs */
3157 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3158 i_ehdrp->e_phoff = outbase;
3159 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3160#endif
3161 }
3162 else
3163 {
3164 i_ehdrp->e_phentsize = 0;
3165 i_phdrp = 0;
3166 i_ehdrp->e_phoff = 0;
3167 }
3168
3169 elf_tdata (abfd)->symtab_hdr.sh_name =
3170 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3171 elf_tdata (abfd)->strtab_hdr.sh_name =
3172 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3173 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3174 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3175 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3176 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3177 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3178 return false;
3179
3180 return true;
3181}
3182
3183/* Assign file positions for all the reloc sections which are not part
3184 of the loadable file image. */
3185
3186void
3187_bfd_elf_assign_file_positions_for_relocs (abfd)
3188 bfd *abfd;
3189{
3190 file_ptr off;
3191 unsigned int i;
3192 Elf_Internal_Shdr **shdrpp;
3193
3194 off = elf_tdata (abfd)->next_file_pos;
3195
3196 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3197 i < elf_elfheader (abfd)->e_shnum;
3198 i++, shdrpp++)
3199 {
3200 Elf_Internal_Shdr *shdrp;
3201
3202 shdrp = *shdrpp;
3203 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3204 && shdrp->sh_offset == -1)
3205 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3206 }
3207
3208 elf_tdata (abfd)->next_file_pos = off;
3209}
3210
3211boolean
3212_bfd_elf_write_object_contents (abfd)
3213 bfd *abfd;
3214{
3215 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3216 Elf_Internal_Ehdr *i_ehdrp;
3217 Elf_Internal_Shdr **i_shdrp;
3218 boolean failed;
3219 unsigned int count;
3220
3221 if (! abfd->output_has_begun
3222 && ! _bfd_elf_compute_section_file_positions
3223 (abfd, (struct bfd_link_info *) NULL))
3224 return false;
3225
3226 i_shdrp = elf_elfsections (abfd);
3227 i_ehdrp = elf_elfheader (abfd);
3228
3229 failed = false;
3230 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3231 if (failed)
3232 return false;
3233
3234 _bfd_elf_assign_file_positions_for_relocs (abfd);
3235
3236 /* After writing the headers, we need to write the sections too... */
3237 for (count = 1; count < i_ehdrp->e_shnum; count++)
3238 {
3239 if (bed->elf_backend_section_processing)
3240 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3241 if (i_shdrp[count]->contents)
3242 {
3243 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3244 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3245 1, abfd)
3246 != i_shdrp[count]->sh_size))
3247 return false;
3248 }
3249 }
3250
3251 /* Write out the section header names. */
3252 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3253 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3254 return false;
3255
3256 if (bed->elf_backend_final_write_processing)
3257 (*bed->elf_backend_final_write_processing) (abfd,
3258 elf_tdata (abfd)->linker);
3259
3260 return bed->s->write_shdrs_and_ehdr (abfd);
3261}
3262
3263boolean
3264_bfd_elf_write_corefile_contents (abfd)
3265 bfd *abfd;
3266{
3267 /* Hopefully this can be done just like an object file. */
3268 return _bfd_elf_write_object_contents (abfd);
3269}
3270/* given a section, search the header to find them... */
3271int
3272_bfd_elf_section_from_bfd_section (abfd, asect)
3273 bfd *abfd;
3274 struct sec *asect;
3275{
3276 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3277 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3278 int index;
3279 Elf_Internal_Shdr *hdr;
3280 int maxindex = elf_elfheader (abfd)->e_shnum;
3281
3282 for (index = 0; index < maxindex; index++)
3283 {
3284 hdr = i_shdrp[index];
3285 if (hdr->bfd_section == asect)
3286 return index;
3287 }
3288
3289 if (bed->elf_backend_section_from_bfd_section)
3290 {
3291 for (index = 0; index < maxindex; index++)
3292 {
3293 int retval;
3294
3295 hdr = i_shdrp[index];
3296 retval = index;
3297 if ((*bed->elf_backend_section_from_bfd_section)
3298 (abfd, hdr, asect, &retval))
3299 return retval;
3300 }
3301 }
3302
3303 if (bfd_is_abs_section (asect))
3304 return SHN_ABS;
3305 if (bfd_is_com_section (asect))
3306 return SHN_COMMON;
3307 if (bfd_is_und_section (asect))
3308 return SHN_UNDEF;
3309
3310 bfd_set_error (bfd_error_nonrepresentable_section);
3311
3312 return -1;
3313}
3314
3315/* Given a BFD symbol, return the index in the ELF symbol table, or -1
3316 on error. */
3317
3318int
3319_bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3320 bfd *abfd;
3321 asymbol **asym_ptr_ptr;
3322{
3323 asymbol *asym_ptr = *asym_ptr_ptr;
3324 int idx;
3325 flagword flags = asym_ptr->flags;
3326
3327 /* When gas creates relocations against local labels, it creates its
3328 own symbol for the section, but does put the symbol into the
3329 symbol chain, so udata is 0. When the linker is generating
3330 relocatable output, this section symbol may be for one of the
3331 input sections rather than the output section. */
3332 if (asym_ptr->udata.i == 0
3333 && (flags & BSF_SECTION_SYM)
3334 && asym_ptr->section)
3335 {
3336 int indx;
3337
3338 if (asym_ptr->section->output_section != NULL)
3339 indx = asym_ptr->section->output_section->index;
3340 else
3341 indx = asym_ptr->section->index;
3342 if (elf_section_syms (abfd)[indx])
3343 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3344 }
3345
3346 idx = asym_ptr->udata.i;
3347
3348 if (idx == 0)
3349 {
3350 /* This case can occur when using --strip-symbol on a symbol
3351 which is used in a relocation entry. */
3352 (*_bfd_error_handler)
3353 (_("%s: symbol `%s' required but not present"),
3354 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3355 bfd_set_error (bfd_error_no_symbols);
3356 return -1;
3357 }
3358
3359#if DEBUG & 4
3360 {
3361 fprintf (stderr,
3362 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3363 (long) asym_ptr, asym_ptr->name, idx, flags,
3364 elf_symbol_flags (flags));
3365 fflush (stderr);
3366 }
3367#endif
3368
3369 return idx;
3370}
3371
3372/* Copy private BFD data. This copies any program header information. */
3373
3374static boolean
3375copy_private_bfd_data (ibfd, obfd)
3376 bfd *ibfd;
3377 bfd *obfd;
3378{
3379 Elf_Internal_Ehdr *iehdr;
3380 struct elf_segment_map *mfirst;
3381 struct elf_segment_map **pm;
3382 struct elf_segment_map *m;
3383 Elf_Internal_Phdr *p;
3384 unsigned int i;
3385 unsigned int num_segments;
3386 boolean phdr_included = false;
3387
3388 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3389 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3390 return true;
3391
3392 if (elf_tdata (ibfd)->phdr == NULL)
3393 return true;
3394
3395 iehdr = elf_elfheader (ibfd);
3396
3397 mfirst = NULL;
3398 pm = &mfirst;
3399
3400 num_segments = elf_elfheader (ibfd)->e_phnum;
3401
3402#define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3403 ((addr) >= (bottom) \
3404 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3405 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3406
3407 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3408
3409#define IS_COREFILE_NOTE(p, s) \
3410 (p->p_type == PT_NOTE \
3411 && bfd_get_format (ibfd) == bfd_core \
3412 && s->vma == 0 && s->lma == 0 \
3413 && (bfd_vma) s->filepos >= p->p_offset \
3414 && (bfd_vma) s->filepos + s->_raw_size \
3415 <= p->p_offset + p->p_filesz)
3416
3417 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3418 linker, which generates a PT_INTERP section with p_vaddr and
3419 p_memsz set to 0. */
3420
3421#define IS_SOLARIS_PT_INTERP(p, s) \
3422 (p->p_vaddr == 0 \
3423 && p->p_filesz > 0 \
3424 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3425 && s->_raw_size > 0 \
3426 && (bfd_vma) s->filepos >= p->p_offset \
3427 && ((bfd_vma) s->filepos + s->_raw_size \
3428 <= p->p_offset + p->p_filesz))
3429
3430 /* Scan through the segments specified in the program header
3431 of the input BFD. */
3432 for (i = 0, p = elf_tdata (ibfd)->phdr; i < num_segments; i++, p++)
3433 {
3434 unsigned int csecs;
3435 asection *s;
3436 asection **sections;
3437 asection *os;
3438 unsigned int isec;
3439 bfd_vma matching_lma;
3440 bfd_vma suggested_lma;
3441 unsigned int j;
3442
3443 /* For each section in the input BFD, decide if it should be
3444 included in the current segment. A section will be included
3445 if it is within the address space of the segment, and it is
3446 an allocated segment, and there is an output section
3447 associated with it. */
3448 csecs = 0;
3449 for (s = ibfd->sections; s != NULL; s = s->next)
3450 if (s->output_section != NULL)
3451 {
3452 if ((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3453 || IS_SOLARIS_PT_INTERP (p, s))
3454 && (s->flags & SEC_ALLOC) != 0)
3455 ++csecs;
3456 else if (IS_COREFILE_NOTE (p, s))
3457 ++csecs;
3458 }
3459
3460 /* Allocate a segment map big enough to contain all of the
3461 sections we have selected. */
3462 m = ((struct elf_segment_map *)
3463 bfd_alloc (obfd,
3464 (sizeof (struct elf_segment_map)
3465 + ((size_t) csecs - 1) * sizeof (asection *))));
3466 if (m == NULL)
3467 return false;
3468
3469 /* Initialise the fields of the segment map. Default to
3470 using the physical address of the segment in the input BFD. */
3471 m->next = NULL;
3472 m->p_type = p->p_type;
3473 m->p_flags = p->p_flags;
3474 m->p_flags_valid = 1;
3475 m->p_paddr = p->p_paddr;
3476 m->p_paddr_valid = 1;
3477
3478 /* Determine if this segment contains the ELF file header
3479 and if it contains the program headers themselves. */
3480 m->includes_filehdr = (p->p_offset == 0
3481 && p->p_filesz >= iehdr->e_ehsize);
3482
3483 m->includes_phdrs = 0;
3484
3485 if (! phdr_included || p->p_type != PT_LOAD)
3486 {
3487 m->includes_phdrs =
3488 (p->p_offset <= (bfd_vma) iehdr->e_phoff
3489 && (p->p_offset + p->p_filesz
3490 >= ((bfd_vma) iehdr->e_phoff
3491 + iehdr->e_phnum * iehdr->e_phentsize)));
3492 if (p->p_type == PT_LOAD && m->includes_phdrs)
3493 phdr_included = true;
3494 }
3495
3496 if (csecs == 0)
3497 {
3498 /* Special segments, such as the PT_PHDR segment, may contain
3499 no sections, but ordinary, loadable segments should contain
3500 something. */
3501
3502 if (p->p_type == PT_LOAD)
3503 _bfd_error_handler
3504 (_("%s: warning: Empty loadable segment detected\n"),
3505 bfd_get_filename (ibfd));
3506
3507 m->count = 0;
3508 *pm = m;
3509 pm = &m->next;
3510
3511 continue;
3512 }
3513
3514 /* Now scan the sections in the input BFD again and attempt
3515 to add their corresponding output sections to the segment map.
3516 The problem here is how to handle an output section which has
3517 been moved (ie had its LMA changed). There are four possibilities:
3518
3519 1. None of the sections have been moved.
3520 In this case we can continue to use the segment LMA from the
3521 input BFD.
3522
3523 2. All of the sections have been moved by the same amount.
3524 In this case we can change the segment's LMA to match the LMA
3525 of the first section.
3526
3527 3. Some of the sections have been moved, others have not.
3528 In this case those sections which have not been moved can be
3529 placed in the current segment which will have to have its size,
3530 and possibly its LMA changed, and a new segment or segments will
3531 have to be created to contain the other sections.
3532
3533 4. The sections have been moved, but not be the same amount.
3534 In this case we can change the segment's LMA to match the LMA
3535 of the first section and we will have to create a new segment
3536 or segments to contain the other sections.
3537
3538 In order to save time, we allocate an array to hold the section
3539 pointers that we are interested in. As these sections get assigned
3540 to a segment, they are removed from this array. */
3541
3542 sections = (asection **) bfd_malloc (sizeof (asection *) * csecs);
3543 if (sections == NULL)
3544 return false;
3545
3546 /* Step One: Scan for segment vs section LMA conflicts.
3547 Also add the sections to the section array allocated above.
3548 Also add the sections to the current segment. In the common
3549 case, where the sections have not been moved, this means that
3550 we have completely filled the segment, and there is nothing
3551 more to do. */
3552
3553 isec = 0;
3554 matching_lma = false;
3555 suggested_lma = 0;
3556
3557 for (j = 0, s = ibfd->sections; s != NULL; s = s->next)
3558 {
3559 os = s->output_section;
3560
3561 if ((((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3562 || IS_SOLARIS_PT_INTERP (p, s))
3563 && (s->flags & SEC_ALLOC) != 0)
3564 || IS_COREFILE_NOTE (p, s))
3565 && os != NULL)
3566 {
3567 sections[j++] = s;
3568
3569 /* The Solaris native linker always sets p_paddr to 0.
3570 We try to catch that case here, and set it to the
3571 correct value. */
3572 if (p->p_paddr == 0
3573 && p->p_vaddr != 0
3574 && isec == 0
3575 && os->lma != 0
3576 && (os->vma == (p->p_vaddr
3577 + (m->includes_filehdr
3578 ? iehdr->e_ehsize
3579 : 0)
3580 + (m->includes_phdrs
3581 ? iehdr->e_phnum * iehdr->e_phentsize
3582 : 0))))
3583 m->p_paddr = p->p_vaddr;
3584
3585 /* Match up the physical address of the segment with the
3586 LMA address of the output section. */
3587 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3588 || IS_COREFILE_NOTE (p, s))
3589 {
3590 if (matching_lma == 0)
3591 matching_lma = os->lma;
3592
3593 /* We assume that if the section fits within the segment
3594 that it does not overlap any other section within that
3595 segment. */
3596 m->sections[isec++] = os;
3597 }
3598 else if (suggested_lma == 0)
3599 suggested_lma = os->lma;
3600 }
3601 }
3602
3603 BFD_ASSERT (j == csecs);
3604
3605 /* Step Two: Adjust the physical address of the current segment,
3606 if necessary. */
3607 if (isec == csecs)
3608 {
3609 /* All of the sections fitted within the segment as currently
3610 specified. This is the default case. Add the segment to
3611 the list of built segments and carry on to process the next
3612 program header in the input BFD. */
3613 m->count = csecs;
3614 *pm = m;
3615 pm = &m->next;
3616
3617 free (sections);
3618 continue;
3619 }
3620 else if (matching_lma != 0)
3621 {
3622 /* At least one section fits inside the current segment.
3623 Keep it, but modify its physical address to match the
3624 LMA of the first section that fitted. */
3625
3626 m->p_paddr = matching_lma;
3627 }
3628 else
3629 {
3630 /* None of the sections fitted inside the current segment.
3631 Change the current segment's physical address to match
3632 the LMA of the first section. */
3633
3634 m->p_paddr = suggested_lma;
3635 }
3636
3637 /* Step Three: Loop over the sections again, this time assigning
3638 those that fit to the current segment and remvoing them from the
3639 sections array; but making sure not to leave large gaps. Once all
3640 possible sections have been assigned to the current segment it is
3641 added to the list of built segments and if sections still remain
3642 to be assigned, a new segment is constructed before repeating
3643 the loop. */
3644 isec = 0;
3645 do
3646 {
3647 m->count = 0;
3648 suggested_lma = 0;
3649
3650 /* Fill the current segment with sections that fit. */
3651 for (j = 0; j < csecs; j++)
3652 {
3653 s = sections[j];
3654
3655 if (s == NULL)
3656 continue;
3657
3658 os = s->output_section;
3659
3660 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3661 || IS_COREFILE_NOTE (p, s))
3662 {
3663 if (m->count == 0)
3664 {
3665 /* If the first section in a segment does not start at
3666 the beginning of the segment, then something is wrong. */
3667 if (os->lma != m->p_paddr)
3668 abort ();
3669 }
3670 else
3671 {
3672 asection * prev_sec;
3673 bfd_vma maxpagesize;
3674
3675 prev_sec = m->sections[m->count - 1];
3676 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3677
3678 /* If the gap between the end of the previous section
3679 and the start of this section is more than maxpagesize
3680 then we need to start a new segment. */
3681 if (BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
3682 < BFD_ALIGN (os->lma, maxpagesize))
3683 {
3684 if (suggested_lma == 0)
3685 suggested_lma = os->lma;
3686
3687 continue;
3688 }
3689 }
3690
3691 m->sections[m->count++] = os;
3692 ++isec;
3693 sections[j] = NULL;
3694 }
3695 else if (suggested_lma == 0)
3696 suggested_lma = os->lma;
3697 }
3698
3699 BFD_ASSERT (m->count > 0);
3700
3701 /* Add the current segment to the list of built segments. */
3702 *pm = m;
3703 pm = &m->next;
3704
3705 if (isec < csecs)
3706 {
3707 /* We still have not allocated all of the sections to
3708 segments. Create a new segment here, initialise it
3709 and carry on looping. */
3710
3711 m = ((struct elf_segment_map *)
3712 bfd_alloc (obfd,
3713 (sizeof (struct elf_segment_map)
3714 + ((size_t) csecs - 1) * sizeof (asection *))));
3715 if (m == NULL)
3716 return false;
3717
3718 /* Initialise the fields of the segment map. Set the physical
3719 physical address to the LMA of the first section that has
3720 not yet been assigned. */
3721
3722 m->next = NULL;
3723 m->p_type = p->p_type;
3724 m->p_flags = p->p_flags;
3725 m->p_flags_valid = 1;
3726 m->p_paddr = suggested_lma;
3727 m->p_paddr_valid = 1;
3728 m->includes_filehdr = 0;
3729 m->includes_phdrs = 0;
3730 }
3731 }
3732 while (isec < csecs);
3733
3734 free (sections);
3735 }
3736
3737 /* The Solaris linker creates program headers in which all the
3738 p_paddr fields are zero. When we try to objcopy or strip such a
3739 file, we get confused. Check for this case, and if we find it
3740 reset the p_paddr_valid fields. */
3741 for (m = mfirst; m != NULL; m = m->next)
3742 if (m->p_paddr != 0)
3743 break;
3744 if (m == NULL)
3745 {
3746 for (m = mfirst; m != NULL; m = m->next)
3747 m->p_paddr_valid = 0;
3748 }
3749
3750 elf_tdata (obfd)->segment_map = mfirst;
3751
3752#if 0
3753 /* Final Step: Sort the segments into ascending order of physical address. */
3754 if (mfirst != NULL)
3755 {
3756 struct elf_segment_map* prev;
3757
3758 prev = mfirst;
3759 for (m = mfirst->next; m != NULL; prev = m, m = m->next)
3760 {
3761 /* Yes I know - its a bubble sort....*/
3762 if (m->next != NULL && (m->next->p_paddr < m->p_paddr))
3763 {
3764 /* swap m and m->next */
3765 prev->next = m->next;
3766 m->next = m->next->next;
3767 prev->next->next = m;
3768
3769 /* restart loop. */
3770 m = mfirst;
3771 }
3772 }
3773 }
3774#endif
3775
3776#undef IS_CONTAINED_BY
3777#undef IS_SOLARIS_PT_INTERP
3778#undef IS_COREFILE_NOTE
3779 return true;
3780}
3781
3782/* Copy private section information. This copies over the entsize
3783 field, and sometimes the info field. */
3784
3785boolean
3786_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
3787 bfd *ibfd;
3788 asection *isec;
3789 bfd *obfd;
3790 asection *osec;
3791{
3792 Elf_Internal_Shdr *ihdr, *ohdr;
3793
3794 if (ibfd->xvec->flavour != bfd_target_elf_flavour
3795 || obfd->xvec->flavour != bfd_target_elf_flavour)
3796 return true;
3797
3798 /* Copy over private BFD data if it has not already been copied.
3799 This must be done here, rather than in the copy_private_bfd_data
3800 entry point, because the latter is called after the section
3801 contents have been set, which means that the program headers have
3802 already been worked out. */
3803 if (elf_tdata (obfd)->segment_map == NULL
3804 && elf_tdata (ibfd)->phdr != NULL)
3805 {
3806 asection *s;
3807
3808 /* Only set up the segments if there are no more SEC_ALLOC
3809 sections. FIXME: This won't do the right thing if objcopy is
3810 used to remove the last SEC_ALLOC section, since objcopy
3811 won't call this routine in that case. */
3812 for (s = isec->next; s != NULL; s = s->next)
3813 if ((s->flags & SEC_ALLOC) != 0)
3814 break;
3815 if (s == NULL)
3816 {
3817 if (! copy_private_bfd_data (ibfd, obfd))
3818 return false;
3819 }
3820 }
3821
3822 ihdr = &elf_section_data (isec)->this_hdr;
3823 ohdr = &elf_section_data (osec)->this_hdr;
3824
3825 ohdr->sh_entsize = ihdr->sh_entsize;
3826
3827 if (ihdr->sh_type == SHT_SYMTAB
3828 || ihdr->sh_type == SHT_DYNSYM
3829 || ihdr->sh_type == SHT_GNU_verneed
3830 || ihdr->sh_type == SHT_GNU_verdef)
3831 ohdr->sh_info = ihdr->sh_info;
3832
3833 return true;
3834}
3835
3836/* Copy private symbol information. If this symbol is in a section
3837 which we did not map into a BFD section, try to map the section
3838 index correctly. We use special macro definitions for the mapped
3839 section indices; these definitions are interpreted by the
3840 swap_out_syms function. */
3841
3842#define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3843#define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3844#define MAP_STRTAB (SHN_LORESERVE - 3)
3845#define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3846
3847boolean
3848_bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
3849 bfd *ibfd;
3850 asymbol *isymarg;
3851 bfd *obfd;
3852 asymbol *osymarg;
3853{
3854 elf_symbol_type *isym, *osym;
3855
3856 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3857 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3858 return true;
3859
3860 isym = elf_symbol_from (ibfd, isymarg);
3861 osym = elf_symbol_from (obfd, osymarg);
3862
3863 if (isym != NULL
3864 && osym != NULL
3865 && bfd_is_abs_section (isym->symbol.section))
3866 {
3867 unsigned int shndx;
3868
3869 shndx = isym->internal_elf_sym.st_shndx;
3870 if (shndx == elf_onesymtab (ibfd))
3871 shndx = MAP_ONESYMTAB;
3872 else if (shndx == elf_dynsymtab (ibfd))
3873 shndx = MAP_DYNSYMTAB;
3874 else if (shndx == elf_tdata (ibfd)->strtab_section)
3875 shndx = MAP_STRTAB;
3876 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
3877 shndx = MAP_SHSTRTAB;
3878 osym->internal_elf_sym.st_shndx = shndx;
3879 }
3880
3881 return true;
3882}
3883
3884/* Swap out the symbols. */
3885
3886static boolean
3887swap_out_syms (abfd, sttp, relocatable_p)
3888 bfd *abfd;
3889 struct bfd_strtab_hash **sttp;
3890 int relocatable_p;
3891{
3892 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3893
3894 if (!elf_map_symbols (abfd))
3895 return false;
3896
3897 /* Dump out the symtabs. */
3898 {
3899 int symcount = bfd_get_symcount (abfd);
3900 asymbol **syms = bfd_get_outsymbols (abfd);
3901 struct bfd_strtab_hash *stt;
3902 Elf_Internal_Shdr *symtab_hdr;
3903 Elf_Internal_Shdr *symstrtab_hdr;
3904 char *outbound_syms;
3905 int idx;
3906
3907 stt = _bfd_elf_stringtab_init ();
3908 if (stt == NULL)
3909 return false;
3910
3911 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3912 symtab_hdr->sh_type = SHT_SYMTAB;
3913 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
3914 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
3915 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
3916 symtab_hdr->sh_addralign = bed->s->file_align;
3917
3918 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
3919 symstrtab_hdr->sh_type = SHT_STRTAB;
3920
3921 outbound_syms = bfd_alloc (abfd,
3922 (1 + symcount) * bed->s->sizeof_sym);
3923 if (outbound_syms == NULL)
3924 return false;
3925 symtab_hdr->contents = (PTR) outbound_syms;
3926
3927 /* now generate the data (for "contents") */
3928 {
3929 /* Fill in zeroth symbol and swap it out. */
3930 Elf_Internal_Sym sym;
3931 sym.st_name = 0;
3932 sym.st_value = 0;
3933 sym.st_size = 0;
3934 sym.st_info = 0;
3935 sym.st_other = 0;
3936 sym.st_shndx = SHN_UNDEF;
3937 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
3938 outbound_syms += bed->s->sizeof_sym;
3939 }
3940 for (idx = 0; idx < symcount; idx++)
3941 {
3942 Elf_Internal_Sym sym;
3943 bfd_vma value = syms[idx]->value;
3944 elf_symbol_type *type_ptr;
3945 flagword flags = syms[idx]->flags;
3946 int type;
3947
3948 if (flags & BSF_SECTION_SYM)
3949 /* Section symbols have no names. */
3950 sym.st_name = 0;
3951 else
3952 {
3953 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
3954 syms[idx]->name,
3955 true, false);
3956 if (sym.st_name == (unsigned long) -1)
3957 return false;
3958 }
3959
3960 type_ptr = elf_symbol_from (abfd, syms[idx]);
3961
3962 if ((flags & BSF_SECTION_SYM) == 0
3963 && bfd_is_com_section (syms[idx]->section))
3964 {
3965 /* ELF common symbols put the alignment into the `value' field,
3966 and the size into the `size' field. This is backwards from
3967 how BFD handles it, so reverse it here. */
3968 sym.st_size = value;
3969 if (type_ptr == NULL
3970 || type_ptr->internal_elf_sym.st_value == 0)
3971 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
3972 else
3973 sym.st_value = type_ptr->internal_elf_sym.st_value;
3974 sym.st_shndx = _bfd_elf_section_from_bfd_section
3975 (abfd, syms[idx]->section);
3976 }
3977 else
3978 {
3979 asection *sec = syms[idx]->section;
3980 int shndx;
3981
3982 if (sec->output_section)
3983 {
3984 value += sec->output_offset;
3985 sec = sec->output_section;
3986 }
3987 /* Don't add in the section vma for relocatable output. */
3988 if (! relocatable_p)
3989 value += sec->vma;
3990 sym.st_value = value;
3991 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
3992
3993 if (bfd_is_abs_section (sec)
3994 && type_ptr != NULL
3995 && type_ptr->internal_elf_sym.st_shndx != 0)
3996 {
3997 /* This symbol is in a real ELF section which we did
3998 not create as a BFD section. Undo the mapping done
3999 by copy_private_symbol_data. */
4000 shndx = type_ptr->internal_elf_sym.st_shndx;
4001 switch (shndx)
4002 {
4003 case MAP_ONESYMTAB:
4004 shndx = elf_onesymtab (abfd);
4005 break;
4006 case MAP_DYNSYMTAB:
4007 shndx = elf_dynsymtab (abfd);
4008 break;
4009 case MAP_STRTAB:
4010 shndx = elf_tdata (abfd)->strtab_section;
4011 break;
4012 case MAP_SHSTRTAB:
4013 shndx = elf_tdata (abfd)->shstrtab_section;
4014 break;
4015 default:
4016 break;
4017 }
4018 }
4019 else
4020 {
4021 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4022
4023 if (shndx == -1)
4024 {
4025 asection *sec2;
4026
4027 /* Writing this would be a hell of a lot easier if
4028 we had some decent documentation on bfd, and
4029 knew what to expect of the library, and what to
4030 demand of applications. For example, it
4031 appears that `objcopy' might not set the
4032 section of a symbol to be a section that is
4033 actually in the output file. */
4034 sec2 = bfd_get_section_by_name (abfd, sec->name);
4035 BFD_ASSERT (sec2 != 0);
4036 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4037 BFD_ASSERT (shndx != -1);
4038 }
4039 }
4040
4041 sym.st_shndx = shndx;
4042 }
4043
4044 if ((flags & BSF_FUNCTION) != 0)
4045 type = STT_FUNC;
4046 else if ((flags & BSF_OBJECT) != 0)
4047 type = STT_OBJECT;
4048 else
4049 type = STT_NOTYPE;
4050
4051 /* Processor-specific types */
4052 if (bed->elf_backend_get_symbol_type)
4053 type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4054
4055 if (flags & BSF_SECTION_SYM)
4056 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4057 else if (bfd_is_com_section (syms[idx]->section))
4058 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4059 else if (bfd_is_und_section (syms[idx]->section))
4060 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4061 ? STB_WEAK
4062 : STB_GLOBAL),
4063 type);
4064 else if (flags & BSF_FILE)
4065 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4066 else
4067 {
4068 int bind = STB_LOCAL;
4069
4070 if (flags & BSF_LOCAL)
4071 bind = STB_LOCAL;
4072 else if (flags & BSF_WEAK)
4073 bind = STB_WEAK;
4074 else if (flags & BSF_GLOBAL)
4075 bind = STB_GLOBAL;
4076
4077 sym.st_info = ELF_ST_INFO (bind, type);
4078 }
4079
4080 if (type_ptr != NULL)
4081 sym.st_other = type_ptr->internal_elf_sym.st_other;
4082 else
4083 sym.st_other = 0;
4084
4085 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4086 outbound_syms += bed->s->sizeof_sym;
4087 }
4088
4089 *sttp = stt;
4090 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4091 symstrtab_hdr->sh_type = SHT_STRTAB;
4092
4093 symstrtab_hdr->sh_flags = 0;
4094 symstrtab_hdr->sh_addr = 0;
4095 symstrtab_hdr->sh_entsize = 0;
4096 symstrtab_hdr->sh_link = 0;
4097 symstrtab_hdr->sh_info = 0;
4098 symstrtab_hdr->sh_addralign = 1;
4099 }
4100
4101 return true;
4102}
4103
4104/* Return the number of bytes required to hold the symtab vector.
4105
4106 Note that we base it on the count plus 1, since we will null terminate
4107 the vector allocated based on this size. However, the ELF symbol table
4108 always has a dummy entry as symbol #0, so it ends up even. */
4109
4110long
4111_bfd_elf_get_symtab_upper_bound (abfd)
4112 bfd *abfd;
4113{
4114 long symcount;
4115 long symtab_size;
4116 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4117
4118 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4119 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4120
4121 return symtab_size;
4122}
4123
4124long
4125_bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4126 bfd *abfd;
4127{
4128 long symcount;
4129 long symtab_size;
4130 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4131
4132 if (elf_dynsymtab (abfd) == 0)
4133 {
4134 bfd_set_error (bfd_error_invalid_operation);
4135 return -1;
4136 }
4137
4138 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4139 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4140
4141 return symtab_size;
4142}
4143
4144long
4145_bfd_elf_get_reloc_upper_bound (abfd, asect)
4146 bfd *abfd;
4147 sec_ptr asect;
4148{
4149 return (asect->reloc_count + 1) * sizeof (arelent *);
4150}
4151
4152/* Canonicalize the relocs. */
4153
4154long
4155_bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4156 bfd *abfd;
4157 sec_ptr section;
4158 arelent **relptr;
4159 asymbol **symbols;
4160{
4161 arelent *tblptr;
4162 unsigned int i;
4163
4164 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4165 section,
4166 symbols,
4167 false))
4168 return -1;
4169
4170 tblptr = section->relocation;
4171 for (i = 0; i < section->reloc_count; i++)
4172 *relptr++ = tblptr++;
4173
4174 *relptr = NULL;
4175
4176 return section->reloc_count;
4177}
4178
4179long
4180_bfd_elf_get_symtab (abfd, alocation)
4181 bfd *abfd;
4182 asymbol **alocation;
4183{
4184 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4185 (abfd, alocation, false);
4186
4187 if (symcount >= 0)
4188 bfd_get_symcount (abfd) = symcount;
4189 return symcount;
4190}
4191
4192long
4193_bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4194 bfd *abfd;
4195 asymbol **alocation;
4196{
4197 return get_elf_backend_data (abfd)->s->slurp_symbol_table
4198 (abfd, alocation, true);
4199}
4200
4201/* Return the size required for the dynamic reloc entries. Any
4202 section that was actually installed in the BFD, and has type
4203 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4204 considered to be a dynamic reloc section. */
4205
4206long
4207_bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4208 bfd *abfd;
4209{
4210 long ret;
4211 asection *s;
4212
4213 if (elf_dynsymtab (abfd) == 0)
4214 {
4215 bfd_set_error (bfd_error_invalid_operation);
4216 return -1;
4217 }
4218
4219 ret = sizeof (arelent *);
4220 for (s = abfd->sections; s != NULL; s = s->next)
4221 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4222 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4223 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4224 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4225 * sizeof (arelent *));
4226
4227 return ret;
4228}
4229
4230/* Canonicalize the dynamic relocation entries. Note that we return
4231 the dynamic relocations as a single block, although they are
4232 actually associated with particular sections; the interface, which
4233 was designed for SunOS style shared libraries, expects that there
4234 is only one set of dynamic relocs. Any section that was actually
4235 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4236 the dynamic symbol table, is considered to be a dynamic reloc
4237 section. */
4238
4239long
4240_bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4241 bfd *abfd;
4242 arelent **storage;
4243 asymbol **syms;
4244{
4245 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4246 asection *s;
4247 long ret;
4248
4249 if (elf_dynsymtab (abfd) == 0)
4250 {
4251 bfd_set_error (bfd_error_invalid_operation);
4252 return -1;
4253 }
4254
4255 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4256 ret = 0;
4257 for (s = abfd->sections; s != NULL; s = s->next)
4258 {
4259 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4260 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4261 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4262 {
4263 arelent *p;
4264 long count, i;
4265
4266 if (! (*slurp_relocs) (abfd, s, syms, true))
4267 return -1;
4268 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4269 p = s->relocation;
4270 for (i = 0; i < count; i++)
4271 *storage++ = p++;
4272 ret += count;
4273 }
4274 }
4275
4276 *storage = NULL;
4277
4278 return ret;
4279}
4280\f
4281/* Read in the version information. */
4282
4283boolean
4284_bfd_elf_slurp_version_tables (abfd)
4285 bfd *abfd;
4286{
4287 bfd_byte *contents = NULL;
4288
4289 if (elf_dynverdef (abfd) != 0)
4290 {
4291 Elf_Internal_Shdr *hdr;
4292 Elf_External_Verdef *everdef;
4293 Elf_Internal_Verdef *iverdef;
4294 unsigned int i;
4295
4296 hdr = &elf_tdata (abfd)->dynverdef_hdr;
4297
4298 elf_tdata (abfd)->verdef =
4299 ((Elf_Internal_Verdef *)
4300 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef)));
4301 if (elf_tdata (abfd)->verdef == NULL)
4302 goto error_return;
4303
4304 elf_tdata (abfd)->cverdefs = hdr->sh_info;
4305
4306 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4307 if (contents == NULL)
4308 goto error_return;
4309 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4310 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4311 goto error_return;
4312
4313 everdef = (Elf_External_Verdef *) contents;
4314 iverdef = elf_tdata (abfd)->verdef;
4315 for (i = 0; i < hdr->sh_info; i++, iverdef++)
4316 {
4317 Elf_External_Verdaux *everdaux;
4318 Elf_Internal_Verdaux *iverdaux;
4319 unsigned int j;
4320
4321 _bfd_elf_swap_verdef_in (abfd, everdef, iverdef);
4322
4323 iverdef->vd_bfd = abfd;
4324
4325 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4326 bfd_alloc (abfd,
4327 (iverdef->vd_cnt
4328 * sizeof (Elf_Internal_Verdaux))));
4329 if (iverdef->vd_auxptr == NULL)
4330 goto error_return;
4331
4332 everdaux = ((Elf_External_Verdaux *)
4333 ((bfd_byte *) everdef + iverdef->vd_aux));
4334 iverdaux = iverdef->vd_auxptr;
4335 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4336 {
4337 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4338
4339 iverdaux->vda_nodename =
4340 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4341 iverdaux->vda_name);
4342 if (iverdaux->vda_nodename == NULL)
4343 goto error_return;
4344
4345 if (j + 1 < iverdef->vd_cnt)
4346 iverdaux->vda_nextptr = iverdaux + 1;
4347 else
4348 iverdaux->vda_nextptr = NULL;
4349
4350 everdaux = ((Elf_External_Verdaux *)
4351 ((bfd_byte *) everdaux + iverdaux->vda_next));
4352 }
4353
4354 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4355
4356 if (i + 1 < hdr->sh_info)
4357 iverdef->vd_nextdef = iverdef + 1;
4358 else
4359 iverdef->vd_nextdef = NULL;
4360
4361 everdef = ((Elf_External_Verdef *)
4362 ((bfd_byte *) everdef + iverdef->vd_next));
4363 }
4364
4365 free (contents);
4366 contents = NULL;
4367 }
4368
4369 if (elf_dynverref (abfd) != 0)
4370 {
4371 Elf_Internal_Shdr *hdr;
4372 Elf_External_Verneed *everneed;
4373 Elf_Internal_Verneed *iverneed;
4374 unsigned int i;
4375
4376 hdr = &elf_tdata (abfd)->dynverref_hdr;
4377
4378 elf_tdata (abfd)->verref =
4379 ((Elf_Internal_Verneed *)
4380 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4381 if (elf_tdata (abfd)->verref == NULL)
4382 goto error_return;
4383
4384 elf_tdata (abfd)->cverrefs = hdr->sh_info;
4385
4386 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4387 if (contents == NULL)
4388 goto error_return;
4389 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4390 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4391 goto error_return;
4392
4393 everneed = (Elf_External_Verneed *) contents;
4394 iverneed = elf_tdata (abfd)->verref;
4395 for (i = 0; i < hdr->sh_info; i++, iverneed++)
4396 {
4397 Elf_External_Vernaux *evernaux;
4398 Elf_Internal_Vernaux *ivernaux;
4399 unsigned int j;
4400
4401 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4402
4403 iverneed->vn_bfd = abfd;
4404
4405 iverneed->vn_filename =
4406 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4407 iverneed->vn_file);
4408 if (iverneed->vn_filename == NULL)
4409 goto error_return;
4410
4411 iverneed->vn_auxptr =
4412 ((Elf_Internal_Vernaux *)
4413 bfd_alloc (abfd,
4414 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4415
4416 evernaux = ((Elf_External_Vernaux *)
4417 ((bfd_byte *) everneed + iverneed->vn_aux));
4418 ivernaux = iverneed->vn_auxptr;
4419 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4420 {
4421 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4422
4423 ivernaux->vna_nodename =
4424 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4425 ivernaux->vna_name);
4426 if (ivernaux->vna_nodename == NULL)
4427 goto error_return;
4428
4429 if (j + 1 < iverneed->vn_cnt)
4430 ivernaux->vna_nextptr = ivernaux + 1;
4431 else
4432 ivernaux->vna_nextptr = NULL;
4433
4434 evernaux = ((Elf_External_Vernaux *)
4435 ((bfd_byte *) evernaux + ivernaux->vna_next));
4436 }
4437
4438 if (i + 1 < hdr->sh_info)
4439 iverneed->vn_nextref = iverneed + 1;
4440 else
4441 iverneed->vn_nextref = NULL;
4442
4443 everneed = ((Elf_External_Verneed *)
4444 ((bfd_byte *) everneed + iverneed->vn_next));
4445 }
4446
4447 free (contents);
4448 contents = NULL;
4449 }
4450
4451 return true;
4452
4453 error_return:
4454 if (contents == NULL)
4455 free (contents);
4456 return false;
4457}
4458\f
4459asymbol *
4460_bfd_elf_make_empty_symbol (abfd)
4461 bfd *abfd;
4462{
4463 elf_symbol_type *newsym;
4464
4465 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4466 if (!newsym)
4467 return NULL;
4468 else
4469 {
4470 newsym->symbol.the_bfd = abfd;
4471 return &newsym->symbol;
4472 }
4473}
4474
4475void
4476_bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4477 bfd *ignore_abfd;
4478 asymbol *symbol;
4479 symbol_info *ret;
4480{
4481 bfd_symbol_info (symbol, ret);
4482}
4483
4484/* Return whether a symbol name implies a local symbol. Most targets
4485 use this function for the is_local_label_name entry point, but some
4486 override it. */
4487
4488boolean
4489_bfd_elf_is_local_label_name (abfd, name)
4490 bfd *abfd;
4491 const char *name;
4492{
4493 /* Normal local symbols start with ``.L''. */
4494 if (name[0] == '.' && name[1] == 'L')
4495 return true;
4496
4497 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4498 DWARF debugging symbols starting with ``..''. */
4499 if (name[0] == '.' && name[1] == '.')
4500 return true;
4501
4502 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4503 emitting DWARF debugging output. I suspect this is actually a
4504 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4505 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4506 underscore to be emitted on some ELF targets). For ease of use,
4507 we treat such symbols as local. */
4508 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
4509 return true;
4510
4511 return false;
4512}
4513
4514alent *
4515_bfd_elf_get_lineno (ignore_abfd, symbol)
4516 bfd *ignore_abfd;
4517 asymbol *symbol;
4518{
4519 abort ();
4520 return NULL;
4521}
4522
4523boolean
4524_bfd_elf_set_arch_mach (abfd, arch, machine)
4525 bfd *abfd;
4526 enum bfd_architecture arch;
4527 unsigned long machine;
4528{
4529 /* If this isn't the right architecture for this backend, and this
4530 isn't the generic backend, fail. */
4531 if (arch != get_elf_backend_data (abfd)->arch
4532 && arch != bfd_arch_unknown
4533 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
4534 return false;
4535
4536 return bfd_default_set_arch_mach (abfd, arch, machine);
4537}
4538
4539/* Find the nearest line to a particular section and offset, for error
4540 reporting. */
4541
4542boolean
4543_bfd_elf_find_nearest_line (abfd,
4544 section,
4545 symbols,
4546 offset,
4547 filename_ptr,
4548 functionname_ptr,
4549 line_ptr)
4550 bfd *abfd;
4551 asection *section;
4552 asymbol **symbols;
4553 bfd_vma offset;
4554 CONST char **filename_ptr;
4555 CONST char **functionname_ptr;
4556 unsigned int *line_ptr;
4557{
4558 boolean found;
4559 const char *filename;
4560 asymbol *func;
4561 bfd_vma low_func;
4562 asymbol **p;
4563
4564 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4565 filename_ptr, functionname_ptr,
4566 line_ptr))
4567 return true;
4568
4569 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4570 filename_ptr, functionname_ptr,
4571 line_ptr))
4572 return true;
4573
4574 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4575 &found, filename_ptr,
4576 functionname_ptr, line_ptr,
4577 &elf_tdata (abfd)->line_info))
4578 return false;
4579 if (found)
4580 return true;
4581
4582 if (symbols == NULL)
4583 return false;
4584
4585 filename = NULL;
4586 func = NULL;
4587 low_func = 0;
4588
4589 for (p = symbols; *p != NULL; p++)
4590 {
4591 elf_symbol_type *q;
4592
4593 q = (elf_symbol_type *) *p;
4594
4595 if (bfd_get_section (&q->symbol) != section)
4596 continue;
4597
4598 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4599 {
4600 default:
4601 break;
4602 case STT_FILE:
4603 filename = bfd_asymbol_name (&q->symbol);
4604 break;
4605 case STT_NOTYPE:
4606 case STT_FUNC:
4607 if (q->symbol.section == section
4608 && q->symbol.value >= low_func
4609 && q->symbol.value <= offset)
4610 {
4611 func = (asymbol *) q;
4612 low_func = q->symbol.value;
4613 }
4614 break;
4615 }
4616 }
4617
4618 if (func == NULL)
4619 return false;
4620
4621 *filename_ptr = filename;
4622 *functionname_ptr = bfd_asymbol_name (func);
4623 *line_ptr = 0;
4624 return true;
4625}
4626
4627int
4628_bfd_elf_sizeof_headers (abfd, reloc)
4629 bfd *abfd;
4630 boolean reloc;
4631{
4632 int ret;
4633
4634 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
4635 if (! reloc)
4636 ret += get_program_header_size (abfd);
4637 return ret;
4638}
4639
4640boolean
4641_bfd_elf_set_section_contents (abfd, section, location, offset, count)
4642 bfd *abfd;
4643 sec_ptr section;
4644 PTR location;
4645 file_ptr offset;
4646 bfd_size_type count;
4647{
4648 Elf_Internal_Shdr *hdr;
4649
4650 if (! abfd->output_has_begun
4651 && ! _bfd_elf_compute_section_file_positions
4652 (abfd, (struct bfd_link_info *) NULL))
4653 return false;
4654
4655 hdr = &elf_section_data (section)->this_hdr;
4656
4657 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
4658 return false;
4659 if (bfd_write (location, 1, count, abfd) != count)
4660 return false;
4661
4662 return true;
4663}
4664
4665void
4666_bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
4667 bfd *abfd;
4668 arelent *cache_ptr;
4669 Elf_Internal_Rela *dst;
4670{
4671 abort ();
4672}
4673
4674#if 0
4675void
4676_bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
4677 bfd *abfd;
4678 arelent *cache_ptr;
4679 Elf_Internal_Rel *dst;
4680{
4681 abort ();
4682}
4683#endif
4684
4685/* Try to convert a non-ELF reloc into an ELF one. */
4686
4687boolean
4688_bfd_elf_validate_reloc (abfd, areloc)
4689 bfd *abfd;
4690 arelent *areloc;
4691{
4692 /* Check whether we really have an ELF howto. */
4693
4694 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
4695 {
4696 bfd_reloc_code_real_type code;
4697 reloc_howto_type *howto;
4698
4699 /* Alien reloc: Try to determine its type to replace it with an
4700 equivalent ELF reloc. */
4701
4702 if (areloc->howto->pc_relative)
4703 {
4704 switch (areloc->howto->bitsize)
4705 {
4706 case 8:
4707 code = BFD_RELOC_8_PCREL;
4708 break;
4709 case 12:
4710 code = BFD_RELOC_12_PCREL;
4711 break;
4712 case 16:
4713 code = BFD_RELOC_16_PCREL;
4714 break;
4715 case 24:
4716 code = BFD_RELOC_24_PCREL;
4717 break;
4718 case 32:
4719 code = BFD_RELOC_32_PCREL;
4720 break;
4721 case 64:
4722 code = BFD_RELOC_64_PCREL;
4723 break;
4724 default:
4725 goto fail;
4726 }
4727
4728 howto = bfd_reloc_type_lookup (abfd, code);
4729
4730 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
4731 {
4732 if (howto->pcrel_offset)
4733 areloc->addend += areloc->address;
4734 else
4735 areloc->addend -= areloc->address; /* addend is unsigned!! */
4736 }
4737 }
4738 else
4739 {
4740 switch (areloc->howto->bitsize)
4741 {
4742 case 8:
4743 code = BFD_RELOC_8;
4744 break;
4745 case 14:
4746 code = BFD_RELOC_14;
4747 break;
4748 case 16:
4749 code = BFD_RELOC_16;
4750 break;
4751 case 26:
4752 code = BFD_RELOC_26;
4753 break;
4754 case 32:
4755 code = BFD_RELOC_32;
4756 break;
4757 case 64:
4758 code = BFD_RELOC_64;
4759 break;
4760 default:
4761 goto fail;
4762 }
4763
4764 howto = bfd_reloc_type_lookup (abfd, code);
4765 }
4766
4767 if (howto)
4768 areloc->howto = howto;
4769 else
4770 goto fail;
4771 }
4772
4773 return true;
4774
4775 fail:
4776 (*_bfd_error_handler)
4777 (_("%s: unsupported relocation type %s"),
4778 bfd_get_filename (abfd), areloc->howto->name);
4779 bfd_set_error (bfd_error_bad_value);
4780 return false;
4781}
4782
4783boolean
4784_bfd_elf_close_and_cleanup (abfd)
4785 bfd *abfd;
4786{
4787 if (bfd_get_format (abfd) == bfd_object)
4788 {
4789 if (elf_shstrtab (abfd) != NULL)
4790 _bfd_stringtab_free (elf_shstrtab (abfd));
4791 }
4792
4793 return _bfd_generic_close_and_cleanup (abfd);
4794}
4795
4796/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
4797 in the relocation's offset. Thus we cannot allow any sort of sanity
4798 range-checking to interfere. There is nothing else to do in processing
4799 this reloc. */
4800
4801bfd_reloc_status_type
4802_bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
4803 bfd *abfd;
4804 arelent *re;
4805 struct symbol_cache_entry *symbol;
4806 PTR data;
4807 asection *is;
4808 bfd *obfd;
4809 char **errmsg;
4810{
4811 return bfd_reloc_ok;
4812}
4813
4814\f
4815/* Elf core file support. Much of this only works on native
4816 toolchains, since we rely on knowing the
4817 machine-dependent procfs structure in order to pick
4818 out details about the corefile. */
4819
4820#ifdef HAVE_SYS_PROCFS_H
4821# include <sys/procfs.h>
4822#endif
4823
4824
4825/* Define offsetof for those systems which lack it. */
4826
4827#ifndef offsetof
4828# define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
4829#endif
4830
4831
4832/* FIXME: this is kinda wrong, but it's what gdb wants. */
4833
4834static int
4835elfcore_make_pid (abfd)
4836 bfd* abfd;
4837{
4838 return ((elf_tdata (abfd)->core_lwpid << 16)
4839 + (elf_tdata (abfd)->core_pid));
4840}
4841
4842
4843/* If there isn't a section called NAME, make one, using
4844 data from SECT. Note, this function will generate a
4845 reference to NAME, so you shouldn't deallocate or
4846 overwrite it. */
4847
4848static boolean
4849elfcore_maybe_make_sect (abfd, name, sect)
4850 bfd* abfd;
4851 char* name;
4852 asection* sect;
4853{
4854 asection* sect2;
4855
4856 if (bfd_get_section_by_name (abfd, name) != NULL)
4857 return true;
4858
4859 sect2 = bfd_make_section (abfd, name);
4860 if (sect2 == NULL)
4861 return false;
4862
4863 sect2->_raw_size = sect->_raw_size;
4864 sect2->filepos = sect->filepos;
4865 sect2->flags = sect->flags;
4866 sect2->alignment_power = sect->alignment_power;
4867 return true;
4868}
4869
4870
4871/* prstatus_t exists on:
4872 solaris 2.[567]
4873 linux 2.[01] + glibc
4874 unixware 4.2
4875*/
4876
4877#if defined (HAVE_PRSTATUS_T)
4878static boolean
4879elfcore_grok_prstatus (abfd, note)
4880 bfd* abfd;
4881 Elf_Internal_Note* note;
4882{
4883 prstatus_t prstat;
4884 char buf[100];
4885 char* name;
4886 asection* sect;
4887
4888 if (note->descsz != sizeof (prstat))
4889 return true;
4890
4891 memcpy (&prstat, note->descdata, sizeof (prstat));
4892
4893 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4894 elf_tdata (abfd)->core_pid = prstat.pr_pid;
4895
4896 /* pr_who exists on:
4897 solaris 2.[567]
4898 unixware 4.2
4899 pr_who doesn't exist on:
4900 linux 2.[01]
4901 */
4902#if defined (HAVE_PRSTATUS_T_PR_WHO)
4903 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
4904#endif
4905
4906 /* Make a ".reg/999" section. */
4907
4908 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
4909 name = bfd_alloc (abfd, strlen (buf) + 1);
4910 if (name == NULL)
4911 return false;
4912 strcpy (name, buf);
4913
4914 sect = bfd_make_section (abfd, name);
4915 if (sect == NULL)
4916 return false;
4917 sect->_raw_size = sizeof (prstat.pr_reg);
4918 sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
4919 sect->flags = SEC_HAS_CONTENTS;
4920 sect->alignment_power = 2;
4921
4922 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
4923 return false;
4924
4925 return true;
4926}
4927#endif /* defined (HAVE_PRSTATUS_T) */
4928
4929
4930/* There isn't a consistent prfpregset_t across platforms,
4931 but it doesn't matter, because we don't have to pick this
4932 data structure apart. */
4933
4934static boolean
4935elfcore_grok_prfpreg (abfd, note)
4936 bfd* abfd;
4937 Elf_Internal_Note* note;
4938{
4939 char buf[100];
4940 char* name;
4941 asection* sect;
4942
4943 /* Make a ".reg2/999" section. */
4944
4945 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
4946 name = bfd_alloc (abfd, strlen (buf) + 1);
4947 if (name == NULL)
4948 return false;
4949 strcpy (name, buf);
4950
4951 sect = bfd_make_section (abfd, name);
4952 if (sect == NULL)
4953 return false;
4954 sect->_raw_size = note->descsz;
4955 sect->filepos = note->descpos;
4956 sect->flags = SEC_HAS_CONTENTS;
4957 sect->alignment_power = 2;
4958
4959 if (! elfcore_maybe_make_sect (abfd, ".reg2", sect))
4960 return false;
4961
4962 return true;
4963}
4964
4965#if defined (HAVE_PRPSINFO_T)
4966# define elfcore_psinfo_t prpsinfo_t
4967#endif
4968
4969#if defined (HAVE_PSINFO_T)
4970# define elfcore_psinfo_t psinfo_t
4971#endif
4972
4973
4974#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
4975
4976/* return a malloc'ed copy of a string at START which is at
4977 most MAX bytes long, possibly without a terminating '\0'.
4978 the copy will always have a terminating '\0'. */
4979
4980static char*
4981elfcore_strndup (abfd, start, max)
4982 bfd* abfd;
4983 char* start;
4984 int max;
4985{
4986 char* dup;
4987 char* end = memchr (start, '\0', max);
4988 int len;
4989
4990 if (end == NULL)
4991 len = max;
4992 else
4993 len = end - start;
4994
4995 dup = bfd_alloc (abfd, len + 1);
4996 if (dup == NULL)
4997 return NULL;
4998
4999 memcpy (dup, start, len);
5000 dup[len] = '\0';
5001
5002 return dup;
5003}
5004
5005static boolean
5006elfcore_grok_psinfo (abfd, note)
5007 bfd* abfd;
5008 Elf_Internal_Note* note;
5009{
5010 elfcore_psinfo_t psinfo;
5011
5012 if (note->descsz != sizeof (elfcore_psinfo_t))
5013 return true;
5014
5015 memcpy (&psinfo, note->descdata, note->descsz);
5016
5017 elf_tdata (abfd)->core_program
5018 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5019
5020 elf_tdata (abfd)->core_command
5021 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5022
5023 /* Note that for some reason, a spurious space is tacked
5024 onto the end of the args in some (at least one anyway)
5025 implementations, so strip it off if it exists. */
5026
5027 {
5028 char* command = elf_tdata (abfd)->core_command;
5029 int n = strlen (command);
5030
5031 if (0 < n && command[n - 1] == ' ')
5032 command[n - 1] = '\0';
5033 }
5034
5035 return true;
5036}
5037#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5038
5039
5040#if defined (HAVE_PSTATUS_T)
5041static boolean
5042elfcore_grok_pstatus (abfd, note)
5043 bfd* abfd;
5044 Elf_Internal_Note* note;
5045{
5046 pstatus_t pstat;
5047
5048 if (note->descsz != sizeof (pstat))
5049 return true;
5050
5051 memcpy (&pstat, note->descdata, sizeof (pstat));
5052
5053 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5054
5055 /* Could grab some more details from the "representative"
5056 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5057 NT_LWPSTATUS note, presumably. */
5058
5059 return true;
5060}
5061#endif /* defined (HAVE_PSTATUS_T) */
5062
5063
5064#if defined (HAVE_LWPSTATUS_T)
5065static boolean
5066elfcore_grok_lwpstatus (abfd, note)
5067 bfd* abfd;
5068 Elf_Internal_Note* note;
5069{
5070 lwpstatus_t lwpstat;
5071 char buf[100];
5072 char* name;
5073 asection* sect;
5074
5075 if (note->descsz != sizeof (lwpstat))
5076 return true;
5077
5078 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5079
5080 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5081 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5082
5083 /* Make a ".reg/999" section. */
5084
5085 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5086 name = bfd_alloc (abfd, strlen (buf) + 1);
5087 if (name == NULL)
5088 return false;
5089 strcpy (name, buf);
5090
5091 sect = bfd_make_section (abfd, name);
5092 if (sect == NULL)
5093 return false;
5094
5095#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5096 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5097 sect->filepos = note->descpos
5098 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5099#endif
5100
5101#if defined (HAVE_LWPSTATUS_T_PR_REG)
5102 sect->_raw_size = sizeof (lwpstat.pr_reg);
5103 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5104#endif
5105
5106 sect->flags = SEC_HAS_CONTENTS;
5107 sect->alignment_power = 2;
5108
5109 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5110 return false;
5111
5112 /* Make a ".reg2/999" section */
5113
5114 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5115 name = bfd_alloc (abfd, strlen (buf) + 1);
5116 if (name == NULL)
5117 return false;
5118 strcpy (name, buf);
5119
5120 sect = bfd_make_section (abfd, name);
5121 if (sect == NULL)
5122 return false;
5123
5124#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5125 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5126 sect->filepos = note->descpos
5127 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5128#endif
5129
5130#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5131 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5132 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5133#endif
5134
5135 sect->flags = SEC_HAS_CONTENTS;
5136 sect->alignment_power = 2;
5137
5138 if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
5139 return false;
5140
5141 return true;
5142}
5143#endif /* defined (HAVE_LWPSTATUS_T) */
5144
5145
5146
5147static boolean
5148elfcore_grok_note (abfd, note)
5149 bfd* abfd;
5150 Elf_Internal_Note* note;
5151{
5152 switch (note->type)
5153 {
5154 default:
5155 return true;
5156
5157#if defined (HAVE_PRSTATUS_T)
5158 case NT_PRSTATUS:
5159 return elfcore_grok_prstatus (abfd, note);
5160#endif
5161
5162#if defined (HAVE_PSTATUS_T)
5163 case NT_PSTATUS:
5164 return elfcore_grok_pstatus (abfd, note);
5165#endif
5166
5167#if defined (HAVE_LWPSTATUS_T)
5168 case NT_LWPSTATUS:
5169 return elfcore_grok_lwpstatus (abfd, note);
5170#endif
5171
5172 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
5173 return elfcore_grok_prfpreg (abfd, note);
5174
5175#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5176 case NT_PRPSINFO:
5177 case NT_PSINFO:
5178 return elfcore_grok_psinfo (abfd, note);
5179#endif
5180 }
5181}
5182
5183
5184static boolean
5185elfcore_read_notes (abfd, offset, size)
5186 bfd* abfd;
5187 bfd_vma offset;
5188 bfd_vma size;
5189{
5190 char* buf;
5191 char* p;
5192
5193 if (size <= 0)
5194 return true;
5195
5196 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5197 return false;
5198
5199 buf = bfd_malloc ((size_t) size);
5200 if (buf == NULL)
5201 return false;
5202
5203 if (bfd_read (buf, size, 1, abfd) != size)
5204 {
5205 error:
5206 free (buf);
5207 return false;
5208 }
5209
5210 p = buf;
5211 while (p < buf + size)
5212 {
5213 /* FIXME: bad alignment assumption. */
5214 Elf_External_Note* xnp = (Elf_External_Note*) p;
5215 Elf_Internal_Note in;
5216
5217 in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5218
5219 in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5220 in.namedata = xnp->name;
5221
5222 in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5223 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5224 in.descpos = offset + (in.descdata - buf);
5225
5226 if (! elfcore_grok_note (abfd, &in))
5227 goto error;
5228
5229 p = in.descdata + BFD_ALIGN (in.descsz, 4);
5230 }
5231
5232 free (buf);
5233 return true;
5234}
5235
5236
5237
5238boolean
5239_bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
5240 bfd* abfd;
5241 Elf_Internal_Phdr* phdr;
5242 int sec_num;
5243{
5244 if (! bfd_section_from_phdr (abfd, phdr, sec_num))
5245 return false;
5246
5247 if (phdr->p_type == PT_NOTE
5248 && ! elfcore_read_notes (abfd, phdr->p_offset, phdr->p_filesz))
5249 return false;
5250
5251 return true;
5252}
5253
A mirror of the official binutils-gdb repository