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