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