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