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