]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Index: doc/ChangeLog
[thirdparty/binutils-gdb.git] / bfd / elf.c
1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* SECTION
22
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 /* For sparc64-cross-sparc32. */
34 #define _SYSCALL32
35 #include "bfd.h"
36 #include "sysdep.h"
37 #include "bfdlink.h"
38 #include "libbfd.h"
39 #define ARCH_SIZE 0
40 #include "elf-bfd.h"
41 #include "libiberty.h"
42
43 static int elf_sort_sections (const void *, const void *);
44 static bfd_boolean assign_file_positions_except_relocs (bfd *);
45 static bfd_boolean prep_headers (bfd *);
46 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
47 static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
48
49 /* Swap version information in and out. The version information is
50 currently size independent. If that ever changes, this code will
51 need to move into elfcode.h. */
52
53 /* Swap in a Verdef structure. */
54
55 void
56 _bfd_elf_swap_verdef_in (bfd *abfd,
57 const Elf_External_Verdef *src,
58 Elf_Internal_Verdef *dst)
59 {
60 dst->vd_version = H_GET_16 (abfd, src->vd_version);
61 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
62 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
63 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
64 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
65 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
66 dst->vd_next = H_GET_32 (abfd, src->vd_next);
67 }
68
69 /* Swap out a Verdef structure. */
70
71 void
72 _bfd_elf_swap_verdef_out (bfd *abfd,
73 const Elf_Internal_Verdef *src,
74 Elf_External_Verdef *dst)
75 {
76 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
77 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
78 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
79 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
80 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
81 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
82 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
83 }
84
85 /* Swap in a Verdaux structure. */
86
87 void
88 _bfd_elf_swap_verdaux_in (bfd *abfd,
89 const Elf_External_Verdaux *src,
90 Elf_Internal_Verdaux *dst)
91 {
92 dst->vda_name = H_GET_32 (abfd, src->vda_name);
93 dst->vda_next = H_GET_32 (abfd, src->vda_next);
94 }
95
96 /* Swap out a Verdaux structure. */
97
98 void
99 _bfd_elf_swap_verdaux_out (bfd *abfd,
100 const Elf_Internal_Verdaux *src,
101 Elf_External_Verdaux *dst)
102 {
103 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
104 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
105 }
106
107 /* Swap in a Verneed structure. */
108
109 void
110 _bfd_elf_swap_verneed_in (bfd *abfd,
111 const Elf_External_Verneed *src,
112 Elf_Internal_Verneed *dst)
113 {
114 dst->vn_version = H_GET_16 (abfd, src->vn_version);
115 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
116 dst->vn_file = H_GET_32 (abfd, src->vn_file);
117 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
118 dst->vn_next = H_GET_32 (abfd, src->vn_next);
119 }
120
121 /* Swap out a Verneed structure. */
122
123 void
124 _bfd_elf_swap_verneed_out (bfd *abfd,
125 const Elf_Internal_Verneed *src,
126 Elf_External_Verneed *dst)
127 {
128 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
129 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
130 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
131 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
132 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
133 }
134
135 /* Swap in a Vernaux structure. */
136
137 void
138 _bfd_elf_swap_vernaux_in (bfd *abfd,
139 const Elf_External_Vernaux *src,
140 Elf_Internal_Vernaux *dst)
141 {
142 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
143 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
144 dst->vna_other = H_GET_16 (abfd, src->vna_other);
145 dst->vna_name = H_GET_32 (abfd, src->vna_name);
146 dst->vna_next = H_GET_32 (abfd, src->vna_next);
147 }
148
149 /* Swap out a Vernaux structure. */
150
151 void
152 _bfd_elf_swap_vernaux_out (bfd *abfd,
153 const Elf_Internal_Vernaux *src,
154 Elf_External_Vernaux *dst)
155 {
156 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
157 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
158 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
159 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
160 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
161 }
162
163 /* Swap in a Versym structure. */
164
165 void
166 _bfd_elf_swap_versym_in (bfd *abfd,
167 const Elf_External_Versym *src,
168 Elf_Internal_Versym *dst)
169 {
170 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
171 }
172
173 /* Swap out a Versym structure. */
174
175 void
176 _bfd_elf_swap_versym_out (bfd *abfd,
177 const Elf_Internal_Versym *src,
178 Elf_External_Versym *dst)
179 {
180 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
181 }
182
183 /* Standard ELF hash function. Do not change this function; you will
184 cause invalid hash tables to be generated. */
185
186 unsigned long
187 bfd_elf_hash (const char *namearg)
188 {
189 const unsigned char *name = (const unsigned char *) namearg;
190 unsigned long h = 0;
191 unsigned long g;
192 int ch;
193
194 while ((ch = *name++) != '\0')
195 {
196 h = (h << 4) + ch;
197 if ((g = (h & 0xf0000000)) != 0)
198 {
199 h ^= g >> 24;
200 /* The ELF ABI says `h &= ~g', but this is equivalent in
201 this case and on some machines one insn instead of two. */
202 h ^= g;
203 }
204 }
205 return h & 0xffffffff;
206 }
207
208 /* Read a specified number of bytes at a specified offset in an ELF
209 file, into a newly allocated buffer, and return a pointer to the
210 buffer. */
211
212 static char *
213 elf_read (bfd *abfd, file_ptr offset, bfd_size_type size)
214 {
215 char *buf;
216
217 if ((buf = bfd_alloc (abfd, size)) == NULL)
218 return NULL;
219 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
220 return NULL;
221 if (bfd_bread (buf, size, abfd) != size)
222 {
223 if (bfd_get_error () != bfd_error_system_call)
224 bfd_set_error (bfd_error_file_truncated);
225 return NULL;
226 }
227 return buf;
228 }
229
230 bfd_boolean
231 bfd_elf_mkobject (bfd *abfd)
232 {
233 /* This just does initialization. */
234 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
235 elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
236 if (elf_tdata (abfd) == 0)
237 return FALSE;
238 /* Since everything is done at close time, do we need any
239 initialization? */
240
241 return TRUE;
242 }
243
244 bfd_boolean
245 bfd_elf_mkcorefile (bfd *abfd)
246 {
247 /* I think this can be done just like an object file. */
248 return bfd_elf_mkobject (abfd);
249 }
250
251 char *
252 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
253 {
254 Elf_Internal_Shdr **i_shdrp;
255 char *shstrtab = NULL;
256 file_ptr offset;
257 bfd_size_type shstrtabsize;
258
259 i_shdrp = elf_elfsections (abfd);
260 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
261 return 0;
262
263 shstrtab = (char *) i_shdrp[shindex]->contents;
264 if (shstrtab == NULL)
265 {
266 /* No cached one, attempt to read, and cache what we read. */
267 offset = i_shdrp[shindex]->sh_offset;
268 shstrtabsize = i_shdrp[shindex]->sh_size;
269 shstrtab = elf_read (abfd, offset, shstrtabsize);
270 i_shdrp[shindex]->contents = shstrtab;
271 }
272 return shstrtab;
273 }
274
275 char *
276 bfd_elf_string_from_elf_section (bfd *abfd,
277 unsigned int shindex,
278 unsigned int strindex)
279 {
280 Elf_Internal_Shdr *hdr;
281
282 if (strindex == 0)
283 return "";
284
285 hdr = elf_elfsections (abfd)[shindex];
286
287 if (hdr->contents == NULL
288 && bfd_elf_get_str_section (abfd, shindex) == NULL)
289 return NULL;
290
291 if (strindex >= hdr->sh_size)
292 {
293 (*_bfd_error_handler)
294 (_("%s: invalid string offset %u >= %lu for section `%s'"),
295 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
296 ((shindex == elf_elfheader(abfd)->e_shstrndx
297 && strindex == hdr->sh_name)
298 ? ".shstrtab"
299 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
300 return "";
301 }
302
303 return ((char *) hdr->contents) + strindex;
304 }
305
306 /* Read and convert symbols to internal format.
307 SYMCOUNT specifies the number of symbols to read, starting from
308 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
309 are non-NULL, they are used to store the internal symbols, external
310 symbols, and symbol section index extensions, respectively. */
311
312 Elf_Internal_Sym *
313 bfd_elf_get_elf_syms (bfd *ibfd,
314 Elf_Internal_Shdr *symtab_hdr,
315 size_t symcount,
316 size_t symoffset,
317 Elf_Internal_Sym *intsym_buf,
318 void *extsym_buf,
319 Elf_External_Sym_Shndx *extshndx_buf)
320 {
321 Elf_Internal_Shdr *shndx_hdr;
322 void *alloc_ext;
323 const bfd_byte *esym;
324 Elf_External_Sym_Shndx *alloc_extshndx;
325 Elf_External_Sym_Shndx *shndx;
326 Elf_Internal_Sym *isym;
327 Elf_Internal_Sym *isymend;
328 const struct elf_backend_data *bed;
329 size_t extsym_size;
330 bfd_size_type amt;
331 file_ptr pos;
332
333 if (symcount == 0)
334 return intsym_buf;
335
336 /* Normal syms might have section extension entries. */
337 shndx_hdr = NULL;
338 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
339 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
340
341 /* Read the symbols. */
342 alloc_ext = NULL;
343 alloc_extshndx = NULL;
344 bed = get_elf_backend_data (ibfd);
345 extsym_size = bed->s->sizeof_sym;
346 amt = symcount * extsym_size;
347 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
348 if (extsym_buf == NULL)
349 {
350 alloc_ext = bfd_malloc (amt);
351 extsym_buf = alloc_ext;
352 }
353 if (extsym_buf == NULL
354 || bfd_seek (ibfd, pos, SEEK_SET) != 0
355 || bfd_bread (extsym_buf, amt, ibfd) != amt)
356 {
357 intsym_buf = NULL;
358 goto out;
359 }
360
361 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
362 extshndx_buf = NULL;
363 else
364 {
365 amt = symcount * sizeof (Elf_External_Sym_Shndx);
366 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
367 if (extshndx_buf == NULL)
368 {
369 alloc_extshndx = bfd_malloc (amt);
370 extshndx_buf = alloc_extshndx;
371 }
372 if (extshndx_buf == NULL
373 || bfd_seek (ibfd, pos, SEEK_SET) != 0
374 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
375 {
376 intsym_buf = NULL;
377 goto out;
378 }
379 }
380
381 if (intsym_buf == NULL)
382 {
383 bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
384 intsym_buf = bfd_malloc (amt);
385 if (intsym_buf == NULL)
386 goto out;
387 }
388
389 /* Convert the symbols to internal form. */
390 isymend = intsym_buf + symcount;
391 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
392 isym < isymend;
393 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
394 (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
395
396 out:
397 if (alloc_ext != NULL)
398 free (alloc_ext);
399 if (alloc_extshndx != NULL)
400 free (alloc_extshndx);
401
402 return intsym_buf;
403 }
404
405 /* Look up a symbol name. */
406 const char *
407 bfd_elf_local_sym_name (bfd *abfd, Elf_Internal_Sym *isym)
408 {
409 unsigned int iname = isym->st_name;
410 unsigned int shindex = elf_tdata (abfd)->symtab_hdr.sh_link;
411 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION)
412 {
413 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
414 shindex = elf_elfheader (abfd)->e_shstrndx;
415 }
416
417 return bfd_elf_string_from_elf_section (abfd, shindex, iname);
418 }
419
420 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
421 sections. The first element is the flags, the rest are section
422 pointers. */
423
424 typedef union elf_internal_group {
425 Elf_Internal_Shdr *shdr;
426 unsigned int flags;
427 } Elf_Internal_Group;
428
429 /* Return the name of the group signature symbol. Why isn't the
430 signature just a string? */
431
432 static const char *
433 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
434 {
435 Elf_Internal_Shdr *hdr;
436 unsigned char esym[sizeof (Elf64_External_Sym)];
437 Elf_External_Sym_Shndx eshndx;
438 Elf_Internal_Sym isym;
439
440 /* First we need to ensure the symbol table is available. */
441 if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
442 return NULL;
443
444 /* Go read the symbol. */
445 hdr = &elf_tdata (abfd)->symtab_hdr;
446 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
447 &isym, esym, &eshndx) == NULL)
448 return NULL;
449
450 return bfd_elf_local_sym_name (abfd, &isym);
451 }
452
453 /* Set next_in_group list pointer, and group name for NEWSECT. */
454
455 static bfd_boolean
456 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
457 {
458 unsigned int num_group = elf_tdata (abfd)->num_group;
459
460 /* If num_group is zero, read in all SHT_GROUP sections. The count
461 is set to -1 if there are no SHT_GROUP sections. */
462 if (num_group == 0)
463 {
464 unsigned int i, shnum;
465
466 /* First count the number of groups. If we have a SHT_GROUP
467 section with just a flag word (ie. sh_size is 4), ignore it. */
468 shnum = elf_numsections (abfd);
469 num_group = 0;
470 for (i = 0; i < shnum; i++)
471 {
472 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
473 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
474 num_group += 1;
475 }
476
477 if (num_group == 0)
478 num_group = (unsigned) -1;
479 elf_tdata (abfd)->num_group = num_group;
480
481 if (num_group > 0)
482 {
483 /* We keep a list of elf section headers for group sections,
484 so we can find them quickly. */
485 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
486 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
487 if (elf_tdata (abfd)->group_sect_ptr == NULL)
488 return FALSE;
489
490 num_group = 0;
491 for (i = 0; i < shnum; i++)
492 {
493 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
494 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
495 {
496 unsigned char *src;
497 Elf_Internal_Group *dest;
498
499 /* Add to list of sections. */
500 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
501 num_group += 1;
502
503 /* Read the raw contents. */
504 BFD_ASSERT (sizeof (*dest) >= 4);
505 amt = shdr->sh_size * sizeof (*dest) / 4;
506 shdr->contents = bfd_alloc (abfd, amt);
507 if (shdr->contents == NULL
508 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
509 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
510 != shdr->sh_size))
511 return FALSE;
512
513 /* Translate raw contents, a flag word followed by an
514 array of elf section indices all in target byte order,
515 to the flag word followed by an array of elf section
516 pointers. */
517 src = shdr->contents + shdr->sh_size;
518 dest = (Elf_Internal_Group *) (shdr->contents + amt);
519 while (1)
520 {
521 unsigned int idx;
522
523 src -= 4;
524 --dest;
525 idx = H_GET_32 (abfd, src);
526 if (src == shdr->contents)
527 {
528 dest->flags = idx;
529 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
530 shdr->bfd_section->flags
531 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
532 break;
533 }
534 if (idx >= shnum)
535 {
536 ((*_bfd_error_handler)
537 (_("%s: invalid SHT_GROUP entry"),
538 bfd_archive_filename (abfd)));
539 idx = 0;
540 }
541 dest->shdr = elf_elfsections (abfd)[idx];
542 }
543 }
544 }
545 }
546 }
547
548 if (num_group != (unsigned) -1)
549 {
550 unsigned int i;
551
552 for (i = 0; i < num_group; i++)
553 {
554 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
555 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
556 unsigned int n_elt = shdr->sh_size / 4;
557
558 /* Look through this group's sections to see if current
559 section is a member. */
560 while (--n_elt != 0)
561 if ((++idx)->shdr == hdr)
562 {
563 asection *s = NULL;
564
565 /* We are a member of this group. Go looking through
566 other members to see if any others are linked via
567 next_in_group. */
568 idx = (Elf_Internal_Group *) shdr->contents;
569 n_elt = shdr->sh_size / 4;
570 while (--n_elt != 0)
571 if ((s = (++idx)->shdr->bfd_section) != NULL
572 && elf_next_in_group (s) != NULL)
573 break;
574 if (n_elt != 0)
575 {
576 /* Snarf the group name from other member, and
577 insert current section in circular list. */
578 elf_group_name (newsect) = elf_group_name (s);
579 elf_next_in_group (newsect) = elf_next_in_group (s);
580 elf_next_in_group (s) = newsect;
581 }
582 else
583 {
584 const char *gname;
585
586 gname = group_signature (abfd, shdr);
587 if (gname == NULL)
588 return FALSE;
589 elf_group_name (newsect) = gname;
590
591 /* Start a circular list with one element. */
592 elf_next_in_group (newsect) = newsect;
593 }
594
595 /* If the group section has been created, point to the
596 new member. */
597 if (shdr->bfd_section != NULL)
598 elf_next_in_group (shdr->bfd_section) = newsect;
599
600 i = num_group - 1;
601 break;
602 }
603 }
604 }
605
606 if (elf_group_name (newsect) == NULL)
607 {
608 (*_bfd_error_handler) (_("%s: no group info for section %s"),
609 bfd_archive_filename (abfd), newsect->name);
610 }
611 return TRUE;
612 }
613
614 bfd_boolean
615 bfd_elf_discard_group (bfd *abfd ATTRIBUTE_UNUSED, asection *group)
616 {
617 asection *first = elf_next_in_group (group);
618 asection *s = first;
619
620 while (s != NULL)
621 {
622 s->output_section = bfd_abs_section_ptr;
623 s = elf_next_in_group (s);
624 /* These lists are circular. */
625 if (s == first)
626 break;
627 }
628 return TRUE;
629 }
630
631 /* Make a BFD section from an ELF section. We store a pointer to the
632 BFD section in the bfd_section field of the header. */
633
634 bfd_boolean
635 _bfd_elf_make_section_from_shdr (bfd *abfd,
636 Elf_Internal_Shdr *hdr,
637 const char *name)
638 {
639 asection *newsect;
640 flagword flags;
641 const struct elf_backend_data *bed;
642
643 if (hdr->bfd_section != NULL)
644 {
645 BFD_ASSERT (strcmp (name,
646 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
647 return TRUE;
648 }
649
650 newsect = bfd_make_section_anyway (abfd, name);
651 if (newsect == NULL)
652 return FALSE;
653
654 /* Always use the real type/flags. */
655 elf_section_type (newsect) = hdr->sh_type;
656 elf_section_flags (newsect) = hdr->sh_flags;
657
658 newsect->filepos = hdr->sh_offset;
659
660 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
661 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
662 || ! bfd_set_section_alignment (abfd, newsect,
663 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
664 return FALSE;
665
666 flags = SEC_NO_FLAGS;
667 if (hdr->sh_type != SHT_NOBITS)
668 flags |= SEC_HAS_CONTENTS;
669 if (hdr->sh_type == SHT_GROUP)
670 flags |= SEC_GROUP | SEC_EXCLUDE;
671 if ((hdr->sh_flags & SHF_ALLOC) != 0)
672 {
673 flags |= SEC_ALLOC;
674 if (hdr->sh_type != SHT_NOBITS)
675 flags |= SEC_LOAD;
676 }
677 if ((hdr->sh_flags & SHF_WRITE) == 0)
678 flags |= SEC_READONLY;
679 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
680 flags |= SEC_CODE;
681 else if ((flags & SEC_LOAD) != 0)
682 flags |= SEC_DATA;
683 if ((hdr->sh_flags & SHF_MERGE) != 0)
684 {
685 flags |= SEC_MERGE;
686 newsect->entsize = hdr->sh_entsize;
687 if ((hdr->sh_flags & SHF_STRINGS) != 0)
688 flags |= SEC_STRINGS;
689 }
690 if (hdr->sh_flags & SHF_GROUP)
691 if (!setup_group (abfd, hdr, newsect))
692 return FALSE;
693 if ((hdr->sh_flags & SHF_TLS) != 0)
694 flags |= SEC_THREAD_LOCAL;
695
696 /* The debugging sections appear to be recognized only by name, not
697 any sort of flag. */
698 {
699 static const char *debug_sec_names [] =
700 {
701 ".debug",
702 ".gnu.linkonce.wi.",
703 ".line",
704 ".stab"
705 };
706 int i;
707
708 for (i = ARRAY_SIZE (debug_sec_names); i--;)
709 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
710 break;
711
712 if (i >= 0)
713 flags |= SEC_DEBUGGING;
714 }
715
716 /* As a GNU extension, if the name begins with .gnu.linkonce, we
717 only link a single copy of the section. This is used to support
718 g++. g++ will emit each template expansion in its own section.
719 The symbols will be defined as weak, so that multiple definitions
720 are permitted. The GNU linker extension is to actually discard
721 all but one of the sections. */
722 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
723 && elf_next_in_group (newsect) == NULL)
724 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
725
726 bed = get_elf_backend_data (abfd);
727 if (bed->elf_backend_section_flags)
728 if (! bed->elf_backend_section_flags (&flags, hdr))
729 return FALSE;
730
731 if (! bfd_set_section_flags (abfd, newsect, flags))
732 return FALSE;
733
734 if ((flags & SEC_ALLOC) != 0)
735 {
736 Elf_Internal_Phdr *phdr;
737 unsigned int i;
738
739 /* Look through the phdrs to see if we need to adjust the lma.
740 If all the p_paddr fields are zero, we ignore them, since
741 some ELF linkers produce such output. */
742 phdr = elf_tdata (abfd)->phdr;
743 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
744 {
745 if (phdr->p_paddr != 0)
746 break;
747 }
748 if (i < elf_elfheader (abfd)->e_phnum)
749 {
750 phdr = elf_tdata (abfd)->phdr;
751 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
752 {
753 /* This section is part of this segment if its file
754 offset plus size lies within the segment's memory
755 span and, if the section is loaded, the extent of the
756 loaded data lies within the extent of the segment.
757
758 Note - we used to check the p_paddr field as well, and
759 refuse to set the LMA if it was 0. This is wrong
760 though, as a perfectly valid initialised segment can
761 have a p_paddr of zero. Some architectures, eg ARM,
762 place special significance on the address 0 and
763 executables need to be able to have a segment which
764 covers this address. */
765 if (phdr->p_type == PT_LOAD
766 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
767 && (hdr->sh_offset + hdr->sh_size
768 <= phdr->p_offset + phdr->p_memsz)
769 && ((flags & SEC_LOAD) == 0
770 || (hdr->sh_offset + hdr->sh_size
771 <= phdr->p_offset + phdr->p_filesz)))
772 {
773 if ((flags & SEC_LOAD) == 0)
774 newsect->lma = (phdr->p_paddr
775 + hdr->sh_addr - phdr->p_vaddr);
776 else
777 /* We used to use the same adjustment for SEC_LOAD
778 sections, but that doesn't work if the segment
779 is packed with code from multiple VMAs.
780 Instead we calculate the section LMA based on
781 the segment LMA. It is assumed that the
782 segment will contain sections with contiguous
783 LMAs, even if the VMAs are not. */
784 newsect->lma = (phdr->p_paddr
785 + hdr->sh_offset - phdr->p_offset);
786
787 /* With contiguous segments, we can't tell from file
788 offsets whether a section with zero size should
789 be placed at the end of one segment or the
790 beginning of the next. Decide based on vaddr. */
791 if (hdr->sh_addr >= phdr->p_vaddr
792 && (hdr->sh_addr + hdr->sh_size
793 <= phdr->p_vaddr + phdr->p_memsz))
794 break;
795 }
796 }
797 }
798 }
799
800 hdr->bfd_section = newsect;
801 elf_section_data (newsect)->this_hdr = *hdr;
802
803 return TRUE;
804 }
805
806 /*
807 INTERNAL_FUNCTION
808 bfd_elf_find_section
809
810 SYNOPSIS
811 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
812
813 DESCRIPTION
814 Helper functions for GDB to locate the string tables.
815 Since BFD hides string tables from callers, GDB needs to use an
816 internal hook to find them. Sun's .stabstr, in particular,
817 isn't even pointed to by the .stab section, so ordinary
818 mechanisms wouldn't work to find it, even if we had some.
819 */
820
821 struct elf_internal_shdr *
822 bfd_elf_find_section (bfd *abfd, char *name)
823 {
824 Elf_Internal_Shdr **i_shdrp;
825 char *shstrtab;
826 unsigned int max;
827 unsigned int i;
828
829 i_shdrp = elf_elfsections (abfd);
830 if (i_shdrp != NULL)
831 {
832 shstrtab = bfd_elf_get_str_section (abfd,
833 elf_elfheader (abfd)->e_shstrndx);
834 if (shstrtab != NULL)
835 {
836 max = elf_numsections (abfd);
837 for (i = 1; i < max; i++)
838 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
839 return i_shdrp[i];
840 }
841 }
842 return 0;
843 }
844
845 const char *const bfd_elf_section_type_names[] = {
846 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
847 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
848 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
849 };
850
851 /* ELF relocs are against symbols. If we are producing relocatable
852 output, and the reloc is against an external symbol, and nothing
853 has given us any additional addend, the resulting reloc will also
854 be against the same symbol. In such a case, we don't want to
855 change anything about the way the reloc is handled, since it will
856 all be done at final link time. Rather than put special case code
857 into bfd_perform_relocation, all the reloc types use this howto
858 function. It just short circuits the reloc if producing
859 relocatable output against an external symbol. */
860
861 bfd_reloc_status_type
862 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
863 arelent *reloc_entry,
864 asymbol *symbol,
865 void *data ATTRIBUTE_UNUSED,
866 asection *input_section,
867 bfd *output_bfd,
868 char **error_message ATTRIBUTE_UNUSED)
869 {
870 if (output_bfd != NULL
871 && (symbol->flags & BSF_SECTION_SYM) == 0
872 && (! reloc_entry->howto->partial_inplace
873 || reloc_entry->addend == 0))
874 {
875 reloc_entry->address += input_section->output_offset;
876 return bfd_reloc_ok;
877 }
878
879 return bfd_reloc_continue;
880 }
881 \f
882 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
883
884 static void
885 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
886 asection *sec)
887 {
888 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
889 sec->sec_info_type = ELF_INFO_TYPE_NONE;
890 }
891
892 /* Finish SHF_MERGE section merging. */
893
894 bfd_boolean
895 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
896 {
897 if (!is_elf_hash_table (info))
898 return FALSE;
899 if (elf_hash_table (info)->merge_info)
900 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
901 merge_sections_remove_hook);
902 return TRUE;
903 }
904
905 void
906 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
907 {
908 sec->output_section = bfd_abs_section_ptr;
909 sec->output_offset = sec->vma;
910 if (!is_elf_hash_table (info))
911 return;
912
913 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
914 }
915 \f
916 /* Copy the program header and other data from one object module to
917 another. */
918
919 bfd_boolean
920 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
921 {
922 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
923 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
924 return TRUE;
925
926 BFD_ASSERT (!elf_flags_init (obfd)
927 || (elf_elfheader (obfd)->e_flags
928 == elf_elfheader (ibfd)->e_flags));
929
930 elf_gp (obfd) = elf_gp (ibfd);
931 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
932 elf_flags_init (obfd) = TRUE;
933 return TRUE;
934 }
935
936 /* Print out the program headers. */
937
938 bfd_boolean
939 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
940 {
941 FILE *f = farg;
942 Elf_Internal_Phdr *p;
943 asection *s;
944 bfd_byte *dynbuf = NULL;
945
946 p = elf_tdata (abfd)->phdr;
947 if (p != NULL)
948 {
949 unsigned int i, c;
950
951 fprintf (f, _("\nProgram Header:\n"));
952 c = elf_elfheader (abfd)->e_phnum;
953 for (i = 0; i < c; i++, p++)
954 {
955 const char *pt;
956 char buf[20];
957
958 switch (p->p_type)
959 {
960 case PT_NULL: pt = "NULL"; break;
961 case PT_LOAD: pt = "LOAD"; break;
962 case PT_DYNAMIC: pt = "DYNAMIC"; break;
963 case PT_INTERP: pt = "INTERP"; break;
964 case PT_NOTE: pt = "NOTE"; break;
965 case PT_SHLIB: pt = "SHLIB"; break;
966 case PT_PHDR: pt = "PHDR"; break;
967 case PT_TLS: pt = "TLS"; break;
968 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
969 case PT_GNU_STACK: pt = "STACK"; break;
970 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
971 }
972 fprintf (f, "%8s off 0x", pt);
973 bfd_fprintf_vma (abfd, f, p->p_offset);
974 fprintf (f, " vaddr 0x");
975 bfd_fprintf_vma (abfd, f, p->p_vaddr);
976 fprintf (f, " paddr 0x");
977 bfd_fprintf_vma (abfd, f, p->p_paddr);
978 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
979 fprintf (f, " filesz 0x");
980 bfd_fprintf_vma (abfd, f, p->p_filesz);
981 fprintf (f, " memsz 0x");
982 bfd_fprintf_vma (abfd, f, p->p_memsz);
983 fprintf (f, " flags %c%c%c",
984 (p->p_flags & PF_R) != 0 ? 'r' : '-',
985 (p->p_flags & PF_W) != 0 ? 'w' : '-',
986 (p->p_flags & PF_X) != 0 ? 'x' : '-');
987 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
988 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
989 fprintf (f, "\n");
990 }
991 }
992
993 s = bfd_get_section_by_name (abfd, ".dynamic");
994 if (s != NULL)
995 {
996 int elfsec;
997 unsigned long shlink;
998 bfd_byte *extdyn, *extdynend;
999 size_t extdynsize;
1000 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1001
1002 fprintf (f, _("\nDynamic Section:\n"));
1003
1004 dynbuf = bfd_malloc (s->_raw_size);
1005 if (dynbuf == NULL)
1006 goto error_return;
1007 if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
1008 goto error_return;
1009
1010 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1011 if (elfsec == -1)
1012 goto error_return;
1013 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1014
1015 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1016 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1017
1018 extdyn = dynbuf;
1019 extdynend = extdyn + s->_raw_size;
1020 for (; extdyn < extdynend; extdyn += extdynsize)
1021 {
1022 Elf_Internal_Dyn dyn;
1023 const char *name;
1024 char ab[20];
1025 bfd_boolean stringp;
1026
1027 (*swap_dyn_in) (abfd, extdyn, &dyn);
1028
1029 if (dyn.d_tag == DT_NULL)
1030 break;
1031
1032 stringp = FALSE;
1033 switch (dyn.d_tag)
1034 {
1035 default:
1036 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1037 name = ab;
1038 break;
1039
1040 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1041 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1042 case DT_PLTGOT: name = "PLTGOT"; break;
1043 case DT_HASH: name = "HASH"; break;
1044 case DT_STRTAB: name = "STRTAB"; break;
1045 case DT_SYMTAB: name = "SYMTAB"; break;
1046 case DT_RELA: name = "RELA"; break;
1047 case DT_RELASZ: name = "RELASZ"; break;
1048 case DT_RELAENT: name = "RELAENT"; break;
1049 case DT_STRSZ: name = "STRSZ"; break;
1050 case DT_SYMENT: name = "SYMENT"; break;
1051 case DT_INIT: name = "INIT"; break;
1052 case DT_FINI: name = "FINI"; break;
1053 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1054 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1055 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1056 case DT_REL: name = "REL"; break;
1057 case DT_RELSZ: name = "RELSZ"; break;
1058 case DT_RELENT: name = "RELENT"; break;
1059 case DT_PLTREL: name = "PLTREL"; break;
1060 case DT_DEBUG: name = "DEBUG"; break;
1061 case DT_TEXTREL: name = "TEXTREL"; break;
1062 case DT_JMPREL: name = "JMPREL"; break;
1063 case DT_BIND_NOW: name = "BIND_NOW"; break;
1064 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1065 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1066 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1067 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1068 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1069 case DT_FLAGS: name = "FLAGS"; break;
1070 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1071 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1072 case DT_CHECKSUM: name = "CHECKSUM"; break;
1073 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1074 case DT_MOVEENT: name = "MOVEENT"; break;
1075 case DT_MOVESZ: name = "MOVESZ"; break;
1076 case DT_FEATURE: name = "FEATURE"; break;
1077 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1078 case DT_SYMINSZ: name = "SYMINSZ"; break;
1079 case DT_SYMINENT: name = "SYMINENT"; break;
1080 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1081 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1082 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1083 case DT_PLTPAD: name = "PLTPAD"; break;
1084 case DT_MOVETAB: name = "MOVETAB"; break;
1085 case DT_SYMINFO: name = "SYMINFO"; break;
1086 case DT_RELACOUNT: name = "RELACOUNT"; break;
1087 case DT_RELCOUNT: name = "RELCOUNT"; break;
1088 case DT_FLAGS_1: name = "FLAGS_1"; break;
1089 case DT_VERSYM: name = "VERSYM"; break;
1090 case DT_VERDEF: name = "VERDEF"; break;
1091 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1092 case DT_VERNEED: name = "VERNEED"; break;
1093 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1094 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1095 case DT_USED: name = "USED"; break;
1096 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1097 }
1098
1099 fprintf (f, " %-11s ", name);
1100 if (! stringp)
1101 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1102 else
1103 {
1104 const char *string;
1105 unsigned int tagv = dyn.d_un.d_val;
1106
1107 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1108 if (string == NULL)
1109 goto error_return;
1110 fprintf (f, "%s", string);
1111 }
1112 fprintf (f, "\n");
1113 }
1114
1115 free (dynbuf);
1116 dynbuf = NULL;
1117 }
1118
1119 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1120 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1121 {
1122 if (! _bfd_elf_slurp_version_tables (abfd))
1123 return FALSE;
1124 }
1125
1126 if (elf_dynverdef (abfd) != 0)
1127 {
1128 Elf_Internal_Verdef *t;
1129
1130 fprintf (f, _("\nVersion definitions:\n"));
1131 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1132 {
1133 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1134 t->vd_flags, t->vd_hash, t->vd_nodename);
1135 if (t->vd_auxptr->vda_nextptr != NULL)
1136 {
1137 Elf_Internal_Verdaux *a;
1138
1139 fprintf (f, "\t");
1140 for (a = t->vd_auxptr->vda_nextptr;
1141 a != NULL;
1142 a = a->vda_nextptr)
1143 fprintf (f, "%s ", a->vda_nodename);
1144 fprintf (f, "\n");
1145 }
1146 }
1147 }
1148
1149 if (elf_dynverref (abfd) != 0)
1150 {
1151 Elf_Internal_Verneed *t;
1152
1153 fprintf (f, _("\nVersion References:\n"));
1154 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1155 {
1156 Elf_Internal_Vernaux *a;
1157
1158 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1159 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1160 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1161 a->vna_flags, a->vna_other, a->vna_nodename);
1162 }
1163 }
1164
1165 return TRUE;
1166
1167 error_return:
1168 if (dynbuf != NULL)
1169 free (dynbuf);
1170 return FALSE;
1171 }
1172
1173 /* Display ELF-specific fields of a symbol. */
1174
1175 void
1176 bfd_elf_print_symbol (bfd *abfd,
1177 void *filep,
1178 asymbol *symbol,
1179 bfd_print_symbol_type how)
1180 {
1181 FILE *file = filep;
1182 switch (how)
1183 {
1184 case bfd_print_symbol_name:
1185 fprintf (file, "%s", symbol->name);
1186 break;
1187 case bfd_print_symbol_more:
1188 fprintf (file, "elf ");
1189 bfd_fprintf_vma (abfd, file, symbol->value);
1190 fprintf (file, " %lx", (long) symbol->flags);
1191 break;
1192 case bfd_print_symbol_all:
1193 {
1194 const char *section_name;
1195 const char *name = NULL;
1196 const struct elf_backend_data *bed;
1197 unsigned char st_other;
1198 bfd_vma val;
1199
1200 section_name = symbol->section ? symbol->section->name : "(*none*)";
1201
1202 bed = get_elf_backend_data (abfd);
1203 if (bed->elf_backend_print_symbol_all)
1204 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1205
1206 if (name == NULL)
1207 {
1208 name = symbol->name;
1209 bfd_print_symbol_vandf (abfd, file, symbol);
1210 }
1211
1212 fprintf (file, " %s\t", section_name);
1213 /* Print the "other" value for a symbol. For common symbols,
1214 we've already printed the size; now print the alignment.
1215 For other symbols, we have no specified alignment, and
1216 we've printed the address; now print the size. */
1217 if (bfd_is_com_section (symbol->section))
1218 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1219 else
1220 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1221 bfd_fprintf_vma (abfd, file, val);
1222
1223 /* If we have version information, print it. */
1224 if (elf_tdata (abfd)->dynversym_section != 0
1225 && (elf_tdata (abfd)->dynverdef_section != 0
1226 || elf_tdata (abfd)->dynverref_section != 0))
1227 {
1228 unsigned int vernum;
1229 const char *version_string;
1230
1231 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1232
1233 if (vernum == 0)
1234 version_string = "";
1235 else if (vernum == 1)
1236 version_string = "Base";
1237 else if (vernum <= elf_tdata (abfd)->cverdefs)
1238 version_string =
1239 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1240 else
1241 {
1242 Elf_Internal_Verneed *t;
1243
1244 version_string = "";
1245 for (t = elf_tdata (abfd)->verref;
1246 t != NULL;
1247 t = t->vn_nextref)
1248 {
1249 Elf_Internal_Vernaux *a;
1250
1251 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1252 {
1253 if (a->vna_other == vernum)
1254 {
1255 version_string = a->vna_nodename;
1256 break;
1257 }
1258 }
1259 }
1260 }
1261
1262 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1263 fprintf (file, " %-11s", version_string);
1264 else
1265 {
1266 int i;
1267
1268 fprintf (file, " (%s)", version_string);
1269 for (i = 10 - strlen (version_string); i > 0; --i)
1270 putc (' ', file);
1271 }
1272 }
1273
1274 /* If the st_other field is not zero, print it. */
1275 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1276
1277 switch (st_other)
1278 {
1279 case 0: break;
1280 case STV_INTERNAL: fprintf (file, " .internal"); break;
1281 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1282 case STV_PROTECTED: fprintf (file, " .protected"); break;
1283 default:
1284 /* Some other non-defined flags are also present, so print
1285 everything hex. */
1286 fprintf (file, " 0x%02x", (unsigned int) st_other);
1287 }
1288
1289 fprintf (file, " %s", name);
1290 }
1291 break;
1292 }
1293 }
1294 \f
1295 /* Create an entry in an ELF linker hash table. */
1296
1297 struct bfd_hash_entry *
1298 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1299 struct bfd_hash_table *table,
1300 const char *string)
1301 {
1302 /* Allocate the structure if it has not already been allocated by a
1303 subclass. */
1304 if (entry == NULL)
1305 {
1306 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1307 if (entry == NULL)
1308 return entry;
1309 }
1310
1311 /* Call the allocation method of the superclass. */
1312 entry = _bfd_link_hash_newfunc (entry, table, string);
1313 if (entry != NULL)
1314 {
1315 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1316 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1317
1318 /* Set local fields. */
1319 ret->indx = -1;
1320 ret->dynindx = -1;
1321 ret->dynstr_index = 0;
1322 ret->elf_hash_value = 0;
1323 ret->weakdef = NULL;
1324 ret->verinfo.verdef = NULL;
1325 ret->vtable_entries_size = 0;
1326 ret->vtable_entries_used = NULL;
1327 ret->vtable_parent = NULL;
1328 ret->got = htab->init_refcount;
1329 ret->plt = htab->init_refcount;
1330 ret->size = 0;
1331 ret->type = STT_NOTYPE;
1332 ret->other = 0;
1333 /* Assume that we have been called by a non-ELF symbol reader.
1334 This flag is then reset by the code which reads an ELF input
1335 file. This ensures that a symbol created by a non-ELF symbol
1336 reader will have the flag set correctly. */
1337 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1338 }
1339
1340 return entry;
1341 }
1342
1343 /* Copy data from an indirect symbol to its direct symbol, hiding the
1344 old indirect symbol. Also used for copying flags to a weakdef. */
1345
1346 void
1347 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
1348 struct elf_link_hash_entry *dir,
1349 struct elf_link_hash_entry *ind)
1350 {
1351 bfd_signed_vma tmp;
1352 bfd_signed_vma lowest_valid = bed->can_refcount;
1353
1354 /* Copy down any references that we may have already seen to the
1355 symbol which just became indirect. */
1356
1357 dir->elf_link_hash_flags |=
1358 (ind->elf_link_hash_flags
1359 & (ELF_LINK_HASH_REF_DYNAMIC
1360 | ELF_LINK_HASH_REF_REGULAR
1361 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1362 | ELF_LINK_NON_GOT_REF));
1363
1364 if (ind->root.type != bfd_link_hash_indirect)
1365 return;
1366
1367 /* Copy over the global and procedure linkage table refcount entries.
1368 These may have been already set up by a check_relocs routine. */
1369 tmp = dir->got.refcount;
1370 if (tmp < lowest_valid)
1371 {
1372 dir->got.refcount = ind->got.refcount;
1373 ind->got.refcount = tmp;
1374 }
1375 else
1376 BFD_ASSERT (ind->got.refcount < lowest_valid);
1377
1378 tmp = dir->plt.refcount;
1379 if (tmp < lowest_valid)
1380 {
1381 dir->plt.refcount = ind->plt.refcount;
1382 ind->plt.refcount = tmp;
1383 }
1384 else
1385 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1386
1387 if (dir->dynindx == -1)
1388 {
1389 dir->dynindx = ind->dynindx;
1390 dir->dynstr_index = ind->dynstr_index;
1391 ind->dynindx = -1;
1392 ind->dynstr_index = 0;
1393 }
1394 else
1395 BFD_ASSERT (ind->dynindx == -1);
1396 }
1397
1398 void
1399 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1400 struct elf_link_hash_entry *h,
1401 bfd_boolean force_local)
1402 {
1403 h->plt = elf_hash_table (info)->init_offset;
1404 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1405 if (force_local)
1406 {
1407 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1408 if (h->dynindx != -1)
1409 {
1410 h->dynindx = -1;
1411 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1412 h->dynstr_index);
1413 }
1414 }
1415 }
1416
1417 /* Initialize an ELF linker hash table. */
1418
1419 bfd_boolean
1420 _bfd_elf_link_hash_table_init
1421 (struct elf_link_hash_table *table,
1422 bfd *abfd,
1423 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1424 struct bfd_hash_table *,
1425 const char *))
1426 {
1427 bfd_boolean ret;
1428
1429 table->dynamic_sections_created = FALSE;
1430 table->dynobj = NULL;
1431 /* Make sure can_refcount is extended to the width and signedness of
1432 init_refcount before we subtract one from it. */
1433 table->init_refcount.refcount = get_elf_backend_data (abfd)->can_refcount;
1434 table->init_refcount.refcount -= 1;
1435 table->init_offset.offset = -(bfd_vma) 1;
1436 /* The first dynamic symbol is a dummy. */
1437 table->dynsymcount = 1;
1438 table->dynstr = NULL;
1439 table->bucketcount = 0;
1440 table->needed = NULL;
1441 table->hgot = NULL;
1442 table->stab_info = NULL;
1443 table->merge_info = NULL;
1444 memset (&table->eh_info, 0, sizeof (table->eh_info));
1445 table->dynlocal = NULL;
1446 table->runpath = NULL;
1447 table->tls_segment = NULL;
1448 table->loaded = NULL;
1449
1450 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1451 table->root.type = bfd_link_elf_hash_table;
1452
1453 return ret;
1454 }
1455
1456 /* Create an ELF linker hash table. */
1457
1458 struct bfd_link_hash_table *
1459 _bfd_elf_link_hash_table_create (bfd *abfd)
1460 {
1461 struct elf_link_hash_table *ret;
1462 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1463
1464 ret = bfd_malloc (amt);
1465 if (ret == NULL)
1466 return NULL;
1467
1468 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1469 {
1470 free (ret);
1471 return NULL;
1472 }
1473
1474 return &ret->root;
1475 }
1476
1477 /* This is a hook for the ELF emulation code in the generic linker to
1478 tell the backend linker what file name to use for the DT_NEEDED
1479 entry for a dynamic object. The generic linker passes name as an
1480 empty string to indicate that no DT_NEEDED entry should be made. */
1481
1482 void
1483 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1484 {
1485 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1486 && bfd_get_format (abfd) == bfd_object)
1487 elf_dt_name (abfd) = name;
1488 }
1489
1490 void
1491 bfd_elf_set_dt_needed_soname (bfd *abfd, const char *name)
1492 {
1493 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1494 && bfd_get_format (abfd) == bfd_object)
1495 elf_dt_soname (abfd) = name;
1496 }
1497
1498 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1499 the linker ELF emulation code. */
1500
1501 struct bfd_link_needed_list *
1502 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1503 struct bfd_link_info *info)
1504 {
1505 if (! is_elf_hash_table (info))
1506 return NULL;
1507 return elf_hash_table (info)->needed;
1508 }
1509
1510 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1511 hook for the linker ELF emulation code. */
1512
1513 struct bfd_link_needed_list *
1514 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1515 struct bfd_link_info *info)
1516 {
1517 if (! is_elf_hash_table (info))
1518 return NULL;
1519 return elf_hash_table (info)->runpath;
1520 }
1521
1522 /* Get the name actually used for a dynamic object for a link. This
1523 is the SONAME entry if there is one. Otherwise, it is the string
1524 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1525
1526 const char *
1527 bfd_elf_get_dt_soname (bfd *abfd)
1528 {
1529 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1530 && bfd_get_format (abfd) == bfd_object)
1531 return elf_dt_name (abfd);
1532 return NULL;
1533 }
1534
1535 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1536 the ELF linker emulation code. */
1537
1538 bfd_boolean
1539 bfd_elf_get_bfd_needed_list (bfd *abfd,
1540 struct bfd_link_needed_list **pneeded)
1541 {
1542 asection *s;
1543 bfd_byte *dynbuf = NULL;
1544 int elfsec;
1545 unsigned long shlink;
1546 bfd_byte *extdyn, *extdynend;
1547 size_t extdynsize;
1548 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1549
1550 *pneeded = NULL;
1551
1552 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1553 || bfd_get_format (abfd) != bfd_object)
1554 return TRUE;
1555
1556 s = bfd_get_section_by_name (abfd, ".dynamic");
1557 if (s == NULL || s->_raw_size == 0)
1558 return TRUE;
1559
1560 dynbuf = bfd_malloc (s->_raw_size);
1561 if (dynbuf == NULL)
1562 goto error_return;
1563
1564 if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
1565 goto error_return;
1566
1567 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1568 if (elfsec == -1)
1569 goto error_return;
1570
1571 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1572
1573 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1574 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1575
1576 extdyn = dynbuf;
1577 extdynend = extdyn + s->_raw_size;
1578 for (; extdyn < extdynend; extdyn += extdynsize)
1579 {
1580 Elf_Internal_Dyn dyn;
1581
1582 (*swap_dyn_in) (abfd, extdyn, &dyn);
1583
1584 if (dyn.d_tag == DT_NULL)
1585 break;
1586
1587 if (dyn.d_tag == DT_NEEDED)
1588 {
1589 const char *string;
1590 struct bfd_link_needed_list *l;
1591 unsigned int tagv = dyn.d_un.d_val;
1592 bfd_size_type amt;
1593
1594 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1595 if (string == NULL)
1596 goto error_return;
1597
1598 amt = sizeof *l;
1599 l = bfd_alloc (abfd, amt);
1600 if (l == NULL)
1601 goto error_return;
1602
1603 l->by = abfd;
1604 l->name = string;
1605 l->next = *pneeded;
1606 *pneeded = l;
1607 }
1608 }
1609
1610 free (dynbuf);
1611
1612 return TRUE;
1613
1614 error_return:
1615 if (dynbuf != NULL)
1616 free (dynbuf);
1617 return FALSE;
1618 }
1619 \f
1620 /* Allocate an ELF string table--force the first byte to be zero. */
1621
1622 struct bfd_strtab_hash *
1623 _bfd_elf_stringtab_init (void)
1624 {
1625 struct bfd_strtab_hash *ret;
1626
1627 ret = _bfd_stringtab_init ();
1628 if (ret != NULL)
1629 {
1630 bfd_size_type loc;
1631
1632 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1633 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1634 if (loc == (bfd_size_type) -1)
1635 {
1636 _bfd_stringtab_free (ret);
1637 ret = NULL;
1638 }
1639 }
1640 return ret;
1641 }
1642 \f
1643 /* ELF .o/exec file reading */
1644
1645 /* Create a new bfd section from an ELF section header. */
1646
1647 bfd_boolean
1648 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1649 {
1650 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1651 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1652 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1653 const char *name;
1654
1655 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1656
1657 switch (hdr->sh_type)
1658 {
1659 case SHT_NULL:
1660 /* Inactive section. Throw it away. */
1661 return TRUE;
1662
1663 case SHT_PROGBITS: /* Normal section with contents. */
1664 case SHT_NOBITS: /* .bss section. */
1665 case SHT_HASH: /* .hash section. */
1666 case SHT_NOTE: /* .note section. */
1667 case SHT_INIT_ARRAY: /* .init_array section. */
1668 case SHT_FINI_ARRAY: /* .fini_array section. */
1669 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1670 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1671
1672 case SHT_DYNAMIC: /* Dynamic linking information. */
1673 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1674 return FALSE;
1675 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1676 {
1677 Elf_Internal_Shdr *dynsymhdr;
1678
1679 /* The shared libraries distributed with hpux11 have a bogus
1680 sh_link field for the ".dynamic" section. Find the
1681 string table for the ".dynsym" section instead. */
1682 if (elf_dynsymtab (abfd) != 0)
1683 {
1684 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1685 hdr->sh_link = dynsymhdr->sh_link;
1686 }
1687 else
1688 {
1689 unsigned int i, num_sec;
1690
1691 num_sec = elf_numsections (abfd);
1692 for (i = 1; i < num_sec; i++)
1693 {
1694 dynsymhdr = elf_elfsections (abfd)[i];
1695 if (dynsymhdr->sh_type == SHT_DYNSYM)
1696 {
1697 hdr->sh_link = dynsymhdr->sh_link;
1698 break;
1699 }
1700 }
1701 }
1702 }
1703 break;
1704
1705 case SHT_SYMTAB: /* A symbol table */
1706 if (elf_onesymtab (abfd) == shindex)
1707 return TRUE;
1708
1709 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1710 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1711 elf_onesymtab (abfd) = shindex;
1712 elf_tdata (abfd)->symtab_hdr = *hdr;
1713 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1714 abfd->flags |= HAS_SYMS;
1715
1716 /* Sometimes a shared object will map in the symbol table. If
1717 SHF_ALLOC is set, and this is a shared object, then we also
1718 treat this section as a BFD section. We can not base the
1719 decision purely on SHF_ALLOC, because that flag is sometimes
1720 set in a relocatable object file, which would confuse the
1721 linker. */
1722 if ((hdr->sh_flags & SHF_ALLOC) != 0
1723 && (abfd->flags & DYNAMIC) != 0
1724 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1725 return FALSE;
1726
1727 return TRUE;
1728
1729 case SHT_DYNSYM: /* A dynamic symbol table */
1730 if (elf_dynsymtab (abfd) == shindex)
1731 return TRUE;
1732
1733 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1734 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1735 elf_dynsymtab (abfd) = shindex;
1736 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1737 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1738 abfd->flags |= HAS_SYMS;
1739
1740 /* Besides being a symbol table, we also treat this as a regular
1741 section, so that objcopy can handle it. */
1742 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1743
1744 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1745 if (elf_symtab_shndx (abfd) == shindex)
1746 return TRUE;
1747
1748 /* Get the associated symbol table. */
1749 if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1750 || hdr->sh_link != elf_onesymtab (abfd))
1751 return FALSE;
1752
1753 elf_symtab_shndx (abfd) = shindex;
1754 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1755 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1756 return TRUE;
1757
1758 case SHT_STRTAB: /* A string table */
1759 if (hdr->bfd_section != NULL)
1760 return TRUE;
1761 if (ehdr->e_shstrndx == shindex)
1762 {
1763 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1764 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1765 return TRUE;
1766 }
1767 {
1768 unsigned int i, num_sec;
1769
1770 num_sec = elf_numsections (abfd);
1771 for (i = 1; i < num_sec; i++)
1772 {
1773 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1774 if (hdr2->sh_link == shindex)
1775 {
1776 if (! bfd_section_from_shdr (abfd, i))
1777 return FALSE;
1778 if (elf_onesymtab (abfd) == i)
1779 {
1780 elf_tdata (abfd)->strtab_hdr = *hdr;
1781 elf_elfsections (abfd)[shindex] =
1782 &elf_tdata (abfd)->strtab_hdr;
1783 return TRUE;
1784 }
1785 if (elf_dynsymtab (abfd) == i)
1786 {
1787 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1788 elf_elfsections (abfd)[shindex] = hdr =
1789 &elf_tdata (abfd)->dynstrtab_hdr;
1790 /* We also treat this as a regular section, so
1791 that objcopy can handle it. */
1792 break;
1793 }
1794 #if 0 /* Not handling other string tables specially right now. */
1795 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1796 /* We have a strtab for some random other section. */
1797 newsect = (asection *) hdr2->bfd_section;
1798 if (!newsect)
1799 break;
1800 hdr->bfd_section = newsect;
1801 hdr2 = &elf_section_data (newsect)->str_hdr;
1802 *hdr2 = *hdr;
1803 elf_elfsections (abfd)[shindex] = hdr2;
1804 #endif
1805 }
1806 }
1807 }
1808
1809 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1810
1811 case SHT_REL:
1812 case SHT_RELA:
1813 /* *These* do a lot of work -- but build no sections! */
1814 {
1815 asection *target_sect;
1816 Elf_Internal_Shdr *hdr2;
1817 unsigned int num_sec = elf_numsections (abfd);
1818
1819 /* Check for a bogus link to avoid crashing. */
1820 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1821 || hdr->sh_link >= num_sec)
1822 {
1823 ((*_bfd_error_handler)
1824 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1825 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1826 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1827 }
1828
1829 /* For some incomprehensible reason Oracle distributes
1830 libraries for Solaris in which some of the objects have
1831 bogus sh_link fields. It would be nice if we could just
1832 reject them, but, unfortunately, some people need to use
1833 them. We scan through the section headers; if we find only
1834 one suitable symbol table, we clobber the sh_link to point
1835 to it. I hope this doesn't break anything. */
1836 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1837 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1838 {
1839 unsigned int scan;
1840 int found;
1841
1842 found = 0;
1843 for (scan = 1; scan < num_sec; scan++)
1844 {
1845 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1846 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1847 {
1848 if (found != 0)
1849 {
1850 found = 0;
1851 break;
1852 }
1853 found = scan;
1854 }
1855 }
1856 if (found != 0)
1857 hdr->sh_link = found;
1858 }
1859
1860 /* Get the symbol table. */
1861 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1862 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1863 return FALSE;
1864
1865 /* If this reloc section does not use the main symbol table we
1866 don't treat it as a reloc section. BFD can't adequately
1867 represent such a section, so at least for now, we don't
1868 try. We just present it as a normal section. We also
1869 can't use it as a reloc section if it points to the null
1870 section. */
1871 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1872 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1873
1874 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1875 return FALSE;
1876 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1877 if (target_sect == NULL)
1878 return FALSE;
1879
1880 if ((target_sect->flags & SEC_RELOC) == 0
1881 || target_sect->reloc_count == 0)
1882 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1883 else
1884 {
1885 bfd_size_type amt;
1886 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1887 amt = sizeof (*hdr2);
1888 hdr2 = bfd_alloc (abfd, amt);
1889 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1890 }
1891 *hdr2 = *hdr;
1892 elf_elfsections (abfd)[shindex] = hdr2;
1893 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1894 target_sect->flags |= SEC_RELOC;
1895 target_sect->relocation = NULL;
1896 target_sect->rel_filepos = hdr->sh_offset;
1897 /* In the section to which the relocations apply, mark whether
1898 its relocations are of the REL or RELA variety. */
1899 if (hdr->sh_size != 0)
1900 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
1901 abfd->flags |= HAS_RELOC;
1902 return TRUE;
1903 }
1904 break;
1905
1906 case SHT_GNU_verdef:
1907 elf_dynverdef (abfd) = shindex;
1908 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1909 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1910 break;
1911
1912 case SHT_GNU_versym:
1913 elf_dynversym (abfd) = shindex;
1914 elf_tdata (abfd)->dynversym_hdr = *hdr;
1915 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1916 break;
1917
1918 case SHT_GNU_verneed:
1919 elf_dynverref (abfd) = shindex;
1920 elf_tdata (abfd)->dynverref_hdr = *hdr;
1921 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1922 break;
1923
1924 case SHT_SHLIB:
1925 return TRUE;
1926
1927 case SHT_GROUP:
1928 /* We need a BFD section for objcopy and relocatable linking,
1929 and it's handy to have the signature available as the section
1930 name. */
1931 name = group_signature (abfd, hdr);
1932 if (name == NULL)
1933 return FALSE;
1934 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
1935 return FALSE;
1936 if (hdr->contents != NULL)
1937 {
1938 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1939 unsigned int n_elt = hdr->sh_size / 4;
1940 asection *s;
1941
1942 if (idx->flags & GRP_COMDAT)
1943 hdr->bfd_section->flags
1944 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1945
1946 while (--n_elt != 0)
1947 if ((s = (++idx)->shdr->bfd_section) != NULL
1948 && elf_next_in_group (s) != NULL)
1949 {
1950 elf_next_in_group (hdr->bfd_section) = s;
1951 break;
1952 }
1953 }
1954 break;
1955
1956 default:
1957 /* Check for any processor-specific section types. */
1958 {
1959 if (bed->elf_backend_section_from_shdr)
1960 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1961 }
1962 break;
1963 }
1964
1965 return TRUE;
1966 }
1967
1968 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1969 Return SEC for sections that have no elf section, and NULL on error. */
1970
1971 asection *
1972 bfd_section_from_r_symndx (bfd *abfd,
1973 struct sym_sec_cache *cache,
1974 asection *sec,
1975 unsigned long r_symndx)
1976 {
1977 Elf_Internal_Shdr *symtab_hdr;
1978 unsigned char esym[sizeof (Elf64_External_Sym)];
1979 Elf_External_Sym_Shndx eshndx;
1980 Elf_Internal_Sym isym;
1981 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1982
1983 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
1984 return cache->sec[ent];
1985
1986 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1987 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
1988 &isym, esym, &eshndx) == NULL)
1989 return NULL;
1990
1991 if (cache->abfd != abfd)
1992 {
1993 memset (cache->indx, -1, sizeof (cache->indx));
1994 cache->abfd = abfd;
1995 }
1996 cache->indx[ent] = r_symndx;
1997 cache->sec[ent] = sec;
1998 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
1999 || isym.st_shndx > SHN_HIRESERVE)
2000 {
2001 asection *s;
2002 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2003 if (s != NULL)
2004 cache->sec[ent] = s;
2005 }
2006 return cache->sec[ent];
2007 }
2008
2009 /* Given an ELF section number, retrieve the corresponding BFD
2010 section. */
2011
2012 asection *
2013 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2014 {
2015 if (index >= elf_numsections (abfd))
2016 return NULL;
2017 return elf_elfsections (abfd)[index]->bfd_section;
2018 }
2019
2020 static struct bfd_elf_special_section const special_sections[] =
2021 {
2022 { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2023 { ".comment", 8, 0, SHT_PROGBITS, 0 },
2024 { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2025 { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2026 { ".debug", 6, 0, SHT_PROGBITS, 0 },
2027 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2028 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2029 { ".line", 5, 0, SHT_PROGBITS, 0 },
2030 { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
2031 { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
2032 { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2033 { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2034 { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2035 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2036 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2037 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2038 { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
2039 { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
2040 { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
2041 { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
2042 { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
2043 { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
2044 { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
2045 { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2046 { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
2047 { ".interp", 7, 0, SHT_PROGBITS, 0 },
2048 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2049 { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
2050 { ".strtab", 7, 0, SHT_STRTAB, 0 },
2051 { ".symtab", 7, 0, SHT_SYMTAB, 0 },
2052 { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
2053 { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
2054 { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2055 { ".note", 5, -1, SHT_NOTE, 0 },
2056 { ".rela", 5, -1, SHT_RELA, 0 },
2057 { ".rel", 4, -1, SHT_REL, 0 },
2058 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2059 { NULL, 0, 0, 0, 0 }
2060 };
2061
2062 static const struct bfd_elf_special_section *
2063 get_special_section (const char *name,
2064 const struct bfd_elf_special_section *special_sections,
2065 unsigned int rela)
2066 {
2067 int i;
2068 int len = strlen (name);
2069
2070 for (i = 0; special_sections[i].prefix != NULL; i++)
2071 {
2072 int suffix_len;
2073 int prefix_len = special_sections[i].prefix_length;
2074
2075 if (len < prefix_len)
2076 continue;
2077 if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
2078 continue;
2079
2080 suffix_len = special_sections[i].suffix_length;
2081 if (suffix_len <= 0)
2082 {
2083 if (name[prefix_len] != 0)
2084 {
2085 if (suffix_len == 0)
2086 continue;
2087 if (name[prefix_len] != '.'
2088 && (suffix_len == -2
2089 || (rela && special_sections[i].type == SHT_REL)))
2090 continue;
2091 }
2092 }
2093 else
2094 {
2095 if (len < prefix_len + suffix_len)
2096 continue;
2097 if (memcmp (name + len - suffix_len,
2098 special_sections[i].prefix + prefix_len,
2099 suffix_len) != 0)
2100 continue;
2101 }
2102 return &special_sections[i];
2103 }
2104
2105 return NULL;
2106 }
2107
2108 const struct bfd_elf_special_section *
2109 _bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
2110 {
2111 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2112 const struct bfd_elf_special_section *ssect = NULL;
2113
2114 /* See if this is one of the special sections. */
2115 if (name)
2116 {
2117 unsigned int rela = bed->default_use_rela_p;
2118
2119 if (bed->special_sections)
2120 ssect = get_special_section (name, bed->special_sections, rela);
2121
2122 if (! ssect)
2123 ssect = get_special_section (name, special_sections, rela);
2124 }
2125
2126 return ssect;
2127 }
2128
2129 bfd_boolean
2130 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2131 {
2132 struct bfd_elf_section_data *sdata;
2133 const struct bfd_elf_special_section *ssect;
2134
2135 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2136 if (sdata == NULL)
2137 {
2138 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2139 if (sdata == NULL)
2140 return FALSE;
2141 sec->used_by_bfd = sdata;
2142 }
2143
2144 elf_section_type (sec) = SHT_NULL;
2145 ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
2146 if (ssect != NULL)
2147 {
2148 elf_section_type (sec) = ssect->type;
2149 elf_section_flags (sec) = ssect->attr;
2150 }
2151
2152 /* Indicate whether or not this section should use RELA relocations. */
2153 sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
2154
2155 return TRUE;
2156 }
2157
2158 /* Create a new bfd section from an ELF program header.
2159
2160 Since program segments have no names, we generate a synthetic name
2161 of the form segment<NUM>, where NUM is generally the index in the
2162 program header table. For segments that are split (see below) we
2163 generate the names segment<NUM>a and segment<NUM>b.
2164
2165 Note that some program segments may have a file size that is different than
2166 (less than) the memory size. All this means is that at execution the
2167 system must allocate the amount of memory specified by the memory size,
2168 but only initialize it with the first "file size" bytes read from the
2169 file. This would occur for example, with program segments consisting
2170 of combined data+bss.
2171
2172 To handle the above situation, this routine generates TWO bfd sections
2173 for the single program segment. The first has the length specified by
2174 the file size of the segment, and the second has the length specified
2175 by the difference between the two sizes. In effect, the segment is split
2176 into it's initialized and uninitialized parts.
2177
2178 */
2179
2180 bfd_boolean
2181 _bfd_elf_make_section_from_phdr (bfd *abfd,
2182 Elf_Internal_Phdr *hdr,
2183 int index,
2184 const char *typename)
2185 {
2186 asection *newsect;
2187 char *name;
2188 char namebuf[64];
2189 size_t len;
2190 int split;
2191
2192 split = ((hdr->p_memsz > 0)
2193 && (hdr->p_filesz > 0)
2194 && (hdr->p_memsz > hdr->p_filesz));
2195 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2196 len = strlen (namebuf) + 1;
2197 name = bfd_alloc (abfd, len);
2198 if (!name)
2199 return FALSE;
2200 memcpy (name, namebuf, len);
2201 newsect = bfd_make_section (abfd, name);
2202 if (newsect == NULL)
2203 return FALSE;
2204 newsect->vma = hdr->p_vaddr;
2205 newsect->lma = hdr->p_paddr;
2206 newsect->_raw_size = hdr->p_filesz;
2207 newsect->filepos = hdr->p_offset;
2208 newsect->flags |= SEC_HAS_CONTENTS;
2209 if (hdr->p_type == PT_LOAD)
2210 {
2211 newsect->flags |= SEC_ALLOC;
2212 newsect->flags |= SEC_LOAD;
2213 if (hdr->p_flags & PF_X)
2214 {
2215 /* FIXME: all we known is that it has execute PERMISSION,
2216 may be data. */
2217 newsect->flags |= SEC_CODE;
2218 }
2219 }
2220 if (!(hdr->p_flags & PF_W))
2221 {
2222 newsect->flags |= SEC_READONLY;
2223 }
2224
2225 if (split)
2226 {
2227 sprintf (namebuf, "%s%db", typename, index);
2228 len = strlen (namebuf) + 1;
2229 name = bfd_alloc (abfd, len);
2230 if (!name)
2231 return FALSE;
2232 memcpy (name, namebuf, len);
2233 newsect = bfd_make_section (abfd, name);
2234 if (newsect == NULL)
2235 return FALSE;
2236 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2237 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2238 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
2239 if (hdr->p_type == PT_LOAD)
2240 {
2241 newsect->flags |= SEC_ALLOC;
2242 if (hdr->p_flags & PF_X)
2243 newsect->flags |= SEC_CODE;
2244 }
2245 if (!(hdr->p_flags & PF_W))
2246 newsect->flags |= SEC_READONLY;
2247 }
2248
2249 return TRUE;
2250 }
2251
2252 bfd_boolean
2253 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2254 {
2255 const struct elf_backend_data *bed;
2256
2257 switch (hdr->p_type)
2258 {
2259 case PT_NULL:
2260 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2261
2262 case PT_LOAD:
2263 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2264
2265 case PT_DYNAMIC:
2266 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2267
2268 case PT_INTERP:
2269 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2270
2271 case PT_NOTE:
2272 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2273 return FALSE;
2274 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2275 return FALSE;
2276 return TRUE;
2277
2278 case PT_SHLIB:
2279 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2280
2281 case PT_PHDR:
2282 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2283
2284 case PT_GNU_EH_FRAME:
2285 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2286 "eh_frame_hdr");
2287
2288 case PT_GNU_STACK:
2289 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2290
2291 default:
2292 /* Check for any processor-specific program segment types.
2293 If no handler for them, default to making "segment" sections. */
2294 bed = get_elf_backend_data (abfd);
2295 if (bed->elf_backend_section_from_phdr)
2296 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2297 else
2298 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2299 }
2300 }
2301
2302 /* Initialize REL_HDR, the section-header for new section, containing
2303 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2304 relocations; otherwise, we use REL relocations. */
2305
2306 bfd_boolean
2307 _bfd_elf_init_reloc_shdr (bfd *abfd,
2308 Elf_Internal_Shdr *rel_hdr,
2309 asection *asect,
2310 bfd_boolean use_rela_p)
2311 {
2312 char *name;
2313 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2314 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2315
2316 name = bfd_alloc (abfd, amt);
2317 if (name == NULL)
2318 return FALSE;
2319 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2320 rel_hdr->sh_name =
2321 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2322 FALSE);
2323 if (rel_hdr->sh_name == (unsigned int) -1)
2324 return FALSE;
2325 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2326 rel_hdr->sh_entsize = (use_rela_p
2327 ? bed->s->sizeof_rela
2328 : bed->s->sizeof_rel);
2329 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2330 rel_hdr->sh_flags = 0;
2331 rel_hdr->sh_addr = 0;
2332 rel_hdr->sh_size = 0;
2333 rel_hdr->sh_offset = 0;
2334
2335 return TRUE;
2336 }
2337
2338 /* Set up an ELF internal section header for a section. */
2339
2340 static void
2341 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2342 {
2343 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2344 bfd_boolean *failedptr = failedptrarg;
2345 Elf_Internal_Shdr *this_hdr;
2346
2347 if (*failedptr)
2348 {
2349 /* We already failed; just get out of the bfd_map_over_sections
2350 loop. */
2351 return;
2352 }
2353
2354 this_hdr = &elf_section_data (asect)->this_hdr;
2355
2356 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2357 asect->name, FALSE);
2358 if (this_hdr->sh_name == (unsigned int) -1)
2359 {
2360 *failedptr = TRUE;
2361 return;
2362 }
2363
2364 this_hdr->sh_flags = 0;
2365
2366 if ((asect->flags & SEC_ALLOC) != 0
2367 || asect->user_set_vma)
2368 this_hdr->sh_addr = asect->vma;
2369 else
2370 this_hdr->sh_addr = 0;
2371
2372 this_hdr->sh_offset = 0;
2373 this_hdr->sh_size = asect->_raw_size;
2374 this_hdr->sh_link = 0;
2375 this_hdr->sh_addralign = 1 << asect->alignment_power;
2376 /* The sh_entsize and sh_info fields may have been set already by
2377 copy_private_section_data. */
2378
2379 this_hdr->bfd_section = asect;
2380 this_hdr->contents = NULL;
2381
2382 /* If the section type is unspecified, we set it based on
2383 asect->flags. */
2384 if (this_hdr->sh_type == SHT_NULL)
2385 {
2386 if ((asect->flags & SEC_ALLOC) != 0
2387 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2388 || (asect->flags & SEC_NEVER_LOAD) != 0))
2389 this_hdr->sh_type = SHT_NOBITS;
2390 else
2391 this_hdr->sh_type = SHT_PROGBITS;
2392 }
2393
2394 switch (this_hdr->sh_type)
2395 {
2396 default:
2397 break;
2398
2399 case SHT_STRTAB:
2400 case SHT_INIT_ARRAY:
2401 case SHT_FINI_ARRAY:
2402 case SHT_PREINIT_ARRAY:
2403 case SHT_NOTE:
2404 case SHT_NOBITS:
2405 case SHT_PROGBITS:
2406 break;
2407
2408 case SHT_HASH:
2409 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2410 break;
2411
2412 case SHT_DYNSYM:
2413 this_hdr->sh_entsize = bed->s->sizeof_sym;
2414 break;
2415
2416 case SHT_DYNAMIC:
2417 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2418 break;
2419
2420 case SHT_RELA:
2421 if (get_elf_backend_data (abfd)->may_use_rela_p)
2422 this_hdr->sh_entsize = bed->s->sizeof_rela;
2423 break;
2424
2425 case SHT_REL:
2426 if (get_elf_backend_data (abfd)->may_use_rel_p)
2427 this_hdr->sh_entsize = bed->s->sizeof_rel;
2428 break;
2429
2430 case SHT_GNU_versym:
2431 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2432 break;
2433
2434 case SHT_GNU_verdef:
2435 this_hdr->sh_entsize = 0;
2436 /* objcopy or strip will copy over sh_info, but may not set
2437 cverdefs. The linker will set cverdefs, but sh_info will be
2438 zero. */
2439 if (this_hdr->sh_info == 0)
2440 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2441 else
2442 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2443 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2444 break;
2445
2446 case SHT_GNU_verneed:
2447 this_hdr->sh_entsize = 0;
2448 /* objcopy or strip will copy over sh_info, but may not set
2449 cverrefs. The linker will set cverrefs, but sh_info will be
2450 zero. */
2451 if (this_hdr->sh_info == 0)
2452 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2453 else
2454 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2455 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2456 break;
2457
2458 case SHT_GROUP:
2459 this_hdr->sh_entsize = 4;
2460 break;
2461 }
2462
2463 if ((asect->flags & SEC_ALLOC) != 0)
2464 this_hdr->sh_flags |= SHF_ALLOC;
2465 if ((asect->flags & SEC_READONLY) == 0)
2466 this_hdr->sh_flags |= SHF_WRITE;
2467 if ((asect->flags & SEC_CODE) != 0)
2468 this_hdr->sh_flags |= SHF_EXECINSTR;
2469 if ((asect->flags & SEC_MERGE) != 0)
2470 {
2471 this_hdr->sh_flags |= SHF_MERGE;
2472 this_hdr->sh_entsize = asect->entsize;
2473 if ((asect->flags & SEC_STRINGS) != 0)
2474 this_hdr->sh_flags |= SHF_STRINGS;
2475 }
2476 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2477 this_hdr->sh_flags |= SHF_GROUP;
2478 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2479 {
2480 this_hdr->sh_flags |= SHF_TLS;
2481 if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2482 {
2483 struct bfd_link_order *o;
2484
2485 this_hdr->sh_size = 0;
2486 for (o = asect->link_order_head; o != NULL; o = o->next)
2487 if (this_hdr->sh_size < o->offset + o->size)
2488 this_hdr->sh_size = o->offset + o->size;
2489 if (this_hdr->sh_size)
2490 this_hdr->sh_type = SHT_NOBITS;
2491 }
2492 }
2493
2494 /* Check for processor-specific section types. */
2495 if (bed->elf_backend_fake_sections
2496 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2497 *failedptr = TRUE;
2498
2499 /* If the section has relocs, set up a section header for the
2500 SHT_REL[A] section. If two relocation sections are required for
2501 this section, it is up to the processor-specific back-end to
2502 create the other. */
2503 if ((asect->flags & SEC_RELOC) != 0
2504 && !_bfd_elf_init_reloc_shdr (abfd,
2505 &elf_section_data (asect)->rel_hdr,
2506 asect,
2507 asect->use_rela_p))
2508 *failedptr = TRUE;
2509 }
2510
2511 /* Fill in the contents of a SHT_GROUP section. */
2512
2513 void
2514 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2515 {
2516 bfd_boolean *failedptr = failedptrarg;
2517 unsigned long symindx;
2518 asection *elt, *first;
2519 unsigned char *loc;
2520 struct bfd_link_order *l;
2521 bfd_boolean gas;
2522
2523 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2524 || *failedptr)
2525 return;
2526
2527 symindx = 0;
2528 if (elf_group_id (sec) != NULL)
2529 symindx = elf_group_id (sec)->udata.i;
2530
2531 if (symindx == 0)
2532 {
2533 /* If called from the assembler, swap_out_syms will have set up
2534 elf_section_syms; If called for "ld -r", use target_index. */
2535 if (elf_section_syms (abfd) != NULL)
2536 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2537 else
2538 symindx = sec->target_index;
2539 }
2540 elf_section_data (sec)->this_hdr.sh_info = symindx;
2541
2542 /* The contents won't be allocated for "ld -r" or objcopy. */
2543 gas = TRUE;
2544 if (sec->contents == NULL)
2545 {
2546 gas = FALSE;
2547 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2548
2549 /* Arrange for the section to be written out. */
2550 elf_section_data (sec)->this_hdr.contents = sec->contents;
2551 if (sec->contents == NULL)
2552 {
2553 *failedptr = TRUE;
2554 return;
2555 }
2556 }
2557
2558 loc = sec->contents + sec->_raw_size;
2559
2560 /* Get the pointer to the first section in the group that gas
2561 squirreled away here. objcopy arranges for this to be set to the
2562 start of the input section group. */
2563 first = elt = elf_next_in_group (sec);
2564
2565 /* First element is a flag word. Rest of section is elf section
2566 indices for all the sections of the group. Write them backwards
2567 just to keep the group in the same order as given in .section
2568 directives, not that it matters. */
2569 while (elt != NULL)
2570 {
2571 asection *s;
2572 unsigned int idx;
2573
2574 loc -= 4;
2575 s = elt;
2576 if (!gas)
2577 s = s->output_section;
2578 idx = 0;
2579 if (s != NULL)
2580 idx = elf_section_data (s)->this_idx;
2581 H_PUT_32 (abfd, idx, loc);
2582 elt = elf_next_in_group (elt);
2583 if (elt == first)
2584 break;
2585 }
2586
2587 /* If this is a relocatable link, then the above did nothing because
2588 SEC is the output section. Look through the input sections
2589 instead. */
2590 for (l = sec->link_order_head; l != NULL; l = l->next)
2591 if (l->type == bfd_indirect_link_order
2592 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2593 do
2594 {
2595 loc -= 4;
2596 H_PUT_32 (abfd,
2597 elf_section_data (elt->output_section)->this_idx, loc);
2598 elt = elf_next_in_group (elt);
2599 /* During a relocatable link, the lists are circular. */
2600 }
2601 while (elt != elf_next_in_group (l->u.indirect.section));
2602
2603 /* With ld -r, merging SHT_GROUP sections results in wasted space
2604 due to allowing for the flag word on each input. We may well
2605 duplicate entries too. */
2606 while ((loc -= 4) > sec->contents)
2607 H_PUT_32 (abfd, 0, loc);
2608
2609 if (loc != sec->contents)
2610 abort ();
2611
2612 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2613 }
2614
2615 /* Assign all ELF section numbers. The dummy first section is handled here
2616 too. The link/info pointers for the standard section types are filled
2617 in here too, while we're at it. */
2618
2619 static bfd_boolean
2620 assign_section_numbers (bfd *abfd)
2621 {
2622 struct elf_obj_tdata *t = elf_tdata (abfd);
2623 asection *sec;
2624 unsigned int section_number, secn;
2625 Elf_Internal_Shdr **i_shdrp;
2626 bfd_size_type amt;
2627
2628 section_number = 1;
2629
2630 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2631
2632 for (sec = abfd->sections; sec; sec = sec->next)
2633 {
2634 struct bfd_elf_section_data *d = elf_section_data (sec);
2635
2636 if (section_number == SHN_LORESERVE)
2637 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2638 d->this_idx = section_number++;
2639 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2640 if ((sec->flags & SEC_RELOC) == 0)
2641 d->rel_idx = 0;
2642 else
2643 {
2644 if (section_number == SHN_LORESERVE)
2645 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2646 d->rel_idx = section_number++;
2647 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2648 }
2649
2650 if (d->rel_hdr2)
2651 {
2652 if (section_number == SHN_LORESERVE)
2653 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2654 d->rel_idx2 = section_number++;
2655 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2656 }
2657 else
2658 d->rel_idx2 = 0;
2659 }
2660
2661 if (section_number == SHN_LORESERVE)
2662 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2663 t->shstrtab_section = section_number++;
2664 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2665 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2666
2667 if (bfd_get_symcount (abfd) > 0)
2668 {
2669 if (section_number == SHN_LORESERVE)
2670 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2671 t->symtab_section = section_number++;
2672 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2673 if (section_number > SHN_LORESERVE - 2)
2674 {
2675 if (section_number == SHN_LORESERVE)
2676 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2677 t->symtab_shndx_section = section_number++;
2678 t->symtab_shndx_hdr.sh_name
2679 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2680 ".symtab_shndx", FALSE);
2681 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2682 return FALSE;
2683 }
2684 if (section_number == SHN_LORESERVE)
2685 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2686 t->strtab_section = section_number++;
2687 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2688 }
2689
2690 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2691 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2692
2693 elf_numsections (abfd) = section_number;
2694 elf_elfheader (abfd)->e_shnum = section_number;
2695 if (section_number > SHN_LORESERVE)
2696 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2697
2698 /* Set up the list of section header pointers, in agreement with the
2699 indices. */
2700 amt = section_number * sizeof (Elf_Internal_Shdr *);
2701 i_shdrp = bfd_zalloc (abfd, amt);
2702 if (i_shdrp == NULL)
2703 return FALSE;
2704
2705 amt = sizeof (Elf_Internal_Shdr);
2706 i_shdrp[0] = bfd_zalloc (abfd, amt);
2707 if (i_shdrp[0] == NULL)
2708 {
2709 bfd_release (abfd, i_shdrp);
2710 return FALSE;
2711 }
2712
2713 elf_elfsections (abfd) = i_shdrp;
2714
2715 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2716 if (bfd_get_symcount (abfd) > 0)
2717 {
2718 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2719 if (elf_numsections (abfd) > SHN_LORESERVE)
2720 {
2721 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2722 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2723 }
2724 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2725 t->symtab_hdr.sh_link = t->strtab_section;
2726 }
2727 for (sec = abfd->sections; sec; sec = sec->next)
2728 {
2729 struct bfd_elf_section_data *d = elf_section_data (sec);
2730 asection *s;
2731 const char *name;
2732
2733 i_shdrp[d->this_idx] = &d->this_hdr;
2734 if (d->rel_idx != 0)
2735 i_shdrp[d->rel_idx] = &d->rel_hdr;
2736 if (d->rel_idx2 != 0)
2737 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2738
2739 /* Fill in the sh_link and sh_info fields while we're at it. */
2740
2741 /* sh_link of a reloc section is the section index of the symbol
2742 table. sh_info is the section index of the section to which
2743 the relocation entries apply. */
2744 if (d->rel_idx != 0)
2745 {
2746 d->rel_hdr.sh_link = t->symtab_section;
2747 d->rel_hdr.sh_info = d->this_idx;
2748 }
2749 if (d->rel_idx2 != 0)
2750 {
2751 d->rel_hdr2->sh_link = t->symtab_section;
2752 d->rel_hdr2->sh_info = d->this_idx;
2753 }
2754
2755 switch (d->this_hdr.sh_type)
2756 {
2757 case SHT_REL:
2758 case SHT_RELA:
2759 /* A reloc section which we are treating as a normal BFD
2760 section. sh_link is the section index of the symbol
2761 table. sh_info is the section index of the section to
2762 which the relocation entries apply. We assume that an
2763 allocated reloc section uses the dynamic symbol table.
2764 FIXME: How can we be sure? */
2765 s = bfd_get_section_by_name (abfd, ".dynsym");
2766 if (s != NULL)
2767 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2768
2769 /* We look up the section the relocs apply to by name. */
2770 name = sec->name;
2771 if (d->this_hdr.sh_type == SHT_REL)
2772 name += 4;
2773 else
2774 name += 5;
2775 s = bfd_get_section_by_name (abfd, name);
2776 if (s != NULL)
2777 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2778 break;
2779
2780 case SHT_STRTAB:
2781 /* We assume that a section named .stab*str is a stabs
2782 string section. We look for a section with the same name
2783 but without the trailing ``str'', and set its sh_link
2784 field to point to this section. */
2785 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2786 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2787 {
2788 size_t len;
2789 char *alc;
2790
2791 len = strlen (sec->name);
2792 alc = bfd_malloc (len - 2);
2793 if (alc == NULL)
2794 return FALSE;
2795 memcpy (alc, sec->name, len - 3);
2796 alc[len - 3] = '\0';
2797 s = bfd_get_section_by_name (abfd, alc);
2798 free (alc);
2799 if (s != NULL)
2800 {
2801 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2802
2803 /* This is a .stab section. */
2804 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2805 elf_section_data (s)->this_hdr.sh_entsize
2806 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2807 }
2808 }
2809 break;
2810
2811 case SHT_DYNAMIC:
2812 case SHT_DYNSYM:
2813 case SHT_GNU_verneed:
2814 case SHT_GNU_verdef:
2815 /* sh_link is the section header index of the string table
2816 used for the dynamic entries, or the symbol table, or the
2817 version strings. */
2818 s = bfd_get_section_by_name (abfd, ".dynstr");
2819 if (s != NULL)
2820 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2821 break;
2822
2823 case SHT_HASH:
2824 case SHT_GNU_versym:
2825 /* sh_link is the section header index of the symbol table
2826 this hash table or version table is for. */
2827 s = bfd_get_section_by_name (abfd, ".dynsym");
2828 if (s != NULL)
2829 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2830 break;
2831
2832 case SHT_GROUP:
2833 d->this_hdr.sh_link = t->symtab_section;
2834 }
2835 }
2836
2837 for (secn = 1; secn < section_number; ++secn)
2838 if (i_shdrp[secn] == NULL)
2839 i_shdrp[secn] = i_shdrp[0];
2840 else
2841 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2842 i_shdrp[secn]->sh_name);
2843 return TRUE;
2844 }
2845
2846 /* Map symbol from it's internal number to the external number, moving
2847 all local symbols to be at the head of the list. */
2848
2849 static int
2850 sym_is_global (bfd *abfd, asymbol *sym)
2851 {
2852 /* If the backend has a special mapping, use it. */
2853 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2854 if (bed->elf_backend_sym_is_global)
2855 return (*bed->elf_backend_sym_is_global) (abfd, sym);
2856
2857 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2858 || bfd_is_und_section (bfd_get_section (sym))
2859 || bfd_is_com_section (bfd_get_section (sym)));
2860 }
2861
2862 static bfd_boolean
2863 elf_map_symbols (bfd *abfd)
2864 {
2865 unsigned int symcount = bfd_get_symcount (abfd);
2866 asymbol **syms = bfd_get_outsymbols (abfd);
2867 asymbol **sect_syms;
2868 unsigned int num_locals = 0;
2869 unsigned int num_globals = 0;
2870 unsigned int num_locals2 = 0;
2871 unsigned int num_globals2 = 0;
2872 int max_index = 0;
2873 unsigned int idx;
2874 asection *asect;
2875 asymbol **new_syms;
2876 bfd_size_type amt;
2877
2878 #ifdef DEBUG
2879 fprintf (stderr, "elf_map_symbols\n");
2880 fflush (stderr);
2881 #endif
2882
2883 for (asect = abfd->sections; asect; asect = asect->next)
2884 {
2885 if (max_index < asect->index)
2886 max_index = asect->index;
2887 }
2888
2889 max_index++;
2890 amt = max_index * sizeof (asymbol *);
2891 sect_syms = bfd_zalloc (abfd, amt);
2892 if (sect_syms == NULL)
2893 return FALSE;
2894 elf_section_syms (abfd) = sect_syms;
2895 elf_num_section_syms (abfd) = max_index;
2896
2897 /* Init sect_syms entries for any section symbols we have already
2898 decided to output. */
2899 for (idx = 0; idx < symcount; idx++)
2900 {
2901 asymbol *sym = syms[idx];
2902
2903 if ((sym->flags & BSF_SECTION_SYM) != 0
2904 && sym->value == 0)
2905 {
2906 asection *sec;
2907
2908 sec = sym->section;
2909
2910 if (sec->owner != NULL)
2911 {
2912 if (sec->owner != abfd)
2913 {
2914 if (sec->output_offset != 0)
2915 continue;
2916
2917 sec = sec->output_section;
2918
2919 /* Empty sections in the input files may have had a
2920 section symbol created for them. (See the comment
2921 near the end of _bfd_generic_link_output_symbols in
2922 linker.c). If the linker script discards such
2923 sections then we will reach this point. Since we know
2924 that we cannot avoid this case, we detect it and skip
2925 the abort and the assignment to the sect_syms array.
2926 To reproduce this particular case try running the
2927 linker testsuite test ld-scripts/weak.exp for an ELF
2928 port that uses the generic linker. */
2929 if (sec->owner == NULL)
2930 continue;
2931
2932 BFD_ASSERT (sec->owner == abfd);
2933 }
2934 sect_syms[sec->index] = syms[idx];
2935 }
2936 }
2937 }
2938
2939 /* Classify all of the symbols. */
2940 for (idx = 0; idx < symcount; idx++)
2941 {
2942 if (!sym_is_global (abfd, syms[idx]))
2943 num_locals++;
2944 else
2945 num_globals++;
2946 }
2947
2948 /* We will be adding a section symbol for each BFD section. Most normal
2949 sections will already have a section symbol in outsymbols, but
2950 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2951 at least in that case. */
2952 for (asect = abfd->sections; asect; asect = asect->next)
2953 {
2954 if (sect_syms[asect->index] == NULL)
2955 {
2956 if (!sym_is_global (abfd, asect->symbol))
2957 num_locals++;
2958 else
2959 num_globals++;
2960 }
2961 }
2962
2963 /* Now sort the symbols so the local symbols are first. */
2964 amt = (num_locals + num_globals) * sizeof (asymbol *);
2965 new_syms = bfd_alloc (abfd, amt);
2966
2967 if (new_syms == NULL)
2968 return FALSE;
2969
2970 for (idx = 0; idx < symcount; idx++)
2971 {
2972 asymbol *sym = syms[idx];
2973 unsigned int i;
2974
2975 if (!sym_is_global (abfd, sym))
2976 i = num_locals2++;
2977 else
2978 i = num_locals + num_globals2++;
2979 new_syms[i] = sym;
2980 sym->udata.i = i + 1;
2981 }
2982 for (asect = abfd->sections; asect; asect = asect->next)
2983 {
2984 if (sect_syms[asect->index] == NULL)
2985 {
2986 asymbol *sym = asect->symbol;
2987 unsigned int i;
2988
2989 sect_syms[asect->index] = sym;
2990 if (!sym_is_global (abfd, sym))
2991 i = num_locals2++;
2992 else
2993 i = num_locals + num_globals2++;
2994 new_syms[i] = sym;
2995 sym->udata.i = i + 1;
2996 }
2997 }
2998
2999 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3000
3001 elf_num_locals (abfd) = num_locals;
3002 elf_num_globals (abfd) = num_globals;
3003 return TRUE;
3004 }
3005
3006 /* Align to the maximum file alignment that could be required for any
3007 ELF data structure. */
3008
3009 static inline file_ptr
3010 align_file_position (file_ptr off, int align)
3011 {
3012 return (off + align - 1) & ~(align - 1);
3013 }
3014
3015 /* Assign a file position to a section, optionally aligning to the
3016 required section alignment. */
3017
3018 file_ptr
3019 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3020 file_ptr offset,
3021 bfd_boolean align)
3022 {
3023 if (align)
3024 {
3025 unsigned int al;
3026
3027 al = i_shdrp->sh_addralign;
3028 if (al > 1)
3029 offset = BFD_ALIGN (offset, al);
3030 }
3031 i_shdrp->sh_offset = offset;
3032 if (i_shdrp->bfd_section != NULL)
3033 i_shdrp->bfd_section->filepos = offset;
3034 if (i_shdrp->sh_type != SHT_NOBITS)
3035 offset += i_shdrp->sh_size;
3036 return offset;
3037 }
3038
3039 /* Compute the file positions we are going to put the sections at, and
3040 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3041 is not NULL, this is being called by the ELF backend linker. */
3042
3043 bfd_boolean
3044 _bfd_elf_compute_section_file_positions (bfd *abfd,
3045 struct bfd_link_info *link_info)
3046 {
3047 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3048 bfd_boolean failed;
3049 struct bfd_strtab_hash *strtab;
3050 Elf_Internal_Shdr *shstrtab_hdr;
3051
3052 if (abfd->output_has_begun)
3053 return TRUE;
3054
3055 /* Do any elf backend specific processing first. */
3056 if (bed->elf_backend_begin_write_processing)
3057 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3058
3059 if (! prep_headers (abfd))
3060 return FALSE;
3061
3062 /* Post process the headers if necessary. */
3063 if (bed->elf_backend_post_process_headers)
3064 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3065
3066 failed = FALSE;
3067 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3068 if (failed)
3069 return FALSE;
3070
3071 if (!assign_section_numbers (abfd))
3072 return FALSE;
3073
3074 /* The backend linker builds symbol table information itself. */
3075 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3076 {
3077 /* Non-zero if doing a relocatable link. */
3078 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3079
3080 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3081 return FALSE;
3082 }
3083
3084 if (link_info == NULL)
3085 {
3086 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3087 if (failed)
3088 return FALSE;
3089 }
3090
3091 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3092 /* sh_name was set in prep_headers. */
3093 shstrtab_hdr->sh_type = SHT_STRTAB;
3094 shstrtab_hdr->sh_flags = 0;
3095 shstrtab_hdr->sh_addr = 0;
3096 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3097 shstrtab_hdr->sh_entsize = 0;
3098 shstrtab_hdr->sh_link = 0;
3099 shstrtab_hdr->sh_info = 0;
3100 /* sh_offset is set in assign_file_positions_except_relocs. */
3101 shstrtab_hdr->sh_addralign = 1;
3102
3103 if (!assign_file_positions_except_relocs (abfd))
3104 return FALSE;
3105
3106 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3107 {
3108 file_ptr off;
3109 Elf_Internal_Shdr *hdr;
3110
3111 off = elf_tdata (abfd)->next_file_pos;
3112
3113 hdr = &elf_tdata (abfd)->symtab_hdr;
3114 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3115
3116 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3117 if (hdr->sh_size != 0)
3118 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3119
3120 hdr = &elf_tdata (abfd)->strtab_hdr;
3121 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3122
3123 elf_tdata (abfd)->next_file_pos = off;
3124
3125 /* Now that we know where the .strtab section goes, write it
3126 out. */
3127 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3128 || ! _bfd_stringtab_emit (abfd, strtab))
3129 return FALSE;
3130 _bfd_stringtab_free (strtab);
3131 }
3132
3133 abfd->output_has_begun = TRUE;
3134
3135 return TRUE;
3136 }
3137
3138 /* Create a mapping from a set of sections to a program segment. */
3139
3140 static struct elf_segment_map *
3141 make_mapping (bfd *abfd,
3142 asection **sections,
3143 unsigned int from,
3144 unsigned int to,
3145 bfd_boolean phdr)
3146 {
3147 struct elf_segment_map *m;
3148 unsigned int i;
3149 asection **hdrpp;
3150 bfd_size_type amt;
3151
3152 amt = sizeof (struct elf_segment_map);
3153 amt += (to - from - 1) * sizeof (asection *);
3154 m = bfd_zalloc (abfd, amt);
3155 if (m == NULL)
3156 return NULL;
3157 m->next = NULL;
3158 m->p_type = PT_LOAD;
3159 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3160 m->sections[i - from] = *hdrpp;
3161 m->count = to - from;
3162
3163 if (from == 0 && phdr)
3164 {
3165 /* Include the headers in the first PT_LOAD segment. */
3166 m->includes_filehdr = 1;
3167 m->includes_phdrs = 1;
3168 }
3169
3170 return m;
3171 }
3172
3173 /* Set up a mapping from BFD sections to program segments. */
3174
3175 static bfd_boolean
3176 map_sections_to_segments (bfd *abfd)
3177 {
3178 asection **sections = NULL;
3179 asection *s;
3180 unsigned int i;
3181 unsigned int count;
3182 struct elf_segment_map *mfirst;
3183 struct elf_segment_map **pm;
3184 struct elf_segment_map *m;
3185 asection *last_hdr;
3186 unsigned int phdr_index;
3187 bfd_vma maxpagesize;
3188 asection **hdrpp;
3189 bfd_boolean phdr_in_segment = TRUE;
3190 bfd_boolean writable;
3191 int tls_count = 0;
3192 asection *first_tls = NULL;
3193 asection *dynsec, *eh_frame_hdr;
3194 bfd_size_type amt;
3195
3196 if (elf_tdata (abfd)->segment_map != NULL)
3197 return TRUE;
3198
3199 if (bfd_count_sections (abfd) == 0)
3200 return TRUE;
3201
3202 /* Select the allocated sections, and sort them. */
3203
3204 amt = bfd_count_sections (abfd) * sizeof (asection *);
3205 sections = bfd_malloc (amt);
3206 if (sections == NULL)
3207 goto error_return;
3208
3209 i = 0;
3210 for (s = abfd->sections; s != NULL; s = s->next)
3211 {
3212 if ((s->flags & SEC_ALLOC) != 0)
3213 {
3214 sections[i] = s;
3215 ++i;
3216 }
3217 }
3218 BFD_ASSERT (i <= bfd_count_sections (abfd));
3219 count = i;
3220
3221 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3222
3223 /* Build the mapping. */
3224
3225 mfirst = NULL;
3226 pm = &mfirst;
3227
3228 /* If we have a .interp section, then create a PT_PHDR segment for
3229 the program headers and a PT_INTERP segment for the .interp
3230 section. */
3231 s = bfd_get_section_by_name (abfd, ".interp");
3232 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3233 {
3234 amt = sizeof (struct elf_segment_map);
3235 m = bfd_zalloc (abfd, amt);
3236 if (m == NULL)
3237 goto error_return;
3238 m->next = NULL;
3239 m->p_type = PT_PHDR;
3240 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3241 m->p_flags = PF_R | PF_X;
3242 m->p_flags_valid = 1;
3243 m->includes_phdrs = 1;
3244
3245 *pm = m;
3246 pm = &m->next;
3247
3248 amt = sizeof (struct elf_segment_map);
3249 m = bfd_zalloc (abfd, amt);
3250 if (m == NULL)
3251 goto error_return;
3252 m->next = NULL;
3253 m->p_type = PT_INTERP;
3254 m->count = 1;
3255 m->sections[0] = s;
3256
3257 *pm = m;
3258 pm = &m->next;
3259 }
3260
3261 /* Look through the sections. We put sections in the same program
3262 segment when the start of the second section can be placed within
3263 a few bytes of the end of the first section. */
3264 last_hdr = NULL;
3265 phdr_index = 0;
3266 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3267 writable = FALSE;
3268 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3269 if (dynsec != NULL
3270 && (dynsec->flags & SEC_LOAD) == 0)
3271 dynsec = NULL;
3272
3273 /* Deal with -Ttext or something similar such that the first section
3274 is not adjacent to the program headers. This is an
3275 approximation, since at this point we don't know exactly how many
3276 program headers we will need. */
3277 if (count > 0)
3278 {
3279 bfd_size_type phdr_size;
3280
3281 phdr_size = elf_tdata (abfd)->program_header_size;
3282 if (phdr_size == 0)
3283 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3284 if ((abfd->flags & D_PAGED) == 0
3285 || sections[0]->lma < phdr_size
3286 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3287 phdr_in_segment = FALSE;
3288 }
3289
3290 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3291 {
3292 asection *hdr;
3293 bfd_boolean new_segment;
3294
3295 hdr = *hdrpp;
3296
3297 /* See if this section and the last one will fit in the same
3298 segment. */
3299
3300 if (last_hdr == NULL)
3301 {
3302 /* If we don't have a segment yet, then we don't need a new
3303 one (we build the last one after this loop). */
3304 new_segment = FALSE;
3305 }
3306 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3307 {
3308 /* If this section has a different relation between the
3309 virtual address and the load address, then we need a new
3310 segment. */
3311 new_segment = TRUE;
3312 }
3313 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3314 < BFD_ALIGN (hdr->lma, maxpagesize))
3315 {
3316 /* If putting this section in this segment would force us to
3317 skip a page in the segment, then we need a new segment. */
3318 new_segment = TRUE;
3319 }
3320 else if ((last_hdr->flags & SEC_LOAD) == 0
3321 && (hdr->flags & SEC_LOAD) != 0)
3322 {
3323 /* We don't want to put a loadable section after a
3324 nonloadable section in the same segment. */
3325 new_segment = TRUE;
3326 }
3327 else if ((abfd->flags & D_PAGED) == 0)
3328 {
3329 /* If the file is not demand paged, which means that we
3330 don't require the sections to be correctly aligned in the
3331 file, then there is no other reason for a new segment. */
3332 new_segment = FALSE;
3333 }
3334 else if (! writable
3335 && (hdr->flags & SEC_READONLY) == 0
3336 && (((last_hdr->lma + last_hdr->_raw_size - 1)
3337 & ~(maxpagesize - 1))
3338 != (hdr->lma & ~(maxpagesize - 1))))
3339 {
3340 /* We don't want to put a writable section in a read only
3341 segment, unless they are on the same page in memory
3342 anyhow. We already know that the last section does not
3343 bring us past the current section on the page, so the
3344 only case in which the new section is not on the same
3345 page as the previous section is when the previous section
3346 ends precisely on a page boundary. */
3347 new_segment = TRUE;
3348 }
3349 else
3350 {
3351 /* Otherwise, we can use the same segment. */
3352 new_segment = FALSE;
3353 }
3354
3355 if (! new_segment)
3356 {
3357 if ((hdr->flags & SEC_READONLY) == 0)
3358 writable = TRUE;
3359 last_hdr = hdr;
3360 continue;
3361 }
3362
3363 /* We need a new program segment. We must create a new program
3364 header holding all the sections from phdr_index until hdr. */
3365
3366 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3367 if (m == NULL)
3368 goto error_return;
3369
3370 *pm = m;
3371 pm = &m->next;
3372
3373 if ((hdr->flags & SEC_READONLY) == 0)
3374 writable = TRUE;
3375 else
3376 writable = FALSE;
3377
3378 last_hdr = hdr;
3379 phdr_index = i;
3380 phdr_in_segment = FALSE;
3381 }
3382
3383 /* Create a final PT_LOAD program segment. */
3384 if (last_hdr != NULL)
3385 {
3386 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3387 if (m == NULL)
3388 goto error_return;
3389
3390 *pm = m;
3391 pm = &m->next;
3392 }
3393
3394 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3395 if (dynsec != NULL)
3396 {
3397 amt = sizeof (struct elf_segment_map);
3398 m = bfd_zalloc (abfd, amt);
3399 if (m == NULL)
3400 goto error_return;
3401 m->next = NULL;
3402 m->p_type = PT_DYNAMIC;
3403 m->count = 1;
3404 m->sections[0] = dynsec;
3405
3406 *pm = m;
3407 pm = &m->next;
3408 }
3409
3410 /* For each loadable .note section, add a PT_NOTE segment. We don't
3411 use bfd_get_section_by_name, because if we link together
3412 nonloadable .note sections and loadable .note sections, we will
3413 generate two .note sections in the output file. FIXME: Using
3414 names for section types is bogus anyhow. */
3415 for (s = abfd->sections; s != NULL; s = s->next)
3416 {
3417 if ((s->flags & SEC_LOAD) != 0
3418 && strncmp (s->name, ".note", 5) == 0)
3419 {
3420 amt = sizeof (struct elf_segment_map);
3421 m = bfd_zalloc (abfd, amt);
3422 if (m == NULL)
3423 goto error_return;
3424 m->next = NULL;
3425 m->p_type = PT_NOTE;
3426 m->count = 1;
3427 m->sections[0] = s;
3428
3429 *pm = m;
3430 pm = &m->next;
3431 }
3432 if (s->flags & SEC_THREAD_LOCAL)
3433 {
3434 if (! tls_count)
3435 first_tls = s;
3436 tls_count++;
3437 }
3438 }
3439
3440 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3441 if (tls_count > 0)
3442 {
3443 int i;
3444
3445 amt = sizeof (struct elf_segment_map);
3446 amt += (tls_count - 1) * sizeof (asection *);
3447 m = bfd_zalloc (abfd, amt);
3448 if (m == NULL)
3449 goto error_return;
3450 m->next = NULL;
3451 m->p_type = PT_TLS;
3452 m->count = tls_count;
3453 /* Mandated PF_R. */
3454 m->p_flags = PF_R;
3455 m->p_flags_valid = 1;
3456 for (i = 0; i < tls_count; ++i)
3457 {
3458 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3459 m->sections[i] = first_tls;
3460 first_tls = first_tls->next;
3461 }
3462
3463 *pm = m;
3464 pm = &m->next;
3465 }
3466
3467 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3468 segment. */
3469 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3470 if (eh_frame_hdr != NULL
3471 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3472 {
3473 amt = sizeof (struct elf_segment_map);
3474 m = bfd_zalloc (abfd, amt);
3475 if (m == NULL)
3476 goto error_return;
3477 m->next = NULL;
3478 m->p_type = PT_GNU_EH_FRAME;
3479 m->count = 1;
3480 m->sections[0] = eh_frame_hdr->output_section;
3481
3482 *pm = m;
3483 pm = &m->next;
3484 }
3485
3486 if (elf_tdata (abfd)->stack_flags)
3487 {
3488 amt = sizeof (struct elf_segment_map);
3489 m = bfd_zalloc (abfd, amt);
3490 if (m == NULL)
3491 goto error_return;
3492 m->next = NULL;
3493 m->p_type = PT_GNU_STACK;
3494 m->p_flags = elf_tdata (abfd)->stack_flags;
3495 m->p_flags_valid = 1;
3496
3497 *pm = m;
3498 pm = &m->next;
3499 }
3500
3501 free (sections);
3502 sections = NULL;
3503
3504 elf_tdata (abfd)->segment_map = mfirst;
3505 return TRUE;
3506
3507 error_return:
3508 if (sections != NULL)
3509 free (sections);
3510 return FALSE;
3511 }
3512
3513 /* Sort sections by address. */
3514
3515 static int
3516 elf_sort_sections (const void *arg1, const void *arg2)
3517 {
3518 const asection *sec1 = *(const asection **) arg1;
3519 const asection *sec2 = *(const asection **) arg2;
3520 bfd_size_type size1, size2;
3521
3522 /* Sort by LMA first, since this is the address used to
3523 place the section into a segment. */
3524 if (sec1->lma < sec2->lma)
3525 return -1;
3526 else if (sec1->lma > sec2->lma)
3527 return 1;
3528
3529 /* Then sort by VMA. Normally the LMA and the VMA will be
3530 the same, and this will do nothing. */
3531 if (sec1->vma < sec2->vma)
3532 return -1;
3533 else if (sec1->vma > sec2->vma)
3534 return 1;
3535
3536 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3537
3538 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3539
3540 if (TOEND (sec1))
3541 {
3542 if (TOEND (sec2))
3543 {
3544 /* If the indicies are the same, do not return 0
3545 here, but continue to try the next comparison. */
3546 if (sec1->target_index - sec2->target_index != 0)
3547 return sec1->target_index - sec2->target_index;
3548 }
3549 else
3550 return 1;
3551 }
3552 else if (TOEND (sec2))
3553 return -1;
3554
3555 #undef TOEND
3556
3557 /* Sort by size, to put zero sized sections
3558 before others at the same address. */
3559
3560 size1 = (sec1->flags & SEC_LOAD) ? sec1->_raw_size : 0;
3561 size2 = (sec2->flags & SEC_LOAD) ? sec2->_raw_size : 0;
3562
3563 if (size1 < size2)
3564 return -1;
3565 if (size1 > size2)
3566 return 1;
3567
3568 return sec1->target_index - sec2->target_index;
3569 }
3570
3571 /* Assign file positions to the sections based on the mapping from
3572 sections to segments. This function also sets up some fields in
3573 the file header, and writes out the program headers. */
3574
3575 static bfd_boolean
3576 assign_file_positions_for_segments (bfd *abfd)
3577 {
3578 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3579 unsigned int count;
3580 struct elf_segment_map *m;
3581 unsigned int alloc;
3582 Elf_Internal_Phdr *phdrs;
3583 file_ptr off, voff;
3584 bfd_vma filehdr_vaddr, filehdr_paddr;
3585 bfd_vma phdrs_vaddr, phdrs_paddr;
3586 Elf_Internal_Phdr *p;
3587 bfd_size_type amt;
3588
3589 if (elf_tdata (abfd)->segment_map == NULL)
3590 {
3591 if (! map_sections_to_segments (abfd))
3592 return FALSE;
3593 }
3594 else
3595 {
3596 /* The placement algorithm assumes that non allocated sections are
3597 not in PT_LOAD segments. We ensure this here by removing such
3598 sections from the segment map. */
3599 for (m = elf_tdata (abfd)->segment_map;
3600 m != NULL;
3601 m = m->next)
3602 {
3603 unsigned int new_count;
3604 unsigned int i;
3605
3606 if (m->p_type != PT_LOAD)
3607 continue;
3608
3609 new_count = 0;
3610 for (i = 0; i < m->count; i ++)
3611 {
3612 if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3613 {
3614 if (i != new_count)
3615 m->sections[new_count] = m->sections[i];
3616
3617 new_count ++;
3618 }
3619 }
3620
3621 if (new_count != m->count)
3622 m->count = new_count;
3623 }
3624 }
3625
3626 if (bed->elf_backend_modify_segment_map)
3627 {
3628 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3629 return FALSE;
3630 }
3631
3632 count = 0;
3633 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3634 ++count;
3635
3636 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3637 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3638 elf_elfheader (abfd)->e_phnum = count;
3639
3640 if (count == 0)
3641 return TRUE;
3642
3643 /* If we already counted the number of program segments, make sure
3644 that we allocated enough space. This happens when SIZEOF_HEADERS
3645 is used in a linker script. */
3646 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3647 if (alloc != 0 && count > alloc)
3648 {
3649 ((*_bfd_error_handler)
3650 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3651 bfd_get_filename (abfd), alloc, count));
3652 bfd_set_error (bfd_error_bad_value);
3653 return FALSE;
3654 }
3655
3656 if (alloc == 0)
3657 alloc = count;
3658
3659 amt = alloc * sizeof (Elf_Internal_Phdr);
3660 phdrs = bfd_alloc (abfd, amt);
3661 if (phdrs == NULL)
3662 return FALSE;
3663
3664 off = bed->s->sizeof_ehdr;
3665 off += alloc * bed->s->sizeof_phdr;
3666
3667 filehdr_vaddr = 0;
3668 filehdr_paddr = 0;
3669 phdrs_vaddr = 0;
3670 phdrs_paddr = 0;
3671
3672 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3673 m != NULL;
3674 m = m->next, p++)
3675 {
3676 unsigned int i;
3677 asection **secpp;
3678
3679 /* If elf_segment_map is not from map_sections_to_segments, the
3680 sections may not be correctly ordered. NOTE: sorting should
3681 not be done to the PT_NOTE section of a corefile, which may
3682 contain several pseudo-sections artificially created by bfd.
3683 Sorting these pseudo-sections breaks things badly. */
3684 if (m->count > 1
3685 && !(elf_elfheader (abfd)->e_type == ET_CORE
3686 && m->p_type == PT_NOTE))
3687 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3688 elf_sort_sections);
3689
3690 p->p_type = m->p_type;
3691 p->p_flags = m->p_flags;
3692
3693 if (p->p_type == PT_LOAD
3694 && m->count > 0
3695 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3696 {
3697 if ((abfd->flags & D_PAGED) != 0)
3698 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3699 else
3700 {
3701 bfd_size_type align;
3702
3703 align = 0;
3704 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3705 {
3706 bfd_size_type secalign;
3707
3708 secalign = bfd_get_section_alignment (abfd, *secpp);
3709 if (secalign > align)
3710 align = secalign;
3711 }
3712
3713 off += (m->sections[0]->vma - off) % (1 << align);
3714 }
3715 }
3716
3717 if (m->count == 0)
3718 p->p_vaddr = 0;
3719 else
3720 p->p_vaddr = m->sections[0]->vma;
3721
3722 if (m->p_paddr_valid)
3723 p->p_paddr = m->p_paddr;
3724 else if (m->count == 0)
3725 p->p_paddr = 0;
3726 else
3727 p->p_paddr = m->sections[0]->lma;
3728
3729 if (p->p_type == PT_LOAD
3730 && (abfd->flags & D_PAGED) != 0)
3731 p->p_align = bed->maxpagesize;
3732 else if (m->count == 0)
3733 p->p_align = 1 << bed->s->log_file_align;
3734 else
3735 p->p_align = 0;
3736
3737 p->p_offset = 0;
3738 p->p_filesz = 0;
3739 p->p_memsz = 0;
3740
3741 if (m->includes_filehdr)
3742 {
3743 if (! m->p_flags_valid)
3744 p->p_flags |= PF_R;
3745 p->p_offset = 0;
3746 p->p_filesz = bed->s->sizeof_ehdr;
3747 p->p_memsz = bed->s->sizeof_ehdr;
3748 if (m->count > 0)
3749 {
3750 BFD_ASSERT (p->p_type == PT_LOAD);
3751
3752 if (p->p_vaddr < (bfd_vma) off)
3753 {
3754 (*_bfd_error_handler)
3755 (_("%s: Not enough room for program headers, try linking with -N"),
3756 bfd_get_filename (abfd));
3757 bfd_set_error (bfd_error_bad_value);
3758 return FALSE;
3759 }
3760
3761 p->p_vaddr -= off;
3762 if (! m->p_paddr_valid)
3763 p->p_paddr -= off;
3764 }
3765 if (p->p_type == PT_LOAD)
3766 {
3767 filehdr_vaddr = p->p_vaddr;
3768 filehdr_paddr = p->p_paddr;
3769 }
3770 }
3771
3772 if (m->includes_phdrs)
3773 {
3774 if (! m->p_flags_valid)
3775 p->p_flags |= PF_R;
3776
3777 if (m->includes_filehdr)
3778 {
3779 if (p->p_type == PT_LOAD)
3780 {
3781 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3782 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3783 }
3784 }
3785 else
3786 {
3787 p->p_offset = bed->s->sizeof_ehdr;
3788
3789 if (m->count > 0)
3790 {
3791 BFD_ASSERT (p->p_type == PT_LOAD);
3792 p->p_vaddr -= off - p->p_offset;
3793 if (! m->p_paddr_valid)
3794 p->p_paddr -= off - p->p_offset;
3795 }
3796
3797 if (p->p_type == PT_LOAD)
3798 {
3799 phdrs_vaddr = p->p_vaddr;
3800 phdrs_paddr = p->p_paddr;
3801 }
3802 else
3803 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3804 }
3805
3806 p->p_filesz += alloc * bed->s->sizeof_phdr;
3807 p->p_memsz += alloc * bed->s->sizeof_phdr;
3808 }
3809
3810 if (p->p_type == PT_LOAD
3811 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3812 {
3813 if (! m->includes_filehdr && ! m->includes_phdrs)
3814 p->p_offset = off;
3815 else
3816 {
3817 file_ptr adjust;
3818
3819 adjust = off - (p->p_offset + p->p_filesz);
3820 p->p_filesz += adjust;
3821 p->p_memsz += adjust;
3822 }
3823 }
3824
3825 voff = off;
3826
3827 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3828 {
3829 asection *sec;
3830 flagword flags;
3831 bfd_size_type align;
3832
3833 sec = *secpp;
3834 flags = sec->flags;
3835 align = 1 << bfd_get_section_alignment (abfd, sec);
3836
3837 /* The section may have artificial alignment forced by a
3838 link script. Notice this case by the gap between the
3839 cumulative phdr lma and the section's lma. */
3840 if (p->p_paddr + p->p_memsz < sec->lma)
3841 {
3842 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3843
3844 p->p_memsz += adjust;
3845 if (p->p_type == PT_LOAD
3846 || (p->p_type == PT_NOTE
3847 && bfd_get_format (abfd) == bfd_core))
3848 {
3849 off += adjust;
3850 voff += adjust;
3851 }
3852 if ((flags & SEC_LOAD) != 0
3853 || (flags & SEC_THREAD_LOCAL) != 0)
3854 p->p_filesz += adjust;
3855 }
3856
3857 if (p->p_type == PT_LOAD)
3858 {
3859 bfd_signed_vma adjust;
3860
3861 if ((flags & SEC_LOAD) != 0)
3862 {
3863 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3864 if (adjust < 0)
3865 adjust = 0;
3866 }
3867 else if ((flags & SEC_ALLOC) != 0)
3868 {
3869 /* The section VMA must equal the file position
3870 modulo the page size. FIXME: I'm not sure if
3871 this adjustment is really necessary. We used to
3872 not have the SEC_LOAD case just above, and then
3873 this was necessary, but now I'm not sure. */
3874 if ((abfd->flags & D_PAGED) != 0)
3875 adjust = (sec->vma - voff) % bed->maxpagesize;
3876 else
3877 adjust = (sec->vma - voff) % align;
3878 }
3879 else
3880 adjust = 0;
3881
3882 if (adjust != 0)
3883 {
3884 if (i == 0)
3885 {
3886 (* _bfd_error_handler) (_("\
3887 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3888 bfd_section_name (abfd, sec),
3889 sec->lma,
3890 p->p_paddr);
3891 return FALSE;
3892 }
3893 p->p_memsz += adjust;
3894 off += adjust;
3895 voff += adjust;
3896 if ((flags & SEC_LOAD) != 0)
3897 p->p_filesz += adjust;
3898 }
3899
3900 sec->filepos = off;
3901
3902 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3903 used in a linker script we may have a section with
3904 SEC_LOAD clear but which is supposed to have
3905 contents. */
3906 if ((flags & SEC_LOAD) != 0
3907 || (flags & SEC_HAS_CONTENTS) != 0)
3908 off += sec->_raw_size;
3909
3910 if ((flags & SEC_ALLOC) != 0
3911 && ((flags & SEC_LOAD) != 0
3912 || (flags & SEC_THREAD_LOCAL) == 0))
3913 voff += sec->_raw_size;
3914 }
3915
3916 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3917 {
3918 /* The actual "note" segment has i == 0.
3919 This is the one that actually contains everything. */
3920 if (i == 0)
3921 {
3922 sec->filepos = off;
3923 p->p_filesz = sec->_raw_size;
3924 off += sec->_raw_size;
3925 voff = off;
3926 }
3927 else
3928 {
3929 /* Fake sections -- don't need to be written. */
3930 sec->filepos = 0;
3931 sec->_raw_size = 0;
3932 flags = sec->flags = 0;
3933 }
3934 p->p_memsz = 0;
3935 p->p_align = 1;
3936 }
3937 else
3938 {
3939 if ((sec->flags & SEC_LOAD) != 0
3940 || (sec->flags & SEC_THREAD_LOCAL) == 0
3941 || p->p_type == PT_TLS)
3942 p->p_memsz += sec->_raw_size;
3943
3944 if ((flags & SEC_LOAD) != 0)
3945 p->p_filesz += sec->_raw_size;
3946
3947 if (p->p_type == PT_TLS
3948 && sec->_raw_size == 0
3949 && (sec->flags & SEC_HAS_CONTENTS) == 0)
3950 {
3951 struct bfd_link_order *o;
3952 bfd_vma tbss_size = 0;
3953
3954 for (o = sec->link_order_head; o != NULL; o = o->next)
3955 if (tbss_size < o->offset + o->size)
3956 tbss_size = o->offset + o->size;
3957
3958 p->p_memsz += tbss_size;
3959 }
3960
3961 if (align > p->p_align
3962 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3963 p->p_align = align;
3964 }
3965
3966 if (! m->p_flags_valid)
3967 {
3968 p->p_flags |= PF_R;
3969 if ((flags & SEC_CODE) != 0)
3970 p->p_flags |= PF_X;
3971 if ((flags & SEC_READONLY) == 0)
3972 p->p_flags |= PF_W;
3973 }
3974 }
3975 }
3976
3977 /* Now that we have set the section file positions, we can set up
3978 the file positions for the non PT_LOAD segments. */
3979 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3980 m != NULL;
3981 m = m->next, p++)
3982 {
3983 if (p->p_type != PT_LOAD && m->count > 0)
3984 {
3985 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3986 p->p_offset = m->sections[0]->filepos;
3987 }
3988 if (m->count == 0)
3989 {
3990 if (m->includes_filehdr)
3991 {
3992 p->p_vaddr = filehdr_vaddr;
3993 if (! m->p_paddr_valid)
3994 p->p_paddr = filehdr_paddr;
3995 }
3996 else if (m->includes_phdrs)
3997 {
3998 p->p_vaddr = phdrs_vaddr;
3999 if (! m->p_paddr_valid)
4000 p->p_paddr = phdrs_paddr;
4001 }
4002 }
4003 }
4004
4005 /* Clear out any program headers we allocated but did not use. */
4006 for (; count < alloc; count++, p++)
4007 {
4008 memset (p, 0, sizeof *p);
4009 p->p_type = PT_NULL;
4010 }
4011
4012 elf_tdata (abfd)->phdr = phdrs;
4013
4014 elf_tdata (abfd)->next_file_pos = off;
4015
4016 /* Write out the program headers. */
4017 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4018 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4019 return FALSE;
4020
4021 return TRUE;
4022 }
4023
4024 /* Get the size of the program header.
4025
4026 If this is called by the linker before any of the section VMA's are set, it
4027 can't calculate the correct value for a strange memory layout. This only
4028 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4029 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4030 data segment (exclusive of .interp and .dynamic).
4031
4032 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4033 will be two segments. */
4034
4035 static bfd_size_type
4036 get_program_header_size (bfd *abfd)
4037 {
4038 size_t segs;
4039 asection *s;
4040 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4041
4042 /* We can't return a different result each time we're called. */
4043 if (elf_tdata (abfd)->program_header_size != 0)
4044 return elf_tdata (abfd)->program_header_size;
4045
4046 if (elf_tdata (abfd)->segment_map != NULL)
4047 {
4048 struct elf_segment_map *m;
4049
4050 segs = 0;
4051 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4052 ++segs;
4053 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4054 return elf_tdata (abfd)->program_header_size;
4055 }
4056
4057 /* Assume we will need exactly two PT_LOAD segments: one for text
4058 and one for data. */
4059 segs = 2;
4060
4061 s = bfd_get_section_by_name (abfd, ".interp");
4062 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4063 {
4064 /* If we have a loadable interpreter section, we need a
4065 PT_INTERP segment. In this case, assume we also need a
4066 PT_PHDR segment, although that may not be true for all
4067 targets. */
4068 segs += 2;
4069 }
4070
4071 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4072 {
4073 /* We need a PT_DYNAMIC segment. */
4074 ++segs;
4075 }
4076
4077 if (elf_tdata (abfd)->eh_frame_hdr)
4078 {
4079 /* We need a PT_GNU_EH_FRAME segment. */
4080 ++segs;
4081 }
4082
4083 if (elf_tdata (abfd)->stack_flags)
4084 {
4085 /* We need a PT_GNU_STACK segment. */
4086 ++segs;
4087 }
4088
4089 for (s = abfd->sections; s != NULL; s = s->next)
4090 {
4091 if ((s->flags & SEC_LOAD) != 0
4092 && strncmp (s->name, ".note", 5) == 0)
4093 {
4094 /* We need a PT_NOTE segment. */
4095 ++segs;
4096 }
4097 }
4098
4099 for (s = abfd->sections; s != NULL; s = s->next)
4100 {
4101 if (s->flags & SEC_THREAD_LOCAL)
4102 {
4103 /* We need a PT_TLS segment. */
4104 ++segs;
4105 break;
4106 }
4107 }
4108
4109 /* Let the backend count up any program headers it might need. */
4110 if (bed->elf_backend_additional_program_headers)
4111 {
4112 int a;
4113
4114 a = (*bed->elf_backend_additional_program_headers) (abfd);
4115 if (a == -1)
4116 abort ();
4117 segs += a;
4118 }
4119
4120 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4121 return elf_tdata (abfd)->program_header_size;
4122 }
4123
4124 /* Work out the file positions of all the sections. This is called by
4125 _bfd_elf_compute_section_file_positions. All the section sizes and
4126 VMAs must be known before this is called.
4127
4128 We do not consider reloc sections at this point, unless they form
4129 part of the loadable image. Reloc sections are assigned file
4130 positions in assign_file_positions_for_relocs, which is called by
4131 write_object_contents and final_link.
4132
4133 We also don't set the positions of the .symtab and .strtab here. */
4134
4135 static bfd_boolean
4136 assign_file_positions_except_relocs (bfd *abfd)
4137 {
4138 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4139 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4140 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4141 unsigned int num_sec = elf_numsections (abfd);
4142 file_ptr off;
4143 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4144
4145 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4146 && bfd_get_format (abfd) != bfd_core)
4147 {
4148 Elf_Internal_Shdr **hdrpp;
4149 unsigned int i;
4150
4151 /* Start after the ELF header. */
4152 off = i_ehdrp->e_ehsize;
4153
4154 /* We are not creating an executable, which means that we are
4155 not creating a program header, and that the actual order of
4156 the sections in the file is unimportant. */
4157 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4158 {
4159 Elf_Internal_Shdr *hdr;
4160
4161 hdr = *hdrpp;
4162 if (hdr->sh_type == SHT_REL
4163 || hdr->sh_type == SHT_RELA
4164 || i == tdata->symtab_section
4165 || i == tdata->symtab_shndx_section
4166 || i == tdata->strtab_section)
4167 {
4168 hdr->sh_offset = -1;
4169 }
4170 else
4171 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4172
4173 if (i == SHN_LORESERVE - 1)
4174 {
4175 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4176 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4177 }
4178 }
4179 }
4180 else
4181 {
4182 unsigned int i;
4183 Elf_Internal_Shdr **hdrpp;
4184
4185 /* Assign file positions for the loaded sections based on the
4186 assignment of sections to segments. */
4187 if (! assign_file_positions_for_segments (abfd))
4188 return FALSE;
4189
4190 /* Assign file positions for the other sections. */
4191
4192 off = elf_tdata (abfd)->next_file_pos;
4193 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4194 {
4195 Elf_Internal_Shdr *hdr;
4196
4197 hdr = *hdrpp;
4198 if (hdr->bfd_section != NULL
4199 && hdr->bfd_section->filepos != 0)
4200 hdr->sh_offset = hdr->bfd_section->filepos;
4201 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4202 {
4203 ((*_bfd_error_handler)
4204 (_("%s: warning: allocated section `%s' not in segment"),
4205 bfd_get_filename (abfd),
4206 (hdr->bfd_section == NULL
4207 ? "*unknown*"
4208 : hdr->bfd_section->name)));
4209 if ((abfd->flags & D_PAGED) != 0)
4210 off += (hdr->sh_addr - off) % bed->maxpagesize;
4211 else
4212 off += (hdr->sh_addr - off) % hdr->sh_addralign;
4213 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4214 FALSE);
4215 }
4216 else if (hdr->sh_type == SHT_REL
4217 || hdr->sh_type == SHT_RELA
4218 || hdr == i_shdrpp[tdata->symtab_section]
4219 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4220 || hdr == i_shdrpp[tdata->strtab_section])
4221 hdr->sh_offset = -1;
4222 else
4223 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4224
4225 if (i == SHN_LORESERVE - 1)
4226 {
4227 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4228 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4229 }
4230 }
4231 }
4232
4233 /* Place the section headers. */
4234 off = align_file_position (off, 1 << bed->s->log_file_align);
4235 i_ehdrp->e_shoff = off;
4236 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4237
4238 elf_tdata (abfd)->next_file_pos = off;
4239
4240 return TRUE;
4241 }
4242
4243 static bfd_boolean
4244 prep_headers (bfd *abfd)
4245 {
4246 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4247 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4248 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4249 struct elf_strtab_hash *shstrtab;
4250 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4251
4252 i_ehdrp = elf_elfheader (abfd);
4253 i_shdrp = elf_elfsections (abfd);
4254
4255 shstrtab = _bfd_elf_strtab_init ();
4256 if (shstrtab == NULL)
4257 return FALSE;
4258
4259 elf_shstrtab (abfd) = shstrtab;
4260
4261 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4262 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4263 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4264 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4265
4266 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4267 i_ehdrp->e_ident[EI_DATA] =
4268 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4269 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4270
4271 if ((abfd->flags & DYNAMIC) != 0)
4272 i_ehdrp->e_type = ET_DYN;
4273 else if ((abfd->flags & EXEC_P) != 0)
4274 i_ehdrp->e_type = ET_EXEC;
4275 else if (bfd_get_format (abfd) == bfd_core)
4276 i_ehdrp->e_type = ET_CORE;
4277 else
4278 i_ehdrp->e_type = ET_REL;
4279
4280 switch (bfd_get_arch (abfd))
4281 {
4282 case bfd_arch_unknown:
4283 i_ehdrp->e_machine = EM_NONE;
4284 break;
4285
4286 /* There used to be a long list of cases here, each one setting
4287 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4288 in the corresponding bfd definition. To avoid duplication,
4289 the switch was removed. Machines that need special handling
4290 can generally do it in elf_backend_final_write_processing(),
4291 unless they need the information earlier than the final write.
4292 Such need can generally be supplied by replacing the tests for
4293 e_machine with the conditions used to determine it. */
4294 default:
4295 i_ehdrp->e_machine = bed->elf_machine_code;
4296 }
4297
4298 i_ehdrp->e_version = bed->s->ev_current;
4299 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4300
4301 /* No program header, for now. */
4302 i_ehdrp->e_phoff = 0;
4303 i_ehdrp->e_phentsize = 0;
4304 i_ehdrp->e_phnum = 0;
4305
4306 /* Each bfd section is section header entry. */
4307 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4308 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4309
4310 /* If we're building an executable, we'll need a program header table. */
4311 if (abfd->flags & EXEC_P)
4312 {
4313 /* It all happens later. */
4314 #if 0
4315 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4316
4317 /* elf_build_phdrs() returns a (NULL-terminated) array of
4318 Elf_Internal_Phdrs. */
4319 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4320 i_ehdrp->e_phoff = outbase;
4321 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4322 #endif
4323 }
4324 else
4325 {
4326 i_ehdrp->e_phentsize = 0;
4327 i_phdrp = 0;
4328 i_ehdrp->e_phoff = 0;
4329 }
4330
4331 elf_tdata (abfd)->symtab_hdr.sh_name =
4332 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4333 elf_tdata (abfd)->strtab_hdr.sh_name =
4334 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4335 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4336 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4337 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4338 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4339 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4340 return FALSE;
4341
4342 return TRUE;
4343 }
4344
4345 /* Assign file positions for all the reloc sections which are not part
4346 of the loadable file image. */
4347
4348 void
4349 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4350 {
4351 file_ptr off;
4352 unsigned int i, num_sec;
4353 Elf_Internal_Shdr **shdrpp;
4354
4355 off = elf_tdata (abfd)->next_file_pos;
4356
4357 num_sec = elf_numsections (abfd);
4358 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4359 {
4360 Elf_Internal_Shdr *shdrp;
4361
4362 shdrp = *shdrpp;
4363 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4364 && shdrp->sh_offset == -1)
4365 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4366 }
4367
4368 elf_tdata (abfd)->next_file_pos = off;
4369 }
4370
4371 bfd_boolean
4372 _bfd_elf_write_object_contents (bfd *abfd)
4373 {
4374 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4375 Elf_Internal_Ehdr *i_ehdrp;
4376 Elf_Internal_Shdr **i_shdrp;
4377 bfd_boolean failed;
4378 unsigned int count, num_sec;
4379
4380 if (! abfd->output_has_begun
4381 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4382 return FALSE;
4383
4384 i_shdrp = elf_elfsections (abfd);
4385 i_ehdrp = elf_elfheader (abfd);
4386
4387 failed = FALSE;
4388 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4389 if (failed)
4390 return FALSE;
4391
4392 _bfd_elf_assign_file_positions_for_relocs (abfd);
4393
4394 /* After writing the headers, we need to write the sections too... */
4395 num_sec = elf_numsections (abfd);
4396 for (count = 1; count < num_sec; count++)
4397 {
4398 if (bed->elf_backend_section_processing)
4399 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4400 if (i_shdrp[count]->contents)
4401 {
4402 bfd_size_type amt = i_shdrp[count]->sh_size;
4403
4404 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4405 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4406 return FALSE;
4407 }
4408 if (count == SHN_LORESERVE - 1)
4409 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4410 }
4411
4412 /* Write out the section header names. */
4413 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4414 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4415 return FALSE;
4416
4417 if (bed->elf_backend_final_write_processing)
4418 (*bed->elf_backend_final_write_processing) (abfd,
4419 elf_tdata (abfd)->linker);
4420
4421 return bed->s->write_shdrs_and_ehdr (abfd);
4422 }
4423
4424 bfd_boolean
4425 _bfd_elf_write_corefile_contents (bfd *abfd)
4426 {
4427 /* Hopefully this can be done just like an object file. */
4428 return _bfd_elf_write_object_contents (abfd);
4429 }
4430
4431 /* Given a section, search the header to find them. */
4432
4433 int
4434 _bfd_elf_section_from_bfd_section (bfd *abfd, struct sec *asect)
4435 {
4436 const struct elf_backend_data *bed;
4437 int index;
4438
4439 if (elf_section_data (asect) != NULL
4440 && elf_section_data (asect)->this_idx != 0)
4441 return elf_section_data (asect)->this_idx;
4442
4443 if (bfd_is_abs_section (asect))
4444 index = SHN_ABS;
4445 else if (bfd_is_com_section (asect))
4446 index = SHN_COMMON;
4447 else if (bfd_is_und_section (asect))
4448 index = SHN_UNDEF;
4449 else
4450 {
4451 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4452 int maxindex = elf_numsections (abfd);
4453
4454 for (index = 1; index < maxindex; index++)
4455 {
4456 Elf_Internal_Shdr *hdr = i_shdrp[index];
4457
4458 if (hdr != NULL && hdr->bfd_section == asect)
4459 return index;
4460 }
4461 index = -1;
4462 }
4463
4464 bed = get_elf_backend_data (abfd);
4465 if (bed->elf_backend_section_from_bfd_section)
4466 {
4467 int retval = index;
4468
4469 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4470 return retval;
4471 }
4472
4473 if (index == -1)
4474 bfd_set_error (bfd_error_nonrepresentable_section);
4475
4476 return index;
4477 }
4478
4479 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4480 on error. */
4481
4482 int
4483 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4484 {
4485 asymbol *asym_ptr = *asym_ptr_ptr;
4486 int idx;
4487 flagword flags = asym_ptr->flags;
4488
4489 /* When gas creates relocations against local labels, it creates its
4490 own symbol for the section, but does put the symbol into the
4491 symbol chain, so udata is 0. When the linker is generating
4492 relocatable output, this section symbol may be for one of the
4493 input sections rather than the output section. */
4494 if (asym_ptr->udata.i == 0
4495 && (flags & BSF_SECTION_SYM)
4496 && asym_ptr->section)
4497 {
4498 int indx;
4499
4500 if (asym_ptr->section->output_section != NULL)
4501 indx = asym_ptr->section->output_section->index;
4502 else
4503 indx = asym_ptr->section->index;
4504 if (indx < elf_num_section_syms (abfd)
4505 && elf_section_syms (abfd)[indx] != NULL)
4506 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4507 }
4508
4509 idx = asym_ptr->udata.i;
4510
4511 if (idx == 0)
4512 {
4513 /* This case can occur when using --strip-symbol on a symbol
4514 which is used in a relocation entry. */
4515 (*_bfd_error_handler)
4516 (_("%s: symbol `%s' required but not present"),
4517 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4518 bfd_set_error (bfd_error_no_symbols);
4519 return -1;
4520 }
4521
4522 #if DEBUG & 4
4523 {
4524 fprintf (stderr,
4525 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4526 (long) asym_ptr, asym_ptr->name, idx, flags,
4527 elf_symbol_flags (flags));
4528 fflush (stderr);
4529 }
4530 #endif
4531
4532 return idx;
4533 }
4534
4535 /* Copy private BFD data. This copies any program header information. */
4536
4537 static bfd_boolean
4538 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4539 {
4540 Elf_Internal_Ehdr *iehdr;
4541 struct elf_segment_map *map;
4542 struct elf_segment_map *map_first;
4543 struct elf_segment_map **pointer_to_map;
4544 Elf_Internal_Phdr *segment;
4545 asection *section;
4546 unsigned int i;
4547 unsigned int num_segments;
4548 bfd_boolean phdr_included = FALSE;
4549 bfd_vma maxpagesize;
4550 struct elf_segment_map *phdr_adjust_seg = NULL;
4551 unsigned int phdr_adjust_num = 0;
4552 const struct elf_backend_data *bed;
4553
4554 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4555 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4556 return TRUE;
4557
4558 if (elf_tdata (ibfd)->phdr == NULL)
4559 return TRUE;
4560
4561 bed = get_elf_backend_data (ibfd);
4562 iehdr = elf_elfheader (ibfd);
4563
4564 map_first = NULL;
4565 pointer_to_map = &map_first;
4566
4567 num_segments = elf_elfheader (ibfd)->e_phnum;
4568 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4569
4570 /* Returns the end address of the segment + 1. */
4571 #define SEGMENT_END(segment, start) \
4572 (start + (segment->p_memsz > segment->p_filesz \
4573 ? segment->p_memsz : segment->p_filesz))
4574
4575 #define SECTION_SIZE(section, segment) \
4576 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4577 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4578 ? section->_raw_size : 0)
4579
4580 /* Returns TRUE if the given section is contained within
4581 the given segment. VMA addresses are compared. */
4582 #define IS_CONTAINED_BY_VMA(section, segment) \
4583 (section->vma >= segment->p_vaddr \
4584 && (section->vma + SECTION_SIZE (section, segment) \
4585 <= (SEGMENT_END (segment, segment->p_vaddr))))
4586
4587 /* Returns TRUE if the given section is contained within
4588 the given segment. LMA addresses are compared. */
4589 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4590 (section->lma >= base \
4591 && (section->lma + SECTION_SIZE (section, segment) \
4592 <= SEGMENT_END (segment, base)))
4593
4594 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4595 #define IS_COREFILE_NOTE(p, s) \
4596 (p->p_type == PT_NOTE \
4597 && bfd_get_format (ibfd) == bfd_core \
4598 && s->vma == 0 && s->lma == 0 \
4599 && (bfd_vma) s->filepos >= p->p_offset \
4600 && ((bfd_vma) s->filepos + s->_raw_size \
4601 <= p->p_offset + p->p_filesz))
4602
4603 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4604 linker, which generates a PT_INTERP section with p_vaddr and
4605 p_memsz set to 0. */
4606 #define IS_SOLARIS_PT_INTERP(p, s) \
4607 (p->p_vaddr == 0 \
4608 && p->p_paddr == 0 \
4609 && p->p_memsz == 0 \
4610 && p->p_filesz > 0 \
4611 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4612 && s->_raw_size > 0 \
4613 && (bfd_vma) s->filepos >= p->p_offset \
4614 && ((bfd_vma) s->filepos + s->_raw_size \
4615 <= p->p_offset + p->p_filesz))
4616
4617 /* Decide if the given section should be included in the given segment.
4618 A section will be included if:
4619 1. It is within the address space of the segment -- we use the LMA
4620 if that is set for the segment and the VMA otherwise,
4621 2. It is an allocated segment,
4622 3. There is an output section associated with it,
4623 4. The section has not already been allocated to a previous segment.
4624 5. PT_TLS segment includes only SHF_TLS sections.
4625 6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4626 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4627 ((((segment->p_paddr \
4628 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4629 : IS_CONTAINED_BY_VMA (section, segment)) \
4630 && (section->flags & SEC_ALLOC) != 0) \
4631 || IS_COREFILE_NOTE (segment, section)) \
4632 && section->output_section != NULL \
4633 && (segment->p_type != PT_TLS \
4634 || (section->flags & SEC_THREAD_LOCAL)) \
4635 && (segment->p_type == PT_LOAD \
4636 || segment->p_type == PT_TLS \
4637 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4638 && ! section->segment_mark)
4639
4640 /* Returns TRUE iff seg1 starts after the end of seg2. */
4641 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4642 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4643
4644 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4645 their VMA address ranges and their LMA address ranges overlap.
4646 It is possible to have overlapping VMA ranges without overlapping LMA
4647 ranges. RedBoot images for example can have both .data and .bss mapped
4648 to the same VMA range, but with the .data section mapped to a different
4649 LMA. */
4650 #define SEGMENT_OVERLAPS(seg1, seg2) \
4651 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4652 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4653 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4654 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4655
4656 /* Initialise the segment mark field. */
4657 for (section = ibfd->sections; section != NULL; section = section->next)
4658 section->segment_mark = FALSE;
4659
4660 /* Scan through the segments specified in the program header
4661 of the input BFD. For this first scan we look for overlaps
4662 in the loadable segments. These can be created by weird
4663 parameters to objcopy. Also, fix some solaris weirdness. */
4664 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4665 i < num_segments;
4666 i++, segment++)
4667 {
4668 unsigned int j;
4669 Elf_Internal_Phdr *segment2;
4670
4671 if (segment->p_type == PT_INTERP)
4672 for (section = ibfd->sections; section; section = section->next)
4673 if (IS_SOLARIS_PT_INTERP (segment, section))
4674 {
4675 /* Mininal change so that the normal section to segment
4676 assigment code will work. */
4677 segment->p_vaddr = section->vma;
4678 break;
4679 }
4680
4681 if (segment->p_type != PT_LOAD)
4682 continue;
4683
4684 /* Determine if this segment overlaps any previous segments. */
4685 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4686 {
4687 bfd_signed_vma extra_length;
4688
4689 if (segment2->p_type != PT_LOAD
4690 || ! SEGMENT_OVERLAPS (segment, segment2))
4691 continue;
4692
4693 /* Merge the two segments together. */
4694 if (segment2->p_vaddr < segment->p_vaddr)
4695 {
4696 /* Extend SEGMENT2 to include SEGMENT and then delete
4697 SEGMENT. */
4698 extra_length =
4699 SEGMENT_END (segment, segment->p_vaddr)
4700 - SEGMENT_END (segment2, segment2->p_vaddr);
4701
4702 if (extra_length > 0)
4703 {
4704 segment2->p_memsz += extra_length;
4705 segment2->p_filesz += extra_length;
4706 }
4707
4708 segment->p_type = PT_NULL;
4709
4710 /* Since we have deleted P we must restart the outer loop. */
4711 i = 0;
4712 segment = elf_tdata (ibfd)->phdr;
4713 break;
4714 }
4715 else
4716 {
4717 /* Extend SEGMENT to include SEGMENT2 and then delete
4718 SEGMENT2. */
4719 extra_length =
4720 SEGMENT_END (segment2, segment2->p_vaddr)
4721 - SEGMENT_END (segment, segment->p_vaddr);
4722
4723 if (extra_length > 0)
4724 {
4725 segment->p_memsz += extra_length;
4726 segment->p_filesz += extra_length;
4727 }
4728
4729 segment2->p_type = PT_NULL;
4730 }
4731 }
4732 }
4733
4734 /* The second scan attempts to assign sections to segments. */
4735 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4736 i < num_segments;
4737 i ++, segment ++)
4738 {
4739 unsigned int section_count;
4740 asection ** sections;
4741 asection * output_section;
4742 unsigned int isec;
4743 bfd_vma matching_lma;
4744 bfd_vma suggested_lma;
4745 unsigned int j;
4746 bfd_size_type amt;
4747
4748 if (segment->p_type == PT_NULL)
4749 continue;
4750
4751 /* Compute how many sections might be placed into this segment. */
4752 for (section = ibfd->sections, section_count = 0;
4753 section != NULL;
4754 section = section->next)
4755 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4756 ++section_count;
4757
4758 /* Allocate a segment map big enough to contain
4759 all of the sections we have selected. */
4760 amt = sizeof (struct elf_segment_map);
4761 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4762 map = bfd_alloc (obfd, amt);
4763 if (map == NULL)
4764 return FALSE;
4765
4766 /* Initialise the fields of the segment map. Default to
4767 using the physical address of the segment in the input BFD. */
4768 map->next = NULL;
4769 map->p_type = segment->p_type;
4770 map->p_flags = segment->p_flags;
4771 map->p_flags_valid = 1;
4772 map->p_paddr = segment->p_paddr;
4773 map->p_paddr_valid = 1;
4774
4775 /* Determine if this segment contains the ELF file header
4776 and if it contains the program headers themselves. */
4777 map->includes_filehdr = (segment->p_offset == 0
4778 && segment->p_filesz >= iehdr->e_ehsize);
4779
4780 map->includes_phdrs = 0;
4781
4782 if (! phdr_included || segment->p_type != PT_LOAD)
4783 {
4784 map->includes_phdrs =
4785 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4786 && (segment->p_offset + segment->p_filesz
4787 >= ((bfd_vma) iehdr->e_phoff
4788 + iehdr->e_phnum * iehdr->e_phentsize)));
4789
4790 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4791 phdr_included = TRUE;
4792 }
4793
4794 if (section_count == 0)
4795 {
4796 /* Special segments, such as the PT_PHDR segment, may contain
4797 no sections, but ordinary, loadable segments should contain
4798 something. They are allowed by the ELF spec however, so only
4799 a warning is produced. */
4800 if (segment->p_type == PT_LOAD)
4801 (*_bfd_error_handler)
4802 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4803 bfd_archive_filename (ibfd));
4804
4805 map->count = 0;
4806 *pointer_to_map = map;
4807 pointer_to_map = &map->next;
4808
4809 continue;
4810 }
4811
4812 /* Now scan the sections in the input BFD again and attempt
4813 to add their corresponding output sections to the segment map.
4814 The problem here is how to handle an output section which has
4815 been moved (ie had its LMA changed). There are four possibilities:
4816
4817 1. None of the sections have been moved.
4818 In this case we can continue to use the segment LMA from the
4819 input BFD.
4820
4821 2. All of the sections have been moved by the same amount.
4822 In this case we can change the segment's LMA to match the LMA
4823 of the first section.
4824
4825 3. Some of the sections have been moved, others have not.
4826 In this case those sections which have not been moved can be
4827 placed in the current segment which will have to have its size,
4828 and possibly its LMA changed, and a new segment or segments will
4829 have to be created to contain the other sections.
4830
4831 4. The sections have been moved, but not by the same amount.
4832 In this case we can change the segment's LMA to match the LMA
4833 of the first section and we will have to create a new segment
4834 or segments to contain the other sections.
4835
4836 In order to save time, we allocate an array to hold the section
4837 pointers that we are interested in. As these sections get assigned
4838 to a segment, they are removed from this array. */
4839
4840 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4841 to work around this long long bug. */
4842 amt = section_count * sizeof (asection *);
4843 sections = bfd_malloc (amt);
4844 if (sections == NULL)
4845 return FALSE;
4846
4847 /* Step One: Scan for segment vs section LMA conflicts.
4848 Also add the sections to the section array allocated above.
4849 Also add the sections to the current segment. In the common
4850 case, where the sections have not been moved, this means that
4851 we have completely filled the segment, and there is nothing
4852 more to do. */
4853 isec = 0;
4854 matching_lma = 0;
4855 suggested_lma = 0;
4856
4857 for (j = 0, section = ibfd->sections;
4858 section != NULL;
4859 section = section->next)
4860 {
4861 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4862 {
4863 output_section = section->output_section;
4864
4865 sections[j ++] = section;
4866
4867 /* The Solaris native linker always sets p_paddr to 0.
4868 We try to catch that case here, and set it to the
4869 correct value. Note - some backends require that
4870 p_paddr be left as zero. */
4871 if (segment->p_paddr == 0
4872 && segment->p_vaddr != 0
4873 && (! bed->want_p_paddr_set_to_zero)
4874 && isec == 0
4875 && output_section->lma != 0
4876 && (output_section->vma == (segment->p_vaddr
4877 + (map->includes_filehdr
4878 ? iehdr->e_ehsize
4879 : 0)
4880 + (map->includes_phdrs
4881 ? (iehdr->e_phnum
4882 * iehdr->e_phentsize)
4883 : 0))))
4884 map->p_paddr = segment->p_vaddr;
4885
4886 /* Match up the physical address of the segment with the
4887 LMA address of the output section. */
4888 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4889 || IS_COREFILE_NOTE (segment, section)
4890 || (bed->want_p_paddr_set_to_zero &&
4891 IS_CONTAINED_BY_VMA (output_section, segment))
4892 )
4893 {
4894 if (matching_lma == 0)
4895 matching_lma = output_section->lma;
4896
4897 /* We assume that if the section fits within the segment
4898 then it does not overlap any other section within that
4899 segment. */
4900 map->sections[isec ++] = output_section;
4901 }
4902 else if (suggested_lma == 0)
4903 suggested_lma = output_section->lma;
4904 }
4905 }
4906
4907 BFD_ASSERT (j == section_count);
4908
4909 /* Step Two: Adjust the physical address of the current segment,
4910 if necessary. */
4911 if (isec == section_count)
4912 {
4913 /* All of the sections fitted within the segment as currently
4914 specified. This is the default case. Add the segment to
4915 the list of built segments and carry on to process the next
4916 program header in the input BFD. */
4917 map->count = section_count;
4918 *pointer_to_map = map;
4919 pointer_to_map = &map->next;
4920
4921 free (sections);
4922 continue;
4923 }
4924 else
4925 {
4926 if (matching_lma != 0)
4927 {
4928 /* At least one section fits inside the current segment.
4929 Keep it, but modify its physical address to match the
4930 LMA of the first section that fitted. */
4931 map->p_paddr = matching_lma;
4932 }
4933 else
4934 {
4935 /* None of the sections fitted inside the current segment.
4936 Change the current segment's physical address to match
4937 the LMA of the first section. */
4938 map->p_paddr = suggested_lma;
4939 }
4940
4941 /* Offset the segment physical address from the lma
4942 to allow for space taken up by elf headers. */
4943 if (map->includes_filehdr)
4944 map->p_paddr -= iehdr->e_ehsize;
4945
4946 if (map->includes_phdrs)
4947 {
4948 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4949
4950 /* iehdr->e_phnum is just an estimate of the number
4951 of program headers that we will need. Make a note
4952 here of the number we used and the segment we chose
4953 to hold these headers, so that we can adjust the
4954 offset when we know the correct value. */
4955 phdr_adjust_num = iehdr->e_phnum;
4956 phdr_adjust_seg = map;
4957 }
4958 }
4959
4960 /* Step Three: Loop over the sections again, this time assigning
4961 those that fit to the current segment and removing them from the
4962 sections array; but making sure not to leave large gaps. Once all
4963 possible sections have been assigned to the current segment it is
4964 added to the list of built segments and if sections still remain
4965 to be assigned, a new segment is constructed before repeating
4966 the loop. */
4967 isec = 0;
4968 do
4969 {
4970 map->count = 0;
4971 suggested_lma = 0;
4972
4973 /* Fill the current segment with sections that fit. */
4974 for (j = 0; j < section_count; j++)
4975 {
4976 section = sections[j];
4977
4978 if (section == NULL)
4979 continue;
4980
4981 output_section = section->output_section;
4982
4983 BFD_ASSERT (output_section != NULL);
4984
4985 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4986 || IS_COREFILE_NOTE (segment, section))
4987 {
4988 if (map->count == 0)
4989 {
4990 /* If the first section in a segment does not start at
4991 the beginning of the segment, then something is
4992 wrong. */
4993 if (output_section->lma !=
4994 (map->p_paddr
4995 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4996 + (map->includes_phdrs
4997 ? iehdr->e_phnum * iehdr->e_phentsize
4998 : 0)))
4999 abort ();
5000 }
5001 else
5002 {
5003 asection * prev_sec;
5004
5005 prev_sec = map->sections[map->count - 1];
5006
5007 /* If the gap between the end of the previous section
5008 and the start of this section is more than
5009 maxpagesize then we need to start a new segment. */
5010 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
5011 maxpagesize)
5012 < BFD_ALIGN (output_section->lma, maxpagesize))
5013 || ((prev_sec->lma + prev_sec->_raw_size)
5014 > output_section->lma))
5015 {
5016 if (suggested_lma == 0)
5017 suggested_lma = output_section->lma;
5018
5019 continue;
5020 }
5021 }
5022
5023 map->sections[map->count++] = output_section;
5024 ++isec;
5025 sections[j] = NULL;
5026 section->segment_mark = TRUE;
5027 }
5028 else if (suggested_lma == 0)
5029 suggested_lma = output_section->lma;
5030 }
5031
5032 BFD_ASSERT (map->count > 0);
5033
5034 /* Add the current segment to the list of built segments. */
5035 *pointer_to_map = map;
5036 pointer_to_map = &map->next;
5037
5038 if (isec < section_count)
5039 {
5040 /* We still have not allocated all of the sections to
5041 segments. Create a new segment here, initialise it
5042 and carry on looping. */
5043 amt = sizeof (struct elf_segment_map);
5044 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5045 map = bfd_alloc (obfd, amt);
5046 if (map == NULL)
5047 {
5048 free (sections);
5049 return FALSE;
5050 }
5051
5052 /* Initialise the fields of the segment map. Set the physical
5053 physical address to the LMA of the first section that has
5054 not yet been assigned. */
5055 map->next = NULL;
5056 map->p_type = segment->p_type;
5057 map->p_flags = segment->p_flags;
5058 map->p_flags_valid = 1;
5059 map->p_paddr = suggested_lma;
5060 map->p_paddr_valid = 1;
5061 map->includes_filehdr = 0;
5062 map->includes_phdrs = 0;
5063 }
5064 }
5065 while (isec < section_count);
5066
5067 free (sections);
5068 }
5069
5070 /* The Solaris linker creates program headers in which all the
5071 p_paddr fields are zero. When we try to objcopy or strip such a
5072 file, we get confused. Check for this case, and if we find it
5073 reset the p_paddr_valid fields. */
5074 for (map = map_first; map != NULL; map = map->next)
5075 if (map->p_paddr != 0)
5076 break;
5077 if (map == NULL)
5078 for (map = map_first; map != NULL; map = map->next)
5079 map->p_paddr_valid = 0;
5080
5081 elf_tdata (obfd)->segment_map = map_first;
5082
5083 /* If we had to estimate the number of program headers that were
5084 going to be needed, then check our estimate now and adjust
5085 the offset if necessary. */
5086 if (phdr_adjust_seg != NULL)
5087 {
5088 unsigned int count;
5089
5090 for (count = 0, map = map_first; map != NULL; map = map->next)
5091 count++;
5092
5093 if (count > phdr_adjust_num)
5094 phdr_adjust_seg->p_paddr
5095 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5096 }
5097
5098 #if 0
5099 /* Final Step: Sort the segments into ascending order of physical
5100 address. */
5101 if (map_first != NULL)
5102 {
5103 struct elf_segment_map *prev;
5104
5105 prev = map_first;
5106 for (map = map_first->next; map != NULL; prev = map, map = map->next)
5107 {
5108 /* Yes I know - its a bubble sort.... */
5109 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
5110 {
5111 /* Swap map and map->next. */
5112 prev->next = map->next;
5113 map->next = map->next->next;
5114 prev->next->next = map;
5115
5116 /* Restart loop. */
5117 map = map_first;
5118 }
5119 }
5120 }
5121 #endif
5122
5123 #undef SEGMENT_END
5124 #undef SECTION_SIZE
5125 #undef IS_CONTAINED_BY_VMA
5126 #undef IS_CONTAINED_BY_LMA
5127 #undef IS_COREFILE_NOTE
5128 #undef IS_SOLARIS_PT_INTERP
5129 #undef INCLUDE_SECTION_IN_SEGMENT
5130 #undef SEGMENT_AFTER_SEGMENT
5131 #undef SEGMENT_OVERLAPS
5132 return TRUE;
5133 }
5134
5135 /* Copy private section information. This copies over the entsize
5136 field, and sometimes the info field. */
5137
5138 bfd_boolean
5139 _bfd_elf_copy_private_section_data (bfd *ibfd,
5140 asection *isec,
5141 bfd *obfd,
5142 asection *osec)
5143 {
5144 Elf_Internal_Shdr *ihdr, *ohdr;
5145
5146 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5147 || obfd->xvec->flavour != bfd_target_elf_flavour)
5148 return TRUE;
5149
5150 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5151 {
5152 asection *s;
5153
5154 /* Only set up the segments if there are no more SEC_ALLOC
5155 sections. FIXME: This won't do the right thing if objcopy is
5156 used to remove the last SEC_ALLOC section, since objcopy
5157 won't call this routine in that case. */
5158 for (s = isec->next; s != NULL; s = s->next)
5159 if ((s->flags & SEC_ALLOC) != 0)
5160 break;
5161 if (s == NULL)
5162 {
5163 if (! copy_private_bfd_data (ibfd, obfd))
5164 return FALSE;
5165 }
5166 }
5167
5168 ihdr = &elf_section_data (isec)->this_hdr;
5169 ohdr = &elf_section_data (osec)->this_hdr;
5170
5171 ohdr->sh_entsize = ihdr->sh_entsize;
5172
5173 if (ihdr->sh_type == SHT_SYMTAB
5174 || ihdr->sh_type == SHT_DYNSYM
5175 || ihdr->sh_type == SHT_GNU_verneed
5176 || ihdr->sh_type == SHT_GNU_verdef)
5177 ohdr->sh_info = ihdr->sh_info;
5178
5179 /* Set things up for objcopy. The output SHT_GROUP section will
5180 have its elf_next_in_group pointing back to the input group
5181 members. */
5182 elf_next_in_group (osec) = elf_next_in_group (isec);
5183 elf_group_name (osec) = elf_group_name (isec);
5184
5185 osec->use_rela_p = isec->use_rela_p;
5186
5187 return TRUE;
5188 }
5189
5190 /* Copy private symbol information. If this symbol is in a section
5191 which we did not map into a BFD section, try to map the section
5192 index correctly. We use special macro definitions for the mapped
5193 section indices; these definitions are interpreted by the
5194 swap_out_syms function. */
5195
5196 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5197 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5198 #define MAP_STRTAB (SHN_HIOS + 3)
5199 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5200 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5201
5202 bfd_boolean
5203 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5204 asymbol *isymarg,
5205 bfd *obfd,
5206 asymbol *osymarg)
5207 {
5208 elf_symbol_type *isym, *osym;
5209
5210 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5211 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5212 return TRUE;
5213
5214 isym = elf_symbol_from (ibfd, isymarg);
5215 osym = elf_symbol_from (obfd, osymarg);
5216
5217 if (isym != NULL
5218 && osym != NULL
5219 && bfd_is_abs_section (isym->symbol.section))
5220 {
5221 unsigned int shndx;
5222
5223 shndx = isym->internal_elf_sym.st_shndx;
5224 if (shndx == elf_onesymtab (ibfd))
5225 shndx = MAP_ONESYMTAB;
5226 else if (shndx == elf_dynsymtab (ibfd))
5227 shndx = MAP_DYNSYMTAB;
5228 else if (shndx == elf_tdata (ibfd)->strtab_section)
5229 shndx = MAP_STRTAB;
5230 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5231 shndx = MAP_SHSTRTAB;
5232 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5233 shndx = MAP_SYM_SHNDX;
5234 osym->internal_elf_sym.st_shndx = shndx;
5235 }
5236
5237 return TRUE;
5238 }
5239
5240 /* Swap out the symbols. */
5241
5242 static bfd_boolean
5243 swap_out_syms (bfd *abfd,
5244 struct bfd_strtab_hash **sttp,
5245 int relocatable_p)
5246 {
5247 const struct elf_backend_data *bed;
5248 int symcount;
5249 asymbol **syms;
5250 struct bfd_strtab_hash *stt;
5251 Elf_Internal_Shdr *symtab_hdr;
5252 Elf_Internal_Shdr *symtab_shndx_hdr;
5253 Elf_Internal_Shdr *symstrtab_hdr;
5254 char *outbound_syms;
5255 char *outbound_shndx;
5256 int idx;
5257 bfd_size_type amt;
5258
5259 if (!elf_map_symbols (abfd))
5260 return FALSE;
5261
5262 /* Dump out the symtabs. */
5263 stt = _bfd_elf_stringtab_init ();
5264 if (stt == NULL)
5265 return FALSE;
5266
5267 bed = get_elf_backend_data (abfd);
5268 symcount = bfd_get_symcount (abfd);
5269 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5270 symtab_hdr->sh_type = SHT_SYMTAB;
5271 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5272 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5273 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5274 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5275
5276 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5277 symstrtab_hdr->sh_type = SHT_STRTAB;
5278
5279 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5280 outbound_syms = bfd_alloc (abfd, amt);
5281 if (outbound_syms == NULL)
5282 {
5283 _bfd_stringtab_free (stt);
5284 return FALSE;
5285 }
5286 symtab_hdr->contents = outbound_syms;
5287
5288 outbound_shndx = NULL;
5289 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5290 if (symtab_shndx_hdr->sh_name != 0)
5291 {
5292 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5293 outbound_shndx = bfd_zalloc (abfd, amt);
5294 if (outbound_shndx == NULL)
5295 {
5296 _bfd_stringtab_free (stt);
5297 return FALSE;
5298 }
5299
5300 symtab_shndx_hdr->contents = outbound_shndx;
5301 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5302 symtab_shndx_hdr->sh_size = amt;
5303 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5304 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5305 }
5306
5307 /* Now generate the data (for "contents"). */
5308 {
5309 /* Fill in zeroth symbol and swap it out. */
5310 Elf_Internal_Sym sym;
5311 sym.st_name = 0;
5312 sym.st_value = 0;
5313 sym.st_size = 0;
5314 sym.st_info = 0;
5315 sym.st_other = 0;
5316 sym.st_shndx = SHN_UNDEF;
5317 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5318 outbound_syms += bed->s->sizeof_sym;
5319 if (outbound_shndx != NULL)
5320 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5321 }
5322
5323 syms = bfd_get_outsymbols (abfd);
5324 for (idx = 0; idx < symcount; idx++)
5325 {
5326 Elf_Internal_Sym sym;
5327 bfd_vma value = syms[idx]->value;
5328 elf_symbol_type *type_ptr;
5329 flagword flags = syms[idx]->flags;
5330 int type;
5331
5332 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5333 {
5334 /* Local section symbols have no name. */
5335 sym.st_name = 0;
5336 }
5337 else
5338 {
5339 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5340 syms[idx]->name,
5341 TRUE, FALSE);
5342 if (sym.st_name == (unsigned long) -1)
5343 {
5344 _bfd_stringtab_free (stt);
5345 return FALSE;
5346 }
5347 }
5348
5349 type_ptr = elf_symbol_from (abfd, syms[idx]);
5350
5351 if ((flags & BSF_SECTION_SYM) == 0
5352 && bfd_is_com_section (syms[idx]->section))
5353 {
5354 /* ELF common symbols put the alignment into the `value' field,
5355 and the size into the `size' field. This is backwards from
5356 how BFD handles it, so reverse it here. */
5357 sym.st_size = value;
5358 if (type_ptr == NULL
5359 || type_ptr->internal_elf_sym.st_value == 0)
5360 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5361 else
5362 sym.st_value = type_ptr->internal_elf_sym.st_value;
5363 sym.st_shndx = _bfd_elf_section_from_bfd_section
5364 (abfd, syms[idx]->section);
5365 }
5366 else
5367 {
5368 asection *sec = syms[idx]->section;
5369 int shndx;
5370
5371 if (sec->output_section)
5372 {
5373 value += sec->output_offset;
5374 sec = sec->output_section;
5375 }
5376
5377 /* Don't add in the section vma for relocatable output. */
5378 if (! relocatable_p)
5379 value += sec->vma;
5380 sym.st_value = value;
5381 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5382
5383 if (bfd_is_abs_section (sec)
5384 && type_ptr != NULL
5385 && type_ptr->internal_elf_sym.st_shndx != 0)
5386 {
5387 /* This symbol is in a real ELF section which we did
5388 not create as a BFD section. Undo the mapping done
5389 by copy_private_symbol_data. */
5390 shndx = type_ptr->internal_elf_sym.st_shndx;
5391 switch (shndx)
5392 {
5393 case MAP_ONESYMTAB:
5394 shndx = elf_onesymtab (abfd);
5395 break;
5396 case MAP_DYNSYMTAB:
5397 shndx = elf_dynsymtab (abfd);
5398 break;
5399 case MAP_STRTAB:
5400 shndx = elf_tdata (abfd)->strtab_section;
5401 break;
5402 case MAP_SHSTRTAB:
5403 shndx = elf_tdata (abfd)->shstrtab_section;
5404 break;
5405 case MAP_SYM_SHNDX:
5406 shndx = elf_tdata (abfd)->symtab_shndx_section;
5407 break;
5408 default:
5409 break;
5410 }
5411 }
5412 else
5413 {
5414 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5415
5416 if (shndx == -1)
5417 {
5418 asection *sec2;
5419
5420 /* Writing this would be a hell of a lot easier if
5421 we had some decent documentation on bfd, and
5422 knew what to expect of the library, and what to
5423 demand of applications. For example, it
5424 appears that `objcopy' might not set the
5425 section of a symbol to be a section that is
5426 actually in the output file. */
5427 sec2 = bfd_get_section_by_name (abfd, sec->name);
5428 if (sec2 == NULL)
5429 {
5430 _bfd_error_handler (_("\
5431 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5432 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5433 sec->name);
5434 bfd_set_error (bfd_error_invalid_operation);
5435 _bfd_stringtab_free (stt);
5436 return FALSE;
5437 }
5438
5439 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5440 BFD_ASSERT (shndx != -1);
5441 }
5442 }
5443
5444 sym.st_shndx = shndx;
5445 }
5446
5447 if ((flags & BSF_THREAD_LOCAL) != 0)
5448 type = STT_TLS;
5449 else if ((flags & BSF_FUNCTION) != 0)
5450 type = STT_FUNC;
5451 else if ((flags & BSF_OBJECT) != 0)
5452 type = STT_OBJECT;
5453 else
5454 type = STT_NOTYPE;
5455
5456 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5457 type = STT_TLS;
5458
5459 /* Processor-specific types. */
5460 if (type_ptr != NULL
5461 && bed->elf_backend_get_symbol_type)
5462 type = ((*bed->elf_backend_get_symbol_type)
5463 (&type_ptr->internal_elf_sym, type));
5464
5465 if (flags & BSF_SECTION_SYM)
5466 {
5467 if (flags & BSF_GLOBAL)
5468 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5469 else
5470 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5471 }
5472 else if (bfd_is_com_section (syms[idx]->section))
5473 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5474 else if (bfd_is_und_section (syms[idx]->section))
5475 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5476 ? STB_WEAK
5477 : STB_GLOBAL),
5478 type);
5479 else if (flags & BSF_FILE)
5480 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5481 else
5482 {
5483 int bind = STB_LOCAL;
5484
5485 if (flags & BSF_LOCAL)
5486 bind = STB_LOCAL;
5487 else if (flags & BSF_WEAK)
5488 bind = STB_WEAK;
5489 else if (flags & BSF_GLOBAL)
5490 bind = STB_GLOBAL;
5491
5492 sym.st_info = ELF_ST_INFO (bind, type);
5493 }
5494
5495 if (type_ptr != NULL)
5496 sym.st_other = type_ptr->internal_elf_sym.st_other;
5497 else
5498 sym.st_other = 0;
5499
5500 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5501 outbound_syms += bed->s->sizeof_sym;
5502 if (outbound_shndx != NULL)
5503 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5504 }
5505
5506 *sttp = stt;
5507 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5508 symstrtab_hdr->sh_type = SHT_STRTAB;
5509
5510 symstrtab_hdr->sh_flags = 0;
5511 symstrtab_hdr->sh_addr = 0;
5512 symstrtab_hdr->sh_entsize = 0;
5513 symstrtab_hdr->sh_link = 0;
5514 symstrtab_hdr->sh_info = 0;
5515 symstrtab_hdr->sh_addralign = 1;
5516
5517 return TRUE;
5518 }
5519
5520 /* Return the number of bytes required to hold the symtab vector.
5521
5522 Note that we base it on the count plus 1, since we will null terminate
5523 the vector allocated based on this size. However, the ELF symbol table
5524 always has a dummy entry as symbol #0, so it ends up even. */
5525
5526 long
5527 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
5528 {
5529 long symcount;
5530 long symtab_size;
5531 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5532
5533 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5534 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5535 if (symcount > 0)
5536 symtab_size -= sizeof (asymbol *);
5537
5538 return symtab_size;
5539 }
5540
5541 long
5542 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
5543 {
5544 long symcount;
5545 long symtab_size;
5546 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5547
5548 if (elf_dynsymtab (abfd) == 0)
5549 {
5550 bfd_set_error (bfd_error_invalid_operation);
5551 return -1;
5552 }
5553
5554 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5555 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5556 if (symcount > 0)
5557 symtab_size -= sizeof (asymbol *);
5558
5559 return symtab_size;
5560 }
5561
5562 long
5563 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
5564 sec_ptr asect)
5565 {
5566 return (asect->reloc_count + 1) * sizeof (arelent *);
5567 }
5568
5569 /* Canonicalize the relocs. */
5570
5571 long
5572 _bfd_elf_canonicalize_reloc (bfd *abfd,
5573 sec_ptr section,
5574 arelent **relptr,
5575 asymbol **symbols)
5576 {
5577 arelent *tblptr;
5578 unsigned int i;
5579 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5580
5581 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
5582 return -1;
5583
5584 tblptr = section->relocation;
5585 for (i = 0; i < section->reloc_count; i++)
5586 *relptr++ = tblptr++;
5587
5588 *relptr = NULL;
5589
5590 return section->reloc_count;
5591 }
5592
5593 long
5594 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
5595 {
5596 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5597 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
5598
5599 if (symcount >= 0)
5600 bfd_get_symcount (abfd) = symcount;
5601 return symcount;
5602 }
5603
5604 long
5605 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
5606 asymbol **allocation)
5607 {
5608 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5609 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
5610
5611 if (symcount >= 0)
5612 bfd_get_dynamic_symcount (abfd) = symcount;
5613 return symcount;
5614 }
5615
5616 /* Return the size required for the dynamic reloc entries. Any
5617 section that was actually installed in the BFD, and has type
5618 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5619 considered to be a dynamic reloc section. */
5620
5621 long
5622 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
5623 {
5624 long ret;
5625 asection *s;
5626
5627 if (elf_dynsymtab (abfd) == 0)
5628 {
5629 bfd_set_error (bfd_error_invalid_operation);
5630 return -1;
5631 }
5632
5633 ret = sizeof (arelent *);
5634 for (s = abfd->sections; s != NULL; s = s->next)
5635 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5636 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5637 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5638 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5639 * sizeof (arelent *));
5640
5641 return ret;
5642 }
5643
5644 /* Canonicalize the dynamic relocation entries. Note that we return
5645 the dynamic relocations as a single block, although they are
5646 actually associated with particular sections; the interface, which
5647 was designed for SunOS style shared libraries, expects that there
5648 is only one set of dynamic relocs. Any section that was actually
5649 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5650 the dynamic symbol table, is considered to be a dynamic reloc
5651 section. */
5652
5653 long
5654 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
5655 arelent **storage,
5656 asymbol **syms)
5657 {
5658 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5659 asection *s;
5660 long ret;
5661
5662 if (elf_dynsymtab (abfd) == 0)
5663 {
5664 bfd_set_error (bfd_error_invalid_operation);
5665 return -1;
5666 }
5667
5668 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5669 ret = 0;
5670 for (s = abfd->sections; s != NULL; s = s->next)
5671 {
5672 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5673 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5674 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5675 {
5676 arelent *p;
5677 long count, i;
5678
5679 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
5680 return -1;
5681 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5682 p = s->relocation;
5683 for (i = 0; i < count; i++)
5684 *storage++ = p++;
5685 ret += count;
5686 }
5687 }
5688
5689 *storage = NULL;
5690
5691 return ret;
5692 }
5693 \f
5694 /* Read in the version information. */
5695
5696 bfd_boolean
5697 _bfd_elf_slurp_version_tables (bfd *abfd)
5698 {
5699 bfd_byte *contents = NULL;
5700 bfd_size_type amt;
5701
5702 if (elf_dynverdef (abfd) != 0)
5703 {
5704 Elf_Internal_Shdr *hdr;
5705 Elf_External_Verdef *everdef;
5706 Elf_Internal_Verdef *iverdef;
5707 Elf_Internal_Verdef *iverdefarr;
5708 Elf_Internal_Verdef iverdefmem;
5709 unsigned int i;
5710 unsigned int maxidx;
5711
5712 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5713
5714 contents = bfd_malloc (hdr->sh_size);
5715 if (contents == NULL)
5716 goto error_return;
5717 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5718 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
5719 goto error_return;
5720
5721 /* We know the number of entries in the section but not the maximum
5722 index. Therefore we have to run through all entries and find
5723 the maximum. */
5724 everdef = (Elf_External_Verdef *) contents;
5725 maxidx = 0;
5726 for (i = 0; i < hdr->sh_info; ++i)
5727 {
5728 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5729
5730 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5731 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5732
5733 everdef = ((Elf_External_Verdef *)
5734 ((bfd_byte *) everdef + iverdefmem.vd_next));
5735 }
5736
5737 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5738 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
5739 if (elf_tdata (abfd)->verdef == NULL)
5740 goto error_return;
5741
5742 elf_tdata (abfd)->cverdefs = maxidx;
5743
5744 everdef = (Elf_External_Verdef *) contents;
5745 iverdefarr = elf_tdata (abfd)->verdef;
5746 for (i = 0; i < hdr->sh_info; i++)
5747 {
5748 Elf_External_Verdaux *everdaux;
5749 Elf_Internal_Verdaux *iverdaux;
5750 unsigned int j;
5751
5752 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5753
5754 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5755 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5756
5757 iverdef->vd_bfd = abfd;
5758
5759 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5760 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
5761 if (iverdef->vd_auxptr == NULL)
5762 goto error_return;
5763
5764 everdaux = ((Elf_External_Verdaux *)
5765 ((bfd_byte *) everdef + iverdef->vd_aux));
5766 iverdaux = iverdef->vd_auxptr;
5767 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5768 {
5769 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5770
5771 iverdaux->vda_nodename =
5772 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5773 iverdaux->vda_name);
5774 if (iverdaux->vda_nodename == NULL)
5775 goto error_return;
5776
5777 if (j + 1 < iverdef->vd_cnt)
5778 iverdaux->vda_nextptr = iverdaux + 1;
5779 else
5780 iverdaux->vda_nextptr = NULL;
5781
5782 everdaux = ((Elf_External_Verdaux *)
5783 ((bfd_byte *) everdaux + iverdaux->vda_next));
5784 }
5785
5786 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5787
5788 if (i + 1 < hdr->sh_info)
5789 iverdef->vd_nextdef = iverdef + 1;
5790 else
5791 iverdef->vd_nextdef = NULL;
5792
5793 everdef = ((Elf_External_Verdef *)
5794 ((bfd_byte *) everdef + iverdef->vd_next));
5795 }
5796
5797 free (contents);
5798 contents = NULL;
5799 }
5800
5801 if (elf_dynverref (abfd) != 0)
5802 {
5803 Elf_Internal_Shdr *hdr;
5804 Elf_External_Verneed *everneed;
5805 Elf_Internal_Verneed *iverneed;
5806 unsigned int i;
5807
5808 hdr = &elf_tdata (abfd)->dynverref_hdr;
5809
5810 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5811 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
5812 if (elf_tdata (abfd)->verref == NULL)
5813 goto error_return;
5814
5815 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5816
5817 contents = bfd_malloc (hdr->sh_size);
5818 if (contents == NULL)
5819 goto error_return;
5820 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5821 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
5822 goto error_return;
5823
5824 everneed = (Elf_External_Verneed *) contents;
5825 iverneed = elf_tdata (abfd)->verref;
5826 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5827 {
5828 Elf_External_Vernaux *evernaux;
5829 Elf_Internal_Vernaux *ivernaux;
5830 unsigned int j;
5831
5832 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5833
5834 iverneed->vn_bfd = abfd;
5835
5836 iverneed->vn_filename =
5837 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5838 iverneed->vn_file);
5839 if (iverneed->vn_filename == NULL)
5840 goto error_return;
5841
5842 amt = iverneed->vn_cnt;
5843 amt *= sizeof (Elf_Internal_Vernaux);
5844 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
5845
5846 evernaux = ((Elf_External_Vernaux *)
5847 ((bfd_byte *) everneed + iverneed->vn_aux));
5848 ivernaux = iverneed->vn_auxptr;
5849 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5850 {
5851 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5852
5853 ivernaux->vna_nodename =
5854 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5855 ivernaux->vna_name);
5856 if (ivernaux->vna_nodename == NULL)
5857 goto error_return;
5858
5859 if (j + 1 < iverneed->vn_cnt)
5860 ivernaux->vna_nextptr = ivernaux + 1;
5861 else
5862 ivernaux->vna_nextptr = NULL;
5863
5864 evernaux = ((Elf_External_Vernaux *)
5865 ((bfd_byte *) evernaux + ivernaux->vna_next));
5866 }
5867
5868 if (i + 1 < hdr->sh_info)
5869 iverneed->vn_nextref = iverneed + 1;
5870 else
5871 iverneed->vn_nextref = NULL;
5872
5873 everneed = ((Elf_External_Verneed *)
5874 ((bfd_byte *) everneed + iverneed->vn_next));
5875 }
5876
5877 free (contents);
5878 contents = NULL;
5879 }
5880
5881 return TRUE;
5882
5883 error_return:
5884 if (contents != NULL)
5885 free (contents);
5886 return FALSE;
5887 }
5888 \f
5889 asymbol *
5890 _bfd_elf_make_empty_symbol (bfd *abfd)
5891 {
5892 elf_symbol_type *newsym;
5893 bfd_size_type amt = sizeof (elf_symbol_type);
5894
5895 newsym = bfd_zalloc (abfd, amt);
5896 if (!newsym)
5897 return NULL;
5898 else
5899 {
5900 newsym->symbol.the_bfd = abfd;
5901 return &newsym->symbol;
5902 }
5903 }
5904
5905 void
5906 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
5907 asymbol *symbol,
5908 symbol_info *ret)
5909 {
5910 bfd_symbol_info (symbol, ret);
5911 }
5912
5913 /* Return whether a symbol name implies a local symbol. Most targets
5914 use this function for the is_local_label_name entry point, but some
5915 override it. */
5916
5917 bfd_boolean
5918 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
5919 const char *name)
5920 {
5921 /* Normal local symbols start with ``.L''. */
5922 if (name[0] == '.' && name[1] == 'L')
5923 return TRUE;
5924
5925 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5926 DWARF debugging symbols starting with ``..''. */
5927 if (name[0] == '.' && name[1] == '.')
5928 return TRUE;
5929
5930 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5931 emitting DWARF debugging output. I suspect this is actually a
5932 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5933 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5934 underscore to be emitted on some ELF targets). For ease of use,
5935 we treat such symbols as local. */
5936 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5937 return TRUE;
5938
5939 return FALSE;
5940 }
5941
5942 alent *
5943 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
5944 asymbol *symbol ATTRIBUTE_UNUSED)
5945 {
5946 abort ();
5947 return NULL;
5948 }
5949
5950 bfd_boolean
5951 _bfd_elf_set_arch_mach (bfd *abfd,
5952 enum bfd_architecture arch,
5953 unsigned long machine)
5954 {
5955 /* If this isn't the right architecture for this backend, and this
5956 isn't the generic backend, fail. */
5957 if (arch != get_elf_backend_data (abfd)->arch
5958 && arch != bfd_arch_unknown
5959 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5960 return FALSE;
5961
5962 return bfd_default_set_arch_mach (abfd, arch, machine);
5963 }
5964
5965 /* Find the function to a particular section and offset,
5966 for error reporting. */
5967
5968 static bfd_boolean
5969 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
5970 asection *section,
5971 asymbol **symbols,
5972 bfd_vma offset,
5973 const char **filename_ptr,
5974 const char **functionname_ptr)
5975 {
5976 const char *filename;
5977 asymbol *func;
5978 bfd_vma low_func;
5979 asymbol **p;
5980
5981 filename = NULL;
5982 func = NULL;
5983 low_func = 0;
5984
5985 for (p = symbols; *p != NULL; p++)
5986 {
5987 elf_symbol_type *q;
5988
5989 q = (elf_symbol_type *) *p;
5990
5991 if (bfd_get_section (&q->symbol) != section)
5992 continue;
5993
5994 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5995 {
5996 default:
5997 break;
5998 case STT_FILE:
5999 filename = bfd_asymbol_name (&q->symbol);
6000 break;
6001 case STT_NOTYPE:
6002 case STT_FUNC:
6003 if (q->symbol.section == section
6004 && q->symbol.value >= low_func
6005 && q->symbol.value <= offset)
6006 {
6007 func = (asymbol *) q;
6008 low_func = q->symbol.value;
6009 }
6010 break;
6011 }
6012 }
6013
6014 if (func == NULL)
6015 return FALSE;
6016
6017 if (filename_ptr)
6018 *filename_ptr = filename;
6019 if (functionname_ptr)
6020 *functionname_ptr = bfd_asymbol_name (func);
6021
6022 return TRUE;
6023 }
6024
6025 /* Find the nearest line to a particular section and offset,
6026 for error reporting. */
6027
6028 bfd_boolean
6029 _bfd_elf_find_nearest_line (bfd *abfd,
6030 asection *section,
6031 asymbol **symbols,
6032 bfd_vma offset,
6033 const char **filename_ptr,
6034 const char **functionname_ptr,
6035 unsigned int *line_ptr)
6036 {
6037 bfd_boolean found;
6038
6039 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6040 filename_ptr, functionname_ptr,
6041 line_ptr))
6042 {
6043 if (!*functionname_ptr)
6044 elf_find_function (abfd, section, symbols, offset,
6045 *filename_ptr ? NULL : filename_ptr,
6046 functionname_ptr);
6047
6048 return TRUE;
6049 }
6050
6051 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6052 filename_ptr, functionname_ptr,
6053 line_ptr, 0,
6054 &elf_tdata (abfd)->dwarf2_find_line_info))
6055 {
6056 if (!*functionname_ptr)
6057 elf_find_function (abfd, section, symbols, offset,
6058 *filename_ptr ? NULL : filename_ptr,
6059 functionname_ptr);
6060
6061 return TRUE;
6062 }
6063
6064 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6065 &found, filename_ptr,
6066 functionname_ptr, line_ptr,
6067 &elf_tdata (abfd)->line_info))
6068 return FALSE;
6069 if (found && (*functionname_ptr || *line_ptr))
6070 return TRUE;
6071
6072 if (symbols == NULL)
6073 return FALSE;
6074
6075 if (! elf_find_function (abfd, section, symbols, offset,
6076 filename_ptr, functionname_ptr))
6077 return FALSE;
6078
6079 *line_ptr = 0;
6080 return TRUE;
6081 }
6082
6083 int
6084 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6085 {
6086 int ret;
6087
6088 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6089 if (! reloc)
6090 ret += get_program_header_size (abfd);
6091 return ret;
6092 }
6093
6094 bfd_boolean
6095 _bfd_elf_set_section_contents (bfd *abfd,
6096 sec_ptr section,
6097 void *location,
6098 file_ptr offset,
6099 bfd_size_type count)
6100 {
6101 Elf_Internal_Shdr *hdr;
6102 bfd_signed_vma pos;
6103
6104 if (! abfd->output_has_begun
6105 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6106 return FALSE;
6107
6108 hdr = &elf_section_data (section)->this_hdr;
6109 pos = hdr->sh_offset + offset;
6110 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6111 || bfd_bwrite (location, count, abfd) != count)
6112 return FALSE;
6113
6114 return TRUE;
6115 }
6116
6117 void
6118 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6119 arelent *cache_ptr ATTRIBUTE_UNUSED,
6120 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6121 {
6122 abort ();
6123 }
6124
6125 /* Try to convert a non-ELF reloc into an ELF one. */
6126
6127 bfd_boolean
6128 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6129 {
6130 /* Check whether we really have an ELF howto. */
6131
6132 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6133 {
6134 bfd_reloc_code_real_type code;
6135 reloc_howto_type *howto;
6136
6137 /* Alien reloc: Try to determine its type to replace it with an
6138 equivalent ELF reloc. */
6139
6140 if (areloc->howto->pc_relative)
6141 {
6142 switch (areloc->howto->bitsize)
6143 {
6144 case 8:
6145 code = BFD_RELOC_8_PCREL;
6146 break;
6147 case 12:
6148 code = BFD_RELOC_12_PCREL;
6149 break;
6150 case 16:
6151 code = BFD_RELOC_16_PCREL;
6152 break;
6153 case 24:
6154 code = BFD_RELOC_24_PCREL;
6155 break;
6156 case 32:
6157 code = BFD_RELOC_32_PCREL;
6158 break;
6159 case 64:
6160 code = BFD_RELOC_64_PCREL;
6161 break;
6162 default:
6163 goto fail;
6164 }
6165
6166 howto = bfd_reloc_type_lookup (abfd, code);
6167
6168 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6169 {
6170 if (howto->pcrel_offset)
6171 areloc->addend += areloc->address;
6172 else
6173 areloc->addend -= areloc->address; /* addend is unsigned!! */
6174 }
6175 }
6176 else
6177 {
6178 switch (areloc->howto->bitsize)
6179 {
6180 case 8:
6181 code = BFD_RELOC_8;
6182 break;
6183 case 14:
6184 code = BFD_RELOC_14;
6185 break;
6186 case 16:
6187 code = BFD_RELOC_16;
6188 break;
6189 case 26:
6190 code = BFD_RELOC_26;
6191 break;
6192 case 32:
6193 code = BFD_RELOC_32;
6194 break;
6195 case 64:
6196 code = BFD_RELOC_64;
6197 break;
6198 default:
6199 goto fail;
6200 }
6201
6202 howto = bfd_reloc_type_lookup (abfd, code);
6203 }
6204
6205 if (howto)
6206 areloc->howto = howto;
6207 else
6208 goto fail;
6209 }
6210
6211 return TRUE;
6212
6213 fail:
6214 (*_bfd_error_handler)
6215 (_("%s: unsupported relocation type %s"),
6216 bfd_archive_filename (abfd), areloc->howto->name);
6217 bfd_set_error (bfd_error_bad_value);
6218 return FALSE;
6219 }
6220
6221 bfd_boolean
6222 _bfd_elf_close_and_cleanup (bfd *abfd)
6223 {
6224 if (bfd_get_format (abfd) == bfd_object)
6225 {
6226 if (elf_shstrtab (abfd) != NULL)
6227 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6228 }
6229
6230 return _bfd_generic_close_and_cleanup (abfd);
6231 }
6232
6233 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6234 in the relocation's offset. Thus we cannot allow any sort of sanity
6235 range-checking to interfere. There is nothing else to do in processing
6236 this reloc. */
6237
6238 bfd_reloc_status_type
6239 _bfd_elf_rel_vtable_reloc_fn
6240 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6241 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED,
6242 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6243 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6244 {
6245 return bfd_reloc_ok;
6246 }
6247 \f
6248 /* Elf core file support. Much of this only works on native
6249 toolchains, since we rely on knowing the
6250 machine-dependent procfs structure in order to pick
6251 out details about the corefile. */
6252
6253 #ifdef HAVE_SYS_PROCFS_H
6254 # include <sys/procfs.h>
6255 #endif
6256
6257 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6258
6259 static int
6260 elfcore_make_pid (bfd *abfd)
6261 {
6262 return ((elf_tdata (abfd)->core_lwpid << 16)
6263 + (elf_tdata (abfd)->core_pid));
6264 }
6265
6266 /* If there isn't a section called NAME, make one, using
6267 data from SECT. Note, this function will generate a
6268 reference to NAME, so you shouldn't deallocate or
6269 overwrite it. */
6270
6271 static bfd_boolean
6272 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6273 {
6274 asection *sect2;
6275
6276 if (bfd_get_section_by_name (abfd, name) != NULL)
6277 return TRUE;
6278
6279 sect2 = bfd_make_section (abfd, name);
6280 if (sect2 == NULL)
6281 return FALSE;
6282
6283 sect2->_raw_size = sect->_raw_size;
6284 sect2->filepos = sect->filepos;
6285 sect2->flags = sect->flags;
6286 sect2->alignment_power = sect->alignment_power;
6287 return TRUE;
6288 }
6289
6290 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6291 actually creates up to two pseudosections:
6292 - For the single-threaded case, a section named NAME, unless
6293 such a section already exists.
6294 - For the multi-threaded case, a section named "NAME/PID", where
6295 PID is elfcore_make_pid (abfd).
6296 Both pseudosections have identical contents. */
6297 bfd_boolean
6298 _bfd_elfcore_make_pseudosection (bfd *abfd,
6299 char *name,
6300 size_t size,
6301 ufile_ptr filepos)
6302 {
6303 char buf[100];
6304 char *threaded_name;
6305 size_t len;
6306 asection *sect;
6307
6308 /* Build the section name. */
6309
6310 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6311 len = strlen (buf) + 1;
6312 threaded_name = bfd_alloc (abfd, len);
6313 if (threaded_name == NULL)
6314 return FALSE;
6315 memcpy (threaded_name, buf, len);
6316
6317 sect = bfd_make_section (abfd, threaded_name);
6318 if (sect == NULL)
6319 return FALSE;
6320 sect->_raw_size = size;
6321 sect->filepos = filepos;
6322 sect->flags = SEC_HAS_CONTENTS;
6323 sect->alignment_power = 2;
6324
6325 return elfcore_maybe_make_sect (abfd, name, sect);
6326 }
6327
6328 /* prstatus_t exists on:
6329 solaris 2.5+
6330 linux 2.[01] + glibc
6331 unixware 4.2
6332 */
6333
6334 #if defined (HAVE_PRSTATUS_T)
6335
6336 static bfd_boolean
6337 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6338 {
6339 size_t raw_size;
6340 int offset;
6341
6342 if (note->descsz == sizeof (prstatus_t))
6343 {
6344 prstatus_t prstat;
6345
6346 raw_size = sizeof (prstat.pr_reg);
6347 offset = offsetof (prstatus_t, pr_reg);
6348 memcpy (&prstat, note->descdata, sizeof (prstat));
6349
6350 /* Do not overwrite the core signal if it
6351 has already been set by another thread. */
6352 if (elf_tdata (abfd)->core_signal == 0)
6353 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6354 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6355
6356 /* pr_who exists on:
6357 solaris 2.5+
6358 unixware 4.2
6359 pr_who doesn't exist on:
6360 linux 2.[01]
6361 */
6362 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6363 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6364 #endif
6365 }
6366 #if defined (HAVE_PRSTATUS32_T)
6367 else if (note->descsz == sizeof (prstatus32_t))
6368 {
6369 /* 64-bit host, 32-bit corefile */
6370 prstatus32_t prstat;
6371
6372 raw_size = sizeof (prstat.pr_reg);
6373 offset = offsetof (prstatus32_t, pr_reg);
6374 memcpy (&prstat, note->descdata, sizeof (prstat));
6375
6376 /* Do not overwrite the core signal if it
6377 has already been set by another thread. */
6378 if (elf_tdata (abfd)->core_signal == 0)
6379 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6380 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6381
6382 /* pr_who exists on:
6383 solaris 2.5+
6384 unixware 4.2
6385 pr_who doesn't exist on:
6386 linux 2.[01]
6387 */
6388 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6389 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6390 #endif
6391 }
6392 #endif /* HAVE_PRSTATUS32_T */
6393 else
6394 {
6395 /* Fail - we don't know how to handle any other
6396 note size (ie. data object type). */
6397 return TRUE;
6398 }
6399
6400 /* Make a ".reg/999" section and a ".reg" section. */
6401 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6402 raw_size, note->descpos + offset);
6403 }
6404 #endif /* defined (HAVE_PRSTATUS_T) */
6405
6406 /* Create a pseudosection containing the exact contents of NOTE. */
6407 static bfd_boolean
6408 elfcore_make_note_pseudosection (bfd *abfd,
6409 char *name,
6410 Elf_Internal_Note *note)
6411 {
6412 return _bfd_elfcore_make_pseudosection (abfd, name,
6413 note->descsz, note->descpos);
6414 }
6415
6416 /* There isn't a consistent prfpregset_t across platforms,
6417 but it doesn't matter, because we don't have to pick this
6418 data structure apart. */
6419
6420 static bfd_boolean
6421 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
6422 {
6423 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6424 }
6425
6426 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6427 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6428 literally. */
6429
6430 static bfd_boolean
6431 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
6432 {
6433 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6434 }
6435
6436 #if defined (HAVE_PRPSINFO_T)
6437 typedef prpsinfo_t elfcore_psinfo_t;
6438 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6439 typedef prpsinfo32_t elfcore_psinfo32_t;
6440 #endif
6441 #endif
6442
6443 #if defined (HAVE_PSINFO_T)
6444 typedef psinfo_t elfcore_psinfo_t;
6445 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6446 typedef psinfo32_t elfcore_psinfo32_t;
6447 #endif
6448 #endif
6449
6450 /* return a malloc'ed copy of a string at START which is at
6451 most MAX bytes long, possibly without a terminating '\0'.
6452 the copy will always have a terminating '\0'. */
6453
6454 char *
6455 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
6456 {
6457 char *dups;
6458 char *end = memchr (start, '\0', max);
6459 size_t len;
6460
6461 if (end == NULL)
6462 len = max;
6463 else
6464 len = end - start;
6465
6466 dups = bfd_alloc (abfd, len + 1);
6467 if (dups == NULL)
6468 return NULL;
6469
6470 memcpy (dups, start, len);
6471 dups[len] = '\0';
6472
6473 return dups;
6474 }
6475
6476 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6477 static bfd_boolean
6478 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6479 {
6480 if (note->descsz == sizeof (elfcore_psinfo_t))
6481 {
6482 elfcore_psinfo_t psinfo;
6483
6484 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6485
6486 elf_tdata (abfd)->core_program
6487 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6488 sizeof (psinfo.pr_fname));
6489
6490 elf_tdata (abfd)->core_command
6491 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6492 sizeof (psinfo.pr_psargs));
6493 }
6494 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6495 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6496 {
6497 /* 64-bit host, 32-bit corefile */
6498 elfcore_psinfo32_t psinfo;
6499
6500 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6501
6502 elf_tdata (abfd)->core_program
6503 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6504 sizeof (psinfo.pr_fname));
6505
6506 elf_tdata (abfd)->core_command
6507 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6508 sizeof (psinfo.pr_psargs));
6509 }
6510 #endif
6511
6512 else
6513 {
6514 /* Fail - we don't know how to handle any other
6515 note size (ie. data object type). */
6516 return TRUE;
6517 }
6518
6519 /* Note that for some reason, a spurious space is tacked
6520 onto the end of the args in some (at least one anyway)
6521 implementations, so strip it off if it exists. */
6522
6523 {
6524 char *command = elf_tdata (abfd)->core_command;
6525 int n = strlen (command);
6526
6527 if (0 < n && command[n - 1] == ' ')
6528 command[n - 1] = '\0';
6529 }
6530
6531 return TRUE;
6532 }
6533 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6534
6535 #if defined (HAVE_PSTATUS_T)
6536 static bfd_boolean
6537 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
6538 {
6539 if (note->descsz == sizeof (pstatus_t)
6540 #if defined (HAVE_PXSTATUS_T)
6541 || note->descsz == sizeof (pxstatus_t)
6542 #endif
6543 )
6544 {
6545 pstatus_t pstat;
6546
6547 memcpy (&pstat, note->descdata, sizeof (pstat));
6548
6549 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6550 }
6551 #if defined (HAVE_PSTATUS32_T)
6552 else if (note->descsz == sizeof (pstatus32_t))
6553 {
6554 /* 64-bit host, 32-bit corefile */
6555 pstatus32_t pstat;
6556
6557 memcpy (&pstat, note->descdata, sizeof (pstat));
6558
6559 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6560 }
6561 #endif
6562 /* Could grab some more details from the "representative"
6563 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6564 NT_LWPSTATUS note, presumably. */
6565
6566 return TRUE;
6567 }
6568 #endif /* defined (HAVE_PSTATUS_T) */
6569
6570 #if defined (HAVE_LWPSTATUS_T)
6571 static bfd_boolean
6572 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
6573 {
6574 lwpstatus_t lwpstat;
6575 char buf[100];
6576 char *name;
6577 size_t len;
6578 asection *sect;
6579
6580 if (note->descsz != sizeof (lwpstat)
6581 #if defined (HAVE_LWPXSTATUS_T)
6582 && note->descsz != sizeof (lwpxstatus_t)
6583 #endif
6584 )
6585 return TRUE;
6586
6587 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6588
6589 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6590 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6591
6592 /* Make a ".reg/999" section. */
6593
6594 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6595 len = strlen (buf) + 1;
6596 name = bfd_alloc (abfd, len);
6597 if (name == NULL)
6598 return FALSE;
6599 memcpy (name, buf, len);
6600
6601 sect = bfd_make_section (abfd, name);
6602 if (sect == NULL)
6603 return FALSE;
6604
6605 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6606 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6607 sect->filepos = note->descpos
6608 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6609 #endif
6610
6611 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6612 sect->_raw_size = sizeof (lwpstat.pr_reg);
6613 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6614 #endif
6615
6616 sect->flags = SEC_HAS_CONTENTS;
6617 sect->alignment_power = 2;
6618
6619 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6620 return FALSE;
6621
6622 /* Make a ".reg2/999" section */
6623
6624 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6625 len = strlen (buf) + 1;
6626 name = bfd_alloc (abfd, len);
6627 if (name == NULL)
6628 return FALSE;
6629 memcpy (name, buf, len);
6630
6631 sect = bfd_make_section (abfd, name);
6632 if (sect == NULL)
6633 return FALSE;
6634
6635 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6636 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6637 sect->filepos = note->descpos
6638 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6639 #endif
6640
6641 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6642 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6643 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6644 #endif
6645
6646 sect->flags = SEC_HAS_CONTENTS;
6647 sect->alignment_power = 2;
6648
6649 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6650 }
6651 #endif /* defined (HAVE_LWPSTATUS_T) */
6652
6653 #if defined (HAVE_WIN32_PSTATUS_T)
6654 static bfd_boolean
6655 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
6656 {
6657 char buf[30];
6658 char *name;
6659 size_t len;
6660 asection *sect;
6661 win32_pstatus_t pstatus;
6662
6663 if (note->descsz < sizeof (pstatus))
6664 return TRUE;
6665
6666 memcpy (&pstatus, note->descdata, sizeof (pstatus));
6667
6668 switch (pstatus.data_type)
6669 {
6670 case NOTE_INFO_PROCESS:
6671 /* FIXME: need to add ->core_command. */
6672 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6673 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6674 break;
6675
6676 case NOTE_INFO_THREAD:
6677 /* Make a ".reg/999" section. */
6678 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6679
6680 len = strlen (buf) + 1;
6681 name = bfd_alloc (abfd, len);
6682 if (name == NULL)
6683 return FALSE;
6684
6685 memcpy (name, buf, len);
6686
6687 sect = bfd_make_section (abfd, name);
6688 if (sect == NULL)
6689 return FALSE;
6690
6691 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6692 sect->filepos = (note->descpos
6693 + offsetof (struct win32_pstatus,
6694 data.thread_info.thread_context));
6695 sect->flags = SEC_HAS_CONTENTS;
6696 sect->alignment_power = 2;
6697
6698 if (pstatus.data.thread_info.is_active_thread)
6699 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6700 return FALSE;
6701 break;
6702
6703 case NOTE_INFO_MODULE:
6704 /* Make a ".module/xxxxxxxx" section. */
6705 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6706
6707 len = strlen (buf) + 1;
6708 name = bfd_alloc (abfd, len);
6709 if (name == NULL)
6710 return FALSE;
6711
6712 memcpy (name, buf, len);
6713
6714 sect = bfd_make_section (abfd, name);
6715
6716 if (sect == NULL)
6717 return FALSE;
6718
6719 sect->_raw_size = note->descsz;
6720 sect->filepos = note->descpos;
6721 sect->flags = SEC_HAS_CONTENTS;
6722 sect->alignment_power = 2;
6723 break;
6724
6725 default:
6726 return TRUE;
6727 }
6728
6729 return TRUE;
6730 }
6731 #endif /* HAVE_WIN32_PSTATUS_T */
6732
6733 static bfd_boolean
6734 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
6735 {
6736 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6737
6738 switch (note->type)
6739 {
6740 default:
6741 return TRUE;
6742
6743 case NT_PRSTATUS:
6744 if (bed->elf_backend_grok_prstatus)
6745 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6746 return TRUE;
6747 #if defined (HAVE_PRSTATUS_T)
6748 return elfcore_grok_prstatus (abfd, note);
6749 #else
6750 return TRUE;
6751 #endif
6752
6753 #if defined (HAVE_PSTATUS_T)
6754 case NT_PSTATUS:
6755 return elfcore_grok_pstatus (abfd, note);
6756 #endif
6757
6758 #if defined (HAVE_LWPSTATUS_T)
6759 case NT_LWPSTATUS:
6760 return elfcore_grok_lwpstatus (abfd, note);
6761 #endif
6762
6763 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6764 return elfcore_grok_prfpreg (abfd, note);
6765
6766 #if defined (HAVE_WIN32_PSTATUS_T)
6767 case NT_WIN32PSTATUS:
6768 return elfcore_grok_win32pstatus (abfd, note);
6769 #endif
6770
6771 case NT_PRXFPREG: /* Linux SSE extension */
6772 if (note->namesz == 6
6773 && strcmp (note->namedata, "LINUX") == 0)
6774 return elfcore_grok_prxfpreg (abfd, note);
6775 else
6776 return TRUE;
6777
6778 case NT_PRPSINFO:
6779 case NT_PSINFO:
6780 if (bed->elf_backend_grok_psinfo)
6781 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6782 return TRUE;
6783 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6784 return elfcore_grok_psinfo (abfd, note);
6785 #else
6786 return TRUE;
6787 #endif
6788
6789 case NT_AUXV:
6790 {
6791 asection *sect = bfd_make_section (abfd, ".auxv");
6792
6793 if (sect == NULL)
6794 return FALSE;
6795 sect->_raw_size = note->descsz;
6796 sect->filepos = note->descpos;
6797 sect->flags = SEC_HAS_CONTENTS;
6798 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
6799
6800 return TRUE;
6801 }
6802 }
6803 }
6804
6805 static bfd_boolean
6806 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
6807 {
6808 char *cp;
6809
6810 cp = strchr (note->namedata, '@');
6811 if (cp != NULL)
6812 {
6813 *lwpidp = atoi(cp + 1);
6814 return TRUE;
6815 }
6816 return FALSE;
6817 }
6818
6819 static bfd_boolean
6820 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
6821 {
6822
6823 /* Signal number at offset 0x08. */
6824 elf_tdata (abfd)->core_signal
6825 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6826
6827 /* Process ID at offset 0x50. */
6828 elf_tdata (abfd)->core_pid
6829 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6830
6831 /* Command name at 0x7c (max 32 bytes, including nul). */
6832 elf_tdata (abfd)->core_command
6833 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6834
6835 return TRUE;
6836 }
6837
6838 static bfd_boolean
6839 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
6840 {
6841 int lwp;
6842
6843 if (elfcore_netbsd_get_lwpid (note, &lwp))
6844 elf_tdata (abfd)->core_lwpid = lwp;
6845
6846 if (note->type == NT_NETBSDCORE_PROCINFO)
6847 {
6848 /* NetBSD-specific core "procinfo". Note that we expect to
6849 find this note before any of the others, which is fine,
6850 since the kernel writes this note out first when it
6851 creates a core file. */
6852
6853 return elfcore_grok_netbsd_procinfo (abfd, note);
6854 }
6855
6856 /* As of Jan 2002 there are no other machine-independent notes
6857 defined for NetBSD core files. If the note type is less
6858 than the start of the machine-dependent note types, we don't
6859 understand it. */
6860
6861 if (note->type < NT_NETBSDCORE_FIRSTMACH)
6862 return TRUE;
6863
6864
6865 switch (bfd_get_arch (abfd))
6866 {
6867 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6868 PT_GETFPREGS == mach+2. */
6869
6870 case bfd_arch_alpha:
6871 case bfd_arch_sparc:
6872 switch (note->type)
6873 {
6874 case NT_NETBSDCORE_FIRSTMACH+0:
6875 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6876
6877 case NT_NETBSDCORE_FIRSTMACH+2:
6878 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6879
6880 default:
6881 return TRUE;
6882 }
6883
6884 /* On all other arch's, PT_GETREGS == mach+1 and
6885 PT_GETFPREGS == mach+3. */
6886
6887 default:
6888 switch (note->type)
6889 {
6890 case NT_NETBSDCORE_FIRSTMACH+1:
6891 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6892
6893 case NT_NETBSDCORE_FIRSTMACH+3:
6894 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6895
6896 default:
6897 return TRUE;
6898 }
6899 }
6900 /* NOTREACHED */
6901 }
6902
6903 static bfd_boolean
6904 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
6905 {
6906 void *ddata = note->descdata;
6907 char buf[100];
6908 char *name;
6909 asection *sect;
6910 short sig;
6911 unsigned flags;
6912
6913 /* nto_procfs_status 'pid' field is at offset 0. */
6914 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
6915
6916 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
6917 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
6918
6919 /* nto_procfs_status 'flags' field is at offset 8. */
6920 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
6921
6922 /* nto_procfs_status 'what' field is at offset 14. */
6923 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
6924 {
6925 elf_tdata (abfd)->core_signal = sig;
6926 elf_tdata (abfd)->core_lwpid = *tid;
6927 }
6928
6929 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
6930 do not come from signals so we make sure we set the current
6931 thread just in case. */
6932 if (flags & 0x00000080)
6933 elf_tdata (abfd)->core_lwpid = *tid;
6934
6935 /* Make a ".qnx_core_status/%d" section. */
6936 sprintf (buf, ".qnx_core_status/%d", *tid);
6937
6938 name = bfd_alloc (abfd, strlen (buf) + 1);
6939 if (name == NULL)
6940 return FALSE;
6941 strcpy (name, buf);
6942
6943 sect = bfd_make_section (abfd, name);
6944 if (sect == NULL)
6945 return FALSE;
6946
6947 sect->_raw_size = note->descsz;
6948 sect->filepos = note->descpos;
6949 sect->flags = SEC_HAS_CONTENTS;
6950 sect->alignment_power = 2;
6951
6952 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
6953 }
6954
6955 static bfd_boolean
6956 elfcore_grok_nto_gregs (bfd *abfd, Elf_Internal_Note *note, pid_t tid)
6957 {
6958 char buf[100];
6959 char *name;
6960 asection *sect;
6961
6962 /* Make a ".reg/%d" section. */
6963 sprintf (buf, ".reg/%d", tid);
6964
6965 name = bfd_alloc (abfd, strlen (buf) + 1);
6966 if (name == NULL)
6967 return FALSE;
6968 strcpy (name, buf);
6969
6970 sect = bfd_make_section (abfd, name);
6971 if (sect == NULL)
6972 return FALSE;
6973
6974 sect->_raw_size = note->descsz;
6975 sect->filepos = note->descpos;
6976 sect->flags = SEC_HAS_CONTENTS;
6977 sect->alignment_power = 2;
6978
6979 /* This is the current thread. */
6980 if (elf_tdata (abfd)->core_lwpid == tid)
6981 return elfcore_maybe_make_sect (abfd, ".reg", sect);
6982
6983 return TRUE;
6984 }
6985
6986 #define BFD_QNT_CORE_INFO 7
6987 #define BFD_QNT_CORE_STATUS 8
6988 #define BFD_QNT_CORE_GREG 9
6989 #define BFD_QNT_CORE_FPREG 10
6990
6991 static bfd_boolean
6992 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
6993 {
6994 /* Every GREG section has a STATUS section before it. Store the
6995 tid from the previous call to pass down to the next gregs
6996 function. */
6997 static pid_t tid = 1;
6998
6999 switch (note->type)
7000 {
7001 case BFD_QNT_CORE_INFO: return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7002 case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
7003 case BFD_QNT_CORE_GREG: return elfcore_grok_nto_gregs (abfd, note, tid);
7004 case BFD_QNT_CORE_FPREG: return elfcore_grok_prfpreg (abfd, note);
7005 default: return TRUE;
7006 }
7007 }
7008
7009 /* Function: elfcore_write_note
7010
7011 Inputs:
7012 buffer to hold note
7013 name of note
7014 type of note
7015 data for note
7016 size of data for note
7017
7018 Return:
7019 End of buffer containing note. */
7020
7021 char *
7022 elfcore_write_note (bfd *abfd,
7023 char *buf,
7024 int *bufsiz,
7025 const char *name,
7026 int type,
7027 const void *input,
7028 int size)
7029 {
7030 Elf_External_Note *xnp;
7031 size_t namesz;
7032 size_t pad;
7033 size_t newspace;
7034 char *p, *dest;
7035
7036 namesz = 0;
7037 pad = 0;
7038 if (name != NULL)
7039 {
7040 const struct elf_backend_data *bed;
7041
7042 namesz = strlen (name) + 1;
7043 bed = get_elf_backend_data (abfd);
7044 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7045 }
7046
7047 newspace = 12 + namesz + pad + size;
7048
7049 p = realloc (buf, *bufsiz + newspace);
7050 dest = p + *bufsiz;
7051 *bufsiz += newspace;
7052 xnp = (Elf_External_Note *) dest;
7053 H_PUT_32 (abfd, namesz, xnp->namesz);
7054 H_PUT_32 (abfd, size, xnp->descsz);
7055 H_PUT_32 (abfd, type, xnp->type);
7056 dest = xnp->name;
7057 if (name != NULL)
7058 {
7059 memcpy (dest, name, namesz);
7060 dest += namesz;
7061 while (pad != 0)
7062 {
7063 *dest++ = '\0';
7064 --pad;
7065 }
7066 }
7067 memcpy (dest, input, size);
7068 return p;
7069 }
7070
7071 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7072 char *
7073 elfcore_write_prpsinfo (bfd *abfd,
7074 char *buf,
7075 int *bufsiz,
7076 const char *fname,
7077 const char *psargs)
7078 {
7079 int note_type;
7080 char *note_name = "CORE";
7081
7082 #if defined (HAVE_PSINFO_T)
7083 psinfo_t data;
7084 note_type = NT_PSINFO;
7085 #else
7086 prpsinfo_t data;
7087 note_type = NT_PRPSINFO;
7088 #endif
7089
7090 memset (&data, 0, sizeof (data));
7091 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7092 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7093 return elfcore_write_note (abfd, buf, bufsiz,
7094 note_name, note_type, &data, sizeof (data));
7095 }
7096 #endif /* PSINFO_T or PRPSINFO_T */
7097
7098 #if defined (HAVE_PRSTATUS_T)
7099 char *
7100 elfcore_write_prstatus (bfd *abfd,
7101 char *buf,
7102 int *bufsiz,
7103 long pid,
7104 int cursig,
7105 const void *gregs)
7106 {
7107 prstatus_t prstat;
7108 char *note_name = "CORE";
7109
7110 memset (&prstat, 0, sizeof (prstat));
7111 prstat.pr_pid = pid;
7112 prstat.pr_cursig = cursig;
7113 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7114 return elfcore_write_note (abfd, buf, bufsiz,
7115 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7116 }
7117 #endif /* HAVE_PRSTATUS_T */
7118
7119 #if defined (HAVE_LWPSTATUS_T)
7120 char *
7121 elfcore_write_lwpstatus (bfd *abfd,
7122 char *buf,
7123 int *bufsiz,
7124 long pid,
7125 int cursig,
7126 const void *gregs)
7127 {
7128 lwpstatus_t lwpstat;
7129 char *note_name = "CORE";
7130
7131 memset (&lwpstat, 0, sizeof (lwpstat));
7132 lwpstat.pr_lwpid = pid >> 16;
7133 lwpstat.pr_cursig = cursig;
7134 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7135 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7136 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7137 #if !defined(gregs)
7138 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7139 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7140 #else
7141 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7142 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7143 #endif
7144 #endif
7145 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7146 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7147 }
7148 #endif /* HAVE_LWPSTATUS_T */
7149
7150 #if defined (HAVE_PSTATUS_T)
7151 char *
7152 elfcore_write_pstatus (bfd *abfd,
7153 char *buf,
7154 int *bufsiz,
7155 long pid,
7156 int cursig,
7157 const void *gregs)
7158 {
7159 pstatus_t pstat;
7160 char *note_name = "CORE";
7161
7162 memset (&pstat, 0, sizeof (pstat));
7163 pstat.pr_pid = pid & 0xffff;
7164 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7165 NT_PSTATUS, &pstat, sizeof (pstat));
7166 return buf;
7167 }
7168 #endif /* HAVE_PSTATUS_T */
7169
7170 char *
7171 elfcore_write_prfpreg (bfd *abfd,
7172 char *buf,
7173 int *bufsiz,
7174 const void *fpregs,
7175 int size)
7176 {
7177 char *note_name = "CORE";
7178 return elfcore_write_note (abfd, buf, bufsiz,
7179 note_name, NT_FPREGSET, fpregs, size);
7180 }
7181
7182 char *
7183 elfcore_write_prxfpreg (bfd *abfd,
7184 char *buf,
7185 int *bufsiz,
7186 const void *xfpregs,
7187 int size)
7188 {
7189 char *note_name = "LINUX";
7190 return elfcore_write_note (abfd, buf, bufsiz,
7191 note_name, NT_PRXFPREG, xfpregs, size);
7192 }
7193
7194 static bfd_boolean
7195 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7196 {
7197 char *buf;
7198 char *p;
7199
7200 if (size <= 0)
7201 return TRUE;
7202
7203 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7204 return FALSE;
7205
7206 buf = bfd_malloc (size);
7207 if (buf == NULL)
7208 return FALSE;
7209
7210 if (bfd_bread (buf, size, abfd) != size)
7211 {
7212 error:
7213 free (buf);
7214 return FALSE;
7215 }
7216
7217 p = buf;
7218 while (p < buf + size)
7219 {
7220 /* FIXME: bad alignment assumption. */
7221 Elf_External_Note *xnp = (Elf_External_Note *) p;
7222 Elf_Internal_Note in;
7223
7224 in.type = H_GET_32 (abfd, xnp->type);
7225
7226 in.namesz = H_GET_32 (abfd, xnp->namesz);
7227 in.namedata = xnp->name;
7228
7229 in.descsz = H_GET_32 (abfd, xnp->descsz);
7230 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7231 in.descpos = offset + (in.descdata - buf);
7232
7233 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7234 {
7235 if (! elfcore_grok_netbsd_note (abfd, &in))
7236 goto error;
7237 }
7238 else if (strncmp (in.namedata, "QNX", 3) == 0)
7239 {
7240 if (! elfcore_grok_nto_note (abfd, &in))
7241 goto error;
7242 }
7243 else
7244 {
7245 if (! elfcore_grok_note (abfd, &in))
7246 goto error;
7247 }
7248
7249 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7250 }
7251
7252 free (buf);
7253 return TRUE;
7254 }
7255 \f
7256 /* Providing external access to the ELF program header table. */
7257
7258 /* Return an upper bound on the number of bytes required to store a
7259 copy of ABFD's program header table entries. Return -1 if an error
7260 occurs; bfd_get_error will return an appropriate code. */
7261
7262 long
7263 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7264 {
7265 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7266 {
7267 bfd_set_error (bfd_error_wrong_format);
7268 return -1;
7269 }
7270
7271 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7272 }
7273
7274 /* Copy ABFD's program header table entries to *PHDRS. The entries
7275 will be stored as an array of Elf_Internal_Phdr structures, as
7276 defined in include/elf/internal.h. To find out how large the
7277 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7278
7279 Return the number of program header table entries read, or -1 if an
7280 error occurs; bfd_get_error will return an appropriate code. */
7281
7282 int
7283 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7284 {
7285 int num_phdrs;
7286
7287 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7288 {
7289 bfd_set_error (bfd_error_wrong_format);
7290 return -1;
7291 }
7292
7293 num_phdrs = elf_elfheader (abfd)->e_phnum;
7294 memcpy (phdrs, elf_tdata (abfd)->phdr,
7295 num_phdrs * sizeof (Elf_Internal_Phdr));
7296
7297 return num_phdrs;
7298 }
7299
7300 void
7301 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7302 {
7303 #ifdef BFD64
7304 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7305
7306 i_ehdrp = elf_elfheader (abfd);
7307 if (i_ehdrp == NULL)
7308 sprintf_vma (buf, value);
7309 else
7310 {
7311 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7312 {
7313 #if BFD_HOST_64BIT_LONG
7314 sprintf (buf, "%016lx", value);
7315 #else
7316 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7317 _bfd_int64_low (value));
7318 #endif
7319 }
7320 else
7321 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7322 }
7323 #else
7324 sprintf_vma (buf, value);
7325 #endif
7326 }
7327
7328 void
7329 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7330 {
7331 #ifdef BFD64
7332 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7333
7334 i_ehdrp = elf_elfheader (abfd);
7335 if (i_ehdrp == NULL)
7336 fprintf_vma ((FILE *) stream, value);
7337 else
7338 {
7339 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7340 {
7341 #if BFD_HOST_64BIT_LONG
7342 fprintf ((FILE *) stream, "%016lx", value);
7343 #else
7344 fprintf ((FILE *) stream, "%08lx%08lx",
7345 _bfd_int64_high (value), _bfd_int64_low (value));
7346 #endif
7347 }
7348 else
7349 fprintf ((FILE *) stream, "%08lx",
7350 (unsigned long) (value & 0xffffffff));
7351 }
7352 #else
7353 fprintf_vma ((FILE *) stream, value);
7354 #endif
7355 }
7356
7357 enum elf_reloc_type_class
7358 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
7359 {
7360 return reloc_class_normal;
7361 }
7362
7363 /* For RELA architectures, return the relocation value for a
7364 relocation against a local symbol. */
7365
7366 bfd_vma
7367 _bfd_elf_rela_local_sym (bfd *abfd,
7368 Elf_Internal_Sym *sym,
7369 asection *sec,
7370 Elf_Internal_Rela *rel)
7371 {
7372 bfd_vma relocation;
7373
7374 relocation = (sec->output_section->vma
7375 + sec->output_offset
7376 + sym->st_value);
7377 if ((sec->flags & SEC_MERGE)
7378 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7379 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
7380 {
7381 asection *msec;
7382
7383 msec = sec;
7384 rel->r_addend =
7385 _bfd_merged_section_offset (abfd, &msec,
7386 elf_section_data (sec)->sec_info,
7387 sym->st_value + rel->r_addend,
7388 0)
7389 - relocation;
7390 rel->r_addend += msec->output_section->vma + msec->output_offset;
7391 }
7392 return relocation;
7393 }
7394
7395 bfd_vma
7396 _bfd_elf_rel_local_sym (bfd *abfd,
7397 Elf_Internal_Sym *sym,
7398 asection **psec,
7399 bfd_vma addend)
7400 {
7401 asection *sec = *psec;
7402
7403 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
7404 return sym->st_value + addend;
7405
7406 return _bfd_merged_section_offset (abfd, psec,
7407 elf_section_data (sec)->sec_info,
7408 sym->st_value + addend, 0);
7409 }
7410
7411 bfd_vma
7412 _bfd_elf_section_offset (bfd *abfd,
7413 struct bfd_link_info *info,
7414 asection *sec,
7415 bfd_vma offset)
7416 {
7417 struct bfd_elf_section_data *sec_data;
7418
7419 sec_data = elf_section_data (sec);
7420 switch (sec->sec_info_type)
7421 {
7422 case ELF_INFO_TYPE_STABS:
7423 return _bfd_stab_section_offset (abfd,
7424 &elf_hash_table (info)->merge_info,
7425 sec, &sec_data->sec_info, offset);
7426 case ELF_INFO_TYPE_EH_FRAME:
7427 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
7428 default:
7429 return offset;
7430 }
7431 }
7432 \f
7433 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
7434 reconstruct an ELF file by reading the segments out of remote memory
7435 based on the ELF file header at EHDR_VMA and the ELF program headers it
7436 points to. If not null, *LOADBASEP is filled in with the difference
7437 between the VMAs from which the segments were read, and the VMAs the
7438 file headers (and hence BFD's idea of each section's VMA) put them at.
7439
7440 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7441 remote memory at target address VMA into the local buffer at MYADDR; it
7442 should return zero on success or an `errno' code on failure. TEMPL must
7443 be a BFD for an ELF target with the word size and byte order found in
7444 the remote memory. */
7445
7446 bfd *
7447 bfd_elf_bfd_from_remote_memory
7448 (bfd *templ,
7449 bfd_vma ehdr_vma,
7450 bfd_vma *loadbasep,
7451 int (*target_read_memory) (bfd_vma, char *, int))
7452 {
7453 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
7454 (templ, ehdr_vma, loadbasep, target_read_memory);
7455 }
A mirror of the official binutils-gdb repository