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