projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move generic_load declaration to symfile.h
[deliverable/binutils-gdb.git] / bfd / elf.c
CommitLineData
252b5132 1/* ELF executable support for BFD.
340b6d91 2
82704155 3 Copyright (C) 1993-2019 Free Software Foundation, Inc.
252b5132 4
5e8d7549 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
5e8d7549
NC		 7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
5e8d7549 10 (at your option) any later version.
252b5132 11
5e8d7549
NC		 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
252b5132 16
5e8d7549 17 You should have received a copy of the GNU General Public License
b34976b6 18 along with this program; if not, write to the Free Software
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
252b5132 22
1b74d094
BW		 23/*
24SECTION
252b5132
RH		 25 ELF backends
26
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
30
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
661a3fd4 33 haven't bothered yet. */
252b5132 34
7ee38065
MS		 35/* For sparc64-cross-sparc32. */
36#define _SYSCALL32
252b5132 37#include "sysdep.h"
3a551c7a 38#include <limits.h>
3db64b00 39#include "bfd.h"
252b5132
RH		 40#include "bfdlink.h"
41#include "libbfd.h"
42#define ARCH_SIZE 0
43#include "elf-bfd.h"
e0e8c97f 44#include "libiberty.h"
ff59fc36 45#include "safe-ctype.h"
de64ce13 46#include "elf-linux-core.h"
252b5132 47
8bc7f138
L		 48#ifdef CORE_HEADER
49#include CORE_HEADER
50#endif
51
217aa764 52static int elf_sort_sections (const void *, const void *);
c84fca4d 53static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
217aa764 54static bfd_boolean prep_headers (bfd *);
ef10c3ac 55static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ;
276da9b3
L		 56static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type,
57 size_t align) ;
718175fa 58static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
276da9b3 59 file_ptr offset, size_t align);
50b2bdb7 60
252b5132
RH		 61/* Swap version information in and out. The version information is
62 currently size independent. If that ever changes, this code will
63 need to move into elfcode.h. */
64
65/* Swap in a Verdef structure. */
66
67void
217aa764
AM		 68_bfd_elf_swap_verdef_in (bfd *abfd,
69 const Elf_External_Verdef *src,
70 Elf_Internal_Verdef *dst)
252b5132 71{
dc810e39
AM		 72 dst->vd_version = H_GET_16 (abfd, src->vd_version);
73 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
74 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
75 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
76 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
77 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
78 dst->vd_next = H_GET_32 (abfd, src->vd_next);
252b5132
RH		 79}
80
81/* Swap out a Verdef structure. */
82
83void
217aa764
AM		 84_bfd_elf_swap_verdef_out (bfd *abfd,
85 const Elf_Internal_Verdef *src,
86 Elf_External_Verdef *dst)
252b5132 87{
dc810e39
AM		 88 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
89 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
90 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
91 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
92 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
93 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
94 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
252b5132
RH		 95}
96
97/* Swap in a Verdaux structure. */
98
99void
217aa764
AM		 100_bfd_elf_swap_verdaux_in (bfd *abfd,
101 const Elf_External_Verdaux *src,
102 Elf_Internal_Verdaux *dst)
252b5132 103{
dc810e39
AM		 104 dst->vda_name = H_GET_32 (abfd, src->vda_name);
105 dst->vda_next = H_GET_32 (abfd, src->vda_next);
252b5132
RH		 106}
107
108/* Swap out a Verdaux structure. */
109
110void
217aa764
AM		 111_bfd_elf_swap_verdaux_out (bfd *abfd,
112 const Elf_Internal_Verdaux *src,
113 Elf_External_Verdaux *dst)
252b5132 114{
dc810e39
AM		 115 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
116 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
252b5132
RH		 117}
118
119/* Swap in a Verneed structure. */
120
121void
217aa764
AM		 122_bfd_elf_swap_verneed_in (bfd *abfd,
123 const Elf_External_Verneed *src,
124 Elf_Internal_Verneed *dst)
252b5132 125{
dc810e39
AM		 126 dst->vn_version = H_GET_16 (abfd, src->vn_version);
127 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
128 dst->vn_file = H_GET_32 (abfd, src->vn_file);
129 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
130 dst->vn_next = H_GET_32 (abfd, src->vn_next);
252b5132
RH		 131}
132
133/* Swap out a Verneed structure. */
134
135void
217aa764
AM		 136_bfd_elf_swap_verneed_out (bfd *abfd,
137 const Elf_Internal_Verneed *src,
138 Elf_External_Verneed *dst)
252b5132 139{
dc810e39
AM		 140 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
141 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
142 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
143 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
144 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
252b5132
RH		 145}
146
147/* Swap in a Vernaux structure. */
148
149void
217aa764
AM		 150_bfd_elf_swap_vernaux_in (bfd *abfd,
151 const Elf_External_Vernaux *src,
152 Elf_Internal_Vernaux *dst)
252b5132 153{
dc810e39
AM		 154 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
155 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
156 dst->vna_other = H_GET_16 (abfd, src->vna_other);
157 dst->vna_name = H_GET_32 (abfd, src->vna_name);
158 dst->vna_next = H_GET_32 (abfd, src->vna_next);
252b5132
RH		 159}
160
161/* Swap out a Vernaux structure. */
162
163void
217aa764
AM		 164_bfd_elf_swap_vernaux_out (bfd *abfd,
165 const Elf_Internal_Vernaux *src,
166 Elf_External_Vernaux *dst)
252b5132 167{
dc810e39
AM		 168 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
169 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
170 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
171 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
172 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
252b5132
RH		 173}
174
175/* Swap in a Versym structure. */
176
177void
217aa764
AM		 178_bfd_elf_swap_versym_in (bfd *abfd,
179 const Elf_External_Versym *src,
180 Elf_Internal_Versym *dst)
252b5132 181{
dc810e39 182 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
252b5132
RH		 183}
184
185/* Swap out a Versym structure. */
186
187void
217aa764
AM		 188_bfd_elf_swap_versym_out (bfd *abfd,
189 const Elf_Internal_Versym *src,
190 Elf_External_Versym *dst)
252b5132 191{
dc810e39 192 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
252b5132
RH		 193}
194
195/* Standard ELF hash function. Do not change this function; you will
196 cause invalid hash tables to be generated. */
3a99b017 197
252b5132 198unsigned long
217aa764 199bfd_elf_hash (const char *namearg)
252b5132 200{
3a99b017 201 const unsigned char *name = (const unsigned char *) namearg;
252b5132
RH		 202 unsigned long h = 0;
203 unsigned long g;
204 int ch;
205
206 while ((ch = *name++) != '\0')
207 {
208 h = (h << 4) + ch;
209 if ((g = (h & 0xf0000000)) != 0)
210 {
211 h ^= g >> 24;
212 /* The ELF ABI says `h &= ~g', but this is equivalent in
213 this case and on some machines one insn instead of two. */
214 h ^= g;
215 }
216 }
32dfa85d 217 return h & 0xffffffff;
252b5132
RH		 218}
219
fdc90cb4
JJ		 220/* DT_GNU_HASH hash function. Do not change this function; you will
221 cause invalid hash tables to be generated. */
222
223unsigned long
224bfd_elf_gnu_hash (const char *namearg)
225{
226 const unsigned char *name = (const unsigned char *) namearg;
227 unsigned long h = 5381;
228 unsigned char ch;
229
230 while ((ch = *name++) != '\0')
231 h = (h << 5) + h + ch;
232 return h & 0xffffffff;
233}
234
0c8d6e5c
AM		 235/* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
236 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
b34976b6 237bfd_boolean
0c8d6e5c 238bfd_elf_allocate_object (bfd *abfd,
0ffa91dd 239 size_t object_size,
4dfe6ac6 240 enum elf_target_id object_id)
252b5132 241{
0ffa91dd
NC		 242 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
243 abfd->tdata.any = bfd_zalloc (abfd, object_size);
244 if (abfd->tdata.any == NULL)
245 return FALSE;
252b5132 246
0ffa91dd 247 elf_object_id (abfd) = object_id;
c0355132
AM		 248 if (abfd->direction != read_direction)
249 {
250 struct output_elf_obj_tdata *o = bfd_zalloc (abfd, sizeof *o);
251 if (o == NULL)
252 return FALSE;
253 elf_tdata (abfd)->o = o;
254 elf_program_header_size (abfd) = (bfd_size_type) -1;
255 }
b34976b6 256 return TRUE;
252b5132
RH		 257}
258
0ffa91dd
NC		 259
260bfd_boolean
ae95ffa6 261bfd_elf_make_object (bfd *abfd)
0ffa91dd 262{
ae95ffa6 263 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
0ffa91dd 264 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
ae95ffa6 265 bed->target_id);
0ffa91dd
NC		 266}
267
b34976b6 268bfd_boolean
217aa764 269bfd_elf_mkcorefile (bfd *abfd)
252b5132 270{
c044fabd 271 /* I think this can be done just like an object file. */
228e534f
AM		 272 if (!abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd))
273 return FALSE;
274 elf_tdata (abfd)->core = bfd_zalloc (abfd, sizeof (*elf_tdata (abfd)->core));
275 return elf_tdata (abfd)->core != NULL;
252b5132
RH		 276}
277
72a80a16 278static char *
217aa764 279bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
252b5132
RH		 280{
281 Elf_Internal_Shdr **i_shdrp;
f075ee0c 282 bfd_byte *shstrtab = NULL;
dc810e39
AM		 283 file_ptr offset;
284 bfd_size_type shstrtabsize;
252b5132
RH		 285
286 i_shdrp = elf_elfsections (abfd);
74f2e02b
AM		 287 if (i_shdrp == 0
288 || shindex >= elf_numsections (abfd)
289 || i_shdrp[shindex] == 0)
f075ee0c 290 return NULL;
252b5132 291
f075ee0c 292 shstrtab = i_shdrp[shindex]->contents;
252b5132
RH		 293 if (shstrtab == NULL)
294 {
c044fabd 295 /* No cached one, attempt to read, and cache what we read. */
252b5132
RH		 296 offset = i_shdrp[shindex]->sh_offset;
297 shstrtabsize = i_shdrp[shindex]->sh_size;
c6c60d09
JJ		 298
299 /* Allocate and clear an extra byte at the end, to prevent crashes
300 in case the string table is not terminated. */
3471d59d 301 if (shstrtabsize + 1 <= 1
95a6d235 302 || shstrtabsize > bfd_get_file_size (abfd)
06614111
NC		 303 || bfd_seek (abfd, offset, SEEK_SET) != 0
304 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL)
c6c60d09
JJ		 305 shstrtab = NULL;
306 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
307 {
308 if (bfd_get_error () != bfd_error_system_call)
309 bfd_set_error (bfd_error_file_truncated);
06614111 310 bfd_release (abfd, shstrtab);
c6c60d09 311 shstrtab = NULL;
3471d59d
CC		 312 /* Once we've failed to read it, make sure we don't keep
313 trying. Otherwise, we'll keep allocating space for
314 the string table over and over. */
315 i_shdrp[shindex]->sh_size = 0;
c6c60d09
JJ		 316 }
317 else
318 shstrtab[shstrtabsize] = '\0';
217aa764 319 i_shdrp[shindex]->contents = shstrtab;
252b5132 320 }
f075ee0c 321 return (char *) shstrtab;
252b5132
RH		 322}
323
324char *
217aa764
AM		 325bfd_elf_string_from_elf_section (bfd *abfd,
326 unsigned int shindex,
327 unsigned int strindex)
252b5132
RH		 328{
329 Elf_Internal_Shdr *hdr;
330
331 if (strindex == 0)
332 return "";
333
74f2e02b
AM		 334 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
335 return NULL;
336
252b5132
RH		 337 hdr = elf_elfsections (abfd)[shindex];
338
06614111
NC		 339 if (hdr->contents == NULL)
340 {
341 if (hdr->sh_type != SHT_STRTAB && hdr->sh_type < SHT_LOOS)
342 {
343 /* PR 17512: file: f057ec89. */
695344c0 344 /* xgettext:c-format */
871b3ab2 345 _bfd_error_handler (_("%pB: attempt to load strings from"
63a5468a 346 " a non-string section (number %d)"),
06614111
NC		 347 abfd, shindex);
348 return NULL;
349 }
b1fa9dd6 350
06614111
NC		 351 if (bfd_elf_get_str_section (abfd, shindex) == NULL)
352 return NULL;
353 }
eed5def8
NC		 354 else
355 {
356 /* PR 24273: The string section's contents may have already
357 been loaded elsewhere, eg because a corrupt file has the
358 string section index in the ELF header pointing at a group
359 section. So be paranoid, and test that the last byte of
360 the section is zero. */
361 if (hdr->sh_size == 0 || hdr->contents[hdr->sh_size - 1] != 0)
362 return NULL;
363 }
252b5132
RH		 364
365 if (strindex >= hdr->sh_size)
366 {
1b3a8575 367 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
4eca0228 368 _bfd_error_handler
695344c0 369 /* xgettext:c-format */
2dcf00ce
AM		 370 (_("%pB: invalid string offset %u >= %" PRIu64 " for section `%s'"),
371 abfd, strindex, (uint64_t) hdr->sh_size,
1b3a8575 372 (shindex == shstrndx && strindex == hdr->sh_name
252b5132 373 ? ".shstrtab"
1b3a8575 374 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
45b222d6 375 return NULL;
252b5132
RH		 376 }
377
378 return ((char *) hdr->contents) + strindex;
379}
380
6cdc0ccc
AM		 381/* Read and convert symbols to internal format.
382 SYMCOUNT specifies the number of symbols to read, starting from
383 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
384 are non-NULL, they are used to store the internal symbols, external
b7c368d0
NC		 385 symbols, and symbol section index extensions, respectively.
386 Returns a pointer to the internal symbol buffer (malloced if necessary)
387 or NULL if there were no symbols or some kind of problem. */
6cdc0ccc
AM		 388
389Elf_Internal_Sym *
217aa764
AM		 390bfd_elf_get_elf_syms (bfd *ibfd,
391 Elf_Internal_Shdr *symtab_hdr,
392 size_t symcount,
393 size_t symoffset,
394 Elf_Internal_Sym *intsym_buf,
395 void *extsym_buf,
396 Elf_External_Sym_Shndx *extshndx_buf)
6cdc0ccc
AM		 397{
398 Elf_Internal_Shdr *shndx_hdr;
217aa764 399 void *alloc_ext;
df622259 400 const bfd_byte *esym;
6cdc0ccc
AM		 401 Elf_External_Sym_Shndx *alloc_extshndx;
402 Elf_External_Sym_Shndx *shndx;
4dd07732 403 Elf_Internal_Sym *alloc_intsym;
6cdc0ccc
AM		 404 Elf_Internal_Sym *isym;
405 Elf_Internal_Sym *isymend;
9c5bfbb7 406 const struct elf_backend_data *bed;
6cdc0ccc
AM		 407 size_t extsym_size;
408 bfd_size_type amt;
409 file_ptr pos;
410
e44a2c9c
AM		 411 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
412 abort ();
413
6cdc0ccc
AM		 414 if (symcount == 0)
415 return intsym_buf;
416
417 /* Normal syms might have section extension entries. */
418 shndx_hdr = NULL;
6a40cf0c
NC		 419 if (elf_symtab_shndx_list (ibfd) != NULL)
420 {
421 elf_section_list * entry;
422 Elf_Internal_Shdr **sections = elf_elfsections (ibfd);
423
424 /* Find an index section that is linked to this symtab section. */
425 for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next)
315350be
NC		 426 {
427 /* PR 20063. */
428 if (entry->hdr.sh_link >= elf_numsections (ibfd))
429 continue;
430
431 if (sections[entry->hdr.sh_link] == symtab_hdr)
432 {
433 shndx_hdr = & entry->hdr;
434 break;
435 };
436 }
6a40cf0c
NC		 437
438 if (shndx_hdr == NULL)
439 {
440 if (symtab_hdr == & elf_symtab_hdr (ibfd))
441 /* Not really accurate, but this was how the old code used to work. */
442 shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr;
443 /* Otherwise we do nothing. The assumption is that
444 the index table will not be needed. */
445 }
446 }
6cdc0ccc
AM		 447
448 /* Read the symbols. */
449 alloc_ext = NULL;
450 alloc_extshndx = NULL;
4dd07732 451 alloc_intsym = NULL;
6cdc0ccc
AM		 452 bed = get_elf_backend_data (ibfd);
453 extsym_size = bed->s->sizeof_sym;
ef53be89 454 amt = (bfd_size_type) symcount * extsym_size;
6cdc0ccc
AM		 455 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
456 if (extsym_buf == NULL)
457 {
d0fb9a8d 458 alloc_ext = bfd_malloc2 (symcount, extsym_size);
6cdc0ccc
AM		 459 extsym_buf = alloc_ext;
460 }
461 if (extsym_buf == NULL
462 || bfd_seek (ibfd, pos, SEEK_SET) != 0
463 || bfd_bread (extsym_buf, amt, ibfd) != amt)
464 {
465 intsym_buf = NULL;
466 goto out;
467 }
468
469 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
470 extshndx_buf = NULL;
471 else
472 {
ef53be89 473 amt = (bfd_size_type) symcount * sizeof (Elf_External_Sym_Shndx);
6cdc0ccc
AM		 474 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
475 if (extshndx_buf == NULL)
476 {
a50b1753 477 alloc_extshndx = (Elf_External_Sym_Shndx *)
07d6d2b8 478 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
6cdc0ccc
AM		 479 extshndx_buf = alloc_extshndx;
480 }
481 if (extshndx_buf == NULL
482 || bfd_seek (ibfd, pos, SEEK_SET) != 0
483 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
484 {
485 intsym_buf = NULL;
486 goto out;
487 }
488 }
489
490 if (intsym_buf == NULL)
491 {
a50b1753 492 alloc_intsym = (Elf_Internal_Sym *)
07d6d2b8 493 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
4dd07732 494 intsym_buf = alloc_intsym;
6cdc0ccc
AM		 495 if (intsym_buf == NULL)
496 goto out;
497 }
498
499 /* Convert the symbols to internal form. */
500 isymend = intsym_buf + symcount;
a50b1753 501 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
07d6d2b8 502 shndx = extshndx_buf;
6cdc0ccc
AM		 503 isym < isymend;
504 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
8384fb8f
AM		 505 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
506 {
507 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
695344c0 508 /* xgettext:c-format */
871b3ab2 509 _bfd_error_handler (_("%pB symbol number %lu references"
63a5468a 510 " nonexistent SHT_SYMTAB_SHNDX section"),
4eca0228 511 ibfd, (unsigned long) symoffset);
4dd07732
AM		 512 if (alloc_intsym != NULL)
513 free (alloc_intsym);
8384fb8f
AM		 514 intsym_buf = NULL;
515 goto out;
516 }
6cdc0ccc
AM		 517
518 out:
519 if (alloc_ext != NULL)
520 free (alloc_ext);
521 if (alloc_extshndx != NULL)
522 free (alloc_extshndx);
523
524 return intsym_buf;
525}
526
5cab59f6
AM		 527/* Look up a symbol name. */
528const char *
be8dd2ca
AM		 529bfd_elf_sym_name (bfd *abfd,
530 Elf_Internal_Shdr *symtab_hdr,
26c61ae5
L		 531 Elf_Internal_Sym *isym,
532 asection *sym_sec)
5cab59f6 533{
26c61ae5 534 const char *name;
5cab59f6 535 unsigned int iname = isym->st_name;
be8dd2ca 536 unsigned int shindex = symtab_hdr->sh_link;
26c61ae5 537
138f35cc
JJ		 538 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
539 /* Check for a bogus st_shndx to avoid crashing. */
4fbb74a6 540 && isym->st_shndx < elf_numsections (abfd))
5cab59f6
AM		 541 {
542 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
543 shindex = elf_elfheader (abfd)->e_shstrndx;
544 }
545
26c61ae5
L		 546 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
547 if (name == NULL)
548 name = "(null)";
549 else if (sym_sec && *name == '\0')
550 name = bfd_section_name (abfd, sym_sec);
551
552 return name;
5cab59f6
AM		 553}
554
dbb410c3
AM		 555/* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
556 sections. The first element is the flags, the rest are section
557 pointers. */
558
559typedef union elf_internal_group {
560 Elf_Internal_Shdr *shdr;
561 unsigned int flags;
562} Elf_Internal_Group;
563
b885599b
AM		 564/* Return the name of the group signature symbol. Why isn't the
565 signature just a string? */
566
567static const char *
217aa764 568group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
b885599b 569{
9dce4196 570 Elf_Internal_Shdr *hdr;
9dce4196
AM		 571 unsigned char esym[sizeof (Elf64_External_Sym)];
572 Elf_External_Sym_Shndx eshndx;
573 Elf_Internal_Sym isym;
b885599b 574
13792e9d
L		 575 /* First we need to ensure the symbol table is available. Make sure
576 that it is a symbol table section. */
4fbb74a6
AM		 577 if (ghdr->sh_link >= elf_numsections (abfd))
578 return NULL;
13792e9d
L		 579 hdr = elf_elfsections (abfd) [ghdr->sh_link];
580 if (hdr->sh_type != SHT_SYMTAB
581 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
b885599b
AM		 582 return NULL;
583
9dce4196
AM		 584 /* Go read the symbol. */
585 hdr = &elf_tdata (abfd)->symtab_hdr;
6cdc0ccc
AM		 586 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
587 &isym, esym, &eshndx) == NULL)
b885599b 588 return NULL;
9dce4196 589
26c61ae5 590 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
b885599b
AM		 591}
592
dbb410c3
AM		 593/* Set next_in_group list pointer, and group name for NEWSECT. */
594
b34976b6 595static bfd_boolean
217aa764 596setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
dbb410c3
AM		 597{
598 unsigned int num_group = elf_tdata (abfd)->num_group;
599
600 /* If num_group is zero, read in all SHT_GROUP sections. The count
601 is set to -1 if there are no SHT_GROUP sections. */
602 if (num_group == 0)
603 {
604 unsigned int i, shnum;
605
606 /* First count the number of groups. If we have a SHT_GROUP
607 section with just a flag word (ie. sh_size is 4), ignore it. */
9ad5cbcf 608 shnum = elf_numsections (abfd);
dbb410c3 609 num_group = 0;
08a40648 610
44534af3 611#define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
1783205a 612 ( (shdr)->sh_type == SHT_GROUP \
44534af3 613 && (shdr)->sh_size >= minsize \
1783205a
NC		 614 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
615 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
08a40648 616
dbb410c3
AM		 617 for (i = 0; i < shnum; i++)
618 {
619 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
1783205a 620
44534af3 621 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
dbb410c3
AM		 622 num_group += 1;
623 }
624
625 if (num_group == 0)
20dbb49d
L		 626 {
627 num_group = (unsigned) -1;
628 elf_tdata (abfd)->num_group = num_group;
ce497010 629 elf_tdata (abfd)->group_sect_ptr = NULL;
20dbb49d
L		 630 }
631 else
dbb410c3
AM		 632 {
633 /* We keep a list of elf section headers for group sections,
634 so we can find them quickly. */
20dbb49d 635 bfd_size_type amt;
d0fb9a8d 636
20dbb49d 637 elf_tdata (abfd)->num_group = num_group;
a50b1753 638 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
07d6d2b8 639 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
dbb410c3 640 if (elf_tdata (abfd)->group_sect_ptr == NULL)
b34976b6 641 return FALSE;
4bba0fb1
AM		 642 memset (elf_tdata (abfd)->group_sect_ptr, 0,
643 num_group * sizeof (Elf_Internal_Shdr *));
dbb410c3 644 num_group = 0;
ce497010 645
dbb410c3
AM		 646 for (i = 0; i < shnum; i++)
647 {
648 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
1783205a 649
44534af3 650 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
dbb410c3 651 {
973ffd63 652 unsigned char *src;
dbb410c3
AM		 653 Elf_Internal_Group *dest;
654
07d6d2b8
AM		 655 /* Make sure the group section has a BFD section
656 attached to it. */
657 if (!bfd_section_from_shdr (abfd, i))
658 return FALSE;
659
dbb410c3
AM		 660 /* Add to list of sections. */
661 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
662 num_group += 1;
663
664 /* Read the raw contents. */
665 BFD_ASSERT (sizeof (*dest) >= 4);
666 amt = shdr->sh_size * sizeof (*dest) / 4;
a50b1753 667 shdr->contents = (unsigned char *)
eed5def8 668 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
1783205a
NC		 669 /* PR binutils/4110: Handle corrupt group headers. */
670 if (shdr->contents == NULL)
671 {
672 _bfd_error_handler
695344c0 673 /* xgettext:c-format */
871b3ab2 674 (_("%pB: corrupt size field in group section"
2dcf00ce
AM		 675 " header: %#" PRIx64),
676 abfd, (uint64_t) shdr->sh_size);
1783205a 677 bfd_set_error (bfd_error_bad_value);
493a3386
NC		 678 -- num_group;
679 continue;
1783205a
NC		 680 }
681
682 memset (shdr->contents, 0, amt);
683
684 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
dbb410c3
AM		 685 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
686 != shdr->sh_size))
493a3386
NC		 687 {
688 _bfd_error_handler
695344c0 689 /* xgettext:c-format */
871b3ab2 690 (_("%pB: invalid size field in group section"
2dcf00ce
AM		 691 " header: %#" PRIx64 ""),
692 abfd, (uint64_t) shdr->sh_size);
493a3386
NC		 693 bfd_set_error (bfd_error_bad_value);
694 -- num_group;
63a5468a
AM		 695 /* PR 17510: If the group contents are even
696 partially corrupt, do not allow any of the
697 contents to be used. */
493a3386
NC		 698 memset (shdr->contents, 0, amt);
699 continue;
700 }
708d7d0d 701
dbb410c3
AM		 702 /* Translate raw contents, a flag word followed by an
703 array of elf section indices all in target byte order,
704 to the flag word followed by an array of elf section
705 pointers. */
706 src = shdr->contents + shdr->sh_size;
707 dest = (Elf_Internal_Group *) (shdr->contents + amt);
06614111 708
dbb410c3
AM		 709 while (1)
710 {
711 unsigned int idx;
712
713 src -= 4;
714 --dest;
715 idx = H_GET_32 (abfd, src);
716 if (src == shdr->contents)
717 {
718 dest->flags = idx;
b885599b
AM		 719 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
720 shdr->bfd_section->flags
721 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
dbb410c3
AM		 722 break;
723 }
4bba0fb1 724 if (idx < shnum)
bae363f1
L		 725 {
726 dest->shdr = elf_elfsections (abfd)[idx];
727 /* PR binutils/23199: All sections in a
728 section group should be marked with
729 SHF_GROUP. But some tools generate
730 broken objects without SHF_GROUP. Fix
731 them up here. */
732 dest->shdr->sh_flags |= SHF_GROUP;
733 }
4bba0fb1
AM		 734 if (idx >= shnum
735 || dest->shdr->sh_type == SHT_GROUP)
dbb410c3 736 {
4eca0228 737 _bfd_error_handler
4bba0fb1
AM		 738 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
739 abfd, i);
740 dest->shdr = NULL;
dbb410c3 741 }
dbb410c3
AM		 742 }
743 }
744 }
493a3386
NC		 745
746 /* PR 17510: Corrupt binaries might contain invalid groups. */
747 if (num_group != (unsigned) elf_tdata (abfd)->num_group)
748 {
749 elf_tdata (abfd)->num_group = num_group;
750
751 /* If all groups are invalid then fail. */
752 if (num_group == 0)
753 {
754 elf_tdata (abfd)->group_sect_ptr = NULL;
755 elf_tdata (abfd)->num_group = num_group = -1;
4eca0228 756 _bfd_error_handler
871b3ab2 757 (_("%pB: no valid group sections found"), abfd);
493a3386
NC		 758 bfd_set_error (bfd_error_bad_value);
759 }
760 }
dbb410c3
AM		 761 }
762 }
763
764 if (num_group != (unsigned) -1)
765 {
564e11c9
JW		 766 unsigned int search_offset = elf_tdata (abfd)->group_search_offset;
767 unsigned int j;
dbb410c3 768
564e11c9 769 for (j = 0; j < num_group; j++)
dbb410c3 770 {
564e11c9
JW		 771 /* Begin search from previous found group. */
772 unsigned i = (j + search_offset) % num_group;
773
dbb410c3 774 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
ce497010 775 Elf_Internal_Group *idx;
0c54f692 776 bfd_size_type n_elt;
ce497010
NC		 777
778 if (shdr == NULL)
779 continue;
780
781 idx = (Elf_Internal_Group *) shdr->contents;
0c54f692
NC		 782 if (idx == NULL || shdr->sh_size < 4)
783 {
784 /* See PR 21957 for a reproducer. */
785 /* xgettext:c-format */
871b3ab2 786 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
0c54f692
NC		 787 abfd, shdr->bfd_section);
788 elf_tdata (abfd)->group_sect_ptr[i] = NULL;
789 bfd_set_error (bfd_error_bad_value);
790 return FALSE;
791 }
ce497010 792 n_elt = shdr->sh_size / 4;
dbb410c3
AM		 793
794 /* Look through this group's sections to see if current
795 section is a member. */
796 while (--n_elt != 0)
797 if ((++idx)->shdr == hdr)
798 {
e0e8c97f 799 asection *s = NULL;
dbb410c3
AM		 800
801 /* We are a member of this group. Go looking through
802 other members to see if any others are linked via
803 next_in_group. */
804 idx = (Elf_Internal_Group *) shdr->contents;
805 n_elt = shdr->sh_size / 4;
806 while (--n_elt != 0)
4bba0fb1
AM		 807 if ((++idx)->shdr != NULL
808 && (s = idx->shdr->bfd_section) != NULL
945906ff 809 && elf_next_in_group (s) != NULL)
dbb410c3
AM		 810 break;
811 if (n_elt != 0)
812 {
dbb410c3
AM		 813 /* Snarf the group name from other member, and
814 insert current section in circular list. */
945906ff
AM		 815 elf_group_name (newsect) = elf_group_name (s);
816 elf_next_in_group (newsect) = elf_next_in_group (s);
817 elf_next_in_group (s) = newsect;
dbb410c3
AM		 818 }
819 else
820 {
dbb410c3
AM		 821 const char *gname;
822
b885599b
AM		 823 gname = group_signature (abfd, shdr);
824 if (gname == NULL)
b34976b6 825 return FALSE;
945906ff 826 elf_group_name (newsect) = gname;
dbb410c3
AM		 827
828 /* Start a circular list with one element. */
945906ff 829 elf_next_in_group (newsect) = newsect;
dbb410c3 830 }
b885599b 831
9dce4196
AM		 832 /* If the group section has been created, point to the
833 new member. */
dbb410c3 834 if (shdr->bfd_section != NULL)
945906ff 835 elf_next_in_group (shdr->bfd_section) = newsect;
b885599b 836
564e11c9
JW		 837 elf_tdata (abfd)->group_search_offset = i;
838 j = num_group - 1;
dbb410c3
AM		 839 break;
840 }
841 }
842 }
843
945906ff 844 if (elf_group_name (newsect) == NULL)
dbb410c3 845 {
695344c0 846 /* xgettext:c-format */
871b3ab2 847 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
4eca0228 848 abfd, newsect);
493a3386 849 return FALSE;
dbb410c3 850 }
b34976b6 851 return TRUE;
dbb410c3
AM		 852}
853
3d7f7666 854bfd_boolean
dd863624 855_bfd_elf_setup_sections (bfd *abfd)
3d7f7666
L		 856{
857 unsigned int i;
858 unsigned int num_group = elf_tdata (abfd)->num_group;
859 bfd_boolean result = TRUE;
dd863624
L		 860 asection *s;
861
862 /* Process SHF_LINK_ORDER. */
863 for (s = abfd->sections; s != NULL; s = s->next)
864 {
865 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
866 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
867 {
868 unsigned int elfsec = this_hdr->sh_link;
869 /* FIXME: The old Intel compiler and old strip/objcopy may
870 not set the sh_link or sh_info fields. Hence we could
871 get the situation where elfsec is 0. */
872 if (elfsec == 0)
873 {
4fbb74a6 874 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
dd863624
L		 875 if (bed->link_order_error_handler)
876 bed->link_order_error_handler
695344c0 877 /* xgettext:c-format */
871b3ab2 878 (_("%pB: warning: sh_link not set for section `%pA'"),
dd863624
L		 879 abfd, s);
880 }
881 else
882 {
91d6fa6a 883 asection *linksec = NULL;
25bbc984 884
4fbb74a6
AM		 885 if (elfsec < elf_numsections (abfd))
886 {
887 this_hdr = elf_elfsections (abfd)[elfsec];
91d6fa6a 888 linksec = this_hdr->bfd_section;
4fbb74a6 889 }
25bbc984
L		 890
891 /* PR 1991, 2008:
892 Some strip/objcopy may leave an incorrect value in
893 sh_link. We don't want to proceed. */
91d6fa6a 894 if (linksec == NULL)
25bbc984 895 {
4eca0228 896 _bfd_error_handler
695344c0 897 /* xgettext:c-format */
871b3ab2 898 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
c08bb8dd 899 s->owner, elfsec, s);
25bbc984
L		 900 result = FALSE;
901 }
902
91d6fa6a 903 elf_linked_to_section (s) = linksec;
dd863624
L		 904 }
905 }
53720c49
AM		 906 else if (this_hdr->sh_type == SHT_GROUP
907 && elf_next_in_group (s) == NULL)
908 {
4eca0228 909 _bfd_error_handler
695344c0 910 /* xgettext:c-format */
871b3ab2 911 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
53720c49
AM		 912 abfd, elf_section_data (s)->this_idx);
913 result = FALSE;
914 }
dd863624 915 }
3d7f7666 916
dd863624 917 /* Process section groups. */
3d7f7666
L		 918 if (num_group == (unsigned) -1)
919 return result;
920
921 for (i = 0; i < num_group; i++)
922 {
923 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
4b0e8a5f
NC		 924 Elf_Internal_Group *idx;
925 unsigned int n_elt;
3d7f7666 926
4b0e8a5f
NC		 927 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
928 if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
929 {
4eca0228 930 _bfd_error_handler
695344c0 931 /* xgettext:c-format */
871b3ab2 932 (_("%pB: section group entry number %u is corrupt"),
4b0e8a5f
NC		 933 abfd, i);
934 result = FALSE;
935 continue;
936 }
937
938 idx = (Elf_Internal_Group *) shdr->contents;
939 n_elt = shdr->sh_size / 4;
1b786873 940
3d7f7666 941 while (--n_elt != 0)
24d3e51b
NC		 942 {
943 ++ idx;
944
945 if (idx->shdr == NULL)
946 continue;
947 else if (idx->shdr->bfd_section)
948 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
db4677b8
AM		 949 else if (idx->shdr->sh_type != SHT_RELA
950 && idx->shdr->sh_type != SHT_REL)
24d3e51b
NC		 951 {
952 /* There are some unknown sections in the group. */
953 _bfd_error_handler
954 /* xgettext:c-format */
871b3ab2 955 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
24d3e51b
NC		 956 abfd,
957 idx->shdr->sh_type,
958 bfd_elf_string_from_elf_section (abfd,
959 (elf_elfheader (abfd)
960 ->e_shstrndx),
961 idx->shdr->sh_name),
962 shdr->bfd_section);
963 result = FALSE;
964 }
965 }
3d7f7666 966 }
24d3e51b 967
3d7f7666
L		 968 return result;
969}
970
72adc230
AM		 971bfd_boolean
972bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
973{
974 return elf_next_in_group (sec) != NULL;
975}
976
f6fe1ccd
L		 977static char *
978convert_debug_to_zdebug (bfd *abfd, const char *name)
979{
980 unsigned int len = strlen (name);
981 char *new_name = bfd_alloc (abfd, len + 2);
982 if (new_name == NULL)
983 return NULL;
984 new_name[0] = '.';
985 new_name[1] = 'z';
986 memcpy (new_name + 2, name + 1, len);
987 return new_name;
988}
989
990static char *
991convert_zdebug_to_debug (bfd *abfd, const char *name)
992{
993 unsigned int len = strlen (name);
994 char *new_name = bfd_alloc (abfd, len);
995 if (new_name == NULL)
996 return NULL;
997 new_name[0] = '.';
998 memcpy (new_name + 1, name + 2, len - 1);
999 return new_name;
1000}
1001
252b5132
RH		 1002/* Make a BFD section from an ELF section. We store a pointer to the
1003 BFD section in the bfd_section field of the header. */
1004
b34976b6 1005bfd_boolean
217aa764
AM		 1006_bfd_elf_make_section_from_shdr (bfd *abfd,
1007 Elf_Internal_Shdr *hdr,
6dc132d9
L		 1008 const char *name,
1009 int shindex)
252b5132
RH		 1010{
1011 asection *newsect;
1012 flagword flags;
9c5bfbb7 1013 const struct elf_backend_data *bed;
252b5132
RH		 1014
1015 if (hdr->bfd_section != NULL)
4e011fb5 1016 return TRUE;
252b5132
RH		 1017
1018 newsect = bfd_make_section_anyway (abfd, name);
1019 if (newsect == NULL)
b34976b6 1020 return FALSE;
252b5132 1021
1829f4b2
AM		 1022 hdr->bfd_section = newsect;
1023 elf_section_data (newsect)->this_hdr = *hdr;
6dc132d9 1024 elf_section_data (newsect)->this_idx = shindex;
1829f4b2 1025
2f89ff8d
L		 1026 /* Always use the real type/flags. */
1027 elf_section_type (newsect) = hdr->sh_type;
1028 elf_section_flags (newsect) = hdr->sh_flags;
1029
252b5132
RH		 1030 newsect->filepos = hdr->sh_offset;
1031
1032 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
1033 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
1034 || ! bfd_set_section_alignment (abfd, newsect,
72de5009 1035 bfd_log2 (hdr->sh_addralign)))
b34976b6 1036 return FALSE;
252b5132
RH		 1037
1038 flags = SEC_NO_FLAGS;
1039 if (hdr->sh_type != SHT_NOBITS)
1040 flags |= SEC_HAS_CONTENTS;
dbb410c3 1041 if (hdr->sh_type == SHT_GROUP)
7bdf4127 1042 flags |= SEC_GROUP;
252b5132
RH		 1043 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1044 {
1045 flags |= SEC_ALLOC;
1046 if (hdr->sh_type != SHT_NOBITS)
1047 flags |= SEC_LOAD;
1048 }
1049 if ((hdr->sh_flags & SHF_WRITE) == 0)
1050 flags |= SEC_READONLY;
1051 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1052 flags |= SEC_CODE;
1053 else if ((flags & SEC_LOAD) != 0)
1054 flags |= SEC_DATA;
f5fa8ca2
JJ		 1055 if ((hdr->sh_flags & SHF_MERGE) != 0)
1056 {
1057 flags |= SEC_MERGE;
1058 newsect->entsize = hdr->sh_entsize;
f5fa8ca2 1059 }
84865015
NC		 1060 if ((hdr->sh_flags & SHF_STRINGS) != 0)
1061 flags |= SEC_STRINGS;
dbb410c3
AM		 1062 if (hdr->sh_flags & SHF_GROUP)
1063 if (!setup_group (abfd, hdr, newsect))
b34976b6 1064 return FALSE;
13ae64f3
JJ		 1065 if ((hdr->sh_flags & SHF_TLS) != 0)
1066 flags |= SEC_THREAD_LOCAL;
18ae9cc1
L		 1067 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
1068 flags |= SEC_EXCLUDE;
252b5132 1069
3d2b39cf 1070 if ((flags & SEC_ALLOC) == 0)
7a6cc5fb 1071 {
3d2b39cf
L		 1072 /* The debugging sections appear to be recognized only by name,
1073 not any sort of flag. Their SEC_ALLOC bits are cleared. */
3d2b39cf
L		 1074 if (name [0] == '.')
1075 {
f073ced3
AM		 1076 const char *p;
1077 int n;
1078 if (name[1] == 'd')
1079 p = ".debug", n = 6;
1080 else if (name[1] == 'g' && name[2] == 'n')
1081 p = ".gnu.linkonce.wi.", n = 17;
1082 else if (name[1] == 'g' && name[2] == 'd')
1083 p = ".gdb_index", n = 11; /* yes we really do mean 11. */
1084 else if (name[1] == 'l')
1085 p = ".line", n = 5;
1086 else if (name[1] == 's')
1087 p = ".stab", n = 5;
1088 else if (name[1] == 'z')
1089 p = ".zdebug", n = 7;
1090 else
1091 p = NULL, n = 0;
1092 if (p != NULL && strncmp (name, p, n) == 0)
3d2b39cf
L		 1093 flags |= SEC_DEBUGGING;
1094 }
1095 }
252b5132
RH		 1096
1097 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1098 only link a single copy of the section. This is used to support
1099 g++. g++ will emit each template expansion in its own section.
1100 The symbols will be defined as weak, so that multiple definitions
1101 are permitted. The GNU linker extension is to actually discard
1102 all but one of the sections. */
0112cd26 1103 if (CONST_STRNEQ (name, ".gnu.linkonce")
b885599b 1104 && elf_next_in_group (newsect) == NULL)
252b5132
RH		 1105 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1106
fa152c49
JW		 1107 bed = get_elf_backend_data (abfd);
1108 if (bed->elf_backend_section_flags)
1109 if (! bed->elf_backend_section_flags (&flags, hdr))
b34976b6 1110 return FALSE;
fa152c49 1111
252b5132 1112 if (! bfd_set_section_flags (abfd, newsect, flags))
b34976b6 1113 return FALSE;
252b5132 1114
718175fa
JK		 1115 /* We do not parse the PT_NOTE segments as we are interested even in the
1116 separate debug info files which may have the segments offsets corrupted.
1117 PT_NOTEs from the core files are currently not parsed using BFD. */
1118 if (hdr->sh_type == SHT_NOTE)
1119 {
baea7ef1 1120 bfd_byte *contents;
718175fa 1121
baea7ef1 1122 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
718175fa
JK		 1123 return FALSE;
1124
276da9b3
L		 1125 elf_parse_notes (abfd, (char *) contents, hdr->sh_size,
1126 hdr->sh_offset, hdr->sh_addralign);
718175fa
JK		 1127 free (contents);
1128 }
1129
252b5132
RH		 1130 if ((flags & SEC_ALLOC) != 0)
1131 {
1132 Elf_Internal_Phdr *phdr;
6ffd7900
AM		 1133 unsigned int i, nload;
1134
1135 /* Some ELF linkers produce binaries with all the program header
1136 p_paddr fields zero. If we have such a binary with more than
1137 one PT_LOAD header, then leave the section lma equal to vma
1138 so that we don't create sections with overlapping lma. */
1139 phdr = elf_tdata (abfd)->phdr;
1140 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1141 if (phdr->p_paddr != 0)
1142 break;
1143 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
1144 ++nload;
1145 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
1146 return TRUE;
252b5132 1147
252b5132
RH		 1148 phdr = elf_tdata (abfd)->phdr;
1149 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1150 {
86b2281f
AM		 1151 if (((phdr->p_type == PT_LOAD
1152 && (hdr->sh_flags & SHF_TLS) == 0)
1153 || phdr->p_type == PT_TLS)
9a83a553 1154 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
252b5132 1155 {
88967714
AM		 1156 if ((flags & SEC_LOAD) == 0)
1157 newsect->lma = (phdr->p_paddr
1158 + hdr->sh_addr - phdr->p_vaddr);
1159 else
1160 /* We used to use the same adjustment for SEC_LOAD
1161 sections, but that doesn't work if the segment
1162 is packed with code from multiple VMAs.
1163 Instead we calculate the section LMA based on
1164 the segment LMA. It is assumed that the
1165 segment will contain sections with contiguous
1166 LMAs, even if the VMAs are not. */
1167 newsect->lma = (phdr->p_paddr
1168 + hdr->sh_offset - phdr->p_offset);
1169
1170 /* With contiguous segments, we can't tell from file
1171 offsets whether a section with zero size should
1172 be placed at the end of one segment or the
1173 beginning of the next. Decide based on vaddr. */
1174 if (hdr->sh_addr >= phdr->p_vaddr
1175 && (hdr->sh_addr + hdr->sh_size
1176 <= phdr->p_vaddr + phdr->p_memsz))
1177 break;
252b5132
RH		 1178 }
1179 }
1180 }
1181
4a114e3e
L		 1182 /* Compress/decompress DWARF debug sections with names: .debug_* and
1183 .zdebug_*, after the section flags is set. */
1184 if ((flags & SEC_DEBUGGING)
1185 && ((name[1] == 'd' && name[6] == '_')
1186 || (name[1] == 'z' && name[7] == '_')))
1187 {
1188 enum { nothing, compress, decompress } action = nothing;
151411f8 1189 int compression_header_size;
dab394de 1190 bfd_size_type uncompressed_size;
4207142d 1191 unsigned int uncompressed_align_power;
151411f8
L		 1192 bfd_boolean compressed
1193 = bfd_is_section_compressed_with_header (abfd, newsect,
dab394de 1194 &compression_header_size,
4207142d
MW		 1195 &uncompressed_size,
1196 &uncompressed_align_power);
151411f8 1197 if (compressed)
4a114e3e
L		 1198 {
1199 /* Compressed section. Check if we should decompress. */
1200 if ((abfd->flags & BFD_DECOMPRESS))
1201 action = decompress;
1202 }
151411f8
L		 1203
1204 /* Compress the uncompressed section or convert from/to .zdebug*
1205 section. Check if we should compress. */
1206 if (action == nothing)
4a114e3e 1207 {
151411f8
L		 1208 if (newsect->size != 0
1209 && (abfd->flags & BFD_COMPRESS)
1210 && compression_header_size >= 0
dab394de 1211 && uncompressed_size > 0
151411f8
L		 1212 && (!compressed
1213 || ((compression_header_size > 0)
1214 != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
4a114e3e 1215 action = compress;
151411f8
L		 1216 else
1217 return TRUE;
4a114e3e
L		 1218 }
1219
151411f8 1220 if (action == compress)
4a114e3e 1221 {
4a114e3e
L		 1222 if (!bfd_init_section_compress_status (abfd, newsect))
1223 {
4eca0228 1224 _bfd_error_handler
695344c0 1225 /* xgettext:c-format */
871b3ab2 1226 (_("%pB: unable to initialize compress status for section %s"),
4a114e3e
L		 1227 abfd, name);
1228 return FALSE;
1229 }
151411f8
L		 1230 }
1231 else
1232 {
4a114e3e
L		 1233 if (!bfd_init_section_decompress_status (abfd, newsect))
1234 {
4eca0228 1235 _bfd_error_handler
695344c0 1236 /* xgettext:c-format */
871b3ab2 1237 (_("%pB: unable to initialize decompress status for section %s"),
4a114e3e
L		 1238 abfd, name);
1239 return FALSE;
1240 }
151411f8
L		 1241 }
1242
f6fe1ccd 1243 if (abfd->is_linker_input)
151411f8 1244 {
f6fe1ccd
L		 1245 if (name[1] == 'z'
1246 && (action == decompress
1247 || (action == compress
1248 && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
4e011fb5 1249 {
f6fe1ccd
L		 1250 /* Convert section name from .zdebug_* to .debug_* so
1251 that linker will consider this section as a debug
1252 section. */
1253 char *new_name = convert_zdebug_to_debug (abfd, name);
151411f8
L		 1254 if (new_name == NULL)
1255 return FALSE;
f6fe1ccd 1256 bfd_rename_section (abfd, newsect, new_name);
151411f8 1257 }
4a114e3e 1258 }
f6fe1ccd
L		 1259 else
1260 /* For objdump, don't rename the section. For objcopy, delay
1261 section rename to elf_fake_sections. */
1262 newsect->flags |= SEC_ELF_RENAME;
4a114e3e
L		 1263 }
1264
b34976b6 1265 return TRUE;
252b5132
RH		 1266}
1267
84865015
NC		 1268const char *const bfd_elf_section_type_names[] =
1269{
252b5132
RH		 1270 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1271 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1272 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1273};
1274
1049f94e 1275/* ELF relocs are against symbols. If we are producing relocatable
252b5132
RH		 1276 output, and the reloc is against an external symbol, and nothing
1277 has given us any additional addend, the resulting reloc will also
1278 be against the same symbol. In such a case, we don't want to
1279 change anything about the way the reloc is handled, since it will
1280 all be done at final link time. Rather than put special case code
1281 into bfd_perform_relocation, all the reloc types use this howto
1282 function. It just short circuits the reloc if producing
1049f94e 1283 relocatable output against an external symbol. */
252b5132 1284
252b5132 1285bfd_reloc_status_type
217aa764
AM		 1286bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1287 arelent *reloc_entry,
1288 asymbol *symbol,
1289 void *data ATTRIBUTE_UNUSED,
1290 asection *input_section,
1291 bfd *output_bfd,
1292 char **error_message ATTRIBUTE_UNUSED)
1293{
1294 if (output_bfd != NULL
252b5132
RH		 1295 && (symbol->flags & BSF_SECTION_SYM) == 0
1296 && (! reloc_entry->howto->partial_inplace
1297 || reloc_entry->addend == 0))
1298 {
1299 reloc_entry->address += input_section->output_offset;
1300 return bfd_reloc_ok;
1301 }
1302
1303 return bfd_reloc_continue;
1304}
1305\f
84865015
NC		 1306/* Returns TRUE if section A matches section B.
1307 Names, addresses and links may be different, but everything else
1308 should be the same. */
1309
1310static bfd_boolean
5522f910
NC		 1311section_match (const Elf_Internal_Shdr * a,
1312 const Elf_Internal_Shdr * b)
84865015 1313{
ac85e67c
AM		 1314 if (a->sh_type != b->sh_type
1315 || ((a->sh_flags ^ b->sh_flags) & ~SHF_INFO_LINK) != 0
1316 || a->sh_addralign != b->sh_addralign
1317 || a->sh_entsize != b->sh_entsize)
1318 return FALSE;
1319 if (a->sh_type == SHT_SYMTAB
1320 || a->sh_type == SHT_STRTAB)
1321 return TRUE;
1322 return a->sh_size == b->sh_size;
84865015
NC		 1323}
1324
1325/* Find a section in OBFD that has the same characteristics
1326 as IHEADER. Return the index of this section or SHN_UNDEF if
1327 none can be found. Check's section HINT first, as this is likely
1328 to be the correct section. */
1329
1330static unsigned int
5cc4ca83
ST		 1331find_link (const bfd *obfd, const Elf_Internal_Shdr *iheader,
1332 const unsigned int hint)
84865015
NC		 1333{
1334 Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
1335 unsigned int i;
1336
a55c9876
NC		 1337 BFD_ASSERT (iheader != NULL);
1338
1339 /* See PR 20922 for a reproducer of the NULL test. */
5cc4ca83
ST		 1340 if (hint < elf_numsections (obfd)
1341 && oheaders[hint] != NULL
a55c9876 1342 && section_match (oheaders[hint], iheader))
84865015
NC		 1343 return hint;
1344
1345 for (i = 1; i < elf_numsections (obfd); i++)
1346 {
1347 Elf_Internal_Shdr * oheader = oheaders[i];
1348
a55c9876
NC		 1349 if (oheader == NULL)
1350 continue;
84865015
NC		 1351 if (section_match (oheader, iheader))
1352 /* FIXME: Do we care if there is a potential for
1353 multiple matches ? */
1354 return i;
1355 }
1356
1357 return SHN_UNDEF;
1358}
1359
5522f910
NC		 1360/* PR 19938: Attempt to set the ELF section header fields of an OS or
1361 Processor specific section, based upon a matching input section.
1362 Returns TRUE upon success, FALSE otherwise. */
07d6d2b8 1363
5522f910
NC		 1364static bfd_boolean
1365copy_special_section_fields (const bfd *ibfd,
1366 bfd *obfd,
1367 const Elf_Internal_Shdr *iheader,
1368 Elf_Internal_Shdr *oheader,
1369 const unsigned int secnum)
1370{
1371 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
1372 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1373 bfd_boolean changed = FALSE;
1374 unsigned int sh_link;
1375
1376 if (oheader->sh_type == SHT_NOBITS)
1377 {
1378 /* This is a feature for objcopy --only-keep-debug:
1379 When a section's type is changed to NOBITS, we preserve
1380 the sh_link and sh_info fields so that they can be
1381 matched up with the original.
1382
1383 Note: Strictly speaking these assignments are wrong.
1384 The sh_link and sh_info fields should point to the
1385 relevent sections in the output BFD, which may not be in
1386 the same location as they were in the input BFD. But
1387 the whole point of this action is to preserve the
1388 original values of the sh_link and sh_info fields, so
1389 that they can be matched up with the section headers in
1390 the original file. So strictly speaking we may be
1391 creating an invalid ELF file, but it is only for a file
1392 that just contains debug info and only for sections
1393 without any contents. */
1394 if (oheader->sh_link == 0)
1395 oheader->sh_link = iheader->sh_link;
1396 if (oheader->sh_info == 0)
1397 oheader->sh_info = iheader->sh_info;
1398 return TRUE;
1399 }
1400
1401 /* Allow the target a chance to decide how these fields should be set. */
1402 if (bed->elf_backend_copy_special_section_fields != NULL
1403 && bed->elf_backend_copy_special_section_fields
1404 (ibfd, obfd, iheader, oheader))
1405 return TRUE;
1406
1407 /* We have an iheader which might match oheader, and which has non-zero
1408 sh_info and/or sh_link fields. Attempt to follow those links and find
1409 the section in the output bfd which corresponds to the linked section
1410 in the input bfd. */
1411 if (iheader->sh_link != SHN_UNDEF)
1412 {
4f3ca05b
NC		 1413 /* See PR 20931 for a reproducer. */
1414 if (iheader->sh_link >= elf_numsections (ibfd))
1415 {
76cfced5 1416 _bfd_error_handler
4f3ca05b 1417 /* xgettext:c-format */
9793eb77 1418 (_("%pB: invalid sh_link field (%d) in section number %d"),
4f3ca05b
NC		 1419 ibfd, iheader->sh_link, secnum);
1420 return FALSE;
1421 }
1422
5522f910
NC		 1423 sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
1424 if (sh_link != SHN_UNDEF)
1425 {
1426 oheader->sh_link = sh_link;
1427 changed = TRUE;
1428 }
1429 else
1430 /* FIXME: Should we install iheader->sh_link
1431 if we could not find a match ? */
76cfced5 1432 _bfd_error_handler
695344c0 1433 /* xgettext:c-format */
9793eb77 1434 (_("%pB: failed to find link section for section %d"), obfd, secnum);
5522f910
NC		 1435 }
1436
1437 if (iheader->sh_info)
1438 {
1439 /* The sh_info field can hold arbitrary information, but if the
1440 SHF_LINK_INFO flag is set then it should be interpreted as a
1441 section index. */
1442 if (iheader->sh_flags & SHF_INFO_LINK)
1443 {
1444 sh_link = find_link (obfd, iheaders[iheader->sh_info],
1445 iheader->sh_info);
1446 if (sh_link != SHN_UNDEF)
1447 oheader->sh_flags |= SHF_INFO_LINK;
1448 }
1449 else
1450 /* No idea what it means - just copy it. */
1451 sh_link = iheader->sh_info;
1452
1453 if (sh_link != SHN_UNDEF)
1454 {
1455 oheader->sh_info = sh_link;
1456 changed = TRUE;
1457 }
1458 else
76cfced5 1459 _bfd_error_handler
695344c0 1460 /* xgettext:c-format */
9793eb77 1461 (_("%pB: failed to find info section for section %d"), obfd, secnum);
5522f910
NC		 1462 }
1463
1464 return changed;
1465}
07d6d2b8 1466
0ac4564e
L		 1467/* Copy the program header and other data from one object module to
1468 another. */
252b5132 1469
b34976b6 1470bfd_boolean
217aa764 1471_bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2d502050 1472{
5522f910
NC		 1473 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1474 Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
1475 const struct elf_backend_data *bed;
84865015
NC		 1476 unsigned int i;
1477
2d502050 1478 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
84865015 1479 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 1480 return TRUE;
2d502050 1481
57b828ef
L		 1482 if (!elf_flags_init (obfd))
1483 {
1484 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1485 elf_flags_init (obfd) = TRUE;
1486 }
2d502050 1487
0ac4564e 1488 elf_gp (obfd) = elf_gp (ibfd);
57b828ef
L		 1489
1490 /* Also copy the EI_OSABI field. */
1491 elf_elfheader (obfd)->e_ident[EI_OSABI] =
1492 elf_elfheader (ibfd)->e_ident[EI_OSABI];
104d59d1 1493
5522f910
NC		 1494 /* If set, copy the EI_ABIVERSION field. */
1495 if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
1496 elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
1497 = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
07d6d2b8 1498
104d59d1
JM		 1499 /* Copy object attributes. */
1500 _bfd_elf_copy_obj_attributes (ibfd, obfd);
63b9bbb7 1501
84865015
NC		 1502 if (iheaders == NULL || oheaders == NULL)
1503 return TRUE;
63b9bbb7 1504
5522f910
NC		 1505 bed = get_elf_backend_data (obfd);
1506
1507 /* Possibly copy other fields in the section header. */
84865015 1508 for (i = 1; i < elf_numsections (obfd); i++)
63b9bbb7 1509 {
84865015
NC		 1510 unsigned int j;
1511 Elf_Internal_Shdr * oheader = oheaders[i];
63b9bbb7 1512
5522f910
NC		 1513 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1514 because of a special case need for generating separate debug info
1515 files. See below for more details. */
84865015
NC		 1516 if (oheader == NULL
1517 || (oheader->sh_type != SHT_NOBITS
5522f910
NC		 1518 && oheader->sh_type < SHT_LOOS))
1519 continue;
1520
1521 /* Ignore empty sections, and sections whose
1522 fields have already been initialised. */
1523 if (oheader->sh_size == 0
84865015
NC		 1524 || (oheader->sh_info != 0 && oheader->sh_link != 0))
1525 continue;
63b9bbb7 1526
84865015 1527 /* Scan for the matching section in the input bfd.
5522f910
NC		 1528 First we try for a direct mapping between the input and output sections. */
1529 for (j = 1; j < elf_numsections (ibfd); j++)
1530 {
1531 const Elf_Internal_Shdr * iheader = iheaders[j];
1532
1533 if (iheader == NULL)
1534 continue;
1535
1536 if (oheader->bfd_section != NULL
1537 && iheader->bfd_section != NULL
1538 && iheader->bfd_section->output_section != NULL
1539 && iheader->bfd_section->output_section == oheader->bfd_section)
1540 {
1541 /* We have found a connection from the input section to the
1542 output section. Attempt to copy the header fields. If
1543 this fails then do not try any further sections - there
1544 should only be a one-to-one mapping between input and output. */
1545 if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1546 j = elf_numsections (ibfd);
1547 break;
1548 }
1549 }
1550
1551 if (j < elf_numsections (ibfd))
1552 continue;
1553
1554 /* That failed. So try to deduce the corresponding input section.
84865015
NC		 1555 Unfortunately we cannot compare names as the output string table
1556 is empty, so instead we check size, address and type. */
1557 for (j = 1; j < elf_numsections (ibfd); j++)
1558 {
5522f910 1559 const Elf_Internal_Shdr * iheader = iheaders[j];
84865015 1560
5522f910
NC		 1561 if (iheader == NULL)
1562 continue;
1563
1564 /* Try matching fields in the input section's header.
1565 Since --only-keep-debug turns all non-debug sections into
84865015
NC		 1566 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1567 input type. */
1568 if ((oheader->sh_type == SHT_NOBITS
1569 || iheader->sh_type == oheader->sh_type)
5522f910
NC		 1570 && (iheader->sh_flags & ~ SHF_INFO_LINK)
1571 == (oheader->sh_flags & ~ SHF_INFO_LINK)
84865015
NC		 1572 && iheader->sh_addralign == oheader->sh_addralign
1573 && iheader->sh_entsize == oheader->sh_entsize
1574 && iheader->sh_size == oheader->sh_size
1575 && iheader->sh_addr == oheader->sh_addr
1576 && (iheader->sh_info != oheader->sh_info
1577 || iheader->sh_link != oheader->sh_link))
63b9bbb7 1578 {
5522f910
NC		 1579 if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1580 break;
63b9bbb7
NC		 1581 }
1582 }
5522f910
NC		 1583
1584 if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
1585 {
1586 /* Final attempt. Call the backend copy function
1587 with a NULL input section. */
1588 if (bed->elf_backend_copy_special_section_fields != NULL)
1589 bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
1590 }
63b9bbb7
NC		 1591 }
1592
b34976b6 1593 return TRUE;
2d502050
L		 1594}
1595
cedc298e
L		 1596static const char *
1597get_segment_type (unsigned int p_type)
1598{
1599 const char *pt;
1600 switch (p_type)
1601 {
1602 case PT_NULL: pt = "NULL"; break;
1603 case PT_LOAD: pt = "LOAD"; break;
1604 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1605 case PT_INTERP: pt = "INTERP"; break;
1606 case PT_NOTE: pt = "NOTE"; break;
1607 case PT_SHLIB: pt = "SHLIB"; break;
1608 case PT_PHDR: pt = "PHDR"; break;
1609 case PT_TLS: pt = "TLS"; break;
1610 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
2b05f1b7 1611 case PT_GNU_STACK: pt = "STACK"; break;
cedc298e
L		 1612 case PT_GNU_RELRO: pt = "RELRO"; break;
1613 default: pt = NULL; break;
1614 }
1615 return pt;
1616}
1617
f0b79d91
L		 1618/* Print out the program headers. */
1619
b34976b6 1620bfd_boolean
217aa764 1621_bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
252b5132 1622{
a50b1753 1623 FILE *f = (FILE *) farg;
252b5132
RH		 1624 Elf_Internal_Phdr *p;
1625 asection *s;
1626 bfd_byte *dynbuf = NULL;
1627
1628 p = elf_tdata (abfd)->phdr;
1629 if (p != NULL)
1630 {
1631 unsigned int i, c;
1632
1633 fprintf (f, _("\nProgram Header:\n"));
1634 c = elf_elfheader (abfd)->e_phnum;
1635 for (i = 0; i < c; i++, p++)
1636 {
cedc298e 1637 const char *pt = get_segment_type (p->p_type);
252b5132
RH		 1638 char buf[20];
1639
cedc298e 1640 if (pt == NULL)
252b5132 1641 {
cedc298e
L		 1642 sprintf (buf, "0x%lx", p->p_type);
1643 pt = buf;
252b5132 1644 }
dc810e39 1645 fprintf (f, "%8s off 0x", pt);
60b89a18 1646 bfd_fprintf_vma (abfd, f, p->p_offset);
252b5132 1647 fprintf (f, " vaddr 0x");
60b89a18 1648 bfd_fprintf_vma (abfd, f, p->p_vaddr);
252b5132 1649 fprintf (f, " paddr 0x");
60b89a18 1650 bfd_fprintf_vma (abfd, f, p->p_paddr);
252b5132
RH		 1651 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1652 fprintf (f, " filesz 0x");
60b89a18 1653 bfd_fprintf_vma (abfd, f, p->p_filesz);
252b5132 1654 fprintf (f, " memsz 0x");
60b89a18 1655 bfd_fprintf_vma (abfd, f, p->p_memsz);
252b5132
RH		 1656 fprintf (f, " flags %c%c%c",
1657 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1658 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1659 (p->p_flags & PF_X) != 0 ? 'x' : '-');
dc810e39
AM		 1660 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1661 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
252b5132
RH		 1662 fprintf (f, "\n");
1663 }
1664 }
1665
1666 s = bfd_get_section_by_name (abfd, ".dynamic");
1667 if (s != NULL)
1668 {
cb33740c 1669 unsigned int elfsec;
dc810e39 1670 unsigned long shlink;
252b5132
RH		 1671 bfd_byte *extdyn, *extdynend;
1672 size_t extdynsize;
217aa764 1673 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
252b5132
RH		 1674
1675 fprintf (f, _("\nDynamic Section:\n"));
1676
eea6121a 1677 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
252b5132
RH		 1678 goto error_return;
1679
1680 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
cb33740c 1681 if (elfsec == SHN_BAD)
252b5132 1682 goto error_return;
dc810e39 1683 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
252b5132
RH		 1684
1685 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1686 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1687
1688 extdyn = dynbuf;
06614111
NC		 1689 /* PR 17512: file: 6f427532. */
1690 if (s->size < extdynsize)
1691 goto error_return;
eea6121a 1692 extdynend = extdyn + s->size;
1036838a 1693 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
07d6d2b8 1694 Fix range check. */
1036838a 1695 for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
252b5132
RH		 1696 {
1697 Elf_Internal_Dyn dyn;
ad9563d6 1698 const char *name = "";
252b5132 1699 char ab[20];
b34976b6 1700 bfd_boolean stringp;
ad9563d6 1701 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 1702
217aa764 1703 (*swap_dyn_in) (abfd, extdyn, &dyn);
252b5132
RH		 1704
1705 if (dyn.d_tag == DT_NULL)
1706 break;
1707
b34976b6 1708 stringp = FALSE;
252b5132
RH		 1709 switch (dyn.d_tag)
1710 {
1711 default:
ad9563d6
CM		 1712 if (bed->elf_backend_get_target_dtag)
1713 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1714
1715 if (!strcmp (name, ""))
1716 {
cd9af601 1717 sprintf (ab, "%#" BFD_VMA_FMT "x", dyn.d_tag);
ad9563d6
CM		 1718 name = ab;
1719 }
252b5132
RH		 1720 break;
1721
b34976b6 1722 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
252b5132
RH		 1723 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1724 case DT_PLTGOT: name = "PLTGOT"; break;
1725 case DT_HASH: name = "HASH"; break;
1726 case DT_STRTAB: name = "STRTAB"; break;
1727 case DT_SYMTAB: name = "SYMTAB"; break;
1728 case DT_RELA: name = "RELA"; break;
1729 case DT_RELASZ: name = "RELASZ"; break;
1730 case DT_RELAENT: name = "RELAENT"; break;
1731 case DT_STRSZ: name = "STRSZ"; break;
1732 case DT_SYMENT: name = "SYMENT"; break;
1733 case DT_INIT: name = "INIT"; break;
1734 case DT_FINI: name = "FINI"; break;
b34976b6
AM		 1735 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1736 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
252b5132
RH		 1737 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1738 case DT_REL: name = "REL"; break;
1739 case DT_RELSZ: name = "RELSZ"; break;
1740 case DT_RELENT: name = "RELENT"; break;
1741 case DT_PLTREL: name = "PLTREL"; break;
1742 case DT_DEBUG: name = "DEBUG"; break;
1743 case DT_TEXTREL: name = "TEXTREL"; break;
1744 case DT_JMPREL: name = "JMPREL"; break;
94558834
L		 1745 case DT_BIND_NOW: name = "BIND_NOW"; break;
1746 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1747 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1748 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1749 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
b34976b6 1750 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
94558834
L		 1751 case DT_FLAGS: name = "FLAGS"; break;
1752 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1753 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
d48188b9 1754 case DT_CHECKSUM: name = "CHECKSUM"; break;
94558834
L		 1755 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1756 case DT_MOVEENT: name = "MOVEENT"; break;
1757 case DT_MOVESZ: name = "MOVESZ"; break;
1758 case DT_FEATURE: name = "FEATURE"; break;
1759 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1760 case DT_SYMINSZ: name = "SYMINSZ"; break;
1761 case DT_SYMINENT: name = "SYMINENT"; break;
b34976b6
AM		 1762 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1763 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1764 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
94558834
L		 1765 case DT_PLTPAD: name = "PLTPAD"; break;
1766 case DT_MOVETAB: name = "MOVETAB"; break;
1767 case DT_SYMINFO: name = "SYMINFO"; break;
1768 case DT_RELACOUNT: name = "RELACOUNT"; break;
1769 case DT_RELCOUNT: name = "RELCOUNT"; break;
1770 case DT_FLAGS_1: name = "FLAGS_1"; break;
252b5132
RH		 1771 case DT_VERSYM: name = "VERSYM"; break;
1772 case DT_VERDEF: name = "VERDEF"; break;
1773 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1774 case DT_VERNEED: name = "VERNEED"; break;
1775 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
b34976b6 1776 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
94558834 1777 case DT_USED: name = "USED"; break;
b34976b6 1778 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
fdc90cb4 1779 case DT_GNU_HASH: name = "GNU_HASH"; break;
252b5132
RH		 1780 }
1781
ad9563d6 1782 fprintf (f, " %-20s ", name);
252b5132 1783 if (! stringp)
a1f3c56e
AN		 1784 {
1785 fprintf (f, "0x");
1786 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1787 }
252b5132
RH		 1788 else
1789 {
1790 const char *string;
dc810e39 1791 unsigned int tagv = dyn.d_un.d_val;
252b5132 1792
dc810e39 1793 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
252b5132
RH		 1794 if (string == NULL)
1795 goto error_return;
1796 fprintf (f, "%s", string);
1797 }
1798 fprintf (f, "\n");
1799 }
1800
1801 free (dynbuf);
1802 dynbuf = NULL;
1803 }
1804
1805 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1806 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1807 {
fc0e6df6 1808 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
b34976b6 1809 return FALSE;
252b5132
RH		 1810 }
1811
1812 if (elf_dynverdef (abfd) != 0)
1813 {
1814 Elf_Internal_Verdef *t;
1815
1816 fprintf (f, _("\nVersion definitions:\n"));
1817 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1818 {
1819 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
d0fb9a8d
JJ		 1820 t->vd_flags, t->vd_hash,
1821 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1822 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
252b5132
RH		 1823 {
1824 Elf_Internal_Verdaux *a;
1825
1826 fprintf (f, "\t");
1827 for (a = t->vd_auxptr->vda_nextptr;
1828 a != NULL;
1829 a = a->vda_nextptr)
d0fb9a8d
JJ		 1830 fprintf (f, "%s ",
1831 a->vda_nodename ? a->vda_nodename : "<corrupt>");
252b5132
RH		 1832 fprintf (f, "\n");
1833 }
1834 }
1835 }
1836
1837 if (elf_dynverref (abfd) != 0)
1838 {
1839 Elf_Internal_Verneed *t;
1840
1841 fprintf (f, _("\nVersion References:\n"));
1842 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1843 {
1844 Elf_Internal_Vernaux *a;
1845
d0fb9a8d
JJ		 1846 fprintf (f, _(" required from %s:\n"),
1847 t->vn_filename ? t->vn_filename : "<corrupt>");
252b5132
RH		 1848 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1849 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
d0fb9a8d
JJ		 1850 a->vna_flags, a->vna_other,
1851 a->vna_nodename ? a->vna_nodename : "<corrupt>");
252b5132
RH		 1852 }
1853 }
1854
b34976b6 1855 return TRUE;
252b5132
RH		 1856
1857 error_return:
1858 if (dynbuf != NULL)
1859 free (dynbuf);
b34976b6 1860 return FALSE;
252b5132
RH		 1861}
1862
bb4d2ac2
L		 1863/* Get version string. */
1864
1865const char *
60bb06bc
L		 1866_bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
1867 bfd_boolean *hidden)
bb4d2ac2
L		 1868{
1869 const char *version_string = NULL;
1870 if (elf_dynversym (abfd) != 0
1871 && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
1872 {
1873 unsigned int vernum = ((elf_symbol_type *) symbol)->version;
1874
1875 *hidden = (vernum & VERSYM_HIDDEN) != 0;
1876 vernum &= VERSYM_VERSION;
1877
1878 if (vernum == 0)
1879 version_string = "";
1f6f5dba
L		 1880 else if (vernum == 1
1881 && (vernum > elf_tdata (abfd)->cverdefs
1882 || (elf_tdata (abfd)->verdef[0].vd_flags
1883 == VER_FLG_BASE)))
bb4d2ac2
L		 1884 version_string = "Base";
1885 else if (vernum <= elf_tdata (abfd)->cverdefs)
1886 version_string =
1887 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1888 else
1889 {
1890 Elf_Internal_Verneed *t;
1891
7a815dd5 1892 version_string = _("<corrupt>");
bb4d2ac2
L		 1893 for (t = elf_tdata (abfd)->verref;
1894 t != NULL;
1895 t = t->vn_nextref)
1896 {
1897 Elf_Internal_Vernaux *a;
1898
1899 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1900 {
1901 if (a->vna_other == vernum)
1902 {
1903 version_string = a->vna_nodename;
1904 break;
1905 }
1906 }
1907 }
1908 }
1909 }
1910 return version_string;
1911}
1912
252b5132
RH		 1913/* Display ELF-specific fields of a symbol. */
1914
1915void
217aa764
AM		 1916bfd_elf_print_symbol (bfd *abfd,
1917 void *filep,
1918 asymbol *symbol,
1919 bfd_print_symbol_type how)
252b5132 1920{
a50b1753 1921 FILE *file = (FILE *) filep;
252b5132
RH		 1922 switch (how)
1923 {
1924 case bfd_print_symbol_name:
1925 fprintf (file, "%s", symbol->name);
1926 break;
1927 case bfd_print_symbol_more:
1928 fprintf (file, "elf ");
60b89a18 1929 bfd_fprintf_vma (abfd, file, symbol->value);
cd9af601 1930 fprintf (file, " %x", symbol->flags);
252b5132
RH		 1931 break;
1932 case bfd_print_symbol_all:
1933 {
4e8a9624
AM		 1934 const char *section_name;
1935 const char *name = NULL;
9c5bfbb7 1936 const struct elf_backend_data *bed;
7a13edea 1937 unsigned char st_other;
dbb410c3 1938 bfd_vma val;
bb4d2ac2
L		 1939 const char *version_string;
1940 bfd_boolean hidden;
c044fabd 1941
252b5132 1942 section_name = symbol->section ? symbol->section->name : "(*none*)";
587ff49e
RH		 1943
1944 bed = get_elf_backend_data (abfd);
1945 if (bed->elf_backend_print_symbol_all)
c044fabd 1946 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
587ff49e
RH		 1947
1948 if (name == NULL)
1949 {
7ee38065 1950 name = symbol->name;
217aa764 1951 bfd_print_symbol_vandf (abfd, file, symbol);
587ff49e
RH		 1952 }
1953
252b5132
RH		 1954 fprintf (file, " %s\t", section_name);
1955 /* Print the "other" value for a symbol. For common symbols,
1956 we've already printed the size; now print the alignment.
1957 For other symbols, we have no specified alignment, and
1958 we've printed the address; now print the size. */
dcf6c779 1959 if (symbol->section && bfd_is_com_section (symbol->section))
dbb410c3
AM		 1960 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1961 else
1962 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1963 bfd_fprintf_vma (abfd, file, val);
252b5132
RH		 1964
1965 /* If we have version information, print it. */
60bb06bc
L		 1966 version_string = _bfd_elf_get_symbol_version_string (abfd,
1967 symbol,
1968 &hidden);
bb4d2ac2 1969 if (version_string)
252b5132 1970 {
bb4d2ac2 1971 if (!hidden)
252b5132
RH		 1972 fprintf (file, " %-11s", version_string);
1973 else
1974 {
1975 int i;
1976
1977 fprintf (file, " (%s)", version_string);
1978 for (i = 10 - strlen (version_string); i > 0; --i)
1979 putc (' ', file);
1980 }
1981 }
1982
1983 /* If the st_other field is not zero, print it. */
7a13edea 1984 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
c044fabd 1985
7a13edea
NC		 1986 switch (st_other)
1987 {
1988 case 0: break;
1989 case STV_INTERNAL: fprintf (file, " .internal"); break;
1990 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1991 case STV_PROTECTED: fprintf (file, " .protected"); break;
1992 default:
1993 /* Some other non-defined flags are also present, so print
1994 everything hex. */
1995 fprintf (file, " 0x%02x", (unsigned int) st_other);
1996 }
252b5132 1997
587ff49e 1998 fprintf (file, " %s", name);
252b5132
RH		 1999 }
2000 break;
2001 }
2002}
252b5132
RH		 2003\f
2004/* ELF .o/exec file reading */
2005
c044fabd 2006/* Create a new bfd section from an ELF section header. */
252b5132 2007
b34976b6 2008bfd_boolean
217aa764 2009bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
252b5132 2010{
4fbb74a6
AM		 2011 Elf_Internal_Shdr *hdr;
2012 Elf_Internal_Ehdr *ehdr;
2013 const struct elf_backend_data *bed;
90937f86 2014 const char *name;
bf67003b
NC		 2015 bfd_boolean ret = TRUE;
2016 static bfd_boolean * sections_being_created = NULL;
5a4b0ccc 2017 static bfd * sections_being_created_abfd = NULL;
bf67003b 2018 static unsigned int nesting = 0;
252b5132 2019
4fbb74a6
AM		 2020 if (shindex >= elf_numsections (abfd))
2021 return FALSE;
2022
bf67003b
NC		 2023 if (++ nesting > 3)
2024 {
2025 /* PR17512: A corrupt ELF binary might contain a recursive group of
67ce483b 2026 sections, with each the string indices pointing to the next in the
bf67003b
NC		 2027 loop. Detect this here, by refusing to load a section that we are
2028 already in the process of loading. We only trigger this test if
2029 we have nested at least three sections deep as normal ELF binaries
5a4b0ccc
NC		 2030 can expect to recurse at least once.
2031
2032 FIXME: It would be better if this array was attached to the bfd,
2033 rather than being held in a static pointer. */
2034
2035 if (sections_being_created_abfd != abfd)
2036 sections_being_created = NULL;
bf67003b
NC		 2037 if (sections_being_created == NULL)
2038 {
bf67003b 2039 sections_being_created = (bfd_boolean *)
7a6e0d89 2040 bfd_zalloc2 (abfd, elf_numsections (abfd), sizeof (bfd_boolean));
5a4b0ccc 2041 sections_being_created_abfd = abfd;
bf67003b
NC		 2042 }
2043 if (sections_being_created [shindex])
2044 {
4eca0228 2045 _bfd_error_handler
871b3ab2 2046 (_("%pB: warning: loop in section dependencies detected"), abfd);
bf67003b
NC		 2047 return FALSE;
2048 }
2049 sections_being_created [shindex] = TRUE;
2050 }
2051
4fbb74a6
AM		 2052 hdr = elf_elfsections (abfd)[shindex];
2053 ehdr = elf_elfheader (abfd);
2054 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1b3a8575 2055 hdr->sh_name);
933d961a 2056 if (name == NULL)
bf67003b 2057 goto fail;
252b5132 2058
4fbb74a6 2059 bed = get_elf_backend_data (abfd);
252b5132
RH		 2060 switch (hdr->sh_type)
2061 {
2062 case SHT_NULL:
2063 /* Inactive section. Throw it away. */
bf67003b 2064 goto success;
252b5132 2065
bf67003b
NC		 2066 case SHT_PROGBITS: /* Normal section with contents. */
2067 case SHT_NOBITS: /* .bss section. */
2068 case SHT_HASH: /* .hash section. */
2069 case SHT_NOTE: /* .note section. */
25e27870
L		 2070 case SHT_INIT_ARRAY: /* .init_array section. */
2071 case SHT_FINI_ARRAY: /* .fini_array section. */
2072 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
7f1204bb 2073 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
fdc90cb4 2074 case SHT_GNU_HASH: /* .gnu.hash section. */
bf67003b
NC		 2075 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2076 goto success;
252b5132 2077
797fc050 2078 case SHT_DYNAMIC: /* Dynamic linking information. */
6dc132d9 2079 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
bf67003b
NC		 2080 goto fail;
2081
cfcac11d
NC		 2082 if (hdr->sh_link > elf_numsections (abfd))
2083 {
caa83f8b 2084 /* PR 10478: Accept Solaris binaries with a sh_link
cfcac11d
NC		 2085 field set to SHN_BEFORE or SHN_AFTER. */
2086 switch (bfd_get_arch (abfd))
2087 {
caa83f8b 2088 case bfd_arch_i386:
cfcac11d
NC		 2089 case bfd_arch_sparc:
2090 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
2091 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
2092 break;
2093 /* Otherwise fall through. */
2094 default:
bf67003b 2095 goto fail;
cfcac11d
NC		 2096 }
2097 }
2098 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
bf67003b 2099 goto fail;
cfcac11d 2100 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
797fc050
AM		 2101 {
2102 Elf_Internal_Shdr *dynsymhdr;
2103
2104 /* The shared libraries distributed with hpux11 have a bogus
2105 sh_link field for the ".dynamic" section. Find the
2106 string table for the ".dynsym" section instead. */
2107 if (elf_dynsymtab (abfd) != 0)
2108 {
2109 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2110 hdr->sh_link = dynsymhdr->sh_link;
2111 }
2112 else
2113 {
2114 unsigned int i, num_sec;
2115
2116 num_sec = elf_numsections (abfd);
2117 for (i = 1; i < num_sec; i++)
2118 {
2119 dynsymhdr = elf_elfsections (abfd)[i];
2120 if (dynsymhdr->sh_type == SHT_DYNSYM)
2121 {
2122 hdr->sh_link = dynsymhdr->sh_link;
2123 break;
2124 }
2125 }
2126 }
2127 }
bf67003b 2128 goto success;
797fc050 2129
bf67003b 2130 case SHT_SYMTAB: /* A symbol table. */
252b5132 2131 if (elf_onesymtab (abfd) == shindex)
bf67003b 2132 goto success;
252b5132 2133
a50b2160 2134 if (hdr->sh_entsize != bed->s->sizeof_sym)
bf67003b
NC		 2135 goto fail;
2136
3337c1e5 2137 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
eee3b786
AM		 2138 {
2139 if (hdr->sh_size != 0)
bf67003b 2140 goto fail;
eee3b786
AM		 2141 /* Some assemblers erroneously set sh_info to one with a
2142 zero sh_size. ld sees this as a global symbol count
2143 of (unsigned) -1. Fix it here. */
2144 hdr->sh_info = 0;
bf67003b 2145 goto success;
eee3b786 2146 }
bf67003b 2147
16ad13ec
NC		 2148 /* PR 18854: A binary might contain more than one symbol table.
2149 Unusual, but possible. Warn, but continue. */
2150 if (elf_onesymtab (abfd) != 0)
2151 {
4eca0228 2152 _bfd_error_handler
695344c0 2153 /* xgettext:c-format */
871b3ab2 2154 (_("%pB: warning: multiple symbol tables detected"
63a5468a 2155 " - ignoring the table in section %u"),
16ad13ec
NC		 2156 abfd, shindex);
2157 goto success;
2158 }
252b5132 2159 elf_onesymtab (abfd) = shindex;
6a40cf0c
NC		 2160 elf_symtab_hdr (abfd) = *hdr;
2161 elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
252b5132
RH		 2162 abfd->flags |= HAS_SYMS;
2163
2164 /* Sometimes a shared object will map in the symbol table. If
08a40648
AM		 2165 SHF_ALLOC is set, and this is a shared object, then we also
2166 treat this section as a BFD section. We can not base the
2167 decision purely on SHF_ALLOC, because that flag is sometimes
2168 set in a relocatable object file, which would confuse the
2169 linker. */
252b5132
RH		 2170 if ((hdr->sh_flags & SHF_ALLOC) != 0
2171 && (abfd->flags & DYNAMIC) != 0
6dc132d9
L		 2172 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2173 shindex))
bf67003b 2174 goto fail;
252b5132 2175
1b3a8575
AM		 2176 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2177 can't read symbols without that section loaded as well. It
2178 is most likely specified by the next section header. */
6a40cf0c
NC		 2179 {
2180 elf_section_list * entry;
2181 unsigned int i, num_sec;
1b3a8575 2182
6a40cf0c
NC		 2183 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2184 if (entry->hdr.sh_link == shindex)
2185 goto success;
2186
2187 num_sec = elf_numsections (abfd);
2188 for (i = shindex + 1; i < num_sec; i++)
2189 {
2190 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2191
2192 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2193 && hdr2->sh_link == shindex)
2194 break;
2195 }
2196
2197 if (i == num_sec)
2198 for (i = 1; i < shindex; i++)
1b3a8575
AM		 2199 {
2200 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
6a40cf0c 2201
1b3a8575
AM		 2202 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2203 && hdr2->sh_link == shindex)
2204 break;
2205 }
6a40cf0c
NC		 2206
2207 if (i != shindex)
2208 ret = bfd_section_from_shdr (abfd, i);
2209 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2210 goto success;
2211 }
252b5132 2212
bf67003b 2213 case SHT_DYNSYM: /* A dynamic symbol table. */
252b5132 2214 if (elf_dynsymtab (abfd) == shindex)
bf67003b 2215 goto success;
252b5132 2216
a50b2160 2217 if (hdr->sh_entsize != bed->s->sizeof_sym)
bf67003b
NC		 2218 goto fail;
2219
eee3b786
AM		 2220 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2221 {
2222 if (hdr->sh_size != 0)
bf67003b
NC		 2223 goto fail;
2224
eee3b786
AM		 2225 /* Some linkers erroneously set sh_info to one with a
2226 zero sh_size. ld sees this as a global symbol count
2227 of (unsigned) -1. Fix it here. */
2228 hdr->sh_info = 0;
bf67003b 2229 goto success;
eee3b786 2230 }
bf67003b 2231
16ad13ec
NC		 2232 /* PR 18854: A binary might contain more than one dynamic symbol table.
2233 Unusual, but possible. Warn, but continue. */
2234 if (elf_dynsymtab (abfd) != 0)
2235 {
4eca0228 2236 _bfd_error_handler
695344c0 2237 /* xgettext:c-format */
871b3ab2 2238 (_("%pB: warning: multiple dynamic symbol tables detected"
63a5468a 2239 " - ignoring the table in section %u"),
16ad13ec
NC		 2240 abfd, shindex);
2241 goto success;
2242 }
252b5132
RH		 2243 elf_dynsymtab (abfd) = shindex;
2244 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2245 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2246 abfd->flags |= HAS_SYMS;
2247
2248 /* Besides being a symbol table, we also treat this as a regular
2249 section, so that objcopy can handle it. */
bf67003b
NC		 2250 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2251 goto success;
252b5132 2252
bf67003b 2253 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections. */
6a40cf0c
NC		 2254 {
2255 elf_section_list * entry;
9ad5cbcf 2256
6a40cf0c
NC		 2257 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2258 if (entry->ndx == shindex)
2259 goto success;
07d6d2b8 2260
7a6e0d89 2261 entry = bfd_alloc (abfd, sizeof (*entry));
6a40cf0c
NC		 2262 if (entry == NULL)
2263 goto fail;
2264 entry->ndx = shindex;
2265 entry->hdr = * hdr;
2266 entry->next = elf_symtab_shndx_list (abfd);
2267 elf_symtab_shndx_list (abfd) = entry;
2268 elf_elfsections (abfd)[shindex] = & entry->hdr;
2269 goto success;
2270 }
9ad5cbcf 2271
bf67003b 2272 case SHT_STRTAB: /* A string table. */
252b5132 2273 if (hdr->bfd_section != NULL)
bf67003b
NC		 2274 goto success;
2275
252b5132
RH		 2276 if (ehdr->e_shstrndx == shindex)
2277 {
2278 elf_tdata (abfd)->shstrtab_hdr = *hdr;
2279 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
bf67003b 2280 goto success;
252b5132 2281 }
bf67003b 2282
1b3a8575
AM		 2283 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2284 {
2285 symtab_strtab:
2286 elf_tdata (abfd)->strtab_hdr = *hdr;
2287 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
bf67003b 2288 goto success;
1b3a8575 2289 }
bf67003b 2290
1b3a8575
AM		 2291 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2292 {
2293 dynsymtab_strtab:
2294 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2295 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2296 elf_elfsections (abfd)[shindex] = hdr;
2297 /* We also treat this as a regular section, so that objcopy
2298 can handle it. */
bf67003b
NC		 2299 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2300 shindex);
2301 goto success;
1b3a8575 2302 }
252b5132 2303
1b3a8575
AM		 2304 /* If the string table isn't one of the above, then treat it as a
2305 regular section. We need to scan all the headers to be sure,
2306 just in case this strtab section appeared before the above. */
2307 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2308 {
2309 unsigned int i, num_sec;
252b5132 2310
1b3a8575
AM		 2311 num_sec = elf_numsections (abfd);
2312 for (i = 1; i < num_sec; i++)
2313 {
2314 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2315 if (hdr2->sh_link == shindex)
2316 {
933d961a
JJ		 2317 /* Prevent endless recursion on broken objects. */
2318 if (i == shindex)
bf67003b 2319 goto fail;
1b3a8575 2320 if (! bfd_section_from_shdr (abfd, i))
bf67003b 2321 goto fail;
1b3a8575
AM		 2322 if (elf_onesymtab (abfd) == i)
2323 goto symtab_strtab;
2324 if (elf_dynsymtab (abfd) == i)
2325 goto dynsymtab_strtab;
2326 }
2327 }
2328 }
bf67003b
NC		 2329 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2330 goto success;
252b5132
RH		 2331
2332 case SHT_REL:
2333 case SHT_RELA:
2334 /* *These* do a lot of work -- but build no sections! */
2335 {
2336 asection *target_sect;
d4730f92 2337 Elf_Internal_Shdr *hdr2, **p_hdr;
9ad5cbcf 2338 unsigned int num_sec = elf_numsections (abfd);
d4730f92 2339 struct bfd_elf_section_data *esdt;
252b5132 2340
aa2ca951
JJ		 2341 if (hdr->sh_entsize
2342 != (bfd_size_type) (hdr->sh_type == SHT_REL
a50b2160 2343 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
bf67003b 2344 goto fail;
a50b2160 2345
03ae5f59 2346 /* Check for a bogus link to avoid crashing. */
4fbb74a6 2347 if (hdr->sh_link >= num_sec)
03ae5f59 2348 {
4eca0228 2349 _bfd_error_handler
695344c0 2350 /* xgettext:c-format */
871b3ab2 2351 (_("%pB: invalid link %u for reloc section %s (index %u)"),
4eca0228 2352 abfd, hdr->sh_link, name, shindex);
bf67003b
NC		 2353 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2354 shindex);
2355 goto success;
03ae5f59
ILT		 2356 }
2357
252b5132
RH		 2358 /* For some incomprehensible reason Oracle distributes
2359 libraries for Solaris in which some of the objects have
2360 bogus sh_link fields. It would be nice if we could just
2361 reject them, but, unfortunately, some people need to use
2362 them. We scan through the section headers; if we find only
2363 one suitable symbol table, we clobber the sh_link to point
83b89087
L		 2364 to it. I hope this doesn't break anything.
2365
2366 Don't do it on executable nor shared library. */
2367 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2368 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
252b5132
RH		 2369 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2370 {
9ad5cbcf 2371 unsigned int scan;
252b5132
RH		 2372 int found;
2373
2374 found = 0;
9ad5cbcf 2375 for (scan = 1; scan < num_sec; scan++)
252b5132
RH		 2376 {
2377 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2378 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2379 {
2380 if (found != 0)
2381 {
2382 found = 0;
2383 break;
2384 }
2385 found = scan;
2386 }
2387 }
2388 if (found != 0)
2389 hdr->sh_link = found;
2390 }
2391
2392 /* Get the symbol table. */
1b3a8575
AM		 2393 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2394 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
252b5132 2395 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
bf67003b 2396 goto fail;
252b5132 2397
a4bcd733
AM		 2398 /* If this is an alloc section in an executable or shared
2399 library, or the reloc section does not use the main symbol
2400 table we don't treat it as a reloc section. BFD can't
2401 adequately represent such a section, so at least for now,
2402 we don't try. We just present it as a normal section. We
2403 also can't use it as a reloc section if it points to the
2404 null section, an invalid section, another reloc section, or
2405 its sh_link points to the null section. */
2406 if (((abfd->flags & (DYNAMIC | EXEC_P)) != 0
2407 && (hdr->sh_flags & SHF_ALLOC) != 0)
83b89087 2408 || hdr->sh_link == SHN_UNDEF
a4bcd733 2409 || hdr->sh_link != elf_onesymtab (abfd)
185ef66d 2410 || hdr->sh_info == SHN_UNDEF
185ef66d
AM		 2411 || hdr->sh_info >= num_sec
2412 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2413 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
bf67003b
NC		 2414 {
2415 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2416 shindex);
2417 goto success;
2418 }
252b5132
RH		 2419
2420 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
bf67003b
NC		 2421 goto fail;
2422
252b5132
RH		 2423 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2424 if (target_sect == NULL)
bf67003b 2425 goto fail;
252b5132 2426
d4730f92
BS		 2427 esdt = elf_section_data (target_sect);
2428 if (hdr->sh_type == SHT_RELA)
2429 p_hdr = &esdt->rela.hdr;
252b5132 2430 else
d4730f92
BS		 2431 p_hdr = &esdt->rel.hdr;
2432
06614111
NC		 2433 /* PR 17512: file: 0b4f81b7. */
2434 if (*p_hdr != NULL)
2435 goto fail;
ef53be89 2436 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
d4730f92 2437 if (hdr2 == NULL)
bf67003b 2438 goto fail;
252b5132 2439 *hdr2 = *hdr;
d4730f92 2440 *p_hdr = hdr2;
252b5132 2441 elf_elfsections (abfd)[shindex] = hdr2;
056bafd4
MR		 2442 target_sect->reloc_count += (NUM_SHDR_ENTRIES (hdr)
2443 * bed->s->int_rels_per_ext_rel);
252b5132
RH		 2444 target_sect->flags |= SEC_RELOC;
2445 target_sect->relocation = NULL;
2446 target_sect->rel_filepos = hdr->sh_offset;
bf572ba0
MM		 2447 /* In the section to which the relocations apply, mark whether
2448 its relocations are of the REL or RELA variety. */
72730e0c 2449 if (hdr->sh_size != 0)
d4730f92
BS		 2450 {
2451 if (hdr->sh_type == SHT_RELA)
2452 target_sect->use_rela_p = 1;
2453 }
252b5132 2454 abfd->flags |= HAS_RELOC;
bf67003b 2455 goto success;
252b5132 2456 }
252b5132
RH		 2457
2458 case SHT_GNU_verdef:
2459 elf_dynverdef (abfd) = shindex;
2460 elf_tdata (abfd)->dynverdef_hdr = *hdr;
bf67003b
NC		 2461 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2462 goto success;
252b5132
RH		 2463
2464 case SHT_GNU_versym:
a50b2160 2465 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
bf67003b
NC		 2466 goto fail;
2467
252b5132
RH		 2468 elf_dynversym (abfd) = shindex;
2469 elf_tdata (abfd)->dynversym_hdr = *hdr;
bf67003b
NC		 2470 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2471 goto success;
252b5132
RH		 2472
2473 case SHT_GNU_verneed:
2474 elf_dynverref (abfd) = shindex;
2475 elf_tdata (abfd)->dynverref_hdr = *hdr;
bf67003b
NC		 2476 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2477 goto success;
252b5132
RH		 2478
2479 case SHT_SHLIB:
bf67003b 2480 goto success;
252b5132 2481
dbb410c3 2482 case SHT_GROUP:
44534af3 2483 if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
bf67003b
NC		 2484 goto fail;
2485
6dc132d9 2486 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
bf67003b
NC		 2487 goto fail;
2488
bf67003b 2489 goto success;
dbb410c3 2490
252b5132 2491 default:
104d59d1
JM		 2492 /* Possibly an attributes section. */
2493 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2494 || hdr->sh_type == bed->obj_attrs_section_type)
2495 {
2496 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
bf67003b 2497 goto fail;
104d59d1 2498 _bfd_elf_parse_attributes (abfd, hdr);
bf67003b 2499 goto success;
104d59d1
JM		 2500 }
2501
252b5132 2502 /* Check for any processor-specific section types. */
3eb70a79 2503 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
bf67003b 2504 goto success;
3eb70a79
L		 2505
2506 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2507 {
2508 if ((hdr->sh_flags & SHF_ALLOC) != 0)
2509 /* FIXME: How to properly handle allocated section reserved
2510 for applications? */
4eca0228 2511 _bfd_error_handler
695344c0 2512 /* xgettext:c-format */
871b3ab2 2513 (_("%pB: unknown type [%#x] section `%s'"),
76cfced5 2514 abfd, hdr->sh_type, name);
3eb70a79 2515 else
bf67003b
NC		 2516 {
2517 /* Allow sections reserved for applications. */
2518 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2519 shindex);
2520 goto success;
2521 }
3eb70a79
L		 2522 }
2523 else if (hdr->sh_type >= SHT_LOPROC
2524 && hdr->sh_type <= SHT_HIPROC)
2525 /* FIXME: We should handle this section. */
4eca0228 2526 _bfd_error_handler
695344c0 2527 /* xgettext:c-format */
871b3ab2 2528 (_("%pB: unknown type [%#x] section `%s'"),
76cfced5 2529 abfd, hdr->sh_type, name);
3eb70a79 2530 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
ff15b240
NC		 2531 {
2532 /* Unrecognised OS-specific sections. */
2533 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2534 /* SHF_OS_NONCONFORMING indicates that special knowledge is
08a40648 2535 required to correctly process the section and the file should
ff15b240 2536 be rejected with an error message. */
4eca0228 2537 _bfd_error_handler
695344c0 2538 /* xgettext:c-format */
871b3ab2 2539 (_("%pB: unknown type [%#x] section `%s'"),
76cfced5 2540 abfd, hdr->sh_type, name);
ff15b240 2541 else
bf67003b
NC		 2542 {
2543 /* Otherwise it should be processed. */
2544 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2545 goto success;
2546 }
ff15b240 2547 }
3eb70a79
L		 2548 else
2549 /* FIXME: We should handle this section. */
4eca0228 2550 _bfd_error_handler
695344c0 2551 /* xgettext:c-format */
871b3ab2 2552 (_("%pB: unknown type [%#x] section `%s'"),
76cfced5 2553 abfd, hdr->sh_type, name);
3eb70a79 2554
bf67003b 2555 goto fail;
252b5132
RH		 2556 }
2557
bf67003b
NC		 2558 fail:
2559 ret = FALSE;
2560 success:
e5b470e2 2561 if (sections_being_created && sections_being_created_abfd == abfd)
bf67003b
NC		 2562 sections_being_created [shindex] = FALSE;
2563 if (-- nesting == 0)
5a4b0ccc
NC		 2564 {
2565 sections_being_created = NULL;
2566 sections_being_created_abfd = abfd;
2567 }
bf67003b 2568 return ret;
252b5132
RH		 2569}
2570
87d72d41 2571/* Return the local symbol specified by ABFD, R_SYMNDX. */
ec338859 2572
87d72d41
AM		 2573Elf_Internal_Sym *
2574bfd_sym_from_r_symndx (struct sym_cache *cache,
2575 bfd *abfd,
2576 unsigned long r_symndx)
ec338859 2577{
ec338859
AM		 2578 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2579
a5d1b3b5
AM		 2580 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2581 {
2582 Elf_Internal_Shdr *symtab_hdr;
2583 unsigned char esym[sizeof (Elf64_External_Sym)];
2584 Elf_External_Sym_Shndx eshndx;
ec338859 2585
a5d1b3b5
AM		 2586 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2587 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
87d72d41 2588 &cache->sym[ent], esym, &eshndx) == NULL)
a5d1b3b5 2589 return NULL;
9ad5cbcf 2590
a5d1b3b5
AM		 2591 if (cache->abfd != abfd)
2592 {
2593 memset (cache->indx, -1, sizeof (cache->indx));
2594 cache->abfd = abfd;
2595 }
2596 cache->indx[ent] = r_symndx;
ec338859 2597 }
a5d1b3b5 2598
87d72d41 2599 return &cache->sym[ent];
ec338859
AM		 2600}
2601
252b5132
RH		 2602/* Given an ELF section number, retrieve the corresponding BFD
2603 section. */
2604
2605asection *
91d6fa6a 2606bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
252b5132 2607{
91d6fa6a 2608 if (sec_index >= elf_numsections (abfd))
252b5132 2609 return NULL;
91d6fa6a 2610 return elf_elfsections (abfd)[sec_index]->bfd_section;
252b5132
RH		 2611}
2612
b35d266b 2613static const struct bfd_elf_special_section special_sections_b[] =
2f89ff8d 2614{
0112cd26 2615 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
07d6d2b8 2616 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2617};
2618
b35d266b 2619static const struct bfd_elf_special_section special_sections_c[] =
7f4d3958 2620{
0112cd26 2621 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
07d6d2b8 2622 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2623};
2624
b35d266b 2625static const struct bfd_elf_special_section special_sections_d[] =
7f4d3958 2626{
07d6d2b8
AM		 2627 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2628 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
a9a72a65
DE		 2629 /* There are more DWARF sections than these, but they needn't be added here
2630 unless you have to cope with broken compilers that don't emit section
2631 attributes or you want to help the user writing assembler. */
07d6d2b8
AM		 2632 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2633 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2634 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2635 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
0112cd26 2636 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
07d6d2b8
AM		 2637 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2638 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2639 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2640 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2641};
2642
b35d266b 2643static const struct bfd_elf_special_section special_sections_f[] =
7f4d3958 2644{
07d6d2b8 2645 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
6f9dbcd4 2646 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
07d6d2b8 2647 { NULL, 0 , 0, 0, 0 }
7f4d3958
L		 2648};
2649
b35d266b 2650static const struct bfd_elf_special_section special_sections_g[] =
7f4d3958 2651{
0112cd26 2652 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
07d6d2b8
AM		 2653 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
2654 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2655 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
0112cd26
NC		 2656 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2657 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
07d6d2b8
AM		 2658 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2659 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2660 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2661 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2662};
2663
b35d266b 2664static const struct bfd_elf_special_section special_sections_h[] =
7f4d3958 2665{
07d6d2b8
AM		 2666 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2667 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2668};
2669
b35d266b 2670static const struct bfd_elf_special_section special_sections_i[] =
7f4d3958 2671{
07d6d2b8 2672 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
6f9dbcd4 2673 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
07d6d2b8
AM		 2674 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2675 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2676};
2677
b35d266b 2678static const struct bfd_elf_special_section special_sections_l[] =
7f4d3958 2679{
0112cd26 2680 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
07d6d2b8 2681 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2682};
2683
b35d266b 2684static const struct bfd_elf_special_section special_sections_n[] =
7f4d3958 2685{
0112cd26 2686 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
07d6d2b8
AM		 2687 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2688 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2689};
2690
b35d266b 2691static const struct bfd_elf_special_section special_sections_p[] =
7f4d3958 2692{
6f9dbcd4 2693 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
07d6d2b8
AM		 2694 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2695 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2696};
2697
b35d266b 2698static const struct bfd_elf_special_section special_sections_r[] =
7f4d3958 2699{
0112cd26
NC		 2700 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2701 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
07d6d2b8
AM		 2702 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2703 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2704 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2705};
2706
b35d266b 2707static const struct bfd_elf_special_section special_sections_s[] =
7f4d3958 2708{
0112cd26
NC		 2709 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2710 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2711 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
60ff4dc4
HPN		 2712 /* See struct bfd_elf_special_section declaration for the semantics of
2713 this special case where .prefix_length != strlen (.prefix). */
2714 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
07d6d2b8 2715 { NULL, 0, 0, 0, 0 }
2f89ff8d
L		 2716};
2717
b35d266b 2718static const struct bfd_elf_special_section special_sections_t[] =
7f4d3958 2719{
07d6d2b8
AM		 2720 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2721 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
0112cd26 2722 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
07d6d2b8 2723 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2724};
2725
1b315056
CS		 2726static const struct bfd_elf_special_section special_sections_z[] =
2727{
07d6d2b8
AM		 2728 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2729 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
1b315056
CS		 2730 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2731 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
07d6d2b8 2732 { NULL, 0, 0, 0, 0 }
1b315056
CS		 2733};
2734
e4c93b56 2735static const struct bfd_elf_special_section * const special_sections[] =
7f4d3958 2736{
7f4d3958 2737 special_sections_b, /* 'b' */
98ece1b3 2738 special_sections_c, /* 'c' */
7f4d3958
L		 2739 special_sections_d, /* 'd' */
2740 NULL, /* 'e' */
2741 special_sections_f, /* 'f' */
2742 special_sections_g, /* 'g' */
2743 special_sections_h, /* 'h' */
2744 special_sections_i, /* 'i' */
2745 NULL, /* 'j' */
2746 NULL, /* 'k' */
2747 special_sections_l, /* 'l' */
2748 NULL, /* 'm' */
2749 special_sections_n, /* 'n' */
2750 NULL, /* 'o' */
2751 special_sections_p, /* 'p' */
2752 NULL, /* 'q' */
2753 special_sections_r, /* 'r' */
2754 special_sections_s, /* 's' */
2755 special_sections_t, /* 't' */
1b315056
CS		 2756 NULL, /* 'u' */
2757 NULL, /* 'v' */
2758 NULL, /* 'w' */
2759 NULL, /* 'x' */
2760 NULL, /* 'y' */
2761 special_sections_z /* 'z' */
7f4d3958
L		 2762};
2763
551b43fd
AM		 2764const struct bfd_elf_special_section *
2765_bfd_elf_get_special_section (const char *name,
2766 const struct bfd_elf_special_section *spec,
2767 unsigned int rela)
2f89ff8d
L		 2768{
2769 int i;
7f4d3958 2770 int len;
7f4d3958 2771
551b43fd 2772 len = strlen (name);
7f4d3958 2773
551b43fd 2774 for (i = 0; spec[i].prefix != NULL; i++)
7dcb9820
AM		 2775 {
2776 int suffix_len;
551b43fd 2777 int prefix_len = spec[i].prefix_length;
7dcb9820
AM		 2778
2779 if (len < prefix_len)
2780 continue;
551b43fd 2781 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
7dcb9820
AM		 2782 continue;
2783
551b43fd 2784 suffix_len = spec[i].suffix_length;
7dcb9820
AM		 2785 if (suffix_len <= 0)
2786 {
2787 if (name[prefix_len] != 0)
2788 {
2789 if (suffix_len == 0)
2790 continue;
2791 if (name[prefix_len] != '.'
2792 && (suffix_len == -2
551b43fd 2793 || (rela && spec[i].type == SHT_REL)))
7dcb9820
AM		 2794 continue;
2795 }
2796 }
2797 else
2798 {
2799 if (len < prefix_len + suffix_len)
2800 continue;
2801 if (memcmp (name + len - suffix_len,
551b43fd 2802 spec[i].prefix + prefix_len,
7dcb9820
AM		 2803 suffix_len) != 0)
2804 continue;
2805 }
551b43fd 2806 return &spec[i];
7dcb9820 2807 }
2f89ff8d
L		 2808
2809 return NULL;
2810}
2811
7dcb9820 2812const struct bfd_elf_special_section *
29ef7005 2813_bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2f89ff8d 2814{
551b43fd
AM		 2815 int i;
2816 const struct bfd_elf_special_section *spec;
29ef7005 2817 const struct elf_backend_data *bed;
2f89ff8d
L		 2818
2819 /* See if this is one of the special sections. */
551b43fd
AM		 2820 if (sec->name == NULL)
2821 return NULL;
2f89ff8d 2822
29ef7005
L		 2823 bed = get_elf_backend_data (abfd);
2824 spec = bed->special_sections;
2825 if (spec)
2826 {
2827 spec = _bfd_elf_get_special_section (sec->name,
2828 bed->special_sections,
2829 sec->use_rela_p);
2830 if (spec != NULL)
2831 return spec;
2832 }
2833
551b43fd
AM		 2834 if (sec->name[0] != '.')
2835 return NULL;
2f89ff8d 2836
551b43fd 2837 i = sec->name[1] - 'b';
1b315056 2838 if (i < 0 || i > 'z' - 'b')
551b43fd
AM		 2839 return NULL;
2840
2841 spec = special_sections[i];
2f89ff8d 2842
551b43fd
AM		 2843 if (spec == NULL)
2844 return NULL;
2845
2846 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2f89ff8d
L		 2847}
2848
b34976b6 2849bfd_boolean
217aa764 2850_bfd_elf_new_section_hook (bfd *abfd, asection *sec)
252b5132
RH		 2851{
2852 struct bfd_elf_section_data *sdata;
551b43fd 2853 const struct elf_backend_data *bed;
7dcb9820 2854 const struct bfd_elf_special_section *ssect;
252b5132 2855
f0abc2a1
AM		 2856 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2857 if (sdata == NULL)
2858 {
a50b1753 2859 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
07d6d2b8 2860 sizeof (*sdata));
f0abc2a1
AM		 2861 if (sdata == NULL)
2862 return FALSE;
217aa764 2863 sec->used_by_bfd = sdata;
f0abc2a1 2864 }
bf572ba0 2865
551b43fd
AM		 2866 /* Indicate whether or not this section should use RELA relocations. */
2867 bed = get_elf_backend_data (abfd);
2868 sec->use_rela_p = bed->default_use_rela_p;
2869
e843e0f8
L		 2870 /* When we read a file, we don't need to set ELF section type and
2871 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2872 anyway. We will set ELF section type and flags for all linker
2873 created sections. If user specifies BFD section flags, we will
2874 set ELF section type and flags based on BFD section flags in
02ecc8e9
L		 2875 elf_fake_sections. Special handling for .init_array/.fini_array
2876 output sections since they may contain .ctors/.dtors input
2877 sections. We don't want _bfd_elf_init_private_section_data to
2878 copy ELF section type from .ctors/.dtors input sections. */
2879 if (abfd->direction != read_direction
3496cb2a 2880 || (sec->flags & SEC_LINKER_CREATED) != 0)
2f89ff8d 2881 {
551b43fd 2882 ssect = (*bed->get_sec_type_attr) (abfd, sec);
02ecc8e9
L		 2883 if (ssect != NULL
2884 && (!sec->flags
2885 || (sec->flags & SEC_LINKER_CREATED) != 0
2886 || ssect->type == SHT_INIT_ARRAY
2887 || ssect->type == SHT_FINI_ARRAY))
a31501e9
L		 2888 {
2889 elf_section_type (sec) = ssect->type;
2890 elf_section_flags (sec) = ssect->attr;
2891 }
2f89ff8d
L		 2892 }
2893
f592407e 2894 return _bfd_generic_new_section_hook (abfd, sec);
252b5132
RH		 2895}
2896
2897/* Create a new bfd section from an ELF program header.
2898
2899 Since program segments have no names, we generate a synthetic name
2900 of the form segment<NUM>, where NUM is generally the index in the
2901 program header table. For segments that are split (see below) we
2902 generate the names segment<NUM>a and segment<NUM>b.
2903
2904 Note that some program segments may have a file size that is different than
2905 (less than) the memory size. All this means is that at execution the
2906 system must allocate the amount of memory specified by the memory size,
2907 but only initialize it with the first "file size" bytes read from the
2908 file. This would occur for example, with program segments consisting
2909 of combined data+bss.
2910
2911 To handle the above situation, this routine generates TWO bfd sections
2912 for the single program segment. The first has the length specified by
2913 the file size of the segment, and the second has the length specified
2914 by the difference between the two sizes. In effect, the segment is split
d5191d0c 2915 into its initialized and uninitialized parts.
252b5132
RH		 2916
2917 */
2918
b34976b6 2919bfd_boolean
217aa764
AM		 2920_bfd_elf_make_section_from_phdr (bfd *abfd,
2921 Elf_Internal_Phdr *hdr,
91d6fa6a 2922 int hdr_index,
a50b1753 2923 const char *type_name)
252b5132
RH		 2924{
2925 asection *newsect;
2926 char *name;
2927 char namebuf[64];
d4c88bbb 2928 size_t len;
252b5132
RH		 2929 int split;
2930
2931 split = ((hdr->p_memsz > 0)
2932 && (hdr->p_filesz > 0)
2933 && (hdr->p_memsz > hdr->p_filesz));
d5191d0c
AM		 2934
2935 if (hdr->p_filesz > 0)
252b5132 2936 {
91d6fa6a 2937 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
d5191d0c 2938 len = strlen (namebuf) + 1;
a50b1753 2939 name = (char *) bfd_alloc (abfd, len);
d5191d0c
AM		 2940 if (!name)
2941 return FALSE;
2942 memcpy (name, namebuf, len);
2943 newsect = bfd_make_section (abfd, name);
2944 if (newsect == NULL)
2945 return FALSE;
2946 newsect->vma = hdr->p_vaddr;
2947 newsect->lma = hdr->p_paddr;
2948 newsect->size = hdr->p_filesz;
2949 newsect->filepos = hdr->p_offset;
2950 newsect->flags |= SEC_HAS_CONTENTS;
2951 newsect->alignment_power = bfd_log2 (hdr->p_align);
2952 if (hdr->p_type == PT_LOAD)
252b5132 2953 {
d5191d0c
AM		 2954 newsect->flags |= SEC_ALLOC;
2955 newsect->flags |= SEC_LOAD;
2956 if (hdr->p_flags & PF_X)
2957 {
2958 /* FIXME: all we known is that it has execute PERMISSION,
2959 may be data. */
2960 newsect->flags |= SEC_CODE;
2961 }
2962 }
2963 if (!(hdr->p_flags & PF_W))
2964 {
2965 newsect->flags |= SEC_READONLY;
252b5132 2966 }
252b5132
RH		 2967 }
2968
d5191d0c 2969 if (hdr->p_memsz > hdr->p_filesz)
252b5132 2970 {
d5191d0c
AM		 2971 bfd_vma align;
2972
91d6fa6a 2973 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
d4c88bbb 2974 len = strlen (namebuf) + 1;
a50b1753 2975 name = (char *) bfd_alloc (abfd, len);
252b5132 2976 if (!name)
b34976b6 2977 return FALSE;
d4c88bbb 2978 memcpy (name, namebuf, len);
252b5132
RH		 2979 newsect = bfd_make_section (abfd, name);
2980 if (newsect == NULL)
b34976b6 2981 return FALSE;
252b5132
RH		 2982 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2983 newsect->lma = hdr->p_paddr + hdr->p_filesz;
eea6121a 2984 newsect->size = hdr->p_memsz - hdr->p_filesz;
d5191d0c
AM		 2985 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2986 align = newsect->vma & -newsect->vma;
2987 if (align == 0 || align > hdr->p_align)
2988 align = hdr->p_align;
2989 newsect->alignment_power = bfd_log2 (align);
252b5132
RH		 2990 if (hdr->p_type == PT_LOAD)
2991 {
d5191d0c
AM		 2992 /* Hack for gdb. Segments that have not been modified do
2993 not have their contents written to a core file, on the
2994 assumption that a debugger can find the contents in the
2995 executable. We flag this case by setting the fake
2996 section size to zero. Note that "real" bss sections will
2997 always have their contents dumped to the core file. */
2998 if (bfd_get_format (abfd) == bfd_core)
2999 newsect->size = 0;
252b5132
RH		 3000 newsect->flags |= SEC_ALLOC;
3001 if (hdr->p_flags & PF_X)
3002 newsect->flags |= SEC_CODE;
3003 }
3004 if (!(hdr->p_flags & PF_W))
3005 newsect->flags |= SEC_READONLY;
3006 }
3007
b34976b6 3008 return TRUE;
252b5132
RH		 3009}
3010
b34976b6 3011bfd_boolean
91d6fa6a 3012bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
20cfcaae 3013{
9c5bfbb7 3014 const struct elf_backend_data *bed;
20cfcaae
NC		 3015
3016 switch (hdr->p_type)
3017 {
3018 case PT_NULL:
91d6fa6a 3019 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
20cfcaae
NC		 3020
3021 case PT_LOAD:
91d6fa6a 3022 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
20cfcaae
NC		 3023
3024 case PT_DYNAMIC:
91d6fa6a 3025 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
20cfcaae
NC		 3026
3027 case PT_INTERP:
91d6fa6a 3028 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
20cfcaae
NC		 3029
3030 case PT_NOTE:
91d6fa6a 3031 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
b34976b6 3032 return FALSE;
276da9b3
L		 3033 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz,
3034 hdr->p_align))
b34976b6
AM		 3035 return FALSE;
3036 return TRUE;
20cfcaae
NC		 3037
3038 case PT_SHLIB:
91d6fa6a 3039 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
20cfcaae
NC		 3040
3041 case PT_PHDR:
91d6fa6a 3042 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
20cfcaae 3043
811072d8 3044 case PT_GNU_EH_FRAME:
91d6fa6a 3045 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
811072d8
RM		 3046 "eh_frame_hdr");
3047
2b05f1b7 3048 case PT_GNU_STACK:
91d6fa6a 3049 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
9ee5e499 3050
8c37241b 3051 case PT_GNU_RELRO:
91d6fa6a 3052 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
8c37241b 3053
20cfcaae 3054 default:
8c1acd09 3055 /* Check for any processor-specific program segment types. */
20cfcaae 3056 bed = get_elf_backend_data (abfd);
91d6fa6a 3057 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
20cfcaae
NC		 3058 }
3059}
3060
d4730f92
BS		 3061/* Return the REL_HDR for SEC, assuming there is only a single one, either
3062 REL or RELA. */
3063
3064Elf_Internal_Shdr *
3065_bfd_elf_single_rel_hdr (asection *sec)
3066{
3067 if (elf_section_data (sec)->rel.hdr)
3068 {
3069 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
3070 return elf_section_data (sec)->rel.hdr;
3071 }
3072 else
3073 return elf_section_data (sec)->rela.hdr;
3074}
3075
3e19fb8f
L		 3076static bfd_boolean
3077_bfd_elf_set_reloc_sh_name (bfd *abfd,
3078 Elf_Internal_Shdr *rel_hdr,
3079 const char *sec_name,
3080 bfd_boolean use_rela_p)
3081{
3082 char *name = (char *) bfd_alloc (abfd,
3083 sizeof ".rela" + strlen (sec_name));
3084 if (name == NULL)
3085 return FALSE;
3086
3087 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
3088 rel_hdr->sh_name =
3089 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3090 FALSE);
3091 if (rel_hdr->sh_name == (unsigned int) -1)
3092 return FALSE;
3093
3094 return TRUE;
3095}
3096
d4730f92
BS		 3097/* Allocate and initialize a section-header for a new reloc section,
3098 containing relocations against ASECT. It is stored in RELDATA. If
3099 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3100 relocations. */
23bc299b 3101
5d13b3b3 3102static bfd_boolean
217aa764 3103_bfd_elf_init_reloc_shdr (bfd *abfd,
d4730f92 3104 struct bfd_elf_section_reloc_data *reldata,
f6fe1ccd 3105 const char *sec_name,
3e19fb8f
L		 3106 bfd_boolean use_rela_p,
3107 bfd_boolean delay_st_name_p)
23bc299b 3108{
d4730f92 3109 Elf_Internal_Shdr *rel_hdr;
9c5bfbb7 3110 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92 3111
d4730f92 3112 BFD_ASSERT (reldata->hdr == NULL);
ef53be89 3113 rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
d4730f92 3114 reldata->hdr = rel_hdr;
23bc299b 3115
3e19fb8f
L		 3116 if (delay_st_name_p)
3117 rel_hdr->sh_name = (unsigned int) -1;
3118 else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3119 use_rela_p))
b34976b6 3120 return FALSE;
23bc299b
MM		 3121 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3122 rel_hdr->sh_entsize = (use_rela_p
3123 ? bed->s->sizeof_rela
3124 : bed->s->sizeof_rel);
72de5009 3125 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
28e07a05 3126 rel_hdr->sh_flags = 0;
23bc299b
MM		 3127 rel_hdr->sh_addr = 0;
3128 rel_hdr->sh_size = 0;
3129 rel_hdr->sh_offset = 0;
3130
b34976b6 3131 return TRUE;
23bc299b
MM		 3132}
3133
94be91de
JB		 3134/* Return the default section type based on the passed in section flags. */
3135
3136int
3137bfd_elf_get_default_section_type (flagword flags)
3138{
0e41bebb 3139 if ((flags & (SEC_ALLOC | SEC_IS_COMMON)) != 0
2e76e85a 3140 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
94be91de
JB		 3141 return SHT_NOBITS;
3142 return SHT_PROGBITS;
3143}
3144
d4730f92
BS		 3145struct fake_section_arg
3146{
3147 struct bfd_link_info *link_info;
3148 bfd_boolean failed;
3149};
3150
252b5132
RH		 3151/* Set up an ELF internal section header for a section. */
3152
252b5132 3153static void
d4730f92 3154elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
252b5132 3155{
d4730f92 3156 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
9c5bfbb7 3157 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92 3158 struct bfd_elf_section_data *esd = elf_section_data (asect);
252b5132 3159 Elf_Internal_Shdr *this_hdr;
0414f35b 3160 unsigned int sh_type;
0ce398f1 3161 const char *name = asect->name;
3e19fb8f 3162 bfd_boolean delay_st_name_p = FALSE;
252b5132 3163
d4730f92 3164 if (arg->failed)
252b5132
RH		 3165 {
3166 /* We already failed; just get out of the bfd_map_over_sections
08a40648 3167 loop. */
252b5132
RH		 3168 return;
3169 }
3170
d4730f92 3171 this_hdr = &esd->this_hdr;
252b5132 3172
f6fe1ccd 3173 if (arg->link_info)
0ce398f1 3174 {
f6fe1ccd
L		 3175 /* ld: compress DWARF debug sections with names: .debug_*. */
3176 if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3177 && (asect->flags & SEC_DEBUGGING)
3178 && name[1] == 'd'
3179 && name[6] == '_')
3180 {
3181 /* Set SEC_ELF_COMPRESS to indicate this section should be
3182 compressed. */
3183 asect->flags |= SEC_ELF_COMPRESS;
0ce398f1 3184
dd905818 3185 /* If this section will be compressed, delay adding section
3e19fb8f
L		 3186 name to section name section after it is compressed in
3187 _bfd_elf_assign_file_positions_for_non_load. */
3188 delay_st_name_p = TRUE;
f6fe1ccd
L		 3189 }
3190 }
3191 else if ((asect->flags & SEC_ELF_RENAME))
3192 {
3193 /* objcopy: rename output DWARF debug section. */
3194 if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3195 {
3196 /* When we decompress or compress with SHF_COMPRESSED,
3197 convert section name from .zdebug_* to .debug_* if
3198 needed. */
3199 if (name[1] == 'z')
3200 {
3201 char *new_name = convert_zdebug_to_debug (abfd, name);
3202 if (new_name == NULL)
3203 {
3204 arg->failed = TRUE;
3205 return;
3206 }
3207 name = new_name;
3208 }
3209 }
3210 else if (asect->compress_status == COMPRESS_SECTION_DONE)
0ce398f1 3211 {
f6fe1ccd
L		 3212 /* PR binutils/18087: Compression does not always make a
3213 section smaller. So only rename the section when
3214 compression has actually taken place. If input section
3215 name is .zdebug_*, we should never compress it again. */
3216 char *new_name = convert_debug_to_zdebug (abfd, name);
0ce398f1
L		 3217 if (new_name == NULL)
3218 {
3219 arg->failed = TRUE;
3220 return;
3221 }
f6fe1ccd
L		 3222 BFD_ASSERT (name[1] != 'z');
3223 name = new_name;
0ce398f1
L		 3224 }
3225 }
3226
3e19fb8f
L		 3227 if (delay_st_name_p)
3228 this_hdr->sh_name = (unsigned int) -1;
3229 else
252b5132 3230 {
3e19fb8f
L		 3231 this_hdr->sh_name
3232 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3233 name, FALSE);
3234 if (this_hdr->sh_name == (unsigned int) -1)
3235 {
3236 arg->failed = TRUE;
3237 return;
3238 }
252b5132
RH		 3239 }
3240
a4d8e49b 3241 /* Don't clear sh_flags. Assembler may set additional bits. */
252b5132
RH		 3242
3243 if ((asect->flags & SEC_ALLOC) != 0
3244 || asect->user_set_vma)
3245 this_hdr->sh_addr = asect->vma;
3246 else
3247 this_hdr->sh_addr = 0;
3248
3249 this_hdr->sh_offset = 0;
eea6121a 3250 this_hdr->sh_size = asect->size;
252b5132 3251 this_hdr->sh_link = 0;
c86934ce
NC		 3252 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3253 if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3254 {
4eca0228 3255 _bfd_error_handler
695344c0 3256 /* xgettext:c-format */
9793eb77 3257 (_("%pB: error: alignment power %d of section `%pA' is too big"),
c08bb8dd 3258 abfd, asect->alignment_power, asect);
c86934ce
NC		 3259 arg->failed = TRUE;
3260 return;
3261 }
72de5009 3262 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
252b5132
RH		 3263 /* The sh_entsize and sh_info fields may have been set already by
3264 copy_private_section_data. */
3265
3266 this_hdr->bfd_section = asect;
3267 this_hdr->contents = NULL;
3268
3cddba1e
L		 3269 /* If the section type is unspecified, we set it based on
3270 asect->flags. */
98ece1b3
AM		 3271 if ((asect->flags & SEC_GROUP) != 0)
3272 sh_type = SHT_GROUP;
98ece1b3 3273 else
94be91de 3274 sh_type = bfd_elf_get_default_section_type (asect->flags);
98ece1b3 3275
3cddba1e 3276 if (this_hdr->sh_type == SHT_NULL)
98ece1b3
AM		 3277 this_hdr->sh_type = sh_type;
3278 else if (this_hdr->sh_type == SHT_NOBITS
3279 && sh_type == SHT_PROGBITS
3280 && (asect->flags & SEC_ALLOC) != 0)
3cddba1e 3281 {
98ece1b3
AM		 3282 /* Warn if we are changing a NOBITS section to PROGBITS, but
3283 allow the link to proceed. This can happen when users link
3284 non-bss input sections to bss output sections, or emit data
3285 to a bss output section via a linker script. */
4eca0228 3286 _bfd_error_handler
871b3ab2 3287 (_("warning: section `%pA' type changed to PROGBITS"), asect);
98ece1b3 3288 this_hdr->sh_type = sh_type;
3cddba1e
L		 3289 }
3290
2f89ff8d 3291 switch (this_hdr->sh_type)
252b5132 3292 {
2f89ff8d 3293 default:
2f89ff8d
L		 3294 break;
3295
3296 case SHT_STRTAB:
2f89ff8d
L		 3297 case SHT_NOTE:
3298 case SHT_NOBITS:
3299 case SHT_PROGBITS:
3300 break;
606851fb
AM		 3301
3302 case SHT_INIT_ARRAY:
3303 case SHT_FINI_ARRAY:
3304 case SHT_PREINIT_ARRAY:
3305 this_hdr->sh_entsize = bed->s->arch_size / 8;
3306 break;
2f89ff8d
L		 3307
3308 case SHT_HASH:
c7ac6ff8 3309 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2f89ff8d 3310 break;
5de3bf90 3311
2f89ff8d 3312 case SHT_DYNSYM:
252b5132 3313 this_hdr->sh_entsize = bed->s->sizeof_sym;
2f89ff8d
L		 3314 break;
3315
3316 case SHT_DYNAMIC:
252b5132 3317 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2f89ff8d
L		 3318 break;
3319
3320 case SHT_RELA:
3321 if (get_elf_backend_data (abfd)->may_use_rela_p)
3322 this_hdr->sh_entsize = bed->s->sizeof_rela;
3323 break;
3324
3325 case SHT_REL:
3326 if (get_elf_backend_data (abfd)->may_use_rel_p)
3327 this_hdr->sh_entsize = bed->s->sizeof_rel;
3328 break;
3329
3330 case SHT_GNU_versym:
252b5132 3331 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2f89ff8d
L		 3332 break;
3333
3334 case SHT_GNU_verdef:
252b5132
RH		 3335 this_hdr->sh_entsize = 0;
3336 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM		 3337 cverdefs. The linker will set cverdefs, but sh_info will be
3338 zero. */
252b5132
RH		 3339 if (this_hdr->sh_info == 0)
3340 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3341 else
3342 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3343 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2f89ff8d
L		 3344 break;
3345
3346 case SHT_GNU_verneed:
252b5132
RH		 3347 this_hdr->sh_entsize = 0;
3348 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM		 3349 cverrefs. The linker will set cverrefs, but sh_info will be
3350 zero. */
252b5132
RH		 3351 if (this_hdr->sh_info == 0)
3352 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3353 else
3354 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3355 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2f89ff8d
L		 3356 break;
3357
3358 case SHT_GROUP:
1783205a 3359 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2f89ff8d 3360 break;
fdc90cb4
JJ		 3361
3362 case SHT_GNU_HASH:
3363 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3364 break;
dbb410c3 3365 }
252b5132
RH		 3366
3367 if ((asect->flags & SEC_ALLOC) != 0)
3368 this_hdr->sh_flags |= SHF_ALLOC;
3369 if ((asect->flags & SEC_READONLY) == 0)
3370 this_hdr->sh_flags |= SHF_WRITE;
3371 if ((asect->flags & SEC_CODE) != 0)
3372 this_hdr->sh_flags |= SHF_EXECINSTR;
f5fa8ca2
JJ		 3373 if ((asect->flags & SEC_MERGE) != 0)
3374 {
3375 this_hdr->sh_flags |= SHF_MERGE;
3376 this_hdr->sh_entsize = asect->entsize;
f5fa8ca2 3377 }
84865015
NC		 3378 if ((asect->flags & SEC_STRINGS) != 0)
3379 this_hdr->sh_flags |= SHF_STRINGS;
1126897b 3380 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
dbb410c3 3381 this_hdr->sh_flags |= SHF_GROUP;
13ae64f3 3382 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
704afa60
JJ		 3383 {
3384 this_hdr->sh_flags |= SHF_TLS;
3a800eb9
AM		 3385 if (asect->size == 0
3386 && (asect->flags & SEC_HAS_CONTENTS) == 0)
704afa60 3387 {
3a800eb9 3388 struct bfd_link_order *o = asect->map_tail.link_order;
b34976b6 3389
704afa60 3390 this_hdr->sh_size = 0;
3a800eb9
AM		 3391 if (o != NULL)
3392 {
704afa60 3393 this_hdr->sh_size = o->offset + o->size;
3a800eb9
AM		 3394 if (this_hdr->sh_size != 0)
3395 this_hdr->sh_type = SHT_NOBITS;
3396 }
704afa60
JJ		 3397 }
3398 }
18ae9cc1
L		 3399 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3400 this_hdr->sh_flags |= SHF_EXCLUDE;
252b5132 3401
d4730f92
BS		 3402 /* If the section has relocs, set up a section header for the
3403 SHT_REL[A] section. If two relocation sections are required for
3404 this section, it is up to the processor-specific back-end to
3405 create the other. */
3406 if ((asect->flags & SEC_RELOC) != 0)
3407 {
3408 /* When doing a relocatable link, create both REL and RELA sections if
3409 needed. */
3410 if (arg->link_info
3411 /* Do the normal setup if we wouldn't create any sections here. */
3412 && esd->rel.count + esd->rela.count > 0
0e1862bb
L		 3413 && (bfd_link_relocatable (arg->link_info)
3414 || arg->link_info->emitrelocations))
d4730f92
BS		 3415 {
3416 if (esd->rel.count && esd->rel.hdr == NULL
28e07a05 3417 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name,
db4677b8 3418 FALSE, delay_st_name_p))
d4730f92
BS		 3419 {
3420 arg->failed = TRUE;
3421 return;
3422 }
3423 if (esd->rela.count && esd->rela.hdr == NULL
28e07a05 3424 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name,
db4677b8 3425 TRUE, delay_st_name_p))
d4730f92
BS		 3426 {
3427 arg->failed = TRUE;
3428 return;
3429 }
3430 }
3431 else if (!_bfd_elf_init_reloc_shdr (abfd,
3432 (asect->use_rela_p
3433 ? &esd->rela : &esd->rel),
f6fe1ccd 3434 name,
3e19fb8f
L		 3435 asect->use_rela_p,
3436 delay_st_name_p))
db4677b8 3437 {
d4730f92 3438 arg->failed = TRUE;
db4677b8
AM		 3439 return;
3440 }
d4730f92
BS		 3441 }
3442
252b5132 3443 /* Check for processor-specific section types. */
0414f35b 3444 sh_type = this_hdr->sh_type;
e1fddb6b
AO		 3445 if (bed->elf_backend_fake_sections
3446 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
db4677b8
AM		 3447 {
3448 arg->failed = TRUE;
3449 return;
3450 }
252b5132 3451
42bb2e33 3452 if (sh_type == SHT_NOBITS && asect->size != 0)
0414f35b
AM		 3453 {
3454 /* Don't change the header type from NOBITS if we are being
42bb2e33 3455 called for objcopy --only-keep-debug. */
0414f35b
AM		 3456 this_hdr->sh_type = sh_type;
3457 }
252b5132
RH		 3458}
3459
bcacc0f5
AM		 3460/* Fill in the contents of a SHT_GROUP section. Called from
3461 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3462 when ELF targets use the generic linker, ld. Called for ld -r
3463 from bfd_elf_final_link. */
dbb410c3 3464
1126897b 3465void
217aa764 3466bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
dbb410c3 3467{
a50b1753 3468 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
9dce4196 3469 asection *elt, *first;
dbb410c3 3470 unsigned char *loc;
b34976b6 3471 bfd_boolean gas;
dbb410c3 3472
7e4111ad
L		 3473 /* Ignore linker created group section. See elfNN_ia64_object_p in
3474 elfxx-ia64.c. */
ce5aecf8
AM		 3475 if ((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP
3476 || sec->size == 0
dbb410c3
AM		 3477 || *failedptr)
3478 return;
3479
bcacc0f5
AM		 3480 if (elf_section_data (sec)->this_hdr.sh_info == 0)
3481 {
3482 unsigned long symindx = 0;
3483
3484 /* elf_group_id will have been set up by objcopy and the
3485 generic linker. */
3486 if (elf_group_id (sec) != NULL)
3487 symindx = elf_group_id (sec)->udata.i;
1126897b 3488
bcacc0f5
AM		 3489 if (symindx == 0)
3490 {
3491 /* If called from the assembler, swap_out_syms will have set up
3492 elf_section_syms. */
3493 BFD_ASSERT (elf_section_syms (abfd) != NULL);
3494 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
3495 }
3496 elf_section_data (sec)->this_hdr.sh_info = symindx;
3497 }
3498 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
1126897b 3499 {
bcacc0f5
AM		 3500 /* The ELF backend linker sets sh_info to -2 when the group
3501 signature symbol is global, and thus the index can't be
3502 set until all local symbols are output. */
53720c49
AM		 3503 asection *igroup;
3504 struct bfd_elf_section_data *sec_data;
3505 unsigned long symndx;
3506 unsigned long extsymoff;
bcacc0f5
AM		 3507 struct elf_link_hash_entry *h;
3508
53720c49
AM		 3509 /* The point of this little dance to the first SHF_GROUP section
3510 then back to the SHT_GROUP section is that this gets us to
3511 the SHT_GROUP in the input object. */
3512 igroup = elf_sec_group (elf_next_in_group (sec));
3513 sec_data = elf_section_data (igroup);
3514 symndx = sec_data->this_hdr.sh_info;
3515 extsymoff = 0;
bcacc0f5
AM		 3516 if (!elf_bad_symtab (igroup->owner))
3517 {
3518 Elf_Internal_Shdr *symtab_hdr;
3519
3520 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
3521 extsymoff = symtab_hdr->sh_info;
3522 }
3523 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
3524 while (h->root.type == bfd_link_hash_indirect
3525 || h->root.type == bfd_link_hash_warning)
3526 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3527
3528 elf_section_data (sec)->this_hdr.sh_info = h->indx;
1126897b 3529 }
dbb410c3 3530
1126897b 3531 /* The contents won't be allocated for "ld -r" or objcopy. */
b34976b6 3532 gas = TRUE;
dbb410c3
AM		 3533 if (sec->contents == NULL)
3534 {
b34976b6 3535 gas = FALSE;
a50b1753 3536 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
9dce4196
AM		 3537
3538 /* Arrange for the section to be written out. */
3539 elf_section_data (sec)->this_hdr.contents = sec->contents;
dbb410c3
AM		 3540 if (sec->contents == NULL)
3541 {
b34976b6 3542 *failedptr = TRUE;
dbb410c3
AM		 3543 return;
3544 }
3545 }
3546
eea6121a 3547 loc = sec->contents + sec->size;
dbb410c3 3548
9dce4196
AM		 3549 /* Get the pointer to the first section in the group that gas
3550 squirreled away here. objcopy arranges for this to be set to the
3551 start of the input section group. */
3552 first = elt = elf_next_in_group (sec);
dbb410c3
AM		 3553
3554 /* First element is a flag word. Rest of section is elf section
3555 indices for all the sections of the group. Write them backwards
3556 just to keep the group in the same order as given in .section
3557 directives, not that it matters. */
3558 while (elt != NULL)
3559 {
9dce4196 3560 asection *s;
9dce4196 3561
9dce4196 3562 s = elt;
415f38a6
AM		 3563 if (!gas)
3564 s = s->output_section;
3565 if (s != NULL
3566 && !bfd_is_abs_section (s))
01e1a5bc 3567 {
db4677b8 3568 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
28e07a05
AM		 3569 struct bfd_elf_section_data *input_elf_sec = elf_section_data (elt);
3570
3571 if (elf_sec->rel.hdr != NULL
3572 && (gas
3573 || (input_elf_sec->rel.hdr != NULL
3574 && input_elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0))
db4677b8 3575 {
28e07a05 3576 elf_sec->rel.hdr->sh_flags |= SHF_GROUP;
db4677b8
AM		 3577 loc -= 4;
3578 H_PUT_32 (abfd, elf_sec->rel.idx, loc);
3579 }
28e07a05
AM		 3580 if (elf_sec->rela.hdr != NULL
3581 && (gas
3582 || (input_elf_sec->rela.hdr != NULL
3583 && input_elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0))
db4677b8 3584 {
28e07a05 3585 elf_sec->rela.hdr->sh_flags |= SHF_GROUP;
db4677b8
AM		 3586 loc -= 4;
3587 H_PUT_32 (abfd, elf_sec->rela.idx, loc);
3588 }
01e1a5bc 3589 loc -= 4;
db4677b8 3590 H_PUT_32 (abfd, elf_sec->this_idx, loc);
01e1a5bc 3591 }
945906ff 3592 elt = elf_next_in_group (elt);
9dce4196
AM		 3593 if (elt == first)
3594 break;
dbb410c3
AM		 3595 }
3596
7bdf4127
AB		 3597 loc -= 4;
3598 BFD_ASSERT (loc == sec->contents);
dbb410c3 3599
9dce4196 3600 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
dbb410c3
AM		 3601}
3602
bce964aa
AM		 3603/* Given NAME, the name of a relocation section stripped of its
3604 .rel/.rela prefix, return the section in ABFD to which the
3605 relocations apply. */
bd53a53a
L		 3606
3607asection *
bce964aa
AM		 3608_bfd_elf_plt_get_reloc_section (bfd *abfd, const char *name)
3609{
3610 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3611 section likely apply to .got.plt or .got section. */
3612 if (get_elf_backend_data (abfd)->want_got_plt
3613 && strcmp (name, ".plt") == 0)
3614 {
3615 asection *sec;
3616
3617 name = ".got.plt";
3618 sec = bfd_get_section_by_name (abfd, name);
3619 if (sec != NULL)
3620 return sec;
3621 name = ".got";
3622 }
3623
3624 return bfd_get_section_by_name (abfd, name);
3625}
3626
3627/* Return the section to which RELOC_SEC applies. */
3628
3629static asection *
3630elf_get_reloc_section (asection *reloc_sec)
bd53a53a
L		 3631{
3632 const char *name;
3633 unsigned int type;
3634 bfd *abfd;
bce964aa 3635 const struct elf_backend_data *bed;
bd53a53a
L		 3636
3637 type = elf_section_data (reloc_sec)->this_hdr.sh_type;
3638 if (type != SHT_REL && type != SHT_RELA)
3639 return NULL;
3640
3641 /* We look up the section the relocs apply to by name. */
3642 name = reloc_sec->name;
bce964aa
AM		 3643 if (strncmp (name, ".rel", 4) != 0)
3644 return NULL;
3645 name += 4;
3646 if (type == SHT_RELA && *name++ != 'a')
3647 return NULL;
bd53a53a 3648
bd53a53a 3649 abfd = reloc_sec->owner;
bce964aa
AM		 3650 bed = get_elf_backend_data (abfd);
3651 return bed->get_reloc_section (abfd, name);
bd53a53a
L		 3652}
3653
252b5132
RH		 3654/* Assign all ELF section numbers. The dummy first section is handled here
3655 too. The link/info pointers for the standard section types are filled
3656 in here too, while we're at it. */
3657
b34976b6 3658static bfd_boolean
da9f89d4 3659assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
252b5132
RH		 3660{
3661 struct elf_obj_tdata *t = elf_tdata (abfd);
3662 asection *sec;
3e19fb8f 3663 unsigned int section_number;
252b5132 3664 Elf_Internal_Shdr **i_shdrp;
47cc2cf5 3665 struct bfd_elf_section_data *d;
3516e984 3666 bfd_boolean need_symtab;
252b5132
RH		 3667
3668 section_number = 1;
3669
2b0f7ef9
JJ		 3670 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3671
da9f89d4 3672 /* SHT_GROUP sections are in relocatable files only. */
7bdf4127 3673 if (link_info == NULL || !link_info->resolve_section_groups)
252b5132 3674 {
ef53be89 3675 size_t reloc_count = 0;
14f2c699 3676
da9f89d4 3677 /* Put SHT_GROUP sections first. */
04dd1667 3678 for (sec = abfd->sections; sec != NULL; sec = sec->next)
47cc2cf5 3679 {
5daa8fe7 3680 d = elf_section_data (sec);
da9f89d4
L		 3681
3682 if (d->this_hdr.sh_type == SHT_GROUP)
08a40648 3683 {
5daa8fe7 3684 if (sec->flags & SEC_LINKER_CREATED)
da9f89d4
L		 3685 {
3686 /* Remove the linker created SHT_GROUP sections. */
5daa8fe7 3687 bfd_section_list_remove (abfd, sec);
da9f89d4 3688 abfd->section_count--;
da9f89d4 3689 }
08a40648 3690 else
4fbb74a6 3691 d->this_idx = section_number++;
da9f89d4 3692 }
14f2c699
L		 3693
3694 /* Count relocations. */
3695 reloc_count += sec->reloc_count;
47cc2cf5 3696 }
14f2c699
L		 3697
3698 /* Clear HAS_RELOC if there are no relocations. */
3699 if (reloc_count == 0)
3700 abfd->flags &= ~HAS_RELOC;
47cc2cf5
PB		 3701 }
3702
3703 for (sec = abfd->sections; sec; sec = sec->next)
3704 {
3705 d = elf_section_data (sec);
3706
3707 if (d->this_hdr.sh_type != SHT_GROUP)
4fbb74a6 3708 d->this_idx = section_number++;
3e19fb8f
L		 3709 if (d->this_hdr.sh_name != (unsigned int) -1)
3710 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
d4730f92 3711 if (d->rel.hdr)
2b0f7ef9 3712 {
d4730f92 3713 d->rel.idx = section_number++;
3e19fb8f
L		 3714 if (d->rel.hdr->sh_name != (unsigned int) -1)
3715 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2b0f7ef9 3716 }
d4730f92
BS		 3717 else
3718 d->rel.idx = 0;
23bc299b 3719
d4730f92 3720 if (d->rela.hdr)
2b0f7ef9 3721 {
d4730f92 3722 d->rela.idx = section_number++;
3e19fb8f
L		 3723 if (d->rela.hdr->sh_name != (unsigned int) -1)
3724 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2b0f7ef9 3725 }
23bc299b 3726 else
d4730f92 3727 d->rela.idx = 0;
252b5132
RH		 3728 }
3729
3516e984
L		 3730 need_symtab = (bfd_get_symcount (abfd) > 0
3731 || (link_info == NULL
3732 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3733 == HAS_RELOC)));
3734 if (need_symtab)
252b5132 3735 {
12bd6957 3736 elf_onesymtab (abfd) = section_number++;
2b0f7ef9 3737 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
4fbb74a6 3738 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
9ad5cbcf 3739 {
7a6e0d89 3740 elf_section_list *entry;
6a40cf0c
NC		 3741
3742 BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
3743
7a6e0d89 3744 entry = bfd_zalloc (abfd, sizeof (*entry));
6a40cf0c
NC		 3745 entry->ndx = section_number++;
3746 elf_symtab_shndx_list (abfd) = entry;
3747 entry->hdr.sh_name
9ad5cbcf 3748 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
b34976b6 3749 ".symtab_shndx", FALSE);
6a40cf0c 3750 if (entry->hdr.sh_name == (unsigned int) -1)
b34976b6 3751 return FALSE;
9ad5cbcf 3752 }
12bd6957 3753 elf_strtab_sec (abfd) = section_number++;
2b0f7ef9 3754 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
252b5132
RH		 3755 }
3756
dd905818
NC		 3757 elf_shstrtab_sec (abfd) = section_number++;
3758 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3759 elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
3760
1c52a645
L		 3761 if (section_number >= SHN_LORESERVE)
3762 {
695344c0 3763 /* xgettext:c-format */
871b3ab2 3764 _bfd_error_handler (_("%pB: too many sections: %u"),
1c52a645
L		 3765 abfd, section_number);
3766 return FALSE;
3767 }
3768
9ad5cbcf 3769 elf_numsections (abfd) = section_number;
252b5132
RH		 3770 elf_elfheader (abfd)->e_shnum = section_number;
3771
3772 /* Set up the list of section header pointers, in agreement with the
3773 indices. */
a50b1753 3774 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
07d6d2b8 3775 sizeof (Elf_Internal_Shdr *));
252b5132 3776 if (i_shdrp == NULL)
b34976b6 3777 return FALSE;
252b5132 3778
a50b1753 3779 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
07d6d2b8 3780 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3781 if (i_shdrp[0] == NULL)
3782 {
3783 bfd_release (abfd, i_shdrp);
b34976b6 3784 return FALSE;
252b5132 3785 }
252b5132
RH		 3786
3787 elf_elfsections (abfd) = i_shdrp;
3788
12bd6957 3789 i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3516e984 3790 if (need_symtab)
252b5132 3791 {
12bd6957 3792 i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
4fbb74a6 3793 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
9ad5cbcf 3794 {
6a40cf0c
NC		 3795 elf_section_list * entry = elf_symtab_shndx_list (abfd);
3796 BFD_ASSERT (entry != NULL);
3797 i_shdrp[entry->ndx] = & entry->hdr;
3798 entry->hdr.sh_link = elf_onesymtab (abfd);
9ad5cbcf 3799 }
12bd6957
AM		 3800 i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3801 t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
252b5132 3802 }
38ce5b11 3803
252b5132
RH		 3804 for (sec = abfd->sections; sec; sec = sec->next)
3805 {
252b5132 3806 asection *s;
252b5132 3807
91d6fa6a
NC		 3808 d = elf_section_data (sec);
3809
252b5132 3810 i_shdrp[d->this_idx] = &d->this_hdr;
d4730f92
BS		 3811 if (d->rel.idx != 0)
3812 i_shdrp[d->rel.idx] = d->rel.hdr;
3813 if (d->rela.idx != 0)
3814 i_shdrp[d->rela.idx] = d->rela.hdr;
252b5132
RH		 3815
3816 /* Fill in the sh_link and sh_info fields while we're at it. */
3817
3818 /* sh_link of a reloc section is the section index of the symbol
3819 table. sh_info is the section index of the section to which
3820 the relocation entries apply. */
d4730f92 3821 if (d->rel.idx != 0)
252b5132 3822 {
12bd6957 3823 d->rel.hdr->sh_link = elf_onesymtab (abfd);
d4730f92 3824 d->rel.hdr->sh_info = d->this_idx;
9ef5d938 3825 d->rel.hdr->sh_flags |= SHF_INFO_LINK;
252b5132 3826 }
d4730f92 3827 if (d->rela.idx != 0)
23bc299b 3828 {
12bd6957 3829 d->rela.hdr->sh_link = elf_onesymtab (abfd);
d4730f92 3830 d->rela.hdr->sh_info = d->this_idx;
9ef5d938 3831 d->rela.hdr->sh_flags |= SHF_INFO_LINK;
23bc299b 3832 }
252b5132 3833
38ce5b11
L		 3834 /* We need to set up sh_link for SHF_LINK_ORDER. */
3835 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3836 {
3837 s = elf_linked_to_section (sec);
3838 if (s)
38ce5b11 3839 {
f2876037 3840 /* elf_linked_to_section points to the input section. */
ccd2ec6a 3841 if (link_info != NULL)
38ce5b11 3842 {
f2876037 3843 /* Check discarded linkonce section. */
dbaa2011 3844 if (discarded_section (s))
38ce5b11 3845 {
ccd2ec6a 3846 asection *kept;
4eca0228 3847 _bfd_error_handler
695344c0 3848 /* xgettext:c-format */
871b3ab2
AM		 3849 (_("%pB: sh_link of section `%pA' points to"
3850 " discarded section `%pA' of `%pB'"),
ccd2ec6a
L		 3851 abfd, d->this_hdr.bfd_section,
3852 s, s->owner);
3853 /* Point to the kept section if it has the same
3854 size as the discarded one. */
c0f00686 3855 kept = _bfd_elf_check_kept_section (s, link_info);
ccd2ec6a 3856 if (kept == NULL)
185d09ad 3857 {
ccd2ec6a
L		 3858 bfd_set_error (bfd_error_bad_value);
3859 return FALSE;
185d09ad 3860 }
ccd2ec6a 3861 s = kept;
38ce5b11 3862 }
e424ecc8 3863
ccd2ec6a
L		 3864 s = s->output_section;
3865 BFD_ASSERT (s != NULL);
38ce5b11 3866 }
f2876037
L		 3867 else
3868 {
3869 /* Handle objcopy. */
3870 if (s->output_section == NULL)
3871 {
4eca0228 3872 _bfd_error_handler
695344c0 3873 /* xgettext:c-format */
871b3ab2
AM		 3874 (_("%pB: sh_link of section `%pA' points to"
3875 " removed section `%pA' of `%pB'"),
f2876037
L		 3876 abfd, d->this_hdr.bfd_section, s, s->owner);
3877 bfd_set_error (bfd_error_bad_value);
3878 return FALSE;
3879 }
3880 s = s->output_section;
3881 }
ccd2ec6a
L		 3882 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3883 }
3884 else
3885 {
3886 /* PR 290:
3887 The Intel C compiler generates SHT_IA_64_UNWIND with
3888 SHF_LINK_ORDER. But it doesn't set the sh_link or
3889 sh_info fields. Hence we could get the situation
08a40648 3890 where s is NULL. */
ccd2ec6a
L		 3891 const struct elf_backend_data *bed
3892 = get_elf_backend_data (abfd);
3893 if (bed->link_order_error_handler)
3894 bed->link_order_error_handler
695344c0 3895 /* xgettext:c-format */
871b3ab2 3896 (_("%pB: warning: sh_link not set for section `%pA'"),
ccd2ec6a 3897 abfd, sec);
38ce5b11
L		 3898 }
3899 }
3900
252b5132
RH		 3901 switch (d->this_hdr.sh_type)
3902 {
3903 case SHT_REL:
3904 case SHT_RELA:
3905 /* A reloc section which we are treating as a normal BFD
3906 section. sh_link is the section index of the symbol
3907 table. sh_info is the section index of the section to
3908 which the relocation entries apply. We assume that an
3909 allocated reloc section uses the dynamic symbol table.
3910 FIXME: How can we be sure? */
3911 s = bfd_get_section_by_name (abfd, ".dynsym");
3912 if (s != NULL)
3913 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3914
bce964aa 3915 s = elf_get_reloc_section (sec);
252b5132 3916 if (s != NULL)
9ef5d938
L		 3917 {
3918 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3919 d->this_hdr.sh_flags |= SHF_INFO_LINK;
3920 }
252b5132
RH		 3921 break;
3922
3923 case SHT_STRTAB:
3924 /* We assume that a section named .stab*str is a stabs
3925 string section. We look for a section with the same name
3926 but without the trailing ``str'', and set its sh_link
3927 field to point to this section. */
0112cd26 3928 if (CONST_STRNEQ (sec->name, ".stab")
252b5132
RH		 3929 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3930 {
3931 size_t len;
3932 char *alc;
3933
3934 len = strlen (sec->name);
a50b1753 3935 alc = (char *) bfd_malloc (len - 2);
252b5132 3936 if (alc == NULL)
b34976b6 3937 return FALSE;
d4c88bbb 3938 memcpy (alc, sec->name, len - 3);
252b5132
RH		 3939 alc[len - 3] = '\0';
3940 s = bfd_get_section_by_name (abfd, alc);
3941 free (alc);
3942 if (s != NULL)
3943 {
3944 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3945
3946 /* This is a .stab section. */
0594c12d
AM		 3947 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3948 elf_section_data (s)->this_hdr.sh_entsize
3949 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
252b5132
RH		 3950 }
3951 }
3952 break;
3953
3954 case SHT_DYNAMIC:
3955 case SHT_DYNSYM:
3956 case SHT_GNU_verneed:
3957 case SHT_GNU_verdef:
3958 /* sh_link is the section header index of the string table
3959 used for the dynamic entries, or the symbol table, or the
3960 version strings. */
3961 s = bfd_get_section_by_name (abfd, ".dynstr");
3962 if (s != NULL)
3963 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3964 break;
3965
7f1204bb
JJ		 3966 case SHT_GNU_LIBLIST:
3967 /* sh_link is the section header index of the prelink library
08a40648
AM		 3968 list used for the dynamic entries, or the symbol table, or
3969 the version strings. */
7f1204bb
JJ		 3970 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3971 ? ".dynstr" : ".gnu.libstr");
3972 if (s != NULL)
3973 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3974 break;
3975
252b5132 3976 case SHT_HASH:
fdc90cb4 3977 case SHT_GNU_HASH:
252b5132
RH		 3978 case SHT_GNU_versym:
3979 /* sh_link is the section header index of the symbol table
3980 this hash table or version table is for. */
3981 s = bfd_get_section_by_name (abfd, ".dynsym");
3982 if (s != NULL)
3983 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3984 break;
dbb410c3
AM		 3985
3986 case SHT_GROUP:
12bd6957 3987 d->this_hdr.sh_link = elf_onesymtab (abfd);
252b5132
RH		 3988 }
3989 }
3990
3e19fb8f
L		 3991 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3992 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3993 debug section name from .debug_* to .zdebug_* if needed. */
3994
b34976b6 3995 return TRUE;
252b5132
RH		 3996}
3997
5372391b 3998static bfd_boolean
217aa764 3999sym_is_global (bfd *abfd, asymbol *sym)
252b5132
RH		 4000{
4001 /* If the backend has a special mapping, use it. */
9c5bfbb7 4002 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764
AM		 4003 if (bed->elf_backend_sym_is_global)
4004 return (*bed->elf_backend_sym_is_global) (abfd, sym);
252b5132 4005
e47bf690 4006 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
252b5132
RH		 4007 || bfd_is_und_section (bfd_get_section (sym))
4008 || bfd_is_com_section (bfd_get_section (sym)));
4009}
4010
76359541
TP		 4011/* Filter global symbols of ABFD to include in the import library. All
4012 SYMCOUNT symbols of ABFD can be examined from their pointers in
4013 SYMS. Pointers of symbols to keep should be stored contiguously at
4014 the beginning of that array.
4015
4016 Returns the number of symbols to keep. */
4017
4018unsigned int
4019_bfd_elf_filter_global_symbols (bfd *abfd, struct bfd_link_info *info,
4020 asymbol **syms, long symcount)
4021{
4022 long src_count, dst_count = 0;
4023
4024 for (src_count = 0; src_count < symcount; src_count++)
4025 {
4026 asymbol *sym = syms[src_count];
4027 char *name = (char *) bfd_asymbol_name (sym);
4028 struct bfd_link_hash_entry *h;
4029
4030 if (!sym_is_global (abfd, sym))
4031 continue;
4032
4033 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
5df1bc57
AM		 4034 if (h == NULL)
4035 continue;
76359541
TP		 4036 if (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak)
4037 continue;
76359541
TP		 4038 if (h->linker_def || h->ldscript_def)
4039 continue;
4040
4041 syms[dst_count++] = sym;
4042 }
4043
4044 syms[dst_count] = NULL;
4045
4046 return dst_count;
4047}
4048
5372391b 4049/* Don't output section symbols for sections that are not going to be
c6d8cab4 4050 output, that are duplicates or there is no BFD section. */
5372391b
AM		 4051
4052static bfd_boolean
4053ignore_section_sym (bfd *abfd, asymbol *sym)
4054{
c6d8cab4
L		 4055 elf_symbol_type *type_ptr;
4056
db0c309f
NC		 4057 if (sym == NULL)
4058 return FALSE;
4059
c6d8cab4
L		 4060 if ((sym->flags & BSF_SECTION_SYM) == 0)
4061 return FALSE;
4062
db0c309f
NC		 4063 if (sym->section == NULL)
4064 return TRUE;
4065
c6d8cab4
L		 4066 type_ptr = elf_symbol_from (abfd, sym);
4067 return ((type_ptr != NULL
4068 && type_ptr->internal_elf_sym.st_shndx != 0
4069 && bfd_is_abs_section (sym->section))
4070 || !(sym->section->owner == abfd
db0c309f
NC		 4071 || (sym->section->output_section != NULL
4072 && sym->section->output_section->owner == abfd
2633a79c
AM		 4073 && sym->section->output_offset == 0)
4074 || bfd_is_abs_section (sym->section)));
5372391b
AM		 4075}
4076
2633a79c
AM		 4077/* Map symbol from it's internal number to the external number, moving
4078 all local symbols to be at the head of the list. */
4079
b34976b6 4080static bfd_boolean
12bd6957 4081elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
252b5132 4082{
dc810e39 4083 unsigned int symcount = bfd_get_symcount (abfd);
252b5132
RH		 4084 asymbol **syms = bfd_get_outsymbols (abfd);
4085 asymbol **sect_syms;
dc810e39
AM		 4086 unsigned int num_locals = 0;
4087 unsigned int num_globals = 0;
4088 unsigned int num_locals2 = 0;
4089 unsigned int num_globals2 = 0;
7292b3ac 4090 unsigned int max_index = 0;
dc810e39 4091 unsigned int idx;
252b5132
RH		 4092 asection *asect;
4093 asymbol **new_syms;
252b5132
RH		 4094
4095#ifdef DEBUG
4096 fprintf (stderr, "elf_map_symbols\n");
4097 fflush (stderr);
4098#endif
4099
252b5132
RH		 4100 for (asect = abfd->sections; asect; asect = asect->next)
4101 {
4102 if (max_index < asect->index)
4103 max_index = asect->index;
4104 }
4105
4106 max_index++;
a50b1753 4107 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
252b5132 4108 if (sect_syms == NULL)
b34976b6 4109 return FALSE;
252b5132 4110 elf_section_syms (abfd) = sect_syms;
4e89ac30 4111 elf_num_section_syms (abfd) = max_index;
252b5132 4112
079e9a2f
AM		 4113 /* Init sect_syms entries for any section symbols we have already
4114 decided to output. */
252b5132
RH		 4115 for (idx = 0; idx < symcount; idx++)
4116 {
dc810e39 4117 asymbol *sym = syms[idx];
c044fabd 4118
252b5132 4119 if ((sym->flags & BSF_SECTION_SYM) != 0
0f0a5e58 4120 && sym->value == 0
2633a79c
AM		 4121 && !ignore_section_sym (abfd, sym)
4122 && !bfd_is_abs_section (sym->section))
252b5132 4123 {
5372391b 4124 asection *sec = sym->section;
252b5132 4125
5372391b
AM		 4126 if (sec->owner != abfd)
4127 sec = sec->output_section;
252b5132 4128
5372391b 4129 sect_syms[sec->index] = syms[idx];
252b5132
RH		 4130 }
4131 }
4132
252b5132
RH		 4133 /* Classify all of the symbols. */
4134 for (idx = 0; idx < symcount; idx++)
4135 {
2633a79c 4136 if (sym_is_global (abfd, syms[idx]))
252b5132 4137 num_globals++;
2633a79c
AM		 4138 else if (!ignore_section_sym (abfd, syms[idx]))
4139 num_locals++;
252b5132 4140 }
079e9a2f 4141
5372391b 4142 /* We will be adding a section symbol for each normal BFD section. Most
079e9a2f
AM		 4143 sections will already have a section symbol in outsymbols, but
4144 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4145 at least in that case. */
252b5132
RH		 4146 for (asect = abfd->sections; asect; asect = asect->next)
4147 {
079e9a2f 4148 if (sect_syms[asect->index] == NULL)
252b5132 4149 {
079e9a2f 4150 if (!sym_is_global (abfd, asect->symbol))
252b5132
RH		 4151 num_locals++;
4152 else
4153 num_globals++;
252b5132
RH		 4154 }
4155 }
4156
4157 /* Now sort the symbols so the local symbols are first. */
a50b1753 4158 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
07d6d2b8 4159 sizeof (asymbol *));
dc810e39 4160
252b5132 4161 if (new_syms == NULL)
b34976b6 4162 return FALSE;
252b5132
RH		 4163
4164 for (idx = 0; idx < symcount; idx++)
4165 {
4166 asymbol *sym = syms[idx];
dc810e39 4167 unsigned int i;
252b5132 4168
2633a79c
AM		 4169 if (sym_is_global (abfd, sym))
4170 i = num_locals + num_globals2++;
4171 else if (!ignore_section_sym (abfd, sym))
252b5132
RH		 4172 i = num_locals2++;
4173 else
2633a79c 4174 continue;
252b5132
RH		 4175 new_syms[i] = sym;
4176 sym->udata.i = i + 1;
4177 }
4178 for (asect = abfd->sections; asect; asect = asect->next)
4179 {
079e9a2f 4180 if (sect_syms[asect->index] == NULL)
252b5132 4181 {
079e9a2f 4182 asymbol *sym = asect->symbol;
dc810e39 4183 unsigned int i;
252b5132 4184
079e9a2f 4185 sect_syms[asect->index] = sym;
252b5132
RH		 4186 if (!sym_is_global (abfd, sym))
4187 i = num_locals2++;
4188 else
4189 i = num_locals + num_globals2++;
4190 new_syms[i] = sym;
4191 sym->udata.i = i + 1;
4192 }
4193 }
4194
4195 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
4196
12bd6957 4197 *pnum_locals = num_locals;
b34976b6 4198 return TRUE;
252b5132
RH		 4199}
4200
4201/* Align to the maximum file alignment that could be required for any
4202 ELF data structure. */
4203
268b6b39 4204static inline file_ptr
217aa764 4205align_file_position (file_ptr off, int align)
252b5132
RH		 4206{
4207 return (off + align - 1) & ~(align - 1);
4208}
4209
4210/* Assign a file position to a section, optionally aligning to the
4211 required section alignment. */
4212
217aa764
AM		 4213file_ptr
4214_bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
4215 file_ptr offset,
4216 bfd_boolean align)
252b5132 4217{
72de5009
AM		 4218 if (align && i_shdrp->sh_addralign > 1)
4219 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
252b5132
RH		 4220 i_shdrp->sh_offset = offset;
4221 if (i_shdrp->bfd_section != NULL)
4222 i_shdrp->bfd_section->filepos = offset;
4223 if (i_shdrp->sh_type != SHT_NOBITS)
4224 offset += i_shdrp->sh_size;
4225 return offset;
4226}
4227
4228/* Compute the file positions we are going to put the sections at, and
4229 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4230 is not NULL, this is being called by the ELF backend linker. */
4231
b34976b6 4232bfd_boolean
217aa764
AM		 4233_bfd_elf_compute_section_file_positions (bfd *abfd,
4234 struct bfd_link_info *link_info)
252b5132 4235{
9c5bfbb7 4236 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92 4237 struct fake_section_arg fsargs;
b34976b6 4238 bfd_boolean failed;
ef10c3ac 4239 struct elf_strtab_hash *strtab = NULL;
252b5132 4240 Elf_Internal_Shdr *shstrtab_hdr;
3516e984 4241 bfd_boolean need_symtab;
252b5132
RH		 4242
4243 if (abfd->output_has_begun)
b34976b6 4244 return TRUE;
252b5132
RH		 4245
4246 /* Do any elf backend specific processing first. */
4247 if (bed->elf_backend_begin_write_processing)
4248 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
4249
4250 if (! prep_headers (abfd))
b34976b6 4251 return FALSE;
252b5132 4252
e6c51ed4 4253 /* Post process the headers if necessary. */
78245035 4254 (*bed->elf_backend_post_process_headers) (abfd, link_info);
e6c51ed4 4255
d4730f92
BS		 4256 fsargs.failed = FALSE;
4257 fsargs.link_info = link_info;
4258 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
4259 if (fsargs.failed)
b34976b6 4260 return FALSE;
252b5132 4261
da9f89d4 4262 if (!assign_section_numbers (abfd, link_info))
b34976b6 4263 return FALSE;
252b5132
RH		 4264
4265 /* The backend linker builds symbol table information itself. */
3516e984
L		 4266 need_symtab = (link_info == NULL
4267 && (bfd_get_symcount (abfd) > 0
4268 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
4269 == HAS_RELOC)));
4270 if (need_symtab)
252b5132
RH		 4271 {
4272 /* Non-zero if doing a relocatable link. */
4273 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
4274
4275 if (! swap_out_syms (abfd, &strtab, relocatable_p))
b34976b6 4276 return FALSE;
252b5132
RH		 4277 }
4278
d4730f92 4279 failed = FALSE;
1126897b 4280 if (link_info == NULL)
dbb410c3 4281 {
1126897b 4282 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
dbb410c3 4283 if (failed)
b34976b6 4284 return FALSE;
dbb410c3
AM		 4285 }
4286
252b5132
RH		 4287 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
4288 /* sh_name was set in prep_headers. */
4289 shstrtab_hdr->sh_type = SHT_STRTAB;
84865015 4290 shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
252b5132 4291 shstrtab_hdr->sh_addr = 0;
946748d5 4292 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
252b5132
RH		 4293 shstrtab_hdr->sh_entsize = 0;
4294 shstrtab_hdr->sh_link = 0;
4295 shstrtab_hdr->sh_info = 0;
3e19fb8f 4296 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
252b5132
RH		 4297 shstrtab_hdr->sh_addralign = 1;
4298
c84fca4d 4299 if (!assign_file_positions_except_relocs (abfd, link_info))
b34976b6 4300 return FALSE;
252b5132 4301
3516e984 4302 if (need_symtab)
252b5132
RH		 4303 {
4304 file_ptr off;
4305 Elf_Internal_Shdr *hdr;
4306
12bd6957 4307 off = elf_next_file_pos (abfd);
252b5132 4308
6a40cf0c 4309 hdr = & elf_symtab_hdr (abfd);
b34976b6 4310 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 4311
6a40cf0c
NC		 4312 if (elf_symtab_shndx_list (abfd) != NULL)
4313 {
4314 hdr = & elf_symtab_shndx_list (abfd)->hdr;
4315 if (hdr->sh_size != 0)
4316 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4317 /* FIXME: What about other symtab_shndx sections in the list ? */
4318 }
9ad5cbcf 4319
252b5132 4320 hdr = &elf_tdata (abfd)->strtab_hdr;
b34976b6 4321 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 4322
12bd6957 4323 elf_next_file_pos (abfd) = off;
252b5132
RH		 4324
4325 /* Now that we know where the .strtab section goes, write it
08a40648 4326 out. */
252b5132 4327 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
ef10c3ac 4328 || ! _bfd_elf_strtab_emit (abfd, strtab))
b34976b6 4329 return FALSE;
ef10c3ac 4330 _bfd_elf_strtab_free (strtab);
252b5132
RH		 4331 }
4332
b34976b6 4333 abfd->output_has_begun = TRUE;
252b5132 4334
b34976b6 4335 return TRUE;
252b5132
RH		 4336}
4337
8ded5a0f
AM		 4338/* Make an initial estimate of the size of the program header. If we
4339 get the number wrong here, we'll redo section placement. */
4340
4341static bfd_size_type
4342get_program_header_size (bfd *abfd, struct bfd_link_info *info)
4343{
4344 size_t segs;
4345 asection *s;
2b05f1b7 4346 const struct elf_backend_data *bed;
8ded5a0f
AM		 4347
4348 /* Assume we will need exactly two PT_LOAD segments: one for text
4349 and one for data. */
4350 segs = 2;
4351
4352 s = bfd_get_section_by_name (abfd, ".interp");
1b9e270b 4353 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
8ded5a0f
AM		 4354 {
4355 /* If we have a loadable interpreter section, we need a
4356 PT_INTERP segment. In this case, assume we also need a
4357 PT_PHDR segment, although that may not be true for all
4358 targets. */
e9a38e0f 4359 segs += 2;
8ded5a0f
AM		 4360 }
4361
4362 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4363 {
4364 /* We need a PT_DYNAMIC segment. */
4365 ++segs;
f210dcff 4366 }
08a40648 4367
ceae84aa 4368 if (info != NULL && info->relro)
f210dcff
L		 4369 {
4370 /* We need a PT_GNU_RELRO segment. */
4371 ++segs;
8ded5a0f
AM		 4372 }
4373
12bd6957 4374 if (elf_eh_frame_hdr (abfd))
8ded5a0f
AM		 4375 {
4376 /* We need a PT_GNU_EH_FRAME segment. */
4377 ++segs;
4378 }
4379
12bd6957 4380 if (elf_stack_flags (abfd))
8ded5a0f 4381 {
2b05f1b7
L		 4382 /* We need a PT_GNU_STACK segment. */
4383 ++segs;
4384 }
94b11780 4385
0a59decb
L		 4386 s = bfd_get_section_by_name (abfd,
4387 NOTE_GNU_PROPERTY_SECTION_NAME);
4388 if (s != NULL && s->size != 0)
4389 {
4390 /* We need a PT_GNU_PROPERTY segment. */
4391 ++segs;
4392 }
4393
2b05f1b7
L		 4394 for (s = abfd->sections; s != NULL; s = s->next)
4395 {
8ded5a0f 4396 if ((s->flags & SEC_LOAD) != 0
23e463ed 4397 && elf_section_type (s) == SHT_NOTE)
8ded5a0f 4398 {
23e463ed 4399 unsigned int alignment_power;
8ded5a0f
AM		 4400 /* We need a PT_NOTE segment. */
4401 ++segs;
23e463ed
L		 4402 /* Try to create just one PT_NOTE segment for all adjacent
4403 loadable SHT_NOTE sections. gABI requires that within a
4404 PT_NOTE segment (and also inside of each SHT_NOTE section)
4405 each note should have the same alignment. So we check
4406 whether the sections are correctly aligned. */
4407 alignment_power = s->alignment_power;
4408 while (s->next != NULL
4409 && s->next->alignment_power == alignment_power
4410 && (s->next->flags & SEC_LOAD) != 0
4411 && elf_section_type (s->next) == SHT_NOTE)
4412 s = s->next;
8ded5a0f
AM		 4413 }
4414 }
4415
4416 for (s = abfd->sections; s != NULL; s = s->next)
4417 {
4418 if (s->flags & SEC_THREAD_LOCAL)
4419 {
4420 /* We need a PT_TLS segment. */
4421 ++segs;
4422 break;
4423 }
4424 }
4425
2b05f1b7 4426 bed = get_elf_backend_data (abfd);
a91e1603
L		 4427
4428 if ((abfd->flags & D_PAGED) != 0)
4429 {
4430 /* Add a PT_GNU_MBIND segment for each mbind section. */
4431 unsigned int page_align_power = bfd_log2 (bed->commonpagesize);
4432 for (s = abfd->sections; s != NULL; s = s->next)
4433 if (elf_section_flags (s) & SHF_GNU_MBIND)
4434 {
4435 if (elf_section_data (s)->this_hdr.sh_info
4436 > PT_GNU_MBIND_NUM)
4437 {
4438 _bfd_error_handler
4439 /* xgettext:c-format */
871b3ab2 4440 (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
a91e1603
L		 4441 abfd, s, elf_section_data (s)->this_hdr.sh_info);
4442 continue;
4443 }
4444 /* Align mbind section to page size. */
4445 if (s->alignment_power < page_align_power)
4446 s->alignment_power = page_align_power;
4447 segs ++;
4448 }
4449 }
4450
4451 /* Let the backend count up any program headers it might need. */
4452 if (bed->elf_backend_additional_program_headers)
8ded5a0f
AM		 4453 {
4454 int a;
4455
4456 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
4457 if (a == -1)
4458 abort ();
4459 segs += a;
4460 }
4461
4462 return segs * bed->s->sizeof_phdr;
4463}
4464
2ea37f1c
NC		 4465/* Find the segment that contains the output_section of section. */
4466
4467Elf_Internal_Phdr *
4468_bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
4469{
4470 struct elf_segment_map *m;
4471 Elf_Internal_Phdr *p;
4472
12bd6957 4473 for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
2ea37f1c
NC		 4474 m != NULL;
4475 m = m->next, p++)
4476 {
4477 int i;
4478
4479 for (i = m->count - 1; i >= 0; i--)
4480 if (m->sections[i] == section)
4481 return p;
4482 }
4483
4484 return NULL;
4485}
4486
252b5132
RH		 4487/* Create a mapping from a set of sections to a program segment. */
4488
217aa764
AM		 4489static struct elf_segment_map *
4490make_mapping (bfd *abfd,
4491 asection **sections,
4492 unsigned int from,
4493 unsigned int to,
4494 bfd_boolean phdr)
252b5132
RH		 4495{
4496 struct elf_segment_map *m;
4497 unsigned int i;
4498 asection **hdrpp;
dc810e39 4499 bfd_size_type amt;
252b5132 4500
00bee008
AM		 4501 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4502 amt += (to - from) * sizeof (asection *);
a50b1753 4503 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
252b5132
RH		 4504 if (m == NULL)
4505 return NULL;
4506 m->next = NULL;
4507 m->p_type = PT_LOAD;
4508 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
4509 m->sections[i - from] = *hdrpp;
4510 m->count = to - from;
4511
4512 if (from == 0 && phdr)
4513 {
4514 /* Include the headers in the first PT_LOAD segment. */
4515 m->includes_filehdr = 1;
4516 m->includes_phdrs = 1;
4517 }
4518
4519 return m;
4520}
4521
229fcec5
MM		 4522/* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4523 on failure. */
4524
4525struct elf_segment_map *
4526_bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
4527{
4528 struct elf_segment_map *m;
4529
a50b1753 4530 m = (struct elf_segment_map *) bfd_zalloc (abfd,
07d6d2b8 4531 sizeof (struct elf_segment_map));
229fcec5
MM		 4532 if (m == NULL)
4533 return NULL;
4534 m->next = NULL;
4535 m->p_type = PT_DYNAMIC;
4536 m->count = 1;
4537 m->sections[0] = dynsec;
08a40648 4538
229fcec5
MM		 4539 return m;
4540}
4541
8ded5a0f 4542/* Possibly add or remove segments from the segment map. */
252b5132 4543
b34976b6 4544static bfd_boolean
3dea8fca
AM		 4545elf_modify_segment_map (bfd *abfd,
4546 struct bfd_link_info *info,
4547 bfd_boolean remove_empty_load)
252b5132 4548{
252e386e 4549 struct elf_segment_map **m;
8ded5a0f 4550 const struct elf_backend_data *bed;
252b5132 4551
8ded5a0f
AM		 4552 /* The placement algorithm assumes that non allocated sections are
4553 not in PT_LOAD segments. We ensure this here by removing such
4554 sections from the segment map. We also remove excluded
252e386e
AM		 4555 sections. Finally, any PT_LOAD segment without sections is
4556 removed. */
12bd6957 4557 m = &elf_seg_map (abfd);
252e386e 4558 while (*m)
8ded5a0f
AM		 4559 {
4560 unsigned int i, new_count;
252b5132 4561
252e386e 4562 for (new_count = 0, i = 0; i < (*m)->count; i++)
8ded5a0f 4563 {
252e386e
AM		 4564 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
4565 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
4566 || (*m)->p_type != PT_LOAD))
8ded5a0f 4567 {
252e386e
AM		 4568 (*m)->sections[new_count] = (*m)->sections[i];
4569 new_count++;
8ded5a0f
AM		 4570 }
4571 }
252e386e 4572 (*m)->count = new_count;
252b5132 4573
1a9ccd70
NC		 4574 if (remove_empty_load
4575 && (*m)->p_type == PT_LOAD
4576 && (*m)->count == 0
4577 && !(*m)->includes_phdrs)
252e386e
AM		 4578 *m = (*m)->next;
4579 else
4580 m = &(*m)->next;
8ded5a0f 4581 }
252b5132 4582
8ded5a0f
AM		 4583 bed = get_elf_backend_data (abfd);
4584 if (bed->elf_backend_modify_segment_map != NULL)
252b5132 4585 {
252e386e 4586 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
8ded5a0f 4587 return FALSE;
252b5132 4588 }
252b5132 4589
8ded5a0f
AM		 4590 return TRUE;
4591}
252b5132 4592
dbc88fc1
AM		 4593#define IS_TBSS(s) \
4594 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4595
8ded5a0f 4596/* Set up a mapping from BFD sections to program segments. */
252b5132 4597
8ded5a0f
AM		 4598bfd_boolean
4599_bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
4600{
4601 unsigned int count;
4602 struct elf_segment_map *m;
4603 asection **sections = NULL;
4604 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3dea8fca 4605 bfd_boolean no_user_phdrs;
252b5132 4606
12bd6957 4607 no_user_phdrs = elf_seg_map (abfd) == NULL;
d324f6d6
RM		 4608
4609 if (info != NULL)
4610 info->user_phdrs = !no_user_phdrs;
4611
3dea8fca 4612 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
252b5132 4613 {
8ded5a0f
AM		 4614 asection *s;
4615 unsigned int i;
4616 struct elf_segment_map *mfirst;
4617 struct elf_segment_map **pm;
4618 asection *last_hdr;
4619 bfd_vma last_size;
00bee008 4620 unsigned int hdr_index;
8ded5a0f
AM		 4621 bfd_vma maxpagesize;
4622 asection **hdrpp;
64029e93 4623 bfd_boolean phdr_in_segment;
8ded5a0f 4624 bfd_boolean writable;
2888249f 4625 bfd_boolean executable;
8ded5a0f
AM		 4626 int tls_count = 0;
4627 asection *first_tls = NULL;
a91e1603 4628 asection *first_mbind = NULL;
8ded5a0f
AM		 4629 asection *dynsec, *eh_frame_hdr;
4630 bfd_size_type amt;
8d06853e 4631 bfd_vma addr_mask, wrap_to = 0;
64029e93 4632 bfd_size_type phdr_size;
252b5132 4633
8ded5a0f 4634 /* Select the allocated sections, and sort them. */
252b5132 4635
a50b1753 4636 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
07d6d2b8 4637 sizeof (asection *));
8ded5a0f 4638 if (sections == NULL)
252b5132 4639 goto error_return;
252b5132 4640
8d06853e
AM		 4641 /* Calculate top address, avoiding undefined behaviour of shift
4642 left operator when shift count is equal to size of type
4643 being shifted. */
4644 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
4645 addr_mask = (addr_mask << 1) + 1;
4646
8ded5a0f
AM		 4647 i = 0;
4648 for (s = abfd->sections; s != NULL; s = s->next)
4649 {
4650 if ((s->flags & SEC_ALLOC) != 0)
4651 {
4652 sections[i] = s;
4653 ++i;
8d06853e
AM		 4654 /* A wrapping section potentially clashes with header. */
4655 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
4656 wrap_to = (s->lma + s->size) & addr_mask;
8ded5a0f
AM		 4657 }
4658 }
4659 BFD_ASSERT (i <= bfd_count_sections (abfd));
4660 count = i;
252b5132 4661
8ded5a0f 4662 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
252b5132 4663
64029e93
AM		 4664 phdr_size = elf_program_header_size (abfd);
4665 if (phdr_size == (bfd_size_type) -1)
4666 phdr_size = get_program_header_size (abfd, info);
4667 phdr_size += bed->s->sizeof_ehdr;
4668 maxpagesize = bed->maxpagesize;
4669 if (maxpagesize == 0)
4670 maxpagesize = 1;
4671 phdr_in_segment = info != NULL && info->load_phdrs;
4672 if (count != 0
4673 && (((sections[0]->lma & addr_mask) & (maxpagesize - 1))
4674 >= (phdr_size & (maxpagesize - 1))))
4675 /* For compatibility with old scripts that may not be using
4676 SIZEOF_HEADERS, add headers when it looks like space has
4677 been left for them. */
4678 phdr_in_segment = TRUE;
252b5132 4679
64029e93 4680 /* Build the mapping. */
8ded5a0f
AM		 4681 mfirst = NULL;
4682 pm = &mfirst;
252b5132 4683
8ded5a0f
AM		 4684 /* If we have a .interp section, then create a PT_PHDR segment for
4685 the program headers and a PT_INTERP segment for the .interp
4686 section. */
4687 s = bfd_get_section_by_name (abfd, ".interp");
1b9e270b 4688 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
8ded5a0f
AM		 4689 {
4690 amt = sizeof (struct elf_segment_map);
a50b1753 4691 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM		 4692 if (m == NULL)
4693 goto error_return;
4694 m->next = NULL;
4695 m->p_type = PT_PHDR;
f882209d 4696 m->p_flags = PF_R;
8ded5a0f
AM		 4697 m->p_flags_valid = 1;
4698 m->includes_phdrs = 1;
64029e93 4699 phdr_in_segment = TRUE;
8ded5a0f
AM		 4700 *pm = m;
4701 pm = &m->next;
252b5132 4702
8ded5a0f 4703 amt = sizeof (struct elf_segment_map);
a50b1753 4704 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM		 4705 if (m == NULL)
4706 goto error_return;
4707 m->next = NULL;
4708 m->p_type = PT_INTERP;
4709 m->count = 1;
4710 m->sections[0] = s;
4711
4712 *pm = m;
4713 pm = &m->next;
252b5132 4714 }
8ded5a0f
AM		 4715
4716 /* Look through the sections. We put sections in the same program
4717 segment when the start of the second section can be placed within
4718 a few bytes of the end of the first section. */
4719 last_hdr = NULL;
4720 last_size = 0;
00bee008 4721 hdr_index = 0;
8ded5a0f 4722 writable = FALSE;
2888249f 4723 executable = FALSE;
8ded5a0f
AM		 4724 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
4725 if (dynsec != NULL
4726 && (dynsec->flags & SEC_LOAD) == 0)
4727 dynsec = NULL;
4728
64029e93
AM		 4729 if ((abfd->flags & D_PAGED) == 0)
4730 phdr_in_segment = FALSE;
4731
8ded5a0f
AM		 4732 /* Deal with -Ttext or something similar such that the first section
4733 is not adjacent to the program headers. This is an
4734 approximation, since at this point we don't know exactly how many
4735 program headers we will need. */
64029e93 4736 if (phdr_in_segment && count > 0)
252b5132 4737 {
64029e93
AM		 4738 bfd_vma phdr_lma;
4739 bfd_boolean separate_phdr = FALSE;
4740
4741 phdr_lma = (sections[0]->lma - phdr_size) & addr_mask & -maxpagesize;
4742 if (info != NULL
4743 && info->separate_code
4744 && (sections[0]->flags & SEC_CODE) != 0)
1a9ccd70 4745 {
64029e93
AM		 4746 /* If data sections should be separate from code and
4747 thus not executable, and the first section is
4748 executable then put the file and program headers in
4749 their own PT_LOAD. */
4750 separate_phdr = TRUE;
4751 if ((((phdr_lma + phdr_size - 1) & addr_mask & -maxpagesize)
4752 == (sections[0]->lma & addr_mask & -maxpagesize)))
4753 {
4754 /* The file and program headers are currently on the
4755 same page as the first section. Put them on the
4756 previous page if we can. */
4757 if (phdr_lma >= maxpagesize)
4758 phdr_lma -= maxpagesize;
4759 else
4760 separate_phdr = FALSE;
4761 }
4762 }
4763 if ((sections[0]->lma & addr_mask) < phdr_lma
4764 || (sections[0]->lma & addr_mask) < phdr_size)
4765 /* If file and program headers would be placed at the end
4766 of memory then it's probably better to omit them. */
4767 phdr_in_segment = FALSE;
4768 else if (phdr_lma < wrap_to)
4769 /* If a section wraps around to where we'll be placing
4770 file and program headers, then the headers will be
4771 overwritten. */
4772 phdr_in_segment = FALSE;
4773 else if (separate_phdr)
4774 {
4775 m = make_mapping (abfd, sections, 0, 0, phdr_in_segment);
4776 if (m == NULL)
4777 goto error_return;
4778 m->p_paddr = phdr_lma;
4779 m->p_vaddr_offset
4780 = (sections[0]->vma - phdr_size) & addr_mask & -maxpagesize;
4781 m->p_paddr_valid = 1;
4782 *pm = m;
4783 pm = &m->next;
4784 phdr_in_segment = FALSE;
1a9ccd70 4785 }
252b5132
RH		 4786 }
4787
8ded5a0f 4788 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
252b5132 4789 {
8ded5a0f
AM		 4790 asection *hdr;
4791 bfd_boolean new_segment;
4792
4793 hdr = *hdrpp;
4794
4795 /* See if this section and the last one will fit in the same
4796 segment. */
4797
4798 if (last_hdr == NULL)
4799 {
4800 /* If we don't have a segment yet, then we don't need a new
4801 one (we build the last one after this loop). */
4802 new_segment = FALSE;
4803 }
4804 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
4805 {
4806 /* If this section has a different relation between the
4807 virtual address and the load address, then we need a new
4808 segment. */
4809 new_segment = TRUE;
4810 }
b5599592
AM		 4811 else if (hdr->lma < last_hdr->lma + last_size
4812 || last_hdr->lma + last_size < last_hdr->lma)
4813 {
4814 /* If this section has a load address that makes it overlap
4815 the previous section, then we need a new segment. */
4816 new_segment = TRUE;
4817 }
76cb3a89
AM		 4818 else if ((abfd->flags & D_PAGED) != 0
4819 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
4820 == (hdr->lma & -maxpagesize)))
4821 {
4822 /* If we are demand paged then we can't map two disk
4823 pages onto the same memory page. */
4824 new_segment = FALSE;
4825 }
39948a60
NC		 4826 /* In the next test we have to be careful when last_hdr->lma is close
4827 to the end of the address space. If the aligned address wraps
4828 around to the start of the address space, then there are no more
4829 pages left in memory and it is OK to assume that the current
4830 section can be included in the current segment. */
76cb3a89
AM		 4831 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4832 + maxpagesize > last_hdr->lma)
4833 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4834 + maxpagesize <= hdr->lma))
8ded5a0f
AM		 4835 {
4836 /* If putting this section in this segment would force us to
4837 skip a page in the segment, then we need a new segment. */
4838 new_segment = TRUE;
4839 }
4840 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
76cb3a89 4841 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
8ded5a0f 4842 {
e5654c0f
AM		 4843 /* We don't want to put a loaded section after a
4844 nonloaded (ie. bss style) section in the same segment
4845 as that will force the non-loaded section to be loaded.
76cb3a89 4846 Consider .tbss sections as loaded for this purpose. */
8ded5a0f
AM		 4847 new_segment = TRUE;
4848 }
4849 else if ((abfd->flags & D_PAGED) == 0)
4850 {
4851 /* If the file is not demand paged, which means that we
4852 don't require the sections to be correctly aligned in the
4853 file, then there is no other reason for a new segment. */
4854 new_segment = FALSE;
4855 }
2888249f
L		 4856 else if (info != NULL
4857 && info->separate_code
4858 && executable != ((hdr->flags & SEC_CODE) != 0))
4859 {
4860 new_segment = TRUE;
4861 }
8ded5a0f 4862 else if (! writable
76cb3a89 4863 && (hdr->flags & SEC_READONLY) == 0)
8ded5a0f
AM		 4864 {
4865 /* We don't want to put a writable section in a read only
76cb3a89 4866 segment. */
8ded5a0f
AM		 4867 new_segment = TRUE;
4868 }
4869 else
4870 {
4871 /* Otherwise, we can use the same segment. */
4872 new_segment = FALSE;
4873 }
4874
2889e75b 4875 /* Allow interested parties a chance to override our decision. */
ceae84aa
AM		 4876 if (last_hdr != NULL
4877 && info != NULL
4878 && info->callbacks->override_segment_assignment != NULL)
4879 new_segment
4880 = info->callbacks->override_segment_assignment (info, abfd, hdr,
4881 last_hdr,
4882 new_segment);
2889e75b 4883
8ded5a0f
AM		 4884 if (! new_segment)
4885 {
4886 if ((hdr->flags & SEC_READONLY) == 0)
4887 writable = TRUE;
2888249f
L		 4888 if ((hdr->flags & SEC_CODE) != 0)
4889 executable = TRUE;
8ded5a0f
AM		 4890 last_hdr = hdr;
4891 /* .tbss sections effectively have zero size. */
dbc88fc1 4892 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
8ded5a0f
AM		 4893 continue;
4894 }
4895
4896 /* We need a new program segment. We must create a new program
00bee008 4897 header holding all the sections from hdr_index until hdr. */
8ded5a0f 4898
00bee008 4899 m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
8ded5a0f
AM		 4900 if (m == NULL)
4901 goto error_return;
4902
4903 *pm = m;
4904 pm = &m->next;
4905
252b5132 4906 if ((hdr->flags & SEC_READONLY) == 0)
b34976b6 4907 writable = TRUE;
8ded5a0f
AM		 4908 else
4909 writable = FALSE;
4910
2888249f
L		 4911 if ((hdr->flags & SEC_CODE) == 0)
4912 executable = FALSE;
4913 else
4914 executable = TRUE;
4915
baaff79e
JJ		 4916 last_hdr = hdr;
4917 /* .tbss sections effectively have zero size. */
dbc88fc1 4918 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
00bee008 4919 hdr_index = i;
8ded5a0f 4920 phdr_in_segment = FALSE;
252b5132
RH		 4921 }
4922
86b2281f
AM		 4923 /* Create a final PT_LOAD program segment, but not if it's just
4924 for .tbss. */
4925 if (last_hdr != NULL
00bee008 4926 && (i - hdr_index != 1
dbc88fc1 4927 || !IS_TBSS (last_hdr)))
8ded5a0f 4928 {
00bee008 4929 m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
8ded5a0f
AM		 4930 if (m == NULL)
4931 goto error_return;
252b5132 4932
8ded5a0f
AM		 4933 *pm = m;
4934 pm = &m->next;
4935 }
252b5132 4936
8ded5a0f
AM		 4937 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4938 if (dynsec != NULL)
4939 {
4940 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4941 if (m == NULL)
4942 goto error_return;
4943 *pm = m;
4944 pm = &m->next;
4945 }
252b5132 4946
23e463ed 4947 /* For each batch of consecutive loadable SHT_NOTE sections,
1c5265b5
JJ		 4948 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4949 because if we link together nonloadable .note sections and
4950 loadable .note sections, we will generate two .note sections
23e463ed 4951 in the output file. */
8ded5a0f
AM		 4952 for (s = abfd->sections; s != NULL; s = s->next)
4953 {
4954 if ((s->flags & SEC_LOAD) != 0
23e463ed 4955 && elf_section_type (s) == SHT_NOTE)
8ded5a0f 4956 {
1c5265b5 4957 asection *s2;
23e463ed 4958 unsigned int alignment_power = s->alignment_power;
91d6fa6a
NC		 4959
4960 count = 1;
23e463ed
L		 4961 for (s2 = s; s2->next != NULL; s2 = s2->next)
4962 {
4963 if (s2->next->alignment_power == alignment_power
4964 && (s2->next->flags & SEC_LOAD) != 0
4965 && elf_section_type (s2->next) == SHT_NOTE
4966 && align_power (s2->lma + s2->size,
4967 alignment_power)
4968 == s2->next->lma)
4969 count++;
4970 else
4971 break;
4972 }
00bee008
AM		 4973 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4974 amt += count * sizeof (asection *);
a50b1753 4975 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM		 4976 if (m == NULL)
4977 goto error_return;
4978 m->next = NULL;
4979 m->p_type = PT_NOTE;
1c5265b5
JJ		 4980 m->count = count;
4981 while (count > 1)
4982 {
4983 m->sections[m->count - count--] = s;
4984 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4985 s = s->next;
4986 }
4987 m->sections[m->count - 1] = s;
4988 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
8ded5a0f
AM		 4989 *pm = m;
4990 pm = &m->next;
4991 }
4992 if (s->flags & SEC_THREAD_LOCAL)
4993 {
4994 if (! tls_count)
4995 first_tls = s;
4996 tls_count++;
4997 }
a91e1603
L		 4998 if (first_mbind == NULL
4999 && (elf_section_flags (s) & SHF_GNU_MBIND) != 0)
5000 first_mbind = s;
8ded5a0f 5001 }
252b5132 5002
8ded5a0f
AM		 5003 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5004 if (tls_count > 0)
5005 {
00bee008
AM		 5006 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
5007 amt += tls_count * sizeof (asection *);
a50b1753 5008 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM		 5009 if (m == NULL)
5010 goto error_return;
5011 m->next = NULL;
5012 m->p_type = PT_TLS;
5013 m->count = tls_count;
5014 /* Mandated PF_R. */
5015 m->p_flags = PF_R;
5016 m->p_flags_valid = 1;
d923cae0 5017 s = first_tls;
91d6fa6a 5018 for (i = 0; i < (unsigned int) tls_count; ++i)
8ded5a0f 5019 {
d923cae0
L		 5020 if ((s->flags & SEC_THREAD_LOCAL) == 0)
5021 {
5022 _bfd_error_handler
871b3ab2 5023 (_("%pB: TLS sections are not adjacent:"), abfd);
d923cae0
L		 5024 s = first_tls;
5025 i = 0;
5026 while (i < (unsigned int) tls_count)
5027 {
5028 if ((s->flags & SEC_THREAD_LOCAL) != 0)
5029 {
871b3ab2 5030 _bfd_error_handler (_(" TLS: %pA"), s);
d923cae0
L		 5031 i++;
5032 }
5033 else
871b3ab2 5034 _bfd_error_handler (_(" non-TLS: %pA"), s);
d923cae0
L		 5035 s = s->next;
5036 }
5037 bfd_set_error (bfd_error_bad_value);
5038 goto error_return;
5039 }
5040 m->sections[i] = s;
5041 s = s->next;
8ded5a0f 5042 }
252b5132 5043
8ded5a0f
AM		 5044 *pm = m;
5045 pm = &m->next;
5046 }
252b5132 5047
a91e1603
L		 5048 if (first_mbind && (abfd->flags & D_PAGED) != 0)
5049 for (s = first_mbind; s != NULL; s = s->next)
5050 if ((elf_section_flags (s) & SHF_GNU_MBIND) != 0
5051 && (elf_section_data (s)->this_hdr.sh_info
5052 <= PT_GNU_MBIND_NUM))
5053 {
5054 /* Mandated PF_R. */
5055 unsigned long p_flags = PF_R;
5056 if ((s->flags & SEC_READONLY) == 0)
5057 p_flags |= PF_W;
5058 if ((s->flags & SEC_CODE) != 0)
5059 p_flags |= PF_X;
5060
5061 amt = sizeof (struct elf_segment_map) + sizeof (asection *);
5062 m = bfd_zalloc (abfd, amt);
5063 if (m == NULL)
5064 goto error_return;
5065 m->next = NULL;
5066 m->p_type = (PT_GNU_MBIND_LO
5067 + elf_section_data (s)->this_hdr.sh_info);
5068 m->count = 1;
5069 m->p_flags_valid = 1;
5070 m->sections[0] = s;
5071 m->p_flags = p_flags;
5072
5073 *pm = m;
5074 pm = &m->next;
5075 }
5076
0a59decb
L		 5077 s = bfd_get_section_by_name (abfd,
5078 NOTE_GNU_PROPERTY_SECTION_NAME);
5079 if (s != NULL && s->size != 0)
5080 {
5081 amt = sizeof (struct elf_segment_map) + sizeof (asection *);
5082 m = bfd_zalloc (abfd, amt);
5083 if (m == NULL)
5084 goto error_return;
5085 m->next = NULL;
5086 m->p_type = PT_GNU_PROPERTY;
5087 m->count = 1;
5088 m->p_flags_valid = 1;
5089 m->sections[0] = s;
5090 m->p_flags = PF_R;
5091 *pm = m;
5092 pm = &m->next;
5093 }
5094
8ded5a0f
AM		 5095 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5096 segment. */
12bd6957 5097 eh_frame_hdr = elf_eh_frame_hdr (abfd);
8ded5a0f
AM		 5098 if (eh_frame_hdr != NULL
5099 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
252b5132 5100 {
dc810e39 5101 amt = sizeof (struct elf_segment_map);
a50b1753 5102 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
252b5132
RH		 5103 if (m == NULL)
5104 goto error_return;
5105 m->next = NULL;
8ded5a0f 5106 m->p_type = PT_GNU_EH_FRAME;
252b5132 5107 m->count = 1;
8ded5a0f 5108 m->sections[0] = eh_frame_hdr->output_section;
252b5132
RH		 5109
5110 *pm = m;
5111 pm = &m->next;
5112 }
13ae64f3 5113
12bd6957 5114 if (elf_stack_flags (abfd))
13ae64f3 5115 {
8ded5a0f 5116 amt = sizeof (struct elf_segment_map);
a50b1753 5117 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM		 5118 if (m == NULL)
5119 goto error_return;
5120 m->next = NULL;
2b05f1b7 5121 m->p_type = PT_GNU_STACK;
12bd6957 5122 m->p_flags = elf_stack_flags (abfd);
04c3a755 5123 m->p_align = bed->stack_align;
8ded5a0f 5124 m->p_flags_valid = 1;
04c3a755
NS		 5125 m->p_align_valid = m->p_align != 0;
5126 if (info->stacksize > 0)
5127 {
5128 m->p_size = info->stacksize;
5129 m->p_size_valid = 1;
5130 }
252b5132 5131
8ded5a0f
AM		 5132 *pm = m;
5133 pm = &m->next;
5134 }
65765700 5135
ceae84aa 5136 if (info != NULL && info->relro)
8ded5a0f 5137 {
f210dcff
L		 5138 for (m = mfirst; m != NULL; m = m->next)
5139 {
3832a4d8
AM		 5140 if (m->p_type == PT_LOAD
5141 && m->count != 0
5142 && m->sections[0]->vma >= info->relro_start
5143 && m->sections[0]->vma < info->relro_end)
f210dcff 5144 {
3832a4d8
AM		 5145 i = m->count;
5146 while (--i != (unsigned) -1)
5147 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
5148 == (SEC_LOAD | SEC_HAS_CONTENTS))
5149 break;
5150
43a8475c 5151 if (i != (unsigned) -1)
f210dcff
L		 5152 break;
5153 }
be01b344 5154 }
f210dcff
L		 5155
5156 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5157 if (m != NULL)
5158 {
5159 amt = sizeof (struct elf_segment_map);
a50b1753 5160 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
f210dcff
L		 5161 if (m == NULL)
5162 goto error_return;
5163 m->next = NULL;
5164 m->p_type = PT_GNU_RELRO;
f210dcff
L		 5165 *pm = m;
5166 pm = &m->next;
5167 }
8ded5a0f 5168 }
9ee5e499 5169
8ded5a0f 5170 free (sections);
12bd6957 5171 elf_seg_map (abfd) = mfirst;
9ee5e499
JJ		 5172 }
5173
3dea8fca 5174 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
8ded5a0f 5175 return FALSE;
8c37241b 5176
12bd6957 5177 for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
8ded5a0f 5178 ++count;
12bd6957 5179 elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
252b5132 5180
b34976b6 5181 return TRUE;
252b5132
RH		 5182
5183 error_return:
5184 if (sections != NULL)
5185 free (sections);
b34976b6 5186 return FALSE;
252b5132
RH		 5187}
5188
5189/* Sort sections by address. */
5190
5191static int
217aa764 5192elf_sort_sections (const void *arg1, const void *arg2)
252b5132
RH		 5193{
5194 const asection *sec1 = *(const asection **) arg1;
5195 const asection *sec2 = *(const asection **) arg2;
eecdbe52 5196 bfd_size_type size1, size2;
252b5132
RH		 5197
5198 /* Sort by LMA first, since this is the address used to
5199 place the section into a segment. */
5200 if (sec1->lma < sec2->lma)
5201 return -1;
5202 else if (sec1->lma > sec2->lma)
5203 return 1;
5204
5205 /* Then sort by VMA. Normally the LMA and the VMA will be
5206 the same, and this will do nothing. */
5207 if (sec1->vma < sec2->vma)
5208 return -1;
5209 else if (sec1->vma > sec2->vma)
5210 return 1;
5211
5212 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5213
07c6e936 5214#define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
252b5132
RH		 5215
5216 if (TOEND (sec1))
5217 {
5218 if (TOEND (sec2))
00a7cdc5 5219 {
67ce483b 5220 /* If the indices are the same, do not return 0
00a7cdc5
NC		 5221 here, but continue to try the next comparison. */
5222 if (sec1->target_index - sec2->target_index != 0)
5223 return sec1->target_index - sec2->target_index;
5224 }
252b5132
RH		 5225 else
5226 return 1;
5227 }
00a7cdc5 5228 else if (TOEND (sec2))
252b5132
RH		 5229 return -1;
5230
5231#undef TOEND
5232
00a7cdc5
NC		 5233 /* Sort by size, to put zero sized sections
5234 before others at the same address. */
252b5132 5235
eea6121a
AM		 5236 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
5237 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
eecdbe52
JJ		 5238
5239 if (size1 < size2)
252b5132 5240 return -1;
eecdbe52 5241 if (size1 > size2)
252b5132
RH		 5242 return 1;
5243
5244 return sec1->target_index - sec2->target_index;
5245}
5246
340b6d91
AC		 5247/* Ian Lance Taylor writes:
5248
5249 We shouldn't be using % with a negative signed number. That's just
5250 not good. We have to make sure either that the number is not
5251 negative, or that the number has an unsigned type. When the types
5252 are all the same size they wind up as unsigned. When file_ptr is a
5253 larger signed type, the arithmetic winds up as signed long long,
5254 which is wrong.
5255
5256 What we're trying to say here is something like ``increase OFF by
5257 the least amount that will cause it to be equal to the VMA modulo
5258 the page size.'' */
5259/* In other words, something like:
5260
5261 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5262 off_offset = off % bed->maxpagesize;
5263 if (vma_offset < off_offset)
5264 adjustment = vma_offset + bed->maxpagesize - off_offset;
5265 else
5266 adjustment = vma_offset - off_offset;
08a40648 5267
de194d85 5268 which can be collapsed into the expression below. */
340b6d91
AC		 5269
5270static file_ptr
5271vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
5272{
dc9155b2
NC		 5273 /* PR binutils/16199: Handle an alignment of zero. */
5274 if (maxpagesize == 0)
5275 maxpagesize = 1;
340b6d91
AC		 5276 return ((vma - off) % maxpagesize);
5277}
5278
6d33f217
L		 5279static void
5280print_segment_map (const struct elf_segment_map *m)
5281{
5282 unsigned int j;
5283 const char *pt = get_segment_type (m->p_type);
5284 char buf[32];
5285
5286 if (pt == NULL)
5287 {
5288 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
5289 sprintf (buf, "LOPROC+%7.7x",
5290 (unsigned int) (m->p_type - PT_LOPROC));
5291 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
5292 sprintf (buf, "LOOS+%7.7x",
5293 (unsigned int) (m->p_type - PT_LOOS));
5294 else
5295 snprintf (buf, sizeof (buf), "%8.8x",
5296 (unsigned int) m->p_type);
5297 pt = buf;
5298 }
4a97a0e5 5299 fflush (stdout);
6d33f217
L		 5300 fprintf (stderr, "%s:", pt);
5301 for (j = 0; j < m->count; j++)
5302 fprintf (stderr, " %s", m->sections [j]->name);
5303 putc ('\n',stderr);
4a97a0e5 5304 fflush (stderr);
6d33f217
L		 5305}
5306
32812159
AM		 5307static bfd_boolean
5308write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
5309{
5310 void *buf;
5311 bfd_boolean ret;
5312
5313 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
5314 return FALSE;
5315 buf = bfd_zmalloc (len);
5316 if (buf == NULL)
5317 return FALSE;
5318 ret = bfd_bwrite (buf, len, abfd) == len;
5319 free (buf);
5320 return ret;
5321}
5322
252b5132
RH		 5323/* Assign file positions to the sections based on the mapping from
5324 sections to segments. This function also sets up some fields in
f3520d2f 5325 the file header. */
252b5132 5326
b34976b6 5327static bfd_boolean
f3520d2f
AM		 5328assign_file_positions_for_load_sections (bfd *abfd,
5329 struct bfd_link_info *link_info)
252b5132
RH		 5330{
5331 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 5332 struct elf_segment_map *m;
252b5132 5333 Elf_Internal_Phdr *phdrs;
252b5132 5334 Elf_Internal_Phdr *p;
02bf8d82 5335 file_ptr off;
3f570048 5336 bfd_size_type maxpagesize;
a8c75b76 5337 unsigned int pt_load_count = 0;
f3520d2f 5338 unsigned int alloc;
0920dee7 5339 unsigned int i, j;
2b0bc088 5340 bfd_vma header_pad = 0;
252b5132 5341
e36284ab 5342 if (link_info == NULL
ceae84aa 5343 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
8ded5a0f 5344 return FALSE;
252b5132 5345
8ded5a0f 5346 alloc = 0;
12bd6957 5347 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2b0bc088
NC		 5348 {
5349 ++alloc;
5350 if (m->header_size)
5351 header_pad = m->header_size;
5352 }
252b5132 5353
82f2dbf7
NC		 5354 if (alloc)
5355 {
5356 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
5357 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
5358 }
5359 else
5360 {
5361 /* PR binutils/12467. */
5362 elf_elfheader (abfd)->e_phoff = 0;
5363 elf_elfheader (abfd)->e_phentsize = 0;
5364 }
d324f6d6 5365
8ded5a0f 5366 elf_elfheader (abfd)->e_phnum = alloc;
252b5132 5367
12bd6957
AM		 5368 if (elf_program_header_size (abfd) == (bfd_size_type) -1)
5369 elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
8ded5a0f 5370 else
12bd6957 5371 BFD_ASSERT (elf_program_header_size (abfd)
59e0647f 5372 >= alloc * bed->s->sizeof_phdr);
252b5132
RH		 5373
5374 if (alloc == 0)
f3520d2f 5375 {
12bd6957 5376 elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
8ded5a0f 5377 return TRUE;
f3520d2f 5378 }
252b5132 5379
12bd6957 5380 /* We're writing the size in elf_program_header_size (abfd),
57268894
HPN		 5381 see assign_file_positions_except_relocs, so make sure we have
5382 that amount allocated, with trailing space cleared.
12bd6957
AM		 5383 The variable alloc contains the computed need, while
5384 elf_program_header_size (abfd) contains the size used for the
57268894
HPN		 5385 layout.
5386 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5387 where the layout is forced to according to a larger size in the
5388 last iterations for the testcase ld-elf/header. */
12bd6957 5389 BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
57268894 5390 == 0);
a50b1753
NC		 5391 phdrs = (Elf_Internal_Phdr *)
5392 bfd_zalloc2 (abfd,
07d6d2b8
AM		 5393 (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
5394 sizeof (Elf_Internal_Phdr));
f3520d2f 5395 elf_tdata (abfd)->phdr = phdrs;
252b5132 5396 if (phdrs == NULL)
b34976b6 5397 return FALSE;
252b5132 5398
3f570048
AM		 5399 maxpagesize = 1;
5400 if ((abfd->flags & D_PAGED) != 0)
5401 maxpagesize = bed->maxpagesize;
5402
252b5132
RH		 5403 off = bed->s->sizeof_ehdr;
5404 off += alloc * bed->s->sizeof_phdr;
2b0bc088
NC		 5405 if (header_pad < (bfd_vma) off)
5406 header_pad = 0;
5407 else
5408 header_pad -= off;
5409 off += header_pad;
252b5132 5410
12bd6957 5411 for (m = elf_seg_map (abfd), p = phdrs, j = 0;
252b5132 5412 m != NULL;
0920dee7 5413 m = m->next, p++, j++)
252b5132 5414 {
252b5132 5415 asection **secpp;
bf988460
AM		 5416 bfd_vma off_adjust;
5417 bfd_boolean no_contents;
252b5132
RH		 5418
5419 /* If elf_segment_map is not from map_sections_to_segments, the
08a40648 5420 sections may not be correctly ordered. NOTE: sorting should
52e9b619
MS		 5421 not be done to the PT_NOTE section of a corefile, which may
5422 contain several pseudo-sections artificially created by bfd.
5423 Sorting these pseudo-sections breaks things badly. */
47d9a591
AM		 5424 if (m->count > 1
5425 && !(elf_elfheader (abfd)->e_type == ET_CORE
52e9b619 5426 && m->p_type == PT_NOTE))
252b5132
RH		 5427 qsort (m->sections, (size_t) m->count, sizeof (asection *),
5428 elf_sort_sections);
5429
b301b248
AM		 5430 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5431 number of sections with contents contributing to both p_filesz
5432 and p_memsz, followed by a number of sections with no contents
5433 that just contribute to p_memsz. In this loop, OFF tracks next
02bf8d82 5434 available file offset for PT_LOAD and PT_NOTE segments. */
252b5132 5435 p->p_type = m->p_type;
28a7f3e7 5436 p->p_flags = m->p_flags;
252b5132 5437
3f570048 5438 if (m->count == 0)
5d695627 5439 p->p_vaddr = m->p_vaddr_offset;
3f570048 5440 else
5d695627 5441 p->p_vaddr = m->sections[0]->vma + m->p_vaddr_offset;
3f570048
AM		 5442
5443 if (m->p_paddr_valid)
5444 p->p_paddr = m->p_paddr;
5445 else if (m->count == 0)
5446 p->p_paddr = 0;
5447 else
5d695627 5448 p->p_paddr = m->sections[0]->lma + m->p_vaddr_offset;
3f570048
AM		 5449
5450 if (p->p_type == PT_LOAD
5451 && (abfd->flags & D_PAGED) != 0)
5452 {
5453 /* p_align in demand paged PT_LOAD segments effectively stores
5454 the maximum page size. When copying an executable with
5455 objcopy, we set m->p_align from the input file. Use this
5456 value for maxpagesize rather than bed->maxpagesize, which
5457 may be different. Note that we use maxpagesize for PT_TLS
5458 segment alignment later in this function, so we are relying
5459 on at least one PT_LOAD segment appearing before a PT_TLS
5460 segment. */
5461 if (m->p_align_valid)
5462 maxpagesize = m->p_align;
5463
5464 p->p_align = maxpagesize;
a8c75b76 5465 pt_load_count += 1;
3f570048 5466 }
3271a814
NS		 5467 else if (m->p_align_valid)
5468 p->p_align = m->p_align;
e970b90a
DJ		 5469 else if (m->count == 0)
5470 p->p_align = 1 << bed->s->log_file_align;
3f570048
AM		 5471 else
5472 p->p_align = 0;
5473
bf988460
AM		 5474 no_contents = FALSE;
5475 off_adjust = 0;
252b5132 5476 if (p->p_type == PT_LOAD
b301b248 5477 && m->count > 0)
252b5132 5478 {
b301b248 5479 bfd_size_type align;
a49e53ed 5480 unsigned int align_power = 0;
b301b248 5481
3271a814
NS		 5482 if (m->p_align_valid)
5483 align = p->p_align;
5484 else
252b5132 5485 {
3271a814
NS		 5486 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5487 {
5488 unsigned int secalign;
08a40648 5489
3271a814
NS		 5490 secalign = bfd_get_section_alignment (abfd, *secpp);
5491 if (secalign > align_power)
5492 align_power = secalign;
5493 }
5494 align = (bfd_size_type) 1 << align_power;
5495 if (align < maxpagesize)
5496 align = maxpagesize;
b301b248 5497 }
252b5132 5498
02bf8d82
AM		 5499 for (i = 0; i < m->count; i++)
5500 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
5501 /* If we aren't making room for this section, then
5502 it must be SHT_NOBITS regardless of what we've
5503 set via struct bfd_elf_special_section. */
5504 elf_section_type (m->sections[i]) = SHT_NOBITS;
5505
bf988460 5506 /* Find out whether this segment contains any loadable
aea274d3
AM		 5507 sections. */
5508 no_contents = TRUE;
5509 for (i = 0; i < m->count; i++)
5510 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
5511 {
5512 no_contents = FALSE;
5513 break;
5514 }
bf988460 5515
85cfcbfb 5516 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
a8c75b76
AM		 5517
5518 /* Broken hardware and/or kernel require that files do not
5519 map the same page with different permissions on some hppa
5520 processors. */
5521 if (pt_load_count > 1
5522 && bed->no_page_alias
5523 && (off & (maxpagesize - 1)) != 0
5524 && (off & -maxpagesize) == ((off + off_adjust) & -maxpagesize))
5525 off_adjust += maxpagesize;
bf988460
AM		 5526 off += off_adjust;
5527 if (no_contents)
5528 {
5529 /* We shouldn't need to align the segment on disk since
5530 the segment doesn't need file space, but the gABI
5531 arguably requires the alignment and glibc ld.so
5532 checks it. So to comply with the alignment
5533 requirement but not waste file space, we adjust
5534 p_offset for just this segment. (OFF_ADJUST is
5535 subtracted from OFF later.) This may put p_offset
5536 past the end of file, but that shouldn't matter. */
5537 }
5538 else
5539 off_adjust = 0;
252b5132 5540 }
b1a6d0b1
NC		 5541 /* Make sure the .dynamic section is the first section in the
5542 PT_DYNAMIC segment. */
5543 else if (p->p_type == PT_DYNAMIC
5544 && m->count > 1
5545 && strcmp (m->sections[0]->name, ".dynamic") != 0)
5546 {
5547 _bfd_error_handler
871b3ab2 5548 (_("%pB: The first section in the PT_DYNAMIC segment"
63a5468a 5549 " is not the .dynamic section"),
b301b248 5550 abfd);
b1a6d0b1
NC		 5551 bfd_set_error (bfd_error_bad_value);
5552 return FALSE;
5553 }
3f001e84
JK		 5554 /* Set the note section type to SHT_NOTE. */
5555 else if (p->p_type == PT_NOTE)
5556 for (i = 0; i < m->count; i++)
5557 elf_section_type (m->sections[i]) = SHT_NOTE;
252b5132 5558
252b5132
RH		 5559 p->p_offset = 0;
5560 p->p_filesz = 0;
5561 p->p_memsz = 0;
5562
5563 if (m->includes_filehdr)
5564 {
bf988460 5565 if (!m->p_flags_valid)
252b5132 5566 p->p_flags |= PF_R;
252b5132
RH		 5567 p->p_filesz = bed->s->sizeof_ehdr;
5568 p->p_memsz = bed->s->sizeof_ehdr;
5569 if (m->count > 0)
5570 {
9ab82472
L		 5571 if (p->p_vaddr < (bfd_vma) off
5572 || (!m->p_paddr_valid
5573 && p->p_paddr < (bfd_vma) off))
252b5132 5574 {
4eca0228 5575 _bfd_error_handler
9793eb77 5576 (_("%pB: not enough room for program headers,"
63a5468a 5577 " try linking with -N"),
b301b248 5578 abfd);
252b5132 5579 bfd_set_error (bfd_error_bad_value);
b34976b6 5580 return FALSE;
252b5132
RH		 5581 }
5582
5583 p->p_vaddr -= off;
bf988460 5584 if (!m->p_paddr_valid)
252b5132
RH		 5585 p->p_paddr -= off;
5586 }
252b5132
RH		 5587 }
5588
5589 if (m->includes_phdrs)
5590 {
bf988460 5591 if (!m->p_flags_valid)
252b5132
RH		 5592 p->p_flags |= PF_R;
5593
f3520d2f 5594 if (!m->includes_filehdr)
252b5132
RH		 5595 {
5596 p->p_offset = bed->s->sizeof_ehdr;
5597
5598 if (m->count > 0)
5599 {
252b5132 5600 p->p_vaddr -= off - p->p_offset;
bf988460 5601 if (!m->p_paddr_valid)
252b5132
RH		 5602 p->p_paddr -= off - p->p_offset;
5603 }
252b5132
RH		 5604 }
5605
5606 p->p_filesz += alloc * bed->s->sizeof_phdr;
5607 p->p_memsz += alloc * bed->s->sizeof_phdr;
2b0bc088
NC		 5608 if (m->count)
5609 {
5610 p->p_filesz += header_pad;
5611 p->p_memsz += header_pad;
5612 }
252b5132
RH		 5613 }
5614
5615 if (p->p_type == PT_LOAD
5616 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
5617 {
bf988460 5618 if (!m->includes_filehdr && !m->includes_phdrs)
02bf8d82 5619 p->p_offset = off;
252b5132
RH		 5620 else
5621 {
5622 file_ptr adjust;
5623
5624 adjust = off - (p->p_offset + p->p_filesz);
bf988460
AM		 5625 if (!no_contents)
5626 p->p_filesz += adjust;
252b5132
RH		 5627 p->p_memsz += adjust;
5628 }
5629 }
5630
1ea63fd2
AM		 5631 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5632 maps. Set filepos for sections in PT_LOAD segments, and in
5633 core files, for sections in PT_NOTE segments.
5634 assign_file_positions_for_non_load_sections will set filepos
5635 for other sections and update p_filesz for other segments. */
252b5132
RH		 5636 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5637 {
5638 asection *sec;
252b5132 5639 bfd_size_type align;
627b32bc 5640 Elf_Internal_Shdr *this_hdr;
252b5132
RH		 5641
5642 sec = *secpp;
02bf8d82 5643 this_hdr = &elf_section_data (sec)->this_hdr;
3f570048 5644 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
252b5132 5645
88967714
AM		 5646 if ((p->p_type == PT_LOAD
5647 || p->p_type == PT_TLS)
5648 && (this_hdr->sh_type != SHT_NOBITS
5649 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
5650 && ((this_hdr->sh_flags & SHF_TLS) == 0
5651 || p->p_type == PT_TLS))))
252b5132 5652 {
b5599592
AM		 5653 bfd_vma p_start = p->p_paddr;
5654 bfd_vma p_end = p_start + p->p_memsz;
5655 bfd_vma s_start = sec->lma;
5656 bfd_vma adjust = s_start - p_end;
252b5132 5657
a2d1e028
L		 5658 if (adjust != 0
5659 && (s_start < p_end
5660 || p_end < p_start))
252b5132 5661 {
4eca0228 5662 _bfd_error_handler
695344c0 5663 /* xgettext:c-format */
2dcf00ce
AM		 5664 (_("%pB: section %pA lma %#" PRIx64 " adjusted to %#" PRIx64),
5665 abfd, sec, (uint64_t) s_start, (uint64_t) p_end);
88967714 5666 adjust = 0;
b5599592 5667 sec->lma = p_end;
1cfb7d1e 5668 }
3ac9b6c9 5669 p->p_memsz += adjust;
1cfb7d1e 5670
88967714
AM		 5671 if (this_hdr->sh_type != SHT_NOBITS)
5672 {
32812159
AM		 5673 if (p->p_filesz + adjust < p->p_memsz)
5674 {
5675 /* We have a PROGBITS section following NOBITS ones.
07d6d2b8 5676 Allocate file space for the NOBITS section(s) and
32812159
AM		 5677 zero it. */
5678 adjust = p->p_memsz - p->p_filesz;
5679 if (!write_zeros (abfd, off, adjust))
5680 return FALSE;
5681 }
88967714
AM		 5682 off += adjust;
5683 p->p_filesz += adjust;
252b5132 5684 }
252b5132
RH		 5685 }
5686
5687 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
5688 {
b301b248
AM		 5689 /* The section at i == 0 is the one that actually contains
5690 everything. */
4a938328
MS		 5691 if (i == 0)
5692 {
627b32bc 5693 this_hdr->sh_offset = sec->filepos = off;
6a3cd2b4
AM		 5694 off += this_hdr->sh_size;
5695 p->p_filesz = this_hdr->sh_size;
b301b248
AM		 5696 p->p_memsz = 0;
5697 p->p_align = 1;
252b5132 5698 }
4a938328 5699 else
252b5132 5700 {
b301b248 5701 /* The rest are fake sections that shouldn't be written. */
252b5132 5702 sec->filepos = 0;
eea6121a 5703 sec->size = 0;
b301b248
AM		 5704 sec->flags = 0;
5705 continue;
252b5132 5706 }
252b5132
RH		 5707 }
5708 else
5709 {
1e951488 5710 if (p->p_type == PT_LOAD)
b301b248 5711 {
1e951488
AM		 5712 this_hdr->sh_offset = sec->filepos = off;
5713 if (this_hdr->sh_type != SHT_NOBITS)
5714 off += this_hdr->sh_size;
5715 }
5716 else if (this_hdr->sh_type == SHT_NOBITS
5717 && (this_hdr->sh_flags & SHF_TLS) != 0
5718 && this_hdr->sh_offset == 0)
5719 {
5720 /* This is a .tbss section that didn't get a PT_LOAD.
5721 (See _bfd_elf_map_sections_to_segments "Create a
5722 final PT_LOAD".) Set sh_offset to the value it
5723 would have if we had created a zero p_filesz and
5724 p_memsz PT_LOAD header for the section. This
5725 also makes the PT_TLS header have the same
5726 p_offset value. */
5727 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
5728 off, align);
5729 this_hdr->sh_offset = sec->filepos = off + adjust;
b301b248 5730 }
252b5132 5731
02bf8d82 5732 if (this_hdr->sh_type != SHT_NOBITS)
b301b248 5733 {
6a3cd2b4 5734 p->p_filesz += this_hdr->sh_size;
02bf8d82
AM		 5735 /* A load section without SHF_ALLOC is something like
5736 a note section in a PT_NOTE segment. These take
5737 file space but are not loaded into memory. */
5738 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
6a3cd2b4 5739 p->p_memsz += this_hdr->sh_size;
b301b248 5740 }
6a3cd2b4 5741 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
13ae64f3 5742 {
6a3cd2b4
AM		 5743 if (p->p_type == PT_TLS)
5744 p->p_memsz += this_hdr->sh_size;
5745
5746 /* .tbss is special. It doesn't contribute to p_memsz of
5747 normal segments. */
5748 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
5749 p->p_memsz += this_hdr->sh_size;
13ae64f3
JJ		 5750 }
5751
b10a8ae0
L		 5752 if (align > p->p_align
5753 && !m->p_align_valid
5754 && (p->p_type != PT_LOAD
5755 || (abfd->flags & D_PAGED) == 0))
252b5132
RH		 5756 p->p_align = align;
5757 }
5758
bf988460 5759 if (!m->p_flags_valid)
252b5132
RH		 5760 {
5761 p->p_flags |= PF_R;
02bf8d82 5762 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
252b5132 5763 p->p_flags |= PF_X;
02bf8d82 5764 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
252b5132
RH		 5765 p->p_flags |= PF_W;
5766 }
5767 }
43a8475c 5768
bf988460 5769 off -= off_adjust;
0920dee7 5770
7c928300
AM		 5771 /* Check that all sections are in a PT_LOAD segment.
5772 Don't check funky gdb generated core files. */
5773 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
9a83a553
AM		 5774 {
5775 bfd_boolean check_vma = TRUE;
5776
5777 for (i = 1; i < m->count; i++)
5778 if (m->sections[i]->vma == m->sections[i - 1]->vma
5779 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
5780 ->this_hdr), p) != 0
5781 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
5782 ->this_hdr), p) != 0)
0920dee7 5783 {
9a83a553
AM		 5784 /* Looks like we have overlays packed into the segment. */
5785 check_vma = FALSE;
5786 break;
0920dee7 5787 }
9a83a553
AM		 5788
5789 for (i = 0; i < m->count; i++)
5790 {
5791 Elf_Internal_Shdr *this_hdr;
5792 asection *sec;
5793
5794 sec = m->sections[i];
5795 this_hdr = &(elf_section_data(sec)->this_hdr);
86b2281f
AM		 5796 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
5797 && !ELF_TBSS_SPECIAL (this_hdr, p))
9a83a553 5798 {
4eca0228 5799 _bfd_error_handler
695344c0 5800 /* xgettext:c-format */
871b3ab2 5801 (_("%pB: section `%pA' can't be allocated in segment %d"),
9a83a553
AM		 5802 abfd, sec, j);
5803 print_segment_map (m);
5804 }
5805 }
5806 }
252b5132
RH		 5807 }
5808
12bd6957 5809 elf_next_file_pos (abfd) = off;
f3520d2f
AM		 5810 return TRUE;
5811}
5812
5813/* Assign file positions for the other sections. */
5814
5815static bfd_boolean
5816assign_file_positions_for_non_load_sections (bfd *abfd,
5817 struct bfd_link_info *link_info)
5818{
5819 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5820 Elf_Internal_Shdr **i_shdrpp;
e06efbf1 5821 Elf_Internal_Shdr **hdrpp, **end_hdrpp;
f3520d2f
AM		 5822 Elf_Internal_Phdr *phdrs;
5823 Elf_Internal_Phdr *p;
5824 struct elf_segment_map *m;
62655c7b 5825 struct elf_segment_map *hdrs_segment;
f3520d2f
AM		 5826 bfd_vma filehdr_vaddr, filehdr_paddr;
5827 bfd_vma phdrs_vaddr, phdrs_paddr;
5828 file_ptr off;
f3520d2f
AM		 5829 unsigned int count;
5830
5c182d5f 5831 i_shdrpp = elf_elfsections (abfd);
e06efbf1 5832 end_hdrpp = i_shdrpp + elf_numsections (abfd);
12bd6957 5833 off = elf_next_file_pos (abfd);
e06efbf1 5834 for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5c182d5f 5835 {
5c182d5f
AM		 5836 Elf_Internal_Shdr *hdr;
5837
5838 hdr = *hdrpp;
5839 if (hdr->bfd_section != NULL
252e386e
AM		 5840 && (hdr->bfd_section->filepos != 0
5841 || (hdr->sh_type == SHT_NOBITS
5842 && hdr->contents == NULL)))
627b32bc 5843 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5c182d5f
AM		 5844 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5845 {
e8d2ba53 5846 if (hdr->sh_size != 0)
4eca0228 5847 _bfd_error_handler
695344c0 5848 /* xgettext:c-format */
871b3ab2 5849 (_("%pB: warning: allocated section `%s' not in segment"),
e8d2ba53
AM		 5850 abfd,
5851 (hdr->bfd_section == NULL
5852 ? "*unknown*"
5853 : hdr->bfd_section->name));
3ba71138
L		 5854 /* We don't need to page align empty sections. */
5855 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5c182d5f
AM		 5856 off += vma_page_aligned_bias (hdr->sh_addr, off,
5857 bed->maxpagesize);
5858 else
5859 off += vma_page_aligned_bias (hdr->sh_addr, off,
5860 hdr->sh_addralign);
5861 off = _bfd_elf_assign_file_position_for_section (hdr, off,
5862 FALSE);
5863 }
5864 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5865 && hdr->bfd_section == NULL)
0ce398f1
L		 5866 || (hdr->bfd_section != NULL
5867 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5868 /* Compress DWARF debug sections. */
12bd6957 5869 || hdr == i_shdrpp[elf_onesymtab (abfd)]
6a40cf0c
NC		 5870 || (elf_symtab_shndx_list (abfd) != NULL
5871 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
3e19fb8f
L		 5872 || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5873 || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5c182d5f
AM		 5874 hdr->sh_offset = -1;
5875 else
5876 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5c182d5f
AM		 5877 }
5878
252b5132
RH		 5879 /* Now that we have set the section file positions, we can set up
5880 the file positions for the non PT_LOAD segments. */
f3520d2f
AM		 5881 count = 0;
5882 filehdr_vaddr = 0;
5883 filehdr_paddr = 0;
5884 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5885 phdrs_paddr = 0;
62655c7b 5886 hdrs_segment = NULL;
f3520d2f 5887 phdrs = elf_tdata (abfd)->phdr;
12bd6957 5888 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
f3520d2f
AM		 5889 {
5890 ++count;
5891 if (p->p_type != PT_LOAD)
5892 continue;
5893
5894 if (m->includes_filehdr)
5895 {
5896 filehdr_vaddr = p->p_vaddr;
5897 filehdr_paddr = p->p_paddr;
5898 }
5899 if (m->includes_phdrs)
5900 {
5901 phdrs_vaddr = p->p_vaddr;
5902 phdrs_paddr = p->p_paddr;
5903 if (m->includes_filehdr)
5904 {
62655c7b 5905 hdrs_segment = m;
f3520d2f
AM		 5906 phdrs_vaddr += bed->s->sizeof_ehdr;
5907 phdrs_paddr += bed->s->sizeof_ehdr;
5908 }
5909 }
5910 }
5911
62655c7b
RM		 5912 if (hdrs_segment != NULL && link_info != NULL)
5913 {
5914 /* There is a segment that contains both the file headers and the
5915 program headers, so provide a symbol __ehdr_start pointing there.
5916 A program can use this to examine itself robustly. */
5917
5918 struct elf_link_hash_entry *hash
5919 = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5920 FALSE, FALSE, TRUE);
5921 /* If the symbol was referenced and not defined, define it. */
5922 if (hash != NULL
5923 && (hash->root.type == bfd_link_hash_new
5924 || hash->root.type == bfd_link_hash_undefined
5925 || hash->root.type == bfd_link_hash_undefweak
5926 || hash->root.type == bfd_link_hash_common))
5927 {
5928 asection *s = NULL;
5929 if (hdrs_segment->count != 0)
5930 /* The segment contains sections, so use the first one. */
5931 s = hdrs_segment->sections[0];
5932 else
5933 /* Use the first (i.e. lowest-addressed) section in any segment. */
12bd6957 5934 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62655c7b
RM		 5935 if (m->count != 0)
5936 {
5937 s = m->sections[0];
5938 break;
5939 }
5940
5941 if (s != NULL)
5942 {
5943 hash->root.u.def.value = filehdr_vaddr - s->vma;
5944 hash->root.u.def.section = s;
5945 }
5946 else
5947 {
5948 hash->root.u.def.value = filehdr_vaddr;
5949 hash->root.u.def.section = bfd_abs_section_ptr;
5950 }
5951
5952 hash->root.type = bfd_link_hash_defined;
5953 hash->def_regular = 1;
5954 hash->non_elf = 0;
5955 }
5956 }
5957
12bd6957 5958 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
252b5132 5959 {
129af99f 5960 if (p->p_type == PT_GNU_RELRO)
252b5132 5961 {
f2731e0c 5962 bfd_vma start, end;
01f7e10c 5963 bfd_boolean ok;
1ea63fd2 5964
129af99f 5965 if (link_info != NULL)
8c37241b 5966 {
129af99f 5967 /* During linking the range of the RELRO segment is passed
f2731e0c
AM		 5968 in link_info. Note that there may be padding between
5969 relro_start and the first RELRO section. */
5970 start = link_info->relro_start;
5971 end = link_info->relro_end;
5972 }
5973 else if (m->count != 0)
5974 {
5975 if (!m->p_size_valid)
5976 abort ();
5977 start = m->sections[0]->vma;
5978 end = start + m->p_size;
5979 }
5980 else
5981 {
5982 start = 0;
5983 end = 0;
5984 }
5985
01f7e10c 5986 ok = FALSE;
f2731e0c
AM		 5987 if (start < end)
5988 {
5989 struct elf_segment_map *lm;
5990 const Elf_Internal_Phdr *lp;
5991 unsigned int i;
5992
5993 /* Find a LOAD segment containing a section in the RELRO
5994 segment. */
12bd6957 5995 for (lm = elf_seg_map (abfd), lp = phdrs;
3146fac4
AM		 5996 lm != NULL;
5997 lm = lm->next, lp++)
8c37241b
JJ		 5998 {
5999 if (lp->p_type == PT_LOAD
3146fac4 6000 && lm->count != 0
dbc88fc1
AM		 6001 && (lm->sections[lm->count - 1]->vma
6002 + (!IS_TBSS (lm->sections[lm->count - 1])
6003 ? lm->sections[lm->count - 1]->size
6004 : 0)) > start
f2731e0c 6005 && lm->sections[0]->vma < end)
8c37241b
JJ		 6006 break;
6007 }
f2731e0c 6008
01f7e10c 6009 if (lm != NULL)
129af99f 6010 {
01f7e10c
AM		 6011 /* Find the section starting the RELRO segment. */
6012 for (i = 0; i < lm->count; i++)
6013 {
6014 asection *s = lm->sections[i];
6015 if (s->vma >= start
6016 && s->vma < end
6017 && s->size != 0)
6018 break;
6019 }
6020
6021 if (i < lm->count)
6022 {
6023 p->p_vaddr = lm->sections[i]->vma;
6024 p->p_paddr = lm->sections[i]->lma;
6025 p->p_offset = lm->sections[i]->filepos;
6026 p->p_memsz = end - p->p_vaddr;
6027 p->p_filesz = p->p_memsz;
6028
6029 /* The RELRO segment typically ends a few bytes
6030 into .got.plt but other layouts are possible.
6031 In cases where the end does not match any
6032 loaded section (for instance is in file
6033 padding), trim p_filesz back to correspond to
6034 the end of loaded section contents. */
6035 if (p->p_filesz > lp->p_vaddr + lp->p_filesz - p->p_vaddr)
6036 p->p_filesz = lp->p_vaddr + lp->p_filesz - p->p_vaddr;
6037
6038 /* Preserve the alignment and flags if they are
6039 valid. The gold linker generates RW/4 for
6040 the PT_GNU_RELRO section. It is better for
6041 objcopy/strip to honor these attributes
6042 otherwise gdb will choke when using separate
6043 debug files. */
6044 if (!m->p_align_valid)
6045 p->p_align = 1;
6046 if (!m->p_flags_valid)
6047 p->p_flags = PF_R;
6048 ok = TRUE;
6049 }
129af99f 6050 }
b84a33b5 6051 }
01f7e10c
AM		 6052 if (link_info != NULL)
6053 BFD_ASSERT (ok);
6054 if (!ok)
6055 memset (p, 0, sizeof *p);
129af99f 6056 }
04c3a755
NS		 6057 else if (p->p_type == PT_GNU_STACK)
6058 {
6059 if (m->p_size_valid)
6060 p->p_memsz = m->p_size;
6061 }
129af99f
AS		 6062 else if (m->count != 0)
6063 {
e06efbf1 6064 unsigned int i;
1a9ccd70 6065
129af99f
AS		 6066 if (p->p_type != PT_LOAD
6067 && (p->p_type != PT_NOTE
6068 || bfd_get_format (abfd) != bfd_core))
6069 {
1a9ccd70
NC		 6070 /* A user specified segment layout may include a PHDR
6071 segment that overlaps with a LOAD segment... */
6072 if (p->p_type == PT_PHDR)
6073 {
6074 m->count = 0;
6075 continue;
6076 }
6077
c86934ce
NC		 6078 if (m->includes_filehdr || m->includes_phdrs)
6079 {
b1fa9dd6 6080 /* PR 17512: file: 2195325e. */
4eca0228 6081 _bfd_error_handler
871b3ab2 6082 (_("%pB: error: non-load segment %d includes file header "
76cfced5
AM		 6083 "and/or program header"),
6084 abfd, (int) (p - phdrs));
c86934ce
NC		 6085 return FALSE;
6086 }
129af99f 6087
86b2281f 6088 p->p_filesz = 0;
129af99f 6089 p->p_offset = m->sections[0]->filepos;
86b2281f
AM		 6090 for (i = m->count; i-- != 0;)
6091 {
6092 asection *sect = m->sections[i];
6093 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
6094 if (hdr->sh_type != SHT_NOBITS)
6095 {
6096 p->p_filesz = (sect->filepos - m->sections[0]->filepos
6097 + hdr->sh_size);
6098 break;
6099 }
6100 }
129af99f
AS		 6101 }
6102 }
6103 else if (m->includes_filehdr)
6104 {
6105 p->p_vaddr = filehdr_vaddr;
6106 if (! m->p_paddr_valid)
6107 p->p_paddr = filehdr_paddr;
6108 }
6109 else if (m->includes_phdrs)
6110 {
6111 p->p_vaddr = phdrs_vaddr;
6112 if (! m->p_paddr_valid)
6113 p->p_paddr = phdrs_paddr;
252b5132
RH		 6114 }
6115 }
6116
12bd6957 6117 elf_next_file_pos (abfd) = off;
252b5132 6118
b34976b6 6119 return TRUE;
252b5132
RH		 6120}
6121
6a40cf0c
NC		 6122static elf_section_list *
6123find_section_in_list (unsigned int i, elf_section_list * list)
6124{
6125 for (;list != NULL; list = list->next)
6126 if (list->ndx == i)
6127 break;
6128 return list;
6129}
6130
252b5132
RH		 6131/* Work out the file positions of all the sections. This is called by
6132 _bfd_elf_compute_section_file_positions. All the section sizes and
6133 VMAs must be known before this is called.
6134
e0638f70
AM		 6135 Reloc sections come in two flavours: Those processed specially as
6136 "side-channel" data attached to a section to which they apply, and
6137 those that bfd doesn't process as relocations. The latter sort are
6138 stored in a normal bfd section by bfd_section_from_shdr. We don't
6139 consider the former sort here, unless they form part of the loadable
6140 image. Reloc sections not assigned here will be handled later by
6141 assign_file_positions_for_relocs.
252b5132
RH		 6142
6143 We also don't set the positions of the .symtab and .strtab here. */
6144
b34976b6 6145static bfd_boolean
c84fca4d
AO		 6146assign_file_positions_except_relocs (bfd *abfd,
6147 struct bfd_link_info *link_info)
252b5132 6148{
5c182d5f
AM		 6149 struct elf_obj_tdata *tdata = elf_tdata (abfd);
6150 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
9c5bfbb7 6151 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 6152
6153 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
6154 && bfd_get_format (abfd) != bfd_core)
6155 {
5c182d5f
AM		 6156 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
6157 unsigned int num_sec = elf_numsections (abfd);
252b5132
RH		 6158 Elf_Internal_Shdr **hdrpp;
6159 unsigned int i;
a485e98e 6160 file_ptr off;
252b5132
RH		 6161
6162 /* Start after the ELF header. */
6163 off = i_ehdrp->e_ehsize;
6164
6165 /* We are not creating an executable, which means that we are
6166 not creating a program header, and that the actual order of
6167 the sections in the file is unimportant. */
9ad5cbcf 6168 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH		 6169 {
6170 Elf_Internal_Shdr *hdr;
6171
6172 hdr = *hdrpp;
e0638f70
AM		 6173 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
6174 && hdr->bfd_section == NULL)
0ce398f1
L		 6175 || (hdr->bfd_section != NULL
6176 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
6177 /* Compress DWARF debug sections. */
12bd6957 6178 || i == elf_onesymtab (abfd)
6a40cf0c
NC		 6179 || (elf_symtab_shndx_list (abfd) != NULL
6180 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
3e19fb8f
L		 6181 || i == elf_strtab_sec (abfd)
6182 || i == elf_shstrtab_sec (abfd))
252b5132
RH		 6183 {
6184 hdr->sh_offset = -1;
252b5132 6185 }
9ad5cbcf 6186 else
b34976b6 6187 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 6188 }
a485e98e
AM		 6189
6190 elf_next_file_pos (abfd) = off;
252b5132
RH		 6191 }
6192 else
6193 {
f3520d2f
AM		 6194 unsigned int alloc;
6195
252b5132 6196 /* Assign file positions for the loaded sections based on the
08a40648 6197 assignment of sections to segments. */
f3520d2f
AM		 6198 if (!assign_file_positions_for_load_sections (abfd, link_info))
6199 return FALSE;
6200
6201 /* And for non-load sections. */
6202 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
6203 return FALSE;
6204
e36284ab
AM		 6205 if (bed->elf_backend_modify_program_headers != NULL)
6206 {
6207 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
6208 return FALSE;
6209 }
6210
58e7ebac 6211 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
0e1862bb 6212 if (link_info != NULL && bfd_link_pie (link_info))
58e7ebac
L		 6213 {
6214 unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
6215 Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
6216 Elf_Internal_Phdr *end_segment = &segment[num_segments];
6217
6218 /* Find the lowest p_vaddr in PT_LOAD segments. */
6219 bfd_vma p_vaddr = (bfd_vma) -1;
6220 for (; segment < end_segment; segment++)
6221 if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
6222 p_vaddr = segment->p_vaddr;
6223
6224 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6225 segments is non-zero. */
6226 if (p_vaddr)
6227 i_ehdrp->e_type = ET_EXEC;
6228 }
6229
f3520d2f 6230 /* Write out the program headers. */
6838f2be 6231 alloc = elf_elfheader (abfd)->e_phnum;
1a9ccd70
NC		 6232 if (alloc == 0)
6233 return TRUE;
6234
1a9ccd70
NC		 6235 /* PR ld/20815 - Check that the program header segment, if present, will
6236 be loaded into memory. FIXME: The check below is not sufficient as
6237 really all PT_LOAD segments should be checked before issuing an error
6238 message. Plus the PHDR segment does not have to be the first segment
6239 in the program header table. But this version of the check should
cd584857
NC		 6240 catch all real world use cases.
6241
6242 FIXME: We used to have code here to sort the PT_LOAD segments into
6243 ascending order, as per the ELF spec. But this breaks some programs,
6244 including the Linux kernel. But really either the spec should be
07d6d2b8 6245 changed or the programs updated. */
1a9ccd70 6246 if (alloc > 1
cd584857 6247 && tdata->phdr[0].p_type == PT_PHDR
d00dd7dc
AM		 6248 && (bed->elf_backend_allow_non_load_phdr == NULL
6249 || !bed->elf_backend_allow_non_load_phdr (abfd, tdata->phdr,
6250 alloc))
cd584857
NC		 6251 && tdata->phdr[1].p_type == PT_LOAD
6252 && (tdata->phdr[1].p_vaddr > tdata->phdr[0].p_vaddr
6838f2be
AM		 6253 || (tdata->phdr[1].p_vaddr + tdata->phdr[1].p_memsz
6254 < tdata->phdr[0].p_vaddr + tdata->phdr[0].p_memsz)))
1a9ccd70
NC		 6255 {
6256 /* The fix for this error is usually to edit the linker script being
6257 used and set up the program headers manually. Either that or
6258 leave room for the headers at the start of the SECTIONS. */
6838f2be
AM		 6259 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6260 " by LOAD segment"),
1a9ccd70 6261 abfd);
1a9ccd70
NC		 6262 return FALSE;
6263 }
6264
f3520d2f 6265 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
cd584857
NC		 6266 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
6267 return FALSE;
252b5132
RH		 6268 }
6269
b34976b6 6270 return TRUE;
252b5132
RH		 6271}
6272
b34976b6 6273static bfd_boolean
217aa764 6274prep_headers (bfd *abfd)
252b5132 6275{
3d540e93 6276 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
2b0f7ef9 6277 struct elf_strtab_hash *shstrtab;
9c5bfbb7 6278 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 6279
6280 i_ehdrp = elf_elfheader (abfd);
252b5132 6281
2b0f7ef9 6282 shstrtab = _bfd_elf_strtab_init ();
252b5132 6283 if (shstrtab == NULL)
b34976b6 6284 return FALSE;
252b5132
RH		 6285
6286 elf_shstrtab (abfd) = shstrtab;
6287
6288 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
6289 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
6290 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
6291 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
6292
6293 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
6294 i_ehdrp->e_ident[EI_DATA] =
6295 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
6296 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
6297
252b5132
RH		 6298 if ((abfd->flags & DYNAMIC) != 0)
6299 i_ehdrp->e_type = ET_DYN;
6300 else if ((abfd->flags & EXEC_P) != 0)
6301 i_ehdrp->e_type = ET_EXEC;
6302 else if (bfd_get_format (abfd) == bfd_core)
6303 i_ehdrp->e_type = ET_CORE;
6304 else
6305 i_ehdrp->e_type = ET_REL;
6306
6307 switch (bfd_get_arch (abfd))
6308 {
6309 case bfd_arch_unknown:
6310 i_ehdrp->e_machine = EM_NONE;
6311 break;
aa4f99bb
AO		 6312
6313 /* There used to be a long list of cases here, each one setting
6314 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6315 in the corresponding bfd definition. To avoid duplication,
6316 the switch was removed. Machines that need special handling
6317 can generally do it in elf_backend_final_write_processing(),
6318 unless they need the information earlier than the final write.
6319 Such need can generally be supplied by replacing the tests for
6320 e_machine with the conditions used to determine it. */
252b5132 6321 default:
9c5bfbb7
AM		 6322 i_ehdrp->e_machine = bed->elf_machine_code;
6323 }
aa4f99bb 6324
252b5132
RH		 6325 i_ehdrp->e_version = bed->s->ev_current;
6326 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
6327
c044fabd 6328 /* No program header, for now. */
252b5132
RH		 6329 i_ehdrp->e_phoff = 0;
6330 i_ehdrp->e_phentsize = 0;
6331 i_ehdrp->e_phnum = 0;
6332
c044fabd 6333 /* Each bfd section is section header entry. */
252b5132
RH		 6334 i_ehdrp->e_entry = bfd_get_start_address (abfd);
6335 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
6336
c044fabd 6337 /* If we're building an executable, we'll need a program header table. */
252b5132 6338 if (abfd->flags & EXEC_P)
0e71e495
BE		 6339 /* It all happens later. */
6340 ;
252b5132
RH		 6341 else
6342 {
6343 i_ehdrp->e_phentsize = 0;
252b5132
RH		 6344 i_ehdrp->e_phoff = 0;
6345 }
6346
6347 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 6348 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 6349 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 6350 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 6351 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 6352 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132 6353 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
17ca87fc 6354 || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
252b5132 6355 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 6356 return FALSE;
252b5132 6357
b34976b6 6358 return TRUE;
252b5132
RH		 6359}
6360
6361/* Assign file positions for all the reloc sections which are not part
a485e98e 6362 of the loadable file image, and the file position of section headers. */
252b5132 6363
0ce398f1
L		 6364static bfd_boolean
6365_bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
252b5132
RH		 6366{
6367 file_ptr off;
e06efbf1 6368 Elf_Internal_Shdr **shdrpp, **end_shdrpp;
3e19fb8f 6369 Elf_Internal_Shdr *shdrp;
a485e98e
AM		 6370 Elf_Internal_Ehdr *i_ehdrp;
6371 const struct elf_backend_data *bed;
252b5132 6372
12bd6957 6373 off = elf_next_file_pos (abfd);
252b5132 6374
e06efbf1
L		 6375 shdrpp = elf_elfsections (abfd);
6376 end_shdrpp = shdrpp + elf_numsections (abfd);
6377 for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
252b5132 6378 {
252b5132 6379 shdrp = *shdrpp;
0ce398f1
L		 6380 if (shdrp->sh_offset == -1)
6381 {
3e19fb8f 6382 asection *sec = shdrp->bfd_section;
0ce398f1
L		 6383 bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
6384 || shdrp->sh_type == SHT_RELA);
6385 if (is_rel
3e19fb8f 6386 || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
0ce398f1
L		 6387 {
6388 if (!is_rel)
6389 {
3e19fb8f
L		 6390 const char *name = sec->name;
6391 struct bfd_elf_section_data *d;
6392
0ce398f1 6393 /* Compress DWARF debug sections. */
3e19fb8f 6394 if (!bfd_compress_section (abfd, sec,
0ce398f1
L		 6395 shdrp->contents))
6396 return FALSE;
3e19fb8f
L		 6397
6398 if (sec->compress_status == COMPRESS_SECTION_DONE
6399 && (abfd->flags & BFD_COMPRESS_GABI) == 0)
6400 {
6401 /* If section is compressed with zlib-gnu, convert
6402 section name from .debug_* to .zdebug_*. */
6403 char *new_name
6404 = convert_debug_to_zdebug (abfd, name);
6405 if (new_name == NULL)
6406 return FALSE;
6407 name = new_name;
6408 }
dd905818 6409 /* Add section name to section name section. */
3e19fb8f
L		 6410 if (shdrp->sh_name != (unsigned int) -1)
6411 abort ();
6412 shdrp->sh_name
6413 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
6414 name, FALSE);
6415 d = elf_section_data (sec);
6416
dd905818 6417 /* Add reloc section name to section name section. */
3e19fb8f
L		 6418 if (d->rel.hdr
6419 && !_bfd_elf_set_reloc_sh_name (abfd,
6420 d->rel.hdr,
6421 name, FALSE))
6422 return FALSE;
6423 if (d->rela.hdr
6424 && !_bfd_elf_set_reloc_sh_name (abfd,
6425 d->rela.hdr,
91cb26da 6426 name, TRUE))
3e19fb8f
L		 6427 return FALSE;
6428
0ce398f1 6429 /* Update section size and contents. */
3e19fb8f
L		 6430 shdrp->sh_size = sec->size;
6431 shdrp->contents = sec->contents;
0ce398f1
L		 6432 shdrp->bfd_section->contents = NULL;
6433 }
6434 off = _bfd_elf_assign_file_position_for_section (shdrp,
6435 off,
6436 TRUE);
6437 }
6438 }
252b5132
RH		 6439 }
6440
3e19fb8f
L		 6441 /* Place section name section after DWARF debug sections have been
6442 compressed. */
6443 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6444 shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6445 shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6446 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6447
6448 /* Place the section headers. */
a485e98e
AM		 6449 i_ehdrp = elf_elfheader (abfd);
6450 bed = get_elf_backend_data (abfd);
6451 off = align_file_position (off, 1 << bed->s->log_file_align);
6452 i_ehdrp->e_shoff = off;
6453 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
12bd6957 6454 elf_next_file_pos (abfd) = off;
0ce398f1
L		 6455
6456 return TRUE;
252b5132
RH		 6457}
6458
b34976b6 6459bfd_boolean
217aa764 6460_bfd_elf_write_object_contents (bfd *abfd)
252b5132 6461{
9c5bfbb7 6462 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 6463 Elf_Internal_Shdr **i_shdrp;
b34976b6 6464 bfd_boolean failed;
9ad5cbcf 6465 unsigned int count, num_sec;
30e8ee25 6466 struct elf_obj_tdata *t;
252b5132
RH		 6467
6468 if (! abfd->output_has_begun
217aa764 6469 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 6470 return FALSE;
db727370
JL		 6471 /* Do not rewrite ELF data when the BFD has been opened for update.
6472 abfd->output_has_begun was set to TRUE on opening, so creation of new
6473 sections, and modification of existing section sizes was restricted.
6474 This means the ELF header, program headers and section headers can't have
6475 changed.
6476 If the contents of any sections has been modified, then those changes have
6477 already been written to the BFD. */
6478 else if (abfd->direction == both_direction)
6479 {
6480 BFD_ASSERT (abfd->output_has_begun);
6481 return TRUE;
6482 }
252b5132
RH		 6483
6484 i_shdrp = elf_elfsections (abfd);
252b5132 6485
b34976b6 6486 failed = FALSE;
252b5132
RH		 6487 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6488 if (failed)
b34976b6 6489 return FALSE;
252b5132 6490
0ce398f1
L		 6491 if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6492 return FALSE;
252b5132 6493
c044fabd 6494 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM		 6495 num_sec = elf_numsections (abfd);
6496 for (count = 1; count < num_sec; count++)
252b5132 6497 {
3e19fb8f
L		 6498 i_shdrp[count]->sh_name
6499 = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6500 i_shdrp[count]->sh_name);
252b5132 6501 if (bed->elf_backend_section_processing)
75506100
MR		 6502 if (!(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]))
6503 return FALSE;
252b5132
RH		 6504 if (i_shdrp[count]->contents)
6505 {
dc810e39
AM		 6506 bfd_size_type amt = i_shdrp[count]->sh_size;
6507
252b5132 6508 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 6509 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 6510 return FALSE;
252b5132
RH		 6511 }
6512 }
6513
6514 /* Write out the section header names. */
30e8ee25 6515 t = elf_tdata (abfd);
26ae6d5e 6516 if (elf_shstrtab (abfd) != NULL
30e8ee25 6517 && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
08a40648 6518 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
b34976b6 6519 return FALSE;
252b5132
RH		 6520
6521 if (bed->elf_backend_final_write_processing)
12bd6957 6522 (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
252b5132 6523
ff59fc36
RM		 6524 if (!bed->s->write_shdrs_and_ehdr (abfd))
6525 return FALSE;
6526
6527 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
c0355132
AM		 6528 if (t->o->build_id.after_write_object_contents != NULL)
6529 return (*t->o->build_id.after_write_object_contents) (abfd);
ff59fc36
RM		 6530
6531 return TRUE;
252b5132
RH		 6532}
6533
b34976b6 6534bfd_boolean
217aa764 6535_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 6536{
c044fabd 6537 /* Hopefully this can be done just like an object file. */
252b5132
RH		 6538 return _bfd_elf_write_object_contents (abfd);
6539}
c044fabd
KH		 6540
6541/* Given a section, search the header to find them. */
6542
cb33740c 6543unsigned int
198beae2 6544_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 6545{
9c5bfbb7 6546 const struct elf_backend_data *bed;
91d6fa6a 6547 unsigned int sec_index;
252b5132 6548
9ad5cbcf
AM		 6549 if (elf_section_data (asect) != NULL
6550 && elf_section_data (asect)->this_idx != 0)
6551 return elf_section_data (asect)->this_idx;
6552
6553 if (bfd_is_abs_section (asect))
91d6fa6a 6554 sec_index = SHN_ABS;
af746e92 6555 else if (bfd_is_com_section (asect))
91d6fa6a 6556 sec_index = SHN_COMMON;
af746e92 6557 else if (bfd_is_und_section (asect))
91d6fa6a 6558 sec_index = SHN_UNDEF;
af746e92 6559 else
91d6fa6a 6560 sec_index = SHN_BAD;
252b5132 6561
af746e92 6562 bed = get_elf_backend_data (abfd);
252b5132
RH		 6563 if (bed->elf_backend_section_from_bfd_section)
6564 {
91d6fa6a 6565 int retval = sec_index;
9ad5cbcf 6566
af746e92
AM		 6567 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6568 return retval;
252b5132
RH		 6569 }
6570
91d6fa6a 6571 if (sec_index == SHN_BAD)
af746e92 6572 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 6573
91d6fa6a 6574 return sec_index;
252b5132
RH		 6575}
6576
6577/* Given a BFD symbol, return the index in the ELF symbol table, or -1
6578 on error. */
6579
6580int
217aa764 6581_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH		 6582{
6583 asymbol *asym_ptr = *asym_ptr_ptr;
6584 int idx;
6585 flagword flags = asym_ptr->flags;
6586
6587 /* When gas creates relocations against local labels, it creates its
6588 own symbol for the section, but does put the symbol into the
6589 symbol chain, so udata is 0. When the linker is generating
6590 relocatable output, this section symbol may be for one of the
6591 input sections rather than the output section. */
6592 if (asym_ptr->udata.i == 0
6593 && (flags & BSF_SECTION_SYM)
6594 && asym_ptr->section)
6595 {
5372391b 6596 asection *sec;
252b5132
RH		 6597 int indx;
6598
5372391b
AM		 6599 sec = asym_ptr->section;
6600 if (sec->owner != abfd && sec->output_section != NULL)
6601 sec = sec->output_section;
6602 if (sec->owner == abfd
6603 && (indx = sec->index) < elf_num_section_syms (abfd)
4e89ac30 6604 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH		 6605 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6606 }
6607
6608 idx = asym_ptr->udata.i;
6609
6610 if (idx == 0)
6611 {
6612 /* This case can occur when using --strip-symbol on a symbol
08a40648 6613 which is used in a relocation entry. */
4eca0228 6614 _bfd_error_handler
695344c0 6615 /* xgettext:c-format */
871b3ab2 6616 (_("%pB: symbol `%s' required but not present"),
d003868e 6617 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH		 6618 bfd_set_error (bfd_error_no_symbols);
6619 return -1;
6620 }
6621
6622#if DEBUG & 4
6623 {
6624 fprintf (stderr,
cd9af601
AM		 6625 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6626 (long) asym_ptr, asym_ptr->name, idx, flags);
252b5132
RH		 6627 fflush (stderr);
6628 }
6629#endif
6630
6631 return idx;
6632}
6633
84d1d650 6634/* Rewrite program header information. */
252b5132 6635
b34976b6 6636static bfd_boolean
84d1d650 6637rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
252b5132 6638{
b34976b6
AM		 6639 Elf_Internal_Ehdr *iehdr;
6640 struct elf_segment_map *map;
6641 struct elf_segment_map *map_first;
6642 struct elf_segment_map **pointer_to_map;
6643 Elf_Internal_Phdr *segment;
6644 asection *section;
6645 unsigned int i;
6646 unsigned int num_segments;
6647 bfd_boolean phdr_included = FALSE;
5c44b38e 6648 bfd_boolean p_paddr_valid;
b34976b6
AM		 6649 bfd_vma maxpagesize;
6650 struct elf_segment_map *phdr_adjust_seg = NULL;
6651 unsigned int phdr_adjust_num = 0;
9c5bfbb7 6652 const struct elf_backend_data *bed;
bc67d8a6 6653
caf47ea6 6654 bed = get_elf_backend_data (ibfd);
252b5132
RH		 6655 iehdr = elf_elfheader (ibfd);
6656
bc67d8a6 6657 map_first = NULL;
c044fabd 6658 pointer_to_map = &map_first;
252b5132
RH		 6659
6660 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC		 6661 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6662
6663 /* Returns the end address of the segment + 1. */
aecc8f8a
AM		 6664#define SEGMENT_END(segment, start) \
6665 (start + (segment->p_memsz > segment->p_filesz \
6666 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 6667
eecdbe52
JJ		 6668#define SECTION_SIZE(section, segment) \
6669 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6670 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 6671 ? section->size : 0)
eecdbe52 6672
b34976b6 6673 /* Returns TRUE if the given section is contained within
bc67d8a6 6674 the given segment. VMA addresses are compared. */
aecc8f8a
AM		 6675#define IS_CONTAINED_BY_VMA(section, segment) \
6676 (section->vma >= segment->p_vaddr \
eecdbe52 6677 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 6678 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 6679
b34976b6 6680 /* Returns TRUE if the given section is contained within
bc67d8a6 6681 the given segment. LMA addresses are compared. */
aecc8f8a
AM		 6682#define IS_CONTAINED_BY_LMA(section, segment, base) \
6683 (section->lma >= base \
beab4532 6684 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
eecdbe52 6685 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 6686 <= SEGMENT_END (segment, base)))
252b5132 6687
0efc80c8
L		 6688 /* Handle PT_NOTE segment. */
6689#define IS_NOTE(p, s) \
aecc8f8a 6690 (p->p_type == PT_NOTE \
0efc80c8 6691 && elf_section_type (s) == SHT_NOTE \
aecc8f8a 6692 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 6693 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 6694 <= p->p_offset + p->p_filesz))
252b5132 6695
0efc80c8
L		 6696 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6697 etc. */
6698#define IS_COREFILE_NOTE(p, s) \
6699 (IS_NOTE (p, s) \
6700 && bfd_get_format (ibfd) == bfd_core \
6701 && s->vma == 0 \
6702 && s->lma == 0)
6703
252b5132
RH		 6704 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6705 linker, which generates a PT_INTERP section with p_vaddr and
6706 p_memsz set to 0. */
aecc8f8a
AM		 6707#define IS_SOLARIS_PT_INTERP(p, s) \
6708 (p->p_vaddr == 0 \
6709 && p->p_paddr == 0 \
6710 && p->p_memsz == 0 \
6711 && p->p_filesz > 0 \
6712 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 6713 && s->size > 0 \
aecc8f8a 6714 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 6715 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 6716 <= p->p_offset + p->p_filesz))
5c440b1e 6717
bc67d8a6
NC		 6718 /* Decide if the given section should be included in the given segment.
6719 A section will be included if:
f5ffc919 6720 1. It is within the address space of the segment -- we use the LMA
08a40648 6721 if that is set for the segment and the VMA otherwise,
0efc80c8 6722 2. It is an allocated section or a NOTE section in a PT_NOTE
d324f6d6 6723 segment.
bc67d8a6 6724 3. There is an output section associated with it,
eecdbe52 6725 4. The section has not already been allocated to a previous segment.
2b05f1b7 6726 5. PT_GNU_STACK segments do not include any sections.
03394ac9 6727 6. PT_TLS segment includes only SHF_TLS sections.
6f79b219
JJ		 6728 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6729 8. PT_DYNAMIC should not contain empty sections at the beginning
08a40648 6730 (with the possible exception of .dynamic). */
9f17e2a6 6731#define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
2b05f1b7
L		 6732 ((((segment->p_paddr \
6733 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6734 : IS_CONTAINED_BY_VMA (section, segment)) \
6735 && (section->flags & SEC_ALLOC) != 0) \
0efc80c8 6736 || IS_NOTE (segment, section)) \
2b05f1b7
L		 6737 && segment->p_type != PT_GNU_STACK \
6738 && (segment->p_type != PT_TLS \
6739 || (section->flags & SEC_THREAD_LOCAL)) \
6740 && (segment->p_type == PT_LOAD \
6741 || segment->p_type == PT_TLS \
6742 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6743 && (segment->p_type != PT_DYNAMIC \
6744 || SECTION_SIZE (section, segment) > 0 \
6745 || (segment->p_paddr \
6746 ? segment->p_paddr != section->lma \
6747 : segment->p_vaddr != section->vma) \
6748 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6749 == 0)) \
9933dc52 6750 && (segment->p_type != PT_LOAD || !section->segment_mark))
bc67d8a6 6751
9f17e2a6
L		 6752/* If the output section of a section in the input segment is NULL,
6753 it is removed from the corresponding output segment. */
6754#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6755 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6756 && section->output_section != NULL)
6757
b34976b6 6758 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC		 6759#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6760 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6761
6762 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6763 their VMA address ranges and their LMA address ranges overlap.
6764 It is possible to have overlapping VMA ranges without overlapping LMA
6765 ranges. RedBoot images for example can have both .data and .bss mapped
6766 to the same VMA range, but with the .data section mapped to a different
6767 LMA. */
aecc8f8a 6768#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea 6769 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
08a40648 6770 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
b5f852ea 6771 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
08a40648 6772 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC		 6773
6774 /* Initialise the segment mark field. */
6775 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 6776 section->segment_mark = FALSE;
bc67d8a6 6777
5c44b38e
AM		 6778 /* The Solaris linker creates program headers in which all the
6779 p_paddr fields are zero. When we try to objcopy or strip such a
6780 file, we get confused. Check for this case, and if we find it
6781 don't set the p_paddr_valid fields. */
6782 p_paddr_valid = FALSE;
6783 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6784 i < num_segments;
6785 i++, segment++)
6786 if (segment->p_paddr != 0)
6787 {
6788 p_paddr_valid = TRUE;
6789 break;
6790 }
6791
252b5132 6792 /* Scan through the segments specified in the program header
bc67d8a6 6793 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 6794 in the loadable segments. These can be created by weird
aecc8f8a 6795 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC		 6796 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6797 i < num_segments;
c044fabd 6798 i++, segment++)
252b5132 6799 {
252b5132 6800 unsigned int j;
c044fabd 6801 Elf_Internal_Phdr *segment2;
252b5132 6802
aecc8f8a
AM		 6803 if (segment->p_type == PT_INTERP)
6804 for (section = ibfd->sections; section; section = section->next)
6805 if (IS_SOLARIS_PT_INTERP (segment, section))
6806 {
6807 /* Mininal change so that the normal section to segment
4cc11e76 6808 assignment code will work. */
aecc8f8a
AM		 6809 segment->p_vaddr = section->vma;
6810 break;
6811 }
6812
bc67d8a6 6813 if (segment->p_type != PT_LOAD)
b10a8ae0
L		 6814 {
6815 /* Remove PT_GNU_RELRO segment. */
6816 if (segment->p_type == PT_GNU_RELRO)
6817 segment->p_type = PT_NULL;
6818 continue;
6819 }
c044fabd 6820
bc67d8a6 6821 /* Determine if this segment overlaps any previous segments. */
0067a569 6822 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
bc67d8a6
NC		 6823 {
6824 bfd_signed_vma extra_length;
c044fabd 6825
bc67d8a6 6826 if (segment2->p_type != PT_LOAD
0067a569 6827 || !SEGMENT_OVERLAPS (segment, segment2))
bc67d8a6 6828 continue;
c044fabd 6829
bc67d8a6
NC		 6830 /* Merge the two segments together. */
6831 if (segment2->p_vaddr < segment->p_vaddr)
6832 {
c044fabd 6833 /* Extend SEGMENT2 to include SEGMENT and then delete
08a40648 6834 SEGMENT. */
0067a569
AM		 6835 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6836 - SEGMENT_END (segment2, segment2->p_vaddr));
c044fabd 6837
bc67d8a6
NC		 6838 if (extra_length > 0)
6839 {
0067a569 6840 segment2->p_memsz += extra_length;
bc67d8a6
NC		 6841 segment2->p_filesz += extra_length;
6842 }
c044fabd 6843
bc67d8a6 6844 segment->p_type = PT_NULL;
c044fabd 6845
bc67d8a6
NC		 6846 /* Since we have deleted P we must restart the outer loop. */
6847 i = 0;
6848 segment = elf_tdata (ibfd)->phdr;
6849 break;
6850 }
6851 else
6852 {
c044fabd 6853 /* Extend SEGMENT to include SEGMENT2 and then delete
08a40648 6854 SEGMENT2. */
0067a569
AM		 6855 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6856 - SEGMENT_END (segment, segment->p_vaddr));
c044fabd 6857
bc67d8a6
NC		 6858 if (extra_length > 0)
6859 {
0067a569 6860 segment->p_memsz += extra_length;
bc67d8a6
NC		 6861 segment->p_filesz += extra_length;
6862 }
c044fabd 6863
bc67d8a6
NC		 6864 segment2->p_type = PT_NULL;
6865 }
6866 }
6867 }
c044fabd 6868
bc67d8a6
NC		 6869 /* The second scan attempts to assign sections to segments. */
6870 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6871 i < num_segments;
0067a569 6872 i++, segment++)
bc67d8a6 6873 {
0067a569
AM		 6874 unsigned int section_count;
6875 asection **sections;
6876 asection *output_section;
6877 unsigned int isec;
9933dc52
AM		 6878 asection *matching_lma;
6879 asection *suggested_lma;
0067a569 6880 unsigned int j;
dc810e39 6881 bfd_size_type amt;
0067a569 6882 asection *first_section;
bc67d8a6
NC		 6883
6884 if (segment->p_type == PT_NULL)
6885 continue;
c044fabd 6886
9f17e2a6 6887 first_section = NULL;
bc67d8a6 6888 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC		 6889 for (section = ibfd->sections, section_count = 0;
6890 section != NULL;
6891 section = section->next)
9f17e2a6
L		 6892 {
6893 /* Find the first section in the input segment, which may be
6894 removed from the corresponding output segment. */
6895 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6896 {
6897 if (first_section == NULL)
6898 first_section = section;
6899 if (section->output_section != NULL)
6900 ++section_count;
6901 }
6902 }
811072d8 6903
b5f852ea
NC		 6904 /* Allocate a segment map big enough to contain
6905 all of the sections we have selected. */
00bee008
AM		 6906 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
6907 amt += (bfd_size_type) section_count * sizeof (asection *);
a50b1753 6908 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 6909 if (map == NULL)
b34976b6 6910 return FALSE;
252b5132
RH		 6911
6912 /* Initialise the fields of the segment map. Default to
6913 using the physical address of the segment in the input BFD. */
0067a569
AM		 6914 map->next = NULL;
6915 map->p_type = segment->p_type;
6916 map->p_flags = segment->p_flags;
bc67d8a6 6917 map->p_flags_valid = 1;
55d55ac7 6918
9f17e2a6
L		 6919 /* If the first section in the input segment is removed, there is
6920 no need to preserve segment physical address in the corresponding
6921 output segment. */
945c025a 6922 if (!first_section || first_section->output_section != NULL)
9f17e2a6
L		 6923 {
6924 map->p_paddr = segment->p_paddr;
5c44b38e 6925 map->p_paddr_valid = p_paddr_valid;
9f17e2a6 6926 }
252b5132
RH		 6927
6928 /* Determine if this segment contains the ELF file header
6929 and if it contains the program headers themselves. */
bc67d8a6
NC		 6930 map->includes_filehdr = (segment->p_offset == 0
6931 && segment->p_filesz >= iehdr->e_ehsize);
bc67d8a6 6932 map->includes_phdrs = 0;
252b5132 6933
0067a569 6934 if (!phdr_included || segment->p_type != PT_LOAD)
252b5132 6935 {
bc67d8a6
NC		 6936 map->includes_phdrs =
6937 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6938 && (segment->p_offset + segment->p_filesz
252b5132
RH		 6939 >= ((bfd_vma) iehdr->e_phoff
6940 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 6941
bc67d8a6 6942 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 6943 phdr_included = TRUE;
252b5132
RH		 6944 }
6945
bc67d8a6 6946 if (section_count == 0)
252b5132
RH		 6947 {
6948 /* Special segments, such as the PT_PHDR segment, may contain
6949 no sections, but ordinary, loadable segments should contain
1ed89aa9 6950 something. They are allowed by the ELF spec however, so only
07d6d2b8 6951 a warning is produced.
f98450c6
NC		 6952 There is however the valid use case of embedded systems which
6953 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6954 flash memory with zeros. No warning is shown for that case. */
6955 if (segment->p_type == PT_LOAD
6956 && (segment->p_filesz > 0 || segment->p_memsz == 0))
6957 /* xgettext:c-format */
9793eb77
AM		 6958 _bfd_error_handler
6959 (_("%pB: warning: empty loadable segment detected"
6960 " at vaddr=%#" PRIx64 ", is this intentional?"),
6961 ibfd, (uint64_t) segment->p_vaddr);
252b5132 6962
5d695627 6963 map->p_vaddr_offset = segment->p_vaddr;
bc67d8a6 6964 map->count = 0;
c044fabd
KH		 6965 *pointer_to_map = map;
6966 pointer_to_map = &map->next;
252b5132
RH		 6967
6968 continue;
6969 }
6970
6971 /* Now scan the sections in the input BFD again and attempt
6972 to add their corresponding output sections to the segment map.
6973 The problem here is how to handle an output section which has
6974 been moved (ie had its LMA changed). There are four possibilities:
6975
6976 1. None of the sections have been moved.
6977 In this case we can continue to use the segment LMA from the
6978 input BFD.
6979
6980 2. All of the sections have been moved by the same amount.
6981 In this case we can change the segment's LMA to match the LMA
6982 of the first section.
6983
6984 3. Some of the sections have been moved, others have not.
6985 In this case those sections which have not been moved can be
6986 placed in the current segment which will have to have its size,
6987 and possibly its LMA changed, and a new segment or segments will
6988 have to be created to contain the other sections.
6989
b5f852ea 6990 4. The sections have been moved, but not by the same amount.
252b5132
RH		 6991 In this case we can change the segment's LMA to match the LMA
6992 of the first section and we will have to create a new segment
6993 or segments to contain the other sections.
6994
6995 In order to save time, we allocate an array to hold the section
6996 pointers that we are interested in. As these sections get assigned
6997 to a segment, they are removed from this array. */
6998
a50b1753 6999 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
252b5132 7000 if (sections == NULL)
b34976b6 7001 return FALSE;
252b5132
RH		 7002
7003 /* Step One: Scan for segment vs section LMA conflicts.
7004 Also add the sections to the section array allocated above.
7005 Also add the sections to the current segment. In the common
7006 case, where the sections have not been moved, this means that
7007 we have completely filled the segment, and there is nothing
7008 more to do. */
252b5132 7009 isec = 0;
9933dc52
AM		 7010 matching_lma = NULL;
7011 suggested_lma = NULL;
252b5132 7012
461c4b2e 7013 for (section = first_section, j = 0;
bc67d8a6
NC		 7014 section != NULL;
7015 section = section->next)
252b5132 7016 {
caf47ea6 7017 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 7018 {
bc67d8a6
NC		 7019 output_section = section->output_section;
7020
0067a569 7021 sections[j++] = section;
252b5132
RH		 7022
7023 /* The Solaris native linker always sets p_paddr to 0.
7024 We try to catch that case here, and set it to the
5e8d7549
NC		 7025 correct value. Note - some backends require that
7026 p_paddr be left as zero. */
5c44b38e 7027 if (!p_paddr_valid
4455705d 7028 && segment->p_vaddr != 0
0067a569 7029 && !bed->want_p_paddr_set_to_zero
252b5132 7030 && isec == 0
bc67d8a6 7031 && output_section->lma != 0
9933dc52
AM		 7032 && (align_power (segment->p_vaddr
7033 + (map->includes_filehdr
7034 ? iehdr->e_ehsize : 0)
7035 + (map->includes_phdrs
7036 ? iehdr->e_phnum * iehdr->e_phentsize
7037 : 0),
7038 output_section->alignment_power)
7039 == output_section->vma))
bc67d8a6 7040 map->p_paddr = segment->p_vaddr;
252b5132
RH		 7041
7042 /* Match up the physical address of the segment with the
7043 LMA address of the output section. */
bc67d8a6 7044 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549 7045 || IS_COREFILE_NOTE (segment, section)
0067a569
AM		 7046 || (bed->want_p_paddr_set_to_zero
7047 && IS_CONTAINED_BY_VMA (output_section, segment)))
252b5132 7048 {
9933dc52
AM		 7049 if (matching_lma == NULL
7050 || output_section->lma < matching_lma->lma)
7051 matching_lma = output_section;
252b5132
RH		 7052
7053 /* We assume that if the section fits within the segment
bc67d8a6 7054 then it does not overlap any other section within that
252b5132 7055 segment. */
0067a569
AM		 7056 map->sections[isec++] = output_section;
7057 }
9933dc52
AM		 7058 else if (suggested_lma == NULL)
7059 suggested_lma = output_section;
147d51c2
L		 7060
7061 if (j == section_count)
7062 break;
252b5132
RH		 7063 }
7064 }
7065
bc67d8a6 7066 BFD_ASSERT (j == section_count);
252b5132
RH		 7067
7068 /* Step Two: Adjust the physical address of the current segment,
7069 if necessary. */
bc67d8a6 7070 if (isec == section_count)
252b5132
RH		 7071 {
7072 /* All of the sections fitted within the segment as currently
7073 specified. This is the default case. Add the segment to
7074 the list of built segments and carry on to process the next
7075 program header in the input BFD. */
bc67d8a6 7076 map->count = section_count;
c044fabd
KH		 7077 *pointer_to_map = map;
7078 pointer_to_map = &map->next;
08a40648 7079
5c44b38e
AM		 7080 if (p_paddr_valid
7081 && !bed->want_p_paddr_set_to_zero
9933dc52 7082 && matching_lma->lma != map->p_paddr
5c44b38e
AM		 7083 && !map->includes_filehdr
7084 && !map->includes_phdrs)
3271a814
NS		 7085 /* There is some padding before the first section in the
7086 segment. So, we must account for that in the output
7087 segment's vma. */
5d695627 7088 map->p_vaddr_offset = map->p_paddr - matching_lma->lma;
08a40648 7089
252b5132
RH		 7090 free (sections);
7091 continue;
7092 }
252b5132
RH		 7093 else
7094 {
9933dc52
AM		 7095 /* Change the current segment's physical address to match
7096 the LMA of the first section that fitted, or if no
7097 section fitted, the first section. */
7098 if (matching_lma == NULL)
7099 matching_lma = suggested_lma;
7100
7101 map->p_paddr = matching_lma->lma;
72730e0c 7102
bc67d8a6
NC		 7103 /* Offset the segment physical address from the lma
7104 to allow for space taken up by elf headers. */
9933dc52 7105 if (map->includes_phdrs)
010c8431 7106 {
9933dc52
AM		 7107 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7108
7109 /* iehdr->e_phnum is just an estimate of the number
7110 of program headers that we will need. Make a note
7111 here of the number we used and the segment we chose
7112 to hold these headers, so that we can adjust the
7113 offset when we know the correct value. */
7114 phdr_adjust_num = iehdr->e_phnum;
7115 phdr_adjust_seg = map;
010c8431 7116 }
252b5132 7117
9933dc52 7118 if (map->includes_filehdr)
bc67d8a6 7119 {
9933dc52
AM		 7120 bfd_vma align = (bfd_vma) 1 << matching_lma->alignment_power;
7121 map->p_paddr -= iehdr->e_ehsize;
7122 /* We've subtracted off the size of headers from the
7123 first section lma, but there may have been some
7124 alignment padding before that section too. Try to
7125 account for that by adjusting the segment lma down to
7126 the same alignment. */
7127 if (segment->p_align != 0 && segment->p_align < align)
7128 align = segment->p_align;
7129 map->p_paddr &= -align;
bc67d8a6 7130 }
252b5132
RH		 7131 }
7132
7133 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 7134 those that fit to the current segment and removing them from the
252b5132
RH		 7135 sections array; but making sure not to leave large gaps. Once all
7136 possible sections have been assigned to the current segment it is
7137 added to the list of built segments and if sections still remain
7138 to be assigned, a new segment is constructed before repeating
7139 the loop. */
7140 isec = 0;
7141 do
7142 {
bc67d8a6 7143 map->count = 0;
9933dc52 7144 suggested_lma = NULL;
252b5132
RH		 7145
7146 /* Fill the current segment with sections that fit. */
bc67d8a6 7147 for (j = 0; j < section_count; j++)
252b5132 7148 {
bc67d8a6 7149 section = sections[j];
252b5132 7150
bc67d8a6 7151 if (section == NULL)
252b5132
RH		 7152 continue;
7153
bc67d8a6 7154 output_section = section->output_section;
252b5132 7155
bc67d8a6 7156 BFD_ASSERT (output_section != NULL);
c044fabd 7157
bc67d8a6
NC		 7158 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7159 || IS_COREFILE_NOTE (segment, section))
252b5132 7160 {
bc67d8a6 7161 if (map->count == 0)
252b5132
RH		 7162 {
7163 /* If the first section in a segment does not start at
bc67d8a6
NC		 7164 the beginning of the segment, then something is
7165 wrong. */
9933dc52
AM		 7166 if (align_power (map->p_paddr
7167 + (map->includes_filehdr
7168 ? iehdr->e_ehsize : 0)
7169 + (map->includes_phdrs
7170 ? iehdr->e_phnum * iehdr->e_phentsize
7171 : 0),
7172 output_section->alignment_power)
7173 != output_section->lma)
252b5132
RH		 7174 abort ();
7175 }
7176 else
7177 {
0067a569 7178 asection *prev_sec;
252b5132 7179
bc67d8a6 7180 prev_sec = map->sections[map->count - 1];
252b5132
RH		 7181
7182 /* If the gap between the end of the previous section
bc67d8a6
NC		 7183 and the start of this section is more than
7184 maxpagesize then we need to start a new segment. */
eea6121a 7185 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 7186 maxpagesize)
caf47ea6 7187 < BFD_ALIGN (output_section->lma, maxpagesize))
0067a569 7188 || (prev_sec->lma + prev_sec->size
079e9a2f 7189 > output_section->lma))
252b5132 7190 {
9933dc52
AM		 7191 if (suggested_lma == NULL)
7192 suggested_lma = output_section;
252b5132
RH		 7193
7194 continue;
7195 }
7196 }
7197
bc67d8a6 7198 map->sections[map->count++] = output_section;
252b5132
RH		 7199 ++isec;
7200 sections[j] = NULL;
9933dc52
AM		 7201 if (segment->p_type == PT_LOAD)
7202 section->segment_mark = TRUE;
0067a569 7203 }
9933dc52
AM		 7204 else if (suggested_lma == NULL)
7205 suggested_lma = output_section;
252b5132
RH		 7206 }
7207
beab4532
NC		 7208 /* PR 23932. A corrupt input file may contain sections that cannot
7209 be assigned to any segment - because for example they have a
7210 negative size - or segments that do not contain any sections. */
7211 if (map->count == 0)
7212 {
7213 bfd_set_error (bfd_error_bad_value);
7214 free (sections);
7215 return FALSE;
7216 }
252b5132
RH		 7217
7218 /* Add the current segment to the list of built segments. */
c044fabd
KH		 7219 *pointer_to_map = map;
7220 pointer_to_map = &map->next;
252b5132 7221
bc67d8a6 7222 if (isec < section_count)
252b5132
RH		 7223 {
7224 /* We still have not allocated all of the sections to
7225 segments. Create a new segment here, initialise it
7226 and carry on looping. */
00bee008
AM		 7227 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7228 amt += (bfd_size_type) section_count * sizeof (asection *);
5964fc3a 7229 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 7230 if (map == NULL)
5ed6aba4
NC		 7231 {
7232 free (sections);
7233 return FALSE;
7234 }
252b5132
RH		 7235
7236 /* Initialise the fields of the segment map. Set the physical
7237 physical address to the LMA of the first section that has
7238 not yet been assigned. */
0067a569
AM		 7239 map->next = NULL;
7240 map->p_type = segment->p_type;
7241 map->p_flags = segment->p_flags;
7242 map->p_flags_valid = 1;
9933dc52 7243 map->p_paddr = suggested_lma->lma;
5c44b38e 7244 map->p_paddr_valid = p_paddr_valid;
bc67d8a6 7245 map->includes_filehdr = 0;
0067a569 7246 map->includes_phdrs = 0;
252b5132
RH		 7247 }
7248 }
bc67d8a6 7249 while (isec < section_count);
252b5132
RH		 7250
7251 free (sections);
7252 }
7253
12bd6957 7254 elf_seg_map (obfd) = map_first;
bc67d8a6
NC		 7255
7256 /* If we had to estimate the number of program headers that were
9ad5cbcf 7257 going to be needed, then check our estimate now and adjust
bc67d8a6
NC		 7258 the offset if necessary. */
7259 if (phdr_adjust_seg != NULL)
7260 {
7261 unsigned int count;
c044fabd 7262
bc67d8a6 7263 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 7264 count++;
252b5132 7265
bc67d8a6
NC		 7266 if (count > phdr_adjust_num)
7267 phdr_adjust_seg->p_paddr
7268 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
9933dc52
AM		 7269
7270 for (map = map_first; map != NULL; map = map->next)
7271 if (map->p_type == PT_PHDR)
7272 {
7273 bfd_vma adjust
7274 = phdr_adjust_seg->includes_filehdr ? iehdr->e_ehsize : 0;
7275 map->p_paddr = phdr_adjust_seg->p_paddr + adjust;
7276 break;
7277 }
bc67d8a6 7278 }
c044fabd 7279
bc67d8a6 7280#undef SEGMENT_END
eecdbe52 7281#undef SECTION_SIZE
bc67d8a6
NC		 7282#undef IS_CONTAINED_BY_VMA
7283#undef IS_CONTAINED_BY_LMA
0efc80c8 7284#undef IS_NOTE
252b5132 7285#undef IS_COREFILE_NOTE
bc67d8a6 7286#undef IS_SOLARIS_PT_INTERP
9f17e2a6 7287#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC		 7288#undef INCLUDE_SECTION_IN_SEGMENT
7289#undef SEGMENT_AFTER_SEGMENT
7290#undef SEGMENT_OVERLAPS
b34976b6 7291 return TRUE;
252b5132
RH		 7292}
7293
84d1d650
L		 7294/* Copy ELF program header information. */
7295
7296static bfd_boolean
7297copy_elf_program_header (bfd *ibfd, bfd *obfd)
7298{
7299 Elf_Internal_Ehdr *iehdr;
7300 struct elf_segment_map *map;
7301 struct elf_segment_map *map_first;
7302 struct elf_segment_map **pointer_to_map;
7303 Elf_Internal_Phdr *segment;
7304 unsigned int i;
7305 unsigned int num_segments;
7306 bfd_boolean phdr_included = FALSE;
88967714 7307 bfd_boolean p_paddr_valid;
84d1d650
L		 7308
7309 iehdr = elf_elfheader (ibfd);
7310
7311 map_first = NULL;
7312 pointer_to_map = &map_first;
7313
88967714
AM		 7314 /* If all the segment p_paddr fields are zero, don't set
7315 map->p_paddr_valid. */
7316 p_paddr_valid = FALSE;
84d1d650 7317 num_segments = elf_elfheader (ibfd)->e_phnum;
88967714
AM		 7318 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7319 i < num_segments;
7320 i++, segment++)
7321 if (segment->p_paddr != 0)
7322 {
7323 p_paddr_valid = TRUE;
7324 break;
7325 }
7326
84d1d650
L		 7327 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7328 i < num_segments;
7329 i++, segment++)
7330 {
7331 asection *section;
7332 unsigned int section_count;
7333 bfd_size_type amt;
7334 Elf_Internal_Shdr *this_hdr;
53020534 7335 asection *first_section = NULL;
a76e6f2f 7336 asection *lowest_section;
2542e49e 7337 bfd_boolean no_contents = TRUE;
84d1d650 7338
84d1d650
L		 7339 /* Compute how many sections are in this segment. */
7340 for (section = ibfd->sections, section_count = 0;
7341 section != NULL;
7342 section = section->next)
7343 {
7344 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7345 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
3271a814 7346 {
a76e6f2f
AM		 7347 if (first_section == NULL)
7348 first_section = section;
2542e49e
JL		 7349 if (elf_section_type (section) != SHT_NOBITS)
7350 no_contents = FALSE;
3271a814
NS		 7351 section_count++;
7352 }
84d1d650
L		 7353 }
7354
7355 /* Allocate a segment map big enough to contain
7356 all of the sections we have selected. */
00bee008
AM		 7357 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7358 amt += (bfd_size_type) section_count * sizeof (asection *);
a50b1753 7359 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
84d1d650
L		 7360 if (map == NULL)
7361 return FALSE;
7362
7363 /* Initialize the fields of the output segment map with the
7364 input segment. */
7365 map->next = NULL;
7366 map->p_type = segment->p_type;
7367 map->p_flags = segment->p_flags;
7368 map->p_flags_valid = 1;
7369 map->p_paddr = segment->p_paddr;
88967714 7370 map->p_paddr_valid = p_paddr_valid;
3f570048
AM		 7371 map->p_align = segment->p_align;
7372 map->p_align_valid = 1;
3271a814 7373 map->p_vaddr_offset = 0;
84d1d650 7374
04c3a755
NS		 7375 if (map->p_type == PT_GNU_RELRO
7376 || map->p_type == PT_GNU_STACK)
b10a8ae0
L		 7377 {
7378 /* The PT_GNU_RELRO segment may contain the first a few
7379 bytes in the .got.plt section even if the whole .got.plt
7380 section isn't in the PT_GNU_RELRO segment. We won't
04c3a755
NS		 7381 change the size of the PT_GNU_RELRO segment.
7382 Similarly, PT_GNU_STACK size is significant on uclinux
7383 systems. */
9433b9b1 7384 map->p_size = segment->p_memsz;
b10a8ae0
L		 7385 map->p_size_valid = 1;
7386 }
7387
84d1d650
L		 7388 /* Determine if this segment contains the ELF file header
7389 and if it contains the program headers themselves. */
7390 map->includes_filehdr = (segment->p_offset == 0
7391 && segment->p_filesz >= iehdr->e_ehsize);
7392
7393 map->includes_phdrs = 0;
7394 if (! phdr_included || segment->p_type != PT_LOAD)
7395 {
7396 map->includes_phdrs =
7397 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7398 && (segment->p_offset + segment->p_filesz
7399 >= ((bfd_vma) iehdr->e_phoff
7400 + iehdr->e_phnum * iehdr->e_phentsize)));
7401
7402 if (segment->p_type == PT_LOAD && map->includes_phdrs)
7403 phdr_included = TRUE;
7404 }
7405
bbefd0a9 7406 lowest_section = NULL;
84d1d650
L		 7407 if (section_count != 0)
7408 {
7409 unsigned int isec = 0;
7410
53020534 7411 for (section = first_section;
84d1d650
L		 7412 section != NULL;
7413 section = section->next)
7414 {
7415 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7416 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
53020534
L		 7417 {
7418 map->sections[isec++] = section->output_section;
a76e6f2f
AM		 7419 if ((section->flags & SEC_ALLOC) != 0)
7420 {
7421 bfd_vma seg_off;
7422
bbefd0a9
AM		 7423 if (lowest_section == NULL
7424 || section->lma < lowest_section->lma)
fb8a5684
AM		 7425 lowest_section = section;
7426
a76e6f2f
AM		 7427 /* Section lmas are set up from PT_LOAD header
7428 p_paddr in _bfd_elf_make_section_from_shdr.
7429 If this header has a p_paddr that disagrees
7430 with the section lma, flag the p_paddr as
7431 invalid. */
7432 if ((section->flags & SEC_LOAD) != 0)
7433 seg_off = this_hdr->sh_offset - segment->p_offset;
7434 else
7435 seg_off = this_hdr->sh_addr - segment->p_vaddr;
7436 if (section->lma - segment->p_paddr != seg_off)
7437 map->p_paddr_valid = FALSE;
7438 }
53020534
L		 7439 if (isec == section_count)
7440 break;
7441 }
84d1d650
L		 7442 }
7443 }
7444
a76e6f2f 7445 if (map->includes_filehdr && lowest_section != NULL)
2542e49e
JL		 7446 {
7447 /* Try to keep the space used by the headers plus any
7448 padding fixed. If there are sections with file contents
7449 in this segment then the lowest sh_offset is the best
7450 guess. Otherwise the segment only has file contents for
7451 the headers, and p_filesz is the best guess. */
7452 if (no_contents)
7453 map->header_size = segment->p_filesz;
7454 else
7455 map->header_size = lowest_section->filepos;
7456 }
d324f6d6 7457
5d695627
AM		 7458 if (section_count == 0)
7459 map->p_vaddr_offset = segment->p_vaddr;
7460 else if (!map->includes_phdrs
7461 && !map->includes_filehdr
7462 && map->p_paddr_valid)
7463 /* Account for padding before the first section. */
7464 map->p_vaddr_offset = (segment->p_paddr
7465 - (lowest_section ? lowest_section->lma : 0));
a76e6f2f 7466
84d1d650
L		 7467 map->count = section_count;
7468 *pointer_to_map = map;
7469 pointer_to_map = &map->next;
7470 }
7471
12bd6957 7472 elf_seg_map (obfd) = map_first;
84d1d650
L		 7473 return TRUE;
7474}
7475
7476/* Copy private BFD data. This copies or rewrites ELF program header
7477 information. */
7478
7479static bfd_boolean
7480copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7481{
84d1d650
L		 7482 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7483 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7484 return TRUE;
7485
7486 if (elf_tdata (ibfd)->phdr == NULL)
7487 return TRUE;
7488
7489 if (ibfd->xvec == obfd->xvec)
7490 {
cb3ff1e5
NC		 7491 /* Check to see if any sections in the input BFD
7492 covered by ELF program header have changed. */
d55ce4e2 7493 Elf_Internal_Phdr *segment;
84d1d650
L		 7494 asection *section, *osec;
7495 unsigned int i, num_segments;
7496 Elf_Internal_Shdr *this_hdr;
147d51c2
L		 7497 const struct elf_backend_data *bed;
7498
7499 bed = get_elf_backend_data (ibfd);
7500
7501 /* Regenerate the segment map if p_paddr is set to 0. */
7502 if (bed->want_p_paddr_set_to_zero)
7503 goto rewrite;
84d1d650
L		 7504
7505 /* Initialize the segment mark field. */
7506 for (section = obfd->sections; section != NULL;
7507 section = section->next)
7508 section->segment_mark = FALSE;
7509
7510 num_segments = elf_elfheader (ibfd)->e_phnum;
7511 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7512 i < num_segments;
7513 i++, segment++)
7514 {
5f6999aa
NC		 7515 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7516 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7517 which severly confuses things, so always regenerate the segment
7518 map in this case. */
7519 if (segment->p_paddr == 0
7520 && segment->p_memsz == 0
7521 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
cb3ff1e5 7522 goto rewrite;
5f6999aa 7523
84d1d650
L		 7524 for (section = ibfd->sections;
7525 section != NULL; section = section->next)
7526 {
7527 /* We mark the output section so that we know it comes
7528 from the input BFD. */
7529 osec = section->output_section;
7530 if (osec)
7531 osec->segment_mark = TRUE;
7532
7533 /* Check if this section is covered by the segment. */
7534 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7535 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
84d1d650
L		 7536 {
7537 /* FIXME: Check if its output section is changed or
7538 removed. What else do we need to check? */
7539 if (osec == NULL
7540 || section->flags != osec->flags
7541 || section->lma != osec->lma
7542 || section->vma != osec->vma
7543 || section->size != osec->size
7544 || section->rawsize != osec->rawsize
7545 || section->alignment_power != osec->alignment_power)
7546 goto rewrite;
7547 }
7548 }
7549 }
7550
cb3ff1e5 7551 /* Check to see if any output section do not come from the
84d1d650
L		 7552 input BFD. */
7553 for (section = obfd->sections; section != NULL;
7554 section = section->next)
7555 {
535b785f 7556 if (!section->segment_mark)
84d1d650
L		 7557 goto rewrite;
7558 else
7559 section->segment_mark = FALSE;
7560 }
7561
7562 return copy_elf_program_header (ibfd, obfd);
7563 }
7564
7565rewrite:
f1d85785
L		 7566 if (ibfd->xvec == obfd->xvec)
7567 {
7568 /* When rewriting program header, set the output maxpagesize to
7569 the maximum alignment of input PT_LOAD segments. */
7570 Elf_Internal_Phdr *segment;
7571 unsigned int i;
7572 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7573 bfd_vma maxpagesize = 0;
7574
7575 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7576 i < num_segments;
7577 i++, segment++)
7578 if (segment->p_type == PT_LOAD
7579 && maxpagesize < segment->p_align)
c86934ce
NC		 7580 {
7581 /* PR 17512: file: f17299af. */
7582 if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
695344c0 7583 /* xgettext:c-format */
2dcf00ce
AM		 7584 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7585 PRIx64 " is too large"),
7586 ibfd, (uint64_t) segment->p_align);
c86934ce
NC		 7587 else
7588 maxpagesize = segment->p_align;
7589 }
f1d85785
L		 7590
7591 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7592 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7593 }
7594
84d1d650
L		 7595 return rewrite_elf_program_header (ibfd, obfd);
7596}
7597
ccd2ec6a
L		 7598/* Initialize private output section information from input section. */
7599
7600bfd_boolean
7601_bfd_elf_init_private_section_data (bfd *ibfd,
7602 asection *isec,
7603 bfd *obfd,
7604 asection *osec,
7605 struct bfd_link_info *link_info)
7606
7607{
7608 Elf_Internal_Shdr *ihdr, *ohdr;
0e1862bb
L		 7609 bfd_boolean final_link = (link_info != NULL
7610 && !bfd_link_relocatable (link_info));
ccd2ec6a
L		 7611
7612 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7613 || obfd->xvec->flavour != bfd_target_elf_flavour)
7614 return TRUE;
7615
ba85c43e
NC		 7616 BFD_ASSERT (elf_section_data (osec) != NULL);
7617
dfa7b0b8
AM		 7618 /* For objcopy and relocatable link, don't copy the output ELF
7619 section type from input if the output BFD section flags have been
7620 set to something different. For a final link allow some flags
7621 that the linker clears to differ. */
42bb2e33 7622 if (elf_section_type (osec) == SHT_NULL
dfa7b0b8
AM		 7623 && (osec->flags == isec->flags
7624 || (final_link
7625 && ((osec->flags ^ isec->flags)
0814be7d 7626 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
42bb2e33 7627 elf_section_type (osec) = elf_section_type (isec);
d270463e
L		 7628
7629 /* FIXME: Is this correct for all OS/PROC specific flags? */
7630 elf_section_flags (osec) |= (elf_section_flags (isec)
7631 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a 7632
a91e1603
L		 7633 /* Copy sh_info from input for mbind section. */
7634 if (elf_section_flags (isec) & SHF_GNU_MBIND)
7635 elf_section_data (osec)->this_hdr.sh_info
7636 = elf_section_data (isec)->this_hdr.sh_info;
7637
ccd2ec6a
L		 7638 /* Set things up for objcopy and relocatable link. The output
7639 SHT_GROUP section will have its elf_next_in_group pointing back
7640 to the input group members. Ignore linker created group section.
7641 See elfNN_ia64_object_p in elfxx-ia64.c. */
7bdf4127
AB		 7642 if ((link_info == NULL
7643 || !link_info->resolve_section_groups)
7644 && (elf_sec_group (isec) == NULL
7645 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
ccd2ec6a 7646 {
7bdf4127
AB		 7647 if (elf_section_flags (isec) & SHF_GROUP)
7648 elf_section_flags (osec) |= SHF_GROUP;
7649 elf_next_in_group (osec) = elf_next_in_group (isec);
7650 elf_section_data (osec)->group = elf_section_data (isec)->group;
ccd2ec6a
L		 7651 }
7652
7bdf4127
AB		 7653 /* If not decompress, preserve SHF_COMPRESSED. */
7654 if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7655 elf_section_flags (osec) |= (elf_section_flags (isec)
7656 & SHF_COMPRESSED);
7657
ccd2ec6a
L		 7658 ihdr = &elf_section_data (isec)->this_hdr;
7659
7660 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7661 don't use the output section of the linked-to section since it
7662 may be NULL at this point. */
7663 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7664 {
7665 ohdr = &elf_section_data (osec)->this_hdr;
7666 ohdr->sh_flags |= SHF_LINK_ORDER;
7667 elf_linked_to_section (osec) = elf_linked_to_section (isec);
7668 }
7669
7670 osec->use_rela_p = isec->use_rela_p;
7671
7672 return TRUE;
7673}
7674
252b5132
RH		 7675/* Copy private section information. This copies over the entsize
7676 field, and sometimes the info field. */
7677
b34976b6 7678bfd_boolean
217aa764
AM		 7679_bfd_elf_copy_private_section_data (bfd *ibfd,
7680 asection *isec,
7681 bfd *obfd,
7682 asection *osec)
252b5132
RH		 7683{
7684 Elf_Internal_Shdr *ihdr, *ohdr;
7685
7686 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7687 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 7688 return TRUE;
252b5132 7689
252b5132
RH		 7690 ihdr = &elf_section_data (isec)->this_hdr;
7691 ohdr = &elf_section_data (osec)->this_hdr;
7692
7693 ohdr->sh_entsize = ihdr->sh_entsize;
7694
7695 if (ihdr->sh_type == SHT_SYMTAB
7696 || ihdr->sh_type == SHT_DYNSYM
7697 || ihdr->sh_type == SHT_GNU_verneed
7698 || ihdr->sh_type == SHT_GNU_verdef)
7699 ohdr->sh_info = ihdr->sh_info;
7700
ccd2ec6a
L		 7701 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7702 NULL);
252b5132
RH		 7703}
7704
d0bf826b
AM		 7705/* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7706 necessary if we are removing either the SHT_GROUP section or any of
7707 the group member sections. DISCARDED is the value that a section's
7708 output_section has if the section will be discarded, NULL when this
7709 function is called from objcopy, bfd_abs_section_ptr when called
7710 from the linker. */
80fccad2
BW		 7711
7712bfd_boolean
d0bf826b 7713_bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
80fccad2 7714{
30288845
AM		 7715 asection *isec;
7716
30288845 7717 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
415f38a6 7718 if (elf_section_type (isec) == SHT_GROUP)
30288845
AM		 7719 {
7720 asection *first = elf_next_in_group (isec);
7721 asection *s = first;
d0bf826b
AM		 7722 bfd_size_type removed = 0;
7723
30288845
AM		 7724 while (s != NULL)
7725 {
415f38a6
AM		 7726 /* If this member section is being output but the
7727 SHT_GROUP section is not, then clear the group info
7728 set up by _bfd_elf_copy_private_section_data. */
d0bf826b
AM		 7729 if (s->output_section != discarded
7730 && isec->output_section == discarded)
30288845
AM		 7731 {
7732 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7733 elf_group_name (s->output_section) = NULL;
7734 }
415f38a6
AM		 7735 /* Conversely, if the member section is not being output
7736 but the SHT_GROUP section is, then adjust its size. */
d0bf826b
AM		 7737 else if (s->output_section == discarded
7738 && isec->output_section != discarded)
6e5e9d58
AM		 7739 {
7740 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7741 removed += 4;
7742 if (elf_sec->rel.hdr != NULL
7743 && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7744 removed += 4;
7745 if (elf_sec->rela.hdr != NULL
7746 && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7747 removed += 4;
7748 }
30288845
AM		 7749 s = elf_next_in_group (s);
7750 if (s == first)
7751 break;
7752 }
d0bf826b
AM		 7753 if (removed != 0)
7754 {
7755 if (discarded != NULL)
7756 {
7757 /* If we've been called for ld -r, then we need to
6e5e9d58 7758 adjust the input section size. */
d0bf826b
AM		 7759 if (isec->rawsize == 0)
7760 isec->rawsize = isec->size;
7761 isec->size = isec->rawsize - removed;
6e5e9d58
AM		 7762 if (isec->size <= 4)
7763 {
7764 isec->size = 0;
7765 isec->flags |= SEC_EXCLUDE;
7766 }
d0bf826b
AM		 7767 }
7768 else
7769 {
7770 /* Adjust the output section size when called from
7771 objcopy. */
7772 isec->output_section->size -= removed;
6e5e9d58
AM		 7773 if (isec->output_section->size <= 4)
7774 {
7775 isec->output_section->size = 0;
7776 isec->output_section->flags |= SEC_EXCLUDE;
7777 }
d0bf826b
AM		 7778 }
7779 }
30288845
AM		 7780 }
7781
80fccad2
BW		 7782 return TRUE;
7783}
7784
d0bf826b
AM		 7785/* Copy private header information. */
7786
7787bfd_boolean
7788_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7789{
7790 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7791 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7792 return TRUE;
7793
7794 /* Copy over private BFD data if it has not already been copied.
7795 This must be done here, rather than in the copy_private_bfd_data
7796 entry point, because the latter is called after the section
7797 contents have been set, which means that the program headers have
7798 already been worked out. */
12bd6957 7799 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
d0bf826b
AM		 7800 {
7801 if (! copy_private_bfd_data (ibfd, obfd))
7802 return FALSE;
7803 }
7804
7805 return _bfd_elf_fixup_group_sections (ibfd, NULL);
7806}
7807
252b5132
RH		 7808/* Copy private symbol information. If this symbol is in a section
7809 which we did not map into a BFD section, try to map the section
7810 index correctly. We use special macro definitions for the mapped
7811 section indices; these definitions are interpreted by the
7812 swap_out_syms function. */
7813
9ad5cbcf
AM		 7814#define MAP_ONESYMTAB (SHN_HIOS + 1)
7815#define MAP_DYNSYMTAB (SHN_HIOS + 2)
7816#define MAP_STRTAB (SHN_HIOS + 3)
7817#define MAP_SHSTRTAB (SHN_HIOS + 4)
7818#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 7819
b34976b6 7820bfd_boolean
217aa764
AM		 7821_bfd_elf_copy_private_symbol_data (bfd *ibfd,
7822 asymbol *isymarg,
7823 bfd *obfd,
7824 asymbol *osymarg)
252b5132
RH		 7825{
7826 elf_symbol_type *isym, *osym;
7827
7828 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7829 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 7830 return TRUE;
252b5132
RH		 7831
7832 isym = elf_symbol_from (ibfd, isymarg);
7833 osym = elf_symbol_from (obfd, osymarg);
7834
7835 if (isym != NULL
8424d8f5 7836 && isym->internal_elf_sym.st_shndx != 0
252b5132
RH		 7837 && osym != NULL
7838 && bfd_is_abs_section (isym->symbol.section))
7839 {
7840 unsigned int shndx;
7841
7842 shndx = isym->internal_elf_sym.st_shndx;
7843 if (shndx == elf_onesymtab (ibfd))
7844 shndx = MAP_ONESYMTAB;
7845 else if (shndx == elf_dynsymtab (ibfd))
7846 shndx = MAP_DYNSYMTAB;
12bd6957 7847 else if (shndx == elf_strtab_sec (ibfd))
252b5132 7848 shndx = MAP_STRTAB;
12bd6957 7849 else if (shndx == elf_shstrtab_sec (ibfd))
252b5132 7850 shndx = MAP_SHSTRTAB;
6a40cf0c 7851 else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
9ad5cbcf 7852 shndx = MAP_SYM_SHNDX;
252b5132
RH		 7853 osym->internal_elf_sym.st_shndx = shndx;
7854 }
7855
b34976b6 7856 return TRUE;
252b5132
RH		 7857}
7858
7859/* Swap out the symbols. */
7860
b34976b6 7861static bfd_boolean
217aa764 7862swap_out_syms (bfd *abfd,
ef10c3ac 7863 struct elf_strtab_hash **sttp,
217aa764 7864 int relocatable_p)
252b5132 7865{
9c5bfbb7 7866 const struct elf_backend_data *bed;
079e9a2f
AM		 7867 int symcount;
7868 asymbol **syms;
ef10c3ac 7869 struct elf_strtab_hash *stt;
079e9a2f 7870 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 7871 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 7872 Elf_Internal_Shdr *symstrtab_hdr;
ef10c3ac 7873 struct elf_sym_strtab *symstrtab;
f075ee0c
AM		 7874 bfd_byte *outbound_syms;
7875 bfd_byte *outbound_shndx;
ef10c3ac
L		 7876 unsigned long outbound_syms_index;
7877 unsigned long outbound_shndx_index;
079e9a2f 7878 int idx;
12bd6957 7879 unsigned int num_locals;
079e9a2f 7880 bfd_size_type amt;
174fd7f9 7881 bfd_boolean name_local_sections;
252b5132 7882
12bd6957 7883 if (!elf_map_symbols (abfd, &num_locals))
b34976b6 7884 return FALSE;
252b5132 7885
c044fabd 7886 /* Dump out the symtabs. */
ef10c3ac 7887 stt = _bfd_elf_strtab_init ();
079e9a2f 7888 if (stt == NULL)
b34976b6 7889 return FALSE;
252b5132 7890
079e9a2f
AM		 7891 bed = get_elf_backend_data (abfd);
7892 symcount = bfd_get_symcount (abfd);
7893 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7894 symtab_hdr->sh_type = SHT_SYMTAB;
7895 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7896 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
12bd6957 7897 symtab_hdr->sh_info = num_locals + 1;
72de5009 7898 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
079e9a2f
AM		 7899
7900 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7901 symstrtab_hdr->sh_type = SHT_STRTAB;
7902
ef10c3ac 7903 /* Allocate buffer to swap out the .strtab section. */
7a6e0d89
AM		 7904 symstrtab = (struct elf_sym_strtab *) bfd_malloc2 (symcount + 1,
7905 sizeof (*symstrtab));
ef10c3ac
L		 7906 if (symstrtab == NULL)
7907 {
7908 _bfd_elf_strtab_free (stt);
7909 return FALSE;
7910 }
7911
a50b1753 7912 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
07d6d2b8 7913 bed->s->sizeof_sym);
079e9a2f 7914 if (outbound_syms == NULL)
5ed6aba4 7915 {
ef10c3ac
L		 7916error_return:
7917 _bfd_elf_strtab_free (stt);
7918 free (symstrtab);
5ed6aba4
NC		 7919 return FALSE;
7920 }
217aa764 7921 symtab_hdr->contents = outbound_syms;
ef10c3ac 7922 outbound_syms_index = 0;
252b5132 7923
9ad5cbcf 7924 outbound_shndx = NULL;
ef10c3ac 7925 outbound_shndx_index = 0;
6a40cf0c
NC		 7926
7927 if (elf_symtab_shndx_list (abfd))
9ad5cbcf 7928 {
6a40cf0c
NC		 7929 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7930 if (symtab_shndx_hdr->sh_name != 0)
7931 {
7932 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7933 outbound_shndx = (bfd_byte *)
7934 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7935 if (outbound_shndx == NULL)
7936 goto error_return;
5ed6aba4 7937
6a40cf0c
NC		 7938 symtab_shndx_hdr->contents = outbound_shndx;
7939 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7940 symtab_shndx_hdr->sh_size = amt;
7941 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7942 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7943 }
7944 /* FIXME: What about any other headers in the list ? */
9ad5cbcf
AM		 7945 }
7946
589e6347 7947 /* Now generate the data (for "contents"). */
079e9a2f
AM		 7948 {
7949 /* Fill in zeroth symbol and swap it out. */
7950 Elf_Internal_Sym sym;
7951 sym.st_name = 0;
7952 sym.st_value = 0;
7953 sym.st_size = 0;
7954 sym.st_info = 0;
7955 sym.st_other = 0;
7956 sym.st_shndx = SHN_UNDEF;
35fc36a8 7957 sym.st_target_internal = 0;
ef10c3ac
L		 7958 symstrtab[0].sym = sym;
7959 symstrtab[0].dest_index = outbound_syms_index;
7960 symstrtab[0].destshndx_index = outbound_shndx_index;
7961 outbound_syms_index++;
9ad5cbcf 7962 if (outbound_shndx != NULL)
ef10c3ac 7963 outbound_shndx_index++;
079e9a2f 7964 }
252b5132 7965
174fd7f9
RS		 7966 name_local_sections
7967 = (bed->elf_backend_name_local_section_symbols
7968 && bed->elf_backend_name_local_section_symbols (abfd));
7969
079e9a2f 7970 syms = bfd_get_outsymbols (abfd);
ef10c3ac 7971 for (idx = 0; idx < symcount;)
252b5132 7972 {
252b5132 7973 Elf_Internal_Sym sym;
079e9a2f
AM		 7974 bfd_vma value = syms[idx]->value;
7975 elf_symbol_type *type_ptr;
7976 flagword flags = syms[idx]->flags;
7977 int type;
252b5132 7978
174fd7f9
RS		 7979 if (!name_local_sections
7980 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM		 7981 {
7982 /* Local section symbols have no name. */
ef10c3ac 7983 sym.st_name = (unsigned long) -1;
079e9a2f
AM		 7984 }
7985 else
7986 {
ef10c3ac
L		 7987 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7988 to get the final offset for st_name. */
7989 sym.st_name
7990 = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7991 FALSE);
079e9a2f 7992 if (sym.st_name == (unsigned long) -1)
ef10c3ac 7993 goto error_return;
079e9a2f 7994 }
252b5132 7995
079e9a2f 7996 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 7997
079e9a2f
AM		 7998 if ((flags & BSF_SECTION_SYM) == 0
7999 && bfd_is_com_section (syms[idx]->section))
8000 {
8001 /* ELF common symbols put the alignment into the `value' field,
8002 and the size into the `size' field. This is backwards from
8003 how BFD handles it, so reverse it here. */
8004 sym.st_size = value;
8005 if (type_ptr == NULL
8006 || type_ptr->internal_elf_sym.st_value == 0)
8007 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
8008 else
8009 sym.st_value = type_ptr->internal_elf_sym.st_value;
8010 sym.st_shndx = _bfd_elf_section_from_bfd_section
8011 (abfd, syms[idx]->section);
8012 }
8013 else
8014 {
8015 asection *sec = syms[idx]->section;
cb33740c 8016 unsigned int shndx;
252b5132 8017
079e9a2f
AM		 8018 if (sec->output_section)
8019 {
8020 value += sec->output_offset;
8021 sec = sec->output_section;
8022 }
589e6347 8023
079e9a2f
AM		 8024 /* Don't add in the section vma for relocatable output. */
8025 if (! relocatable_p)
8026 value += sec->vma;
8027 sym.st_value = value;
8028 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
8029
8030 if (bfd_is_abs_section (sec)
8031 && type_ptr != NULL
8032 && type_ptr->internal_elf_sym.st_shndx != 0)
8033 {
8034 /* This symbol is in a real ELF section which we did
8035 not create as a BFD section. Undo the mapping done
8036 by copy_private_symbol_data. */
8037 shndx = type_ptr->internal_elf_sym.st_shndx;
8038 switch (shndx)
8039 {
8040 case MAP_ONESYMTAB:
8041 shndx = elf_onesymtab (abfd);
8042 break;
8043 case MAP_DYNSYMTAB:
8044 shndx = elf_dynsymtab (abfd);
8045 break;
8046 case MAP_STRTAB:
12bd6957 8047 shndx = elf_strtab_sec (abfd);
079e9a2f
AM		 8048 break;
8049 case MAP_SHSTRTAB:
12bd6957 8050 shndx = elf_shstrtab_sec (abfd);
079e9a2f 8051 break;
9ad5cbcf 8052 case MAP_SYM_SHNDX:
6a40cf0c
NC		 8053 if (elf_symtab_shndx_list (abfd))
8054 shndx = elf_symtab_shndx_list (abfd)->ndx;
9ad5cbcf 8055 break;
079e9a2f 8056 default:
15bc576a 8057 shndx = SHN_ABS;
079e9a2f
AM		 8058 break;
8059 }
8060 }
8061 else
8062 {
8063 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 8064
cb33740c 8065 if (shndx == SHN_BAD)
079e9a2f
AM		 8066 {
8067 asection *sec2;
8068
8069 /* Writing this would be a hell of a lot easier if
8070 we had some decent documentation on bfd, and
8071 knew what to expect of the library, and what to
8072 demand of applications. For example, it
8073 appears that `objcopy' might not set the
8074 section of a symbol to be a section that is
8075 actually in the output file. */
8076 sec2 = bfd_get_section_by_name (abfd, sec->name);
5df1bc57
AM		 8077 if (sec2 != NULL)
8078 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
8079 if (shndx == SHN_BAD)
589e6347 8080 {
695344c0 8081 /* xgettext:c-format */
9793eb77
AM		 8082 _bfd_error_handler
8083 (_("unable to find equivalent output section"
8084 " for symbol '%s' from section '%s'"),
8085 syms[idx]->name ? syms[idx]->name : "<Local sym>",
8086 sec->name);
811072d8 8087 bfd_set_error (bfd_error_invalid_operation);
ef10c3ac 8088 goto error_return;
589e6347 8089 }
079e9a2f
AM		 8090 }
8091 }
252b5132 8092
079e9a2f
AM		 8093 sym.st_shndx = shndx;
8094 }
252b5132 8095
13ae64f3
JJ		 8096 if ((flags & BSF_THREAD_LOCAL) != 0)
8097 type = STT_TLS;
d8045f23
NC		 8098 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
8099 type = STT_GNU_IFUNC;
13ae64f3 8100 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM		 8101 type = STT_FUNC;
8102 else if ((flags & BSF_OBJECT) != 0)
8103 type = STT_OBJECT;
d9352518
DB		 8104 else if ((flags & BSF_RELC) != 0)
8105 type = STT_RELC;
8106 else if ((flags & BSF_SRELC) != 0)
8107 type = STT_SRELC;
079e9a2f
AM		 8108 else
8109 type = STT_NOTYPE;
252b5132 8110
13ae64f3
JJ		 8111 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
8112 type = STT_TLS;
8113
589e6347 8114 /* Processor-specific types. */
079e9a2f
AM		 8115 if (type_ptr != NULL
8116 && bed->elf_backend_get_symbol_type)
8117 type = ((*bed->elf_backend_get_symbol_type)
8118 (&type_ptr->internal_elf_sym, type));
252b5132 8119
079e9a2f
AM		 8120 if (flags & BSF_SECTION_SYM)
8121 {
8122 if (flags & BSF_GLOBAL)
8123 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8124 else
8125 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
8126 }
8127 else if (bfd_is_com_section (syms[idx]->section))
0a40daed 8128 {
b8871f35
L		 8129 if (type != STT_TLS)
8130 {
8131 if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8132 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8133 ? STT_COMMON : STT_OBJECT);
8134 else
8135 type = ((flags & BSF_ELF_COMMON) != 0
8136 ? STT_COMMON : STT_OBJECT);
8137 }
8138 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
0a40daed 8139 }
079e9a2f
AM		 8140 else if (bfd_is_und_section (syms[idx]->section))
8141 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8142 ? STB_WEAK
8143 : STB_GLOBAL),
8144 type);
8145 else if (flags & BSF_FILE)
8146 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8147 else
8148 {
8149 int bind = STB_LOCAL;
252b5132 8150
079e9a2f
AM		 8151 if (flags & BSF_LOCAL)
8152 bind = STB_LOCAL;
3e7a7d11
NC		 8153 else if (flags & BSF_GNU_UNIQUE)
8154 bind = STB_GNU_UNIQUE;
079e9a2f
AM		 8155 else if (flags & BSF_WEAK)
8156 bind = STB_WEAK;
8157 else if (flags & BSF_GLOBAL)
8158 bind = STB_GLOBAL;
252b5132 8159
079e9a2f
AM		 8160 sym.st_info = ELF_ST_INFO (bind, type);
8161 }
252b5132 8162
079e9a2f 8163 if (type_ptr != NULL)
35fc36a8
RS		 8164 {
8165 sym.st_other = type_ptr->internal_elf_sym.st_other;
8166 sym.st_target_internal
8167 = type_ptr->internal_elf_sym.st_target_internal;
8168 }
079e9a2f 8169 else
35fc36a8
RS		 8170 {
8171 sym.st_other = 0;
8172 sym.st_target_internal = 0;
8173 }
252b5132 8174
ef10c3ac
L		 8175 idx++;
8176 symstrtab[idx].sym = sym;
8177 symstrtab[idx].dest_index = outbound_syms_index;
8178 symstrtab[idx].destshndx_index = outbound_shndx_index;
8179
8180 outbound_syms_index++;
9ad5cbcf 8181 if (outbound_shndx != NULL)
ef10c3ac
L		 8182 outbound_shndx_index++;
8183 }
8184
8185 /* Finalize the .strtab section. */
8186 _bfd_elf_strtab_finalize (stt);
8187
8188 /* Swap out the .strtab section. */
8189 for (idx = 0; idx <= symcount; idx++)
8190 {
8191 struct elf_sym_strtab *elfsym = &symstrtab[idx];
8192 if (elfsym->sym.st_name == (unsigned long) -1)
8193 elfsym->sym.st_name = 0;
8194 else
8195 elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8196 elfsym->sym.st_name);
8197 bed->s->swap_symbol_out (abfd, &elfsym->sym,
8198 (outbound_syms
8199 + (elfsym->dest_index
8200 * bed->s->sizeof_sym)),
8201 (outbound_shndx
8202 + (elfsym->destshndx_index
8203 * sizeof (Elf_External_Sym_Shndx))));
079e9a2f 8204 }
ef10c3ac 8205 free (symstrtab);
252b5132 8206
079e9a2f 8207 *sttp = stt;
ef10c3ac 8208 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
079e9a2f 8209 symstrtab_hdr->sh_type = SHT_STRTAB;
84865015 8210 symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
079e9a2f
AM		 8211 symstrtab_hdr->sh_addr = 0;
8212 symstrtab_hdr->sh_entsize = 0;
8213 symstrtab_hdr->sh_link = 0;
8214 symstrtab_hdr->sh_info = 0;
8215 symstrtab_hdr->sh_addralign = 1;
252b5132 8216
b34976b6 8217 return TRUE;
252b5132
RH		 8218}
8219
8220/* Return the number of bytes required to hold the symtab vector.
8221
8222 Note that we base it on the count plus 1, since we will null terminate
8223 the vector allocated based on this size. However, the ELF symbol table
8224 always has a dummy entry as symbol #0, so it ends up even. */
8225
8226long
217aa764 8227_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132 8228{
3a551c7a 8229 bfd_size_type symcount;
252b5132
RH		 8230 long symtab_size;
8231 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8232
8233 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3a551c7a
AM		 8234 if (symcount >= LONG_MAX / sizeof (asymbol *))
8235 {
8236 bfd_set_error (bfd_error_file_too_big);
8237 return -1;
8238 }
b99d1833
AM		 8239 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8240 if (symcount > 0)
8241 symtab_size -= sizeof (asymbol *);
252b5132
RH		 8242
8243 return symtab_size;
8244}
8245
8246long
217aa764 8247_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132 8248{
3a551c7a 8249 bfd_size_type symcount;
252b5132
RH		 8250 long symtab_size;
8251 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8252
8253 if (elf_dynsymtab (abfd) == 0)
8254 {
8255 bfd_set_error (bfd_error_invalid_operation);
8256 return -1;
8257 }
8258
8259 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3a551c7a
AM		 8260 if (symcount >= LONG_MAX / sizeof (asymbol *))
8261 {
8262 bfd_set_error (bfd_error_file_too_big);
8263 return -1;
8264 }
b99d1833
AM		 8265 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8266 if (symcount > 0)
8267 symtab_size -= sizeof (asymbol *);
252b5132
RH		 8268
8269 return symtab_size;
8270}
8271
8272long
217aa764
AM		 8273_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8274 sec_ptr asect)
252b5132 8275{
242a1159 8276#if SIZEOF_LONG == SIZEOF_INT
7a6e0d89
AM		 8277 if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
8278 {
8279 bfd_set_error (bfd_error_file_too_big);
8280 return -1;
8281 }
242a1159 8282#endif
252b5132
RH		 8283 return (asect->reloc_count + 1) * sizeof (arelent *);
8284}
8285
8286/* Canonicalize the relocs. */
8287
8288long
217aa764
AM		 8289_bfd_elf_canonicalize_reloc (bfd *abfd,
8290 sec_ptr section,
8291 arelent **relptr,
8292 asymbol **symbols)
252b5132
RH		 8293{
8294 arelent *tblptr;
8295 unsigned int i;
9c5bfbb7 8296 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 8297
b34976b6 8298 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH		 8299 return -1;
8300
8301 tblptr = section->relocation;
8302 for (i = 0; i < section->reloc_count; i++)
8303 *relptr++ = tblptr++;
8304
8305 *relptr = NULL;
8306
8307 return section->reloc_count;
8308}
8309
8310long
6cee3f79 8311_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 8312{
9c5bfbb7 8313 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 8314 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH		 8315
8316 if (symcount >= 0)
8317 bfd_get_symcount (abfd) = symcount;
8318 return symcount;
8319}
8320
8321long
217aa764
AM		 8322_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8323 asymbol **allocation)
252b5132 8324{
9c5bfbb7 8325 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 8326 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ		 8327
8328 if (symcount >= 0)
8329 bfd_get_dynamic_symcount (abfd) = symcount;
8330 return symcount;
252b5132
RH		 8331}
8332
8615f3f2
AM		 8333/* Return the size required for the dynamic reloc entries. Any loadable
8334 section that was actually installed in the BFD, and has type SHT_REL
8335 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8336 dynamic reloc section. */
252b5132
RH		 8337
8338long
217aa764 8339_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132 8340{
3a551c7a 8341 bfd_size_type count;
252b5132
RH		 8342 asection *s;
8343
8344 if (elf_dynsymtab (abfd) == 0)
8345 {
8346 bfd_set_error (bfd_error_invalid_operation);
8347 return -1;
8348 }
8349
3a551c7a 8350 count = 1;
252b5132 8351 for (s = abfd->sections; s != NULL; s = s->next)
266b05cf 8352 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 8353 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8354 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
3a551c7a
AM		 8355 {
8356 count += s->size / elf_section_data (s)->this_hdr.sh_entsize;
8357 if (count > LONG_MAX / sizeof (arelent *))
8358 {
8359 bfd_set_error (bfd_error_file_too_big);
8360 return -1;
8361 }
8362 }
8363 return count * sizeof (arelent *);
252b5132
RH		 8364}
8365
8615f3f2
AM		 8366/* Canonicalize the dynamic relocation entries. Note that we return the
8367 dynamic relocations as a single block, although they are actually
8368 associated with particular sections; the interface, which was
8369 designed for SunOS style shared libraries, expects that there is only
8370 one set of dynamic relocs. Any loadable section that was actually
8371 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8372 dynamic symbol table, is considered to be a dynamic reloc section. */
252b5132
RH		 8373
8374long
217aa764
AM		 8375_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8376 arelent **storage,
8377 asymbol **syms)
252b5132 8378{
217aa764 8379 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH		 8380 asection *s;
8381 long ret;
8382
8383 if (elf_dynsymtab (abfd) == 0)
8384 {
8385 bfd_set_error (bfd_error_invalid_operation);
8386 return -1;
8387 }
8388
8389 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8390 ret = 0;
8391 for (s = abfd->sections; s != NULL; s = s->next)
8392 {
266b05cf 8393 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 8394 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8395 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8396 {
8397 arelent *p;
8398 long count, i;
8399
b34976b6 8400 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 8401 return -1;
eea6121a 8402 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH		 8403 p = s->relocation;
8404 for (i = 0; i < count; i++)
8405 *storage++ = p++;
8406 ret += count;
8407 }
8408 }
8409
8410 *storage = NULL;
8411
8412 return ret;
8413}
8414\f
8415/* Read in the version information. */
8416
b34976b6 8417bfd_boolean
fc0e6df6 8418_bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
252b5132
RH		 8419{
8420 bfd_byte *contents = NULL;
fc0e6df6
PB		 8421 unsigned int freeidx = 0;
8422
8423 if (elf_dynverref (abfd) != 0)
8424 {
8425 Elf_Internal_Shdr *hdr;
8426 Elf_External_Verneed *everneed;
8427 Elf_Internal_Verneed *iverneed;
8428 unsigned int i;
d0fb9a8d 8429 bfd_byte *contents_end;
fc0e6df6
PB		 8430
8431 hdr = &elf_tdata (abfd)->dynverref_hdr;
8432
bd61e135
AM		 8433 if (hdr->sh_info == 0
8434 || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
d0fb9a8d 8435 {
601a03ba 8436error_return_bad_verref:
4eca0228 8437 _bfd_error_handler
871b3ab2 8438 (_("%pB: .gnu.version_r invalid entry"), abfd);
601a03ba 8439 bfd_set_error (bfd_error_bad_value);
d0fb9a8d
JJ		 8440error_return_verref:
8441 elf_tdata (abfd)->verref = NULL;
8442 elf_tdata (abfd)->cverrefs = 0;
8443 goto error_return;
8444 }
601a03ba 8445
7e56c51c
NC		 8446 ufile_ptr filesize = bfd_get_file_size (abfd);
8447 if (filesize > 0 && filesize < hdr->sh_size)
8448 {
8449 /* PR 24708: Avoid attempts to allocate a ridiculous amount
8450 of memory. */
8451 bfd_set_error (bfd_error_no_memory);
8452 _bfd_error_handler
8453 /* xgettext:c-format */
8454 (_("error: %pB version reference section is too large (%#" PRIx64 " bytes)"),
8455 abfd, (uint64_t) hdr->sh_size);
8456 goto error_return_verref;
8457 }
601a03ba
AM		 8458 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8459 if (contents == NULL)
8460 goto error_return_verref;
8461
fc0e6df6
PB		 8462 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8463 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
d0fb9a8d 8464 goto error_return_verref;
fc0e6df6 8465
601a03ba 8466 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
bd61e135 8467 bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
601a03ba
AM		 8468
8469 if (elf_tdata (abfd)->verref == NULL)
d0fb9a8d
JJ		 8470 goto error_return_verref;
8471
8472 BFD_ASSERT (sizeof (Elf_External_Verneed)
8473 == sizeof (Elf_External_Vernaux));
8474 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
fc0e6df6
PB		 8475 everneed = (Elf_External_Verneed *) contents;
8476 iverneed = elf_tdata (abfd)->verref;
8477 for (i = 0; i < hdr->sh_info; i++, iverneed++)
8478 {
8479 Elf_External_Vernaux *evernaux;
8480 Elf_Internal_Vernaux *ivernaux;
8481 unsigned int j;
8482
8483 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8484
8485 iverneed->vn_bfd = abfd;
8486
8487 iverneed->vn_filename =
8488 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8489 iverneed->vn_file);
8490 if (iverneed->vn_filename == NULL)
601a03ba 8491 goto error_return_bad_verref;
fc0e6df6 8492
d0fb9a8d
JJ		 8493 if (iverneed->vn_cnt == 0)
8494 iverneed->vn_auxptr = NULL;
8495 else
8496 {
a50b1753 8497 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
07d6d2b8
AM		 8498 bfd_alloc2 (abfd, iverneed->vn_cnt,
8499 sizeof (Elf_Internal_Vernaux));
d0fb9a8d
JJ		 8500 if (iverneed->vn_auxptr == NULL)
8501 goto error_return_verref;
8502 }
8503
8504 if (iverneed->vn_aux
8505 > (size_t) (contents_end - (bfd_byte *) everneed))
601a03ba 8506 goto error_return_bad_verref;
fc0e6df6
PB		 8507
8508 evernaux = ((Elf_External_Vernaux *)
8509 ((bfd_byte *) everneed + iverneed->vn_aux));
8510 ivernaux = iverneed->vn_auxptr;
8511 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8512 {
8513 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8514
8515 ivernaux->vna_nodename =
8516 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8517 ivernaux->vna_name);
8518 if (ivernaux->vna_nodename == NULL)
601a03ba 8519 goto error_return_bad_verref;
fc0e6df6 8520
25ff461f
AM		 8521 if (ivernaux->vna_other > freeidx)
8522 freeidx = ivernaux->vna_other;
8523
8524 ivernaux->vna_nextptr = NULL;
8525 if (ivernaux->vna_next == 0)
8526 {
8527 iverneed->vn_cnt = j + 1;
8528 break;
8529 }
fc0e6df6
PB		 8530 if (j + 1 < iverneed->vn_cnt)
8531 ivernaux->vna_nextptr = ivernaux + 1;
fc0e6df6 8532
d0fb9a8d
JJ		 8533 if (ivernaux->vna_next
8534 > (size_t) (contents_end - (bfd_byte *) evernaux))
601a03ba 8535 goto error_return_bad_verref;
d0fb9a8d 8536
fc0e6df6
PB		 8537 evernaux = ((Elf_External_Vernaux *)
8538 ((bfd_byte *) evernaux + ivernaux->vna_next));
fc0e6df6
PB		 8539 }
8540
25ff461f
AM		 8541 iverneed->vn_nextref = NULL;
8542 if (iverneed->vn_next == 0)
8543 break;
fc0e6df6
PB		 8544 if (i + 1 < hdr->sh_info)
8545 iverneed->vn_nextref = iverneed + 1;
fc0e6df6 8546
d0fb9a8d
JJ		 8547 if (iverneed->vn_next
8548 > (size_t) (contents_end - (bfd_byte *) everneed))
601a03ba 8549 goto error_return_bad_verref;
d0fb9a8d 8550
fc0e6df6
PB		 8551 everneed = ((Elf_External_Verneed *)
8552 ((bfd_byte *) everneed + iverneed->vn_next));
8553 }
25ff461f 8554 elf_tdata (abfd)->cverrefs = i;
fc0e6df6
PB		 8555
8556 free (contents);
8557 contents = NULL;
8558 }
252b5132
RH		 8559
8560 if (elf_dynverdef (abfd) != 0)
8561 {
8562 Elf_Internal_Shdr *hdr;
8563 Elf_External_Verdef *everdef;
8564 Elf_Internal_Verdef *iverdef;
f631889e
UD		 8565 Elf_Internal_Verdef *iverdefarr;
8566 Elf_Internal_Verdef iverdefmem;
252b5132 8567 unsigned int i;
062e2358 8568 unsigned int maxidx;
d0fb9a8d 8569 bfd_byte *contents_end_def, *contents_end_aux;
252b5132
RH		 8570
8571 hdr = &elf_tdata (abfd)->dynverdef_hdr;
8572
601a03ba
AM		 8573 if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8574 {
8575 error_return_bad_verdef:
4eca0228 8576 _bfd_error_handler
871b3ab2 8577 (_("%pB: .gnu.version_d invalid entry"), abfd);
601a03ba
AM		 8578 bfd_set_error (bfd_error_bad_value);
8579 error_return_verdef:
8580 elf_tdata (abfd)->verdef = NULL;
8581 elf_tdata (abfd)->cverdefs = 0;
8582 goto error_return;
8583 }
8584
a50b1753 8585 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
252b5132 8586 if (contents == NULL)
601a03ba 8587 goto error_return_verdef;
252b5132 8588 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 8589 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
601a03ba 8590 goto error_return_verdef;
d0fb9a8d
JJ		 8591
8592 BFD_ASSERT (sizeof (Elf_External_Verdef)
8593 >= sizeof (Elf_External_Verdaux));
8594 contents_end_def = contents + hdr->sh_size
8595 - sizeof (Elf_External_Verdef);
8596 contents_end_aux = contents + hdr->sh_size
8597 - sizeof (Elf_External_Verdaux);
8598
f631889e
UD		 8599 /* We know the number of entries in the section but not the maximum
8600 index. Therefore we have to run through all entries and find
8601 the maximum. */
252b5132 8602 everdef = (Elf_External_Verdef *) contents;
f631889e
UD		 8603 maxidx = 0;
8604 for (i = 0; i < hdr->sh_info; ++i)
8605 {
8606 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8607
601a03ba
AM		 8608 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8609 goto error_return_bad_verdef;
062e2358
AM		 8610 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8611 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e 8612
25ff461f
AM		 8613 if (iverdefmem.vd_next == 0)
8614 break;
8615
d0fb9a8d
JJ		 8616 if (iverdefmem.vd_next
8617 > (size_t) (contents_end_def - (bfd_byte *) everdef))
601a03ba 8618 goto error_return_bad_verdef;
d0fb9a8d 8619
f631889e
UD		 8620 everdef = ((Elf_External_Verdef *)
8621 ((bfd_byte *) everdef + iverdefmem.vd_next));
8622 }
8623
fc0e6df6
PB		 8624 if (default_imported_symver)
8625 {
8626 if (freeidx > maxidx)
8627 maxidx = ++freeidx;
8628 else
8629 freeidx = ++maxidx;
8630 }
201159ec 8631
601a03ba
AM		 8632 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8633 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
f631889e 8634 if (elf_tdata (abfd)->verdef == NULL)
601a03ba 8635 goto error_return_verdef;
f631889e
UD		 8636
8637 elf_tdata (abfd)->cverdefs = maxidx;
8638
8639 everdef = (Elf_External_Verdef *) contents;
8640 iverdefarr = elf_tdata (abfd)->verdef;
8641 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH		 8642 {
8643 Elf_External_Verdaux *everdaux;
8644 Elf_Internal_Verdaux *iverdaux;
8645 unsigned int j;
8646
f631889e
UD		 8647 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8648
d0fb9a8d 8649 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
601a03ba 8650 goto error_return_bad_verdef;
d0fb9a8d 8651
f631889e 8652 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
595bce75 8653 memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
252b5132
RH		 8654
8655 iverdef->vd_bfd = abfd;
8656
d0fb9a8d
JJ		 8657 if (iverdef->vd_cnt == 0)
8658 iverdef->vd_auxptr = NULL;
8659 else
8660 {
a50b1753 8661 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
07d6d2b8
AM		 8662 bfd_alloc2 (abfd, iverdef->vd_cnt,
8663 sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ		 8664 if (iverdef->vd_auxptr == NULL)
8665 goto error_return_verdef;
8666 }
8667
8668 if (iverdef->vd_aux
8669 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
601a03ba 8670 goto error_return_bad_verdef;
252b5132
RH		 8671
8672 everdaux = ((Elf_External_Verdaux *)
8673 ((bfd_byte *) everdef + iverdef->vd_aux));
8674 iverdaux = iverdef->vd_auxptr;
8675 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8676 {
8677 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8678
8679 iverdaux->vda_nodename =
8680 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8681 iverdaux->vda_name);
8682 if (iverdaux->vda_nodename == NULL)
601a03ba 8683 goto error_return_bad_verdef;
252b5132 8684
25ff461f
AM		 8685 iverdaux->vda_nextptr = NULL;
8686 if (iverdaux->vda_next == 0)
8687 {
8688 iverdef->vd_cnt = j + 1;
8689 break;
8690 }
252b5132
RH		 8691 if (j + 1 < iverdef->vd_cnt)
8692 iverdaux->vda_nextptr = iverdaux + 1;
252b5132 8693
d0fb9a8d
JJ		 8694 if (iverdaux->vda_next
8695 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
601a03ba 8696 goto error_return_bad_verdef;
d0fb9a8d 8697
252b5132
RH		 8698 everdaux = ((Elf_External_Verdaux *)
8699 ((bfd_byte *) everdaux + iverdaux->vda_next));
8700 }
8701
595bce75 8702 iverdef->vd_nodename = NULL;
d0fb9a8d
JJ		 8703 if (iverdef->vd_cnt)
8704 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
252b5132 8705
25ff461f
AM		 8706 iverdef->vd_nextdef = NULL;
8707 if (iverdef->vd_next == 0)
8708 break;
d0fb9a8d 8709 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
252b5132 8710 iverdef->vd_nextdef = iverdef + 1;
252b5132
RH		 8711
8712 everdef = ((Elf_External_Verdef *)
8713 ((bfd_byte *) everdef + iverdef->vd_next));
8714 }
8715
8716 free (contents);
8717 contents = NULL;
8718 }
fc0e6df6 8719 else if (default_imported_symver)
252b5132 8720 {
fc0e6df6
PB		 8721 if (freeidx < 3)
8722 freeidx = 3;
8723 else
8724 freeidx++;
252b5132 8725
a50b1753 8726 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
07d6d2b8 8727 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
fc0e6df6 8728 if (elf_tdata (abfd)->verdef == NULL)
252b5132
RH		 8729 goto error_return;
8730
fc0e6df6
PB		 8731 elf_tdata (abfd)->cverdefs = freeidx;
8732 }
252b5132 8733
fc0e6df6
PB		 8734 /* Create a default version based on the soname. */
8735 if (default_imported_symver)
8736 {
8737 Elf_Internal_Verdef *iverdef;
8738 Elf_Internal_Verdaux *iverdaux;
252b5132 8739
5bb3703f 8740 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
252b5132 8741
fc0e6df6
PB		 8742 iverdef->vd_version = VER_DEF_CURRENT;
8743 iverdef->vd_flags = 0;
8744 iverdef->vd_ndx = freeidx;
8745 iverdef->vd_cnt = 1;
252b5132 8746
fc0e6df6 8747 iverdef->vd_bfd = abfd;
252b5132 8748
fc0e6df6
PB		 8749 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8750 if (iverdef->vd_nodename == NULL)
d0fb9a8d 8751 goto error_return_verdef;
fc0e6df6 8752 iverdef->vd_nextdef = NULL;
601a03ba
AM		 8753 iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8754 bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
d0fb9a8d
JJ		 8755 if (iverdef->vd_auxptr == NULL)
8756 goto error_return_verdef;
252b5132 8757
fc0e6df6
PB		 8758 iverdaux = iverdef->vd_auxptr;
8759 iverdaux->vda_nodename = iverdef->vd_nodename;
252b5132
RH		 8760 }
8761
b34976b6 8762 return TRUE;
252b5132
RH		 8763
8764 error_return:
5ed6aba4 8765 if (contents != NULL)
252b5132 8766 free (contents);
b34976b6 8767 return FALSE;
252b5132
RH		 8768}
8769\f
8770asymbol *
217aa764 8771_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH		 8772{
8773 elf_symbol_type *newsym;
8774
7a6e0d89 8775 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (*newsym));
252b5132
RH		 8776 if (!newsym)
8777 return NULL;
201159ec
NC		 8778 newsym->symbol.the_bfd = abfd;
8779 return &newsym->symbol;
252b5132
RH		 8780}
8781
8782void
217aa764
AM		 8783_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8784 asymbol *symbol,
8785 symbol_info *ret)
252b5132
RH		 8786{
8787 bfd_symbol_info (symbol, ret);
8788}
8789
8790/* Return whether a symbol name implies a local symbol. Most targets
8791 use this function for the is_local_label_name entry point, but some
8792 override it. */
8793
b34976b6 8794bfd_boolean
217aa764
AM		 8795_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8796 const char *name)
252b5132
RH		 8797{
8798 /* Normal local symbols start with ``.L''. */
8799 if (name[0] == '.' && name[1] == 'L')
b34976b6 8800 return TRUE;
252b5132
RH		 8801
8802 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8803 DWARF debugging symbols starting with ``..''. */
8804 if (name[0] == '.' && name[1] == '.')
b34976b6 8805 return TRUE;
252b5132
RH		 8806
8807 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8808 emitting DWARF debugging output. I suspect this is actually a
8809 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8810 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8811 underscore to be emitted on some ELF targets). For ease of use,
8812 we treat such symbols as local. */
8813 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 8814 return TRUE;
252b5132 8815
b1fa9dd6
NC		 8816 /* Treat assembler generated fake symbols, dollar local labels and
8817 forward-backward labels (aka local labels) as locals.
8818 These labels have the form:
8819
07d6d2b8 8820 L0^A.* (fake symbols)
b1fa9dd6
NC		 8821
8822 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8823
8824 Versions which start with .L will have already been matched above,
8825 so we only need to match the rest. */
8826 if (name[0] == 'L' && ISDIGIT (name[1]))
8827 {
8828 bfd_boolean ret = FALSE;
8829 const char * p;
8830 char c;
8831
8832 for (p = name + 2; (c = *p); p++)
8833 {
8834 if (c == 1 || c == 2)
8835 {
8836 if (c == 1 && p == name + 2)
8837 /* A fake symbol. */
8838 return TRUE;
8839
8840 /* FIXME: We are being paranoid here and treating symbols like
8841 L0^Bfoo as if there were non-local, on the grounds that the
8842 assembler will never generate them. But can any symbol
8843 containing an ASCII value in the range 1-31 ever be anything
8844 other than some kind of local ? */
8845 ret = TRUE;
8846 }
8847
8848 if (! ISDIGIT (c))
8849 {
8850 ret = FALSE;
8851 break;
8852 }
8853 }
8854 return ret;
8855 }
ffa54770 8856
b34976b6 8857 return FALSE;
252b5132
RH		 8858}
8859
8860alent *
217aa764
AM		 8861_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8862 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH		 8863{
8864 abort ();
8865 return NULL;
8866}
8867
b34976b6 8868bfd_boolean
217aa764
AM		 8869_bfd_elf_set_arch_mach (bfd *abfd,
8870 enum bfd_architecture arch,
8871 unsigned long machine)
252b5132
RH		 8872{
8873 /* If this isn't the right architecture for this backend, and this
8874 isn't the generic backend, fail. */
8875 if (arch != get_elf_backend_data (abfd)->arch
8876 && arch != bfd_arch_unknown
8877 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 8878 return FALSE;
252b5132
RH		 8879
8880 return bfd_default_set_arch_mach (abfd, arch, machine);
8881}
8882
d1fad7c6
NC		 8883/* Find the nearest line to a particular section and offset,
8884 for error reporting. */
8885
b34976b6 8886bfd_boolean
217aa764 8887_bfd_elf_find_nearest_line (bfd *abfd,
217aa764 8888 asymbol **symbols,
fb167eb2 8889 asection *section,
217aa764
AM		 8890 bfd_vma offset,
8891 const char **filename_ptr,
8892 const char **functionname_ptr,
fb167eb2
AM		 8893 unsigned int *line_ptr,
8894 unsigned int *discriminator_ptr)
d1fad7c6 8895{
b34976b6 8896 bfd_boolean found;
d1fad7c6 8897
fb167eb2 8898 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
4e8a9624 8899 filename_ptr, functionname_ptr,
fb167eb2
AM		 8900 line_ptr, discriminator_ptr,
8901 dwarf_debug_sections, 0,
e00e8198
AM		 8902 &elf_tdata (abfd)->dwarf2_find_line_info)
8903 || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8904 filename_ptr, functionname_ptr,
8905 line_ptr))
d1fad7c6
NC		 8906 {
8907 if (!*functionname_ptr)
e00e8198
AM		 8908 _bfd_elf_find_function (abfd, symbols, section, offset,
8909 *filename_ptr ? NULL : filename_ptr,
8910 functionname_ptr);
b34976b6 8911 return TRUE;
d1fad7c6
NC		 8912 }
8913
8914 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM		 8915 &found, filename_ptr,
8916 functionname_ptr, line_ptr,
8917 &elf_tdata (abfd)->line_info))
b34976b6 8918 return FALSE;
dc43ada5 8919 if (found && (*functionname_ptr || *line_ptr))
b34976b6 8920 return TRUE;
d1fad7c6
NC		 8921
8922 if (symbols == NULL)
b34976b6 8923 return FALSE;
d1fad7c6 8924
e00e8198
AM		 8925 if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8926 filename_ptr, functionname_ptr))
b34976b6 8927 return FALSE;
d1fad7c6 8928
252b5132 8929 *line_ptr = 0;
b34976b6 8930 return TRUE;
252b5132
RH		 8931}
8932
5420f73d
L		 8933/* Find the line for a symbol. */
8934
8935bfd_boolean
8936_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8937 const char **filename_ptr, unsigned int *line_ptr)
9b8d1a36 8938{
fb167eb2
AM		 8939 return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8940 filename_ptr, NULL, line_ptr, NULL,
8941 dwarf_debug_sections, 0,
8942 &elf_tdata (abfd)->dwarf2_find_line_info);
5420f73d
L		 8943}
8944
4ab527b0
FF		 8945/* After a call to bfd_find_nearest_line, successive calls to
8946 bfd_find_inliner_info can be used to get source information about
8947 each level of function inlining that terminated at the address
8948 passed to bfd_find_nearest_line. Currently this is only supported
8949 for DWARF2 with appropriate DWARF3 extensions. */
8950
8951bfd_boolean
8952_bfd_elf_find_inliner_info (bfd *abfd,
8953 const char **filename_ptr,
8954 const char **functionname_ptr,
8955 unsigned int *line_ptr)
8956{
8957 bfd_boolean found;
8958 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8959 functionname_ptr, line_ptr,
8960 & elf_tdata (abfd)->dwarf2_find_line_info);
8961 return found;
8962}
8963
252b5132 8964int
a6b96beb 8965_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 8966{
8ded5a0f
AM		 8967 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8968 int ret = bed->s->sizeof_ehdr;
252b5132 8969
0e1862bb 8970 if (!bfd_link_relocatable (info))
8ded5a0f 8971 {
12bd6957 8972 bfd_size_type phdr_size = elf_program_header_size (abfd);
8ded5a0f 8973
62d7a5f6
AM		 8974 if (phdr_size == (bfd_size_type) -1)
8975 {
8976 struct elf_segment_map *m;
8977
8978 phdr_size = 0;
12bd6957 8979 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62d7a5f6 8980 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 8981
62d7a5f6
AM		 8982 if (phdr_size == 0)
8983 phdr_size = get_program_header_size (abfd, info);
8984 }
8ded5a0f 8985
12bd6957 8986 elf_program_header_size (abfd) = phdr_size;
8ded5a0f
AM		 8987 ret += phdr_size;
8988 }
8989
252b5132
RH		 8990 return ret;
8991}
8992
b34976b6 8993bfd_boolean
217aa764
AM		 8994_bfd_elf_set_section_contents (bfd *abfd,
8995 sec_ptr section,
0f867abe 8996 const void *location,
217aa764
AM		 8997 file_ptr offset,
8998 bfd_size_type count)
252b5132
RH		 8999{
9000 Elf_Internal_Shdr *hdr;
1b6aeedb 9001 file_ptr pos;
252b5132
RH		 9002
9003 if (! abfd->output_has_begun
217aa764 9004 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 9005 return FALSE;
252b5132 9006
0ce398f1
L		 9007 if (!count)
9008 return TRUE;
9009
252b5132 9010 hdr = &elf_section_data (section)->this_hdr;
0ce398f1
L		 9011 if (hdr->sh_offset == (file_ptr) -1)
9012 {
9013 /* We must compress this section. Write output to the buffer. */
9014 unsigned char *contents = hdr->contents;
9015 if ((offset + count) > hdr->sh_size
9016 || (section->flags & SEC_ELF_COMPRESS) == 0
9017 || contents == NULL)
9018 abort ();
9019 memcpy (contents + offset, location, count);
9020 return TRUE;
9021 }
dc810e39
AM		 9022 pos = hdr->sh_offset + offset;
9023 if (bfd_seek (abfd, pos, SEEK_SET) != 0
9024 || bfd_bwrite (location, count, abfd) != count)
b34976b6 9025 return FALSE;
252b5132 9026
b34976b6 9027 return TRUE;
252b5132
RH		 9028}
9029
f3185997 9030bfd_boolean
217aa764
AM		 9031_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
9032 arelent *cache_ptr ATTRIBUTE_UNUSED,
9033 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH		 9034{
9035 abort ();
f3185997 9036 return FALSE;
252b5132
RH		 9037}
9038
252b5132
RH		 9039/* Try to convert a non-ELF reloc into an ELF one. */
9040
b34976b6 9041bfd_boolean
217aa764 9042_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 9043{
c044fabd 9044 /* Check whether we really have an ELF howto. */
252b5132
RH		 9045
9046 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
9047 {
9048 bfd_reloc_code_real_type code;
9049 reloc_howto_type *howto;
9050
9051 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 9052 equivalent ELF reloc. */
252b5132
RH		 9053
9054 if (areloc->howto->pc_relative)
9055 {
9056 switch (areloc->howto->bitsize)
9057 {
9058 case 8:
9059 code = BFD_RELOC_8_PCREL;
9060 break;
9061 case 12:
9062 code = BFD_RELOC_12_PCREL;
9063 break;
9064 case 16:
9065 code = BFD_RELOC_16_PCREL;
9066 break;
9067 case 24:
9068 code = BFD_RELOC_24_PCREL;
9069 break;
9070 case 32:
9071 code = BFD_RELOC_32_PCREL;
9072 break;
9073 case 64:
9074 code = BFD_RELOC_64_PCREL;
9075 break;
9076 default:
9077 goto fail;
9078 }
9079
9080 howto = bfd_reloc_type_lookup (abfd, code);
9081
9082 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
9083 {
9084 if (howto->pcrel_offset)
9085 areloc->addend += areloc->address;
9086 else
9087 areloc->addend -= areloc->address; /* addend is unsigned!! */
9088 }
9089 }
9090 else
9091 {
9092 switch (areloc->howto->bitsize)
9093 {
9094 case 8:
9095 code = BFD_RELOC_8;
9096 break;
9097 case 14:
9098 code = BFD_RELOC_14;
9099 break;
9100 case 16:
9101 code = BFD_RELOC_16;
9102 break;
9103 case 26:
9104 code = BFD_RELOC_26;
9105 break;
9106 case 32:
9107 code = BFD_RELOC_32;
9108 break;
9109 case 64:
9110 code = BFD_RELOC_64;
9111 break;
9112 default:
9113 goto fail;
9114 }
9115
9116 howto = bfd_reloc_type_lookup (abfd, code);
9117 }
9118
9119 if (howto)
9120 areloc->howto = howto;
9121 else
9122 goto fail;
9123 }
9124
b34976b6 9125 return TRUE;
252b5132
RH		 9126
9127 fail:
0aa13fee
AM		 9128 /* xgettext:c-format */
9129 _bfd_error_handler (_("%pB: %s unsupported"),
9130 abfd, areloc->howto->name);
252b5132 9131 bfd_set_error (bfd_error_bad_value);
b34976b6 9132 return FALSE;
252b5132
RH		 9133}
9134
b34976b6 9135bfd_boolean
217aa764 9136_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132 9137{
d9071b0c
TG		 9138 struct elf_obj_tdata *tdata = elf_tdata (abfd);
9139 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
252b5132 9140 {
c0355132 9141 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
2b0f7ef9 9142 _bfd_elf_strtab_free (elf_shstrtab (abfd));
d9071b0c 9143 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
252b5132
RH		 9144 }
9145
9146 return _bfd_generic_close_and_cleanup (abfd);
9147}
9148
9149/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9150 in the relocation's offset. Thus we cannot allow any sort of sanity
9151 range-checking to interfere. There is nothing else to do in processing
9152 this reloc. */
9153
9154bfd_reloc_status_type
217aa764
AM		 9155_bfd_elf_rel_vtable_reloc_fn
9156 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 9157 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM		 9158 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9159 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH		 9160{
9161 return bfd_reloc_ok;
9162}
252b5132
RH		 9163\f
9164/* Elf core file support. Much of this only works on native
9165 toolchains, since we rely on knowing the
9166 machine-dependent procfs structure in order to pick
c044fabd 9167 out details about the corefile. */
252b5132
RH		 9168
9169#ifdef HAVE_SYS_PROCFS_H
16231b7b
DG		 9170/* Needed for new procfs interface on sparc-solaris. */
9171# define _STRUCTURED_PROC 1
252b5132
RH		 9172# include <sys/procfs.h>
9173#endif
9174
261b8d08
PA		 9175/* Return a PID that identifies a "thread" for threaded cores, or the
9176 PID of the main process for non-threaded cores. */
252b5132
RH		 9177
9178static int
217aa764 9179elfcore_make_pid (bfd *abfd)
252b5132 9180{
261b8d08
PA		 9181 int pid;
9182
228e534f 9183 pid = elf_tdata (abfd)->core->lwpid;
261b8d08 9184 if (pid == 0)
228e534f 9185 pid = elf_tdata (abfd)->core->pid;
261b8d08
PA		 9186
9187 return pid;
252b5132
RH		 9188}
9189
252b5132
RH		 9190/* If there isn't a section called NAME, make one, using
9191 data from SECT. Note, this function will generate a
9192 reference to NAME, so you shouldn't deallocate or
c044fabd 9193 overwrite it. */
252b5132 9194
b34976b6 9195static bfd_boolean
217aa764 9196elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 9197{
c044fabd 9198 asection *sect2;
252b5132
RH		 9199
9200 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 9201 return TRUE;
252b5132 9202
117ed4f8 9203 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 9204 if (sect2 == NULL)
b34976b6 9205 return FALSE;
252b5132 9206
eea6121a 9207 sect2->size = sect->size;
252b5132 9208 sect2->filepos = sect->filepos;
252b5132 9209 sect2->alignment_power = sect->alignment_power;
b34976b6 9210 return TRUE;
252b5132
RH		 9211}
9212
bb0082d6
AM		 9213/* Create a pseudosection containing SIZE bytes at FILEPOS. This
9214 actually creates up to two pseudosections:
9215 - For the single-threaded case, a section named NAME, unless
9216 such a section already exists.
9217 - For the multi-threaded case, a section named "NAME/PID", where
9218 PID is elfcore_make_pid (abfd).
24d3e51b 9219 Both pseudosections have identical contents. */
b34976b6 9220bfd_boolean
217aa764
AM		 9221_bfd_elfcore_make_pseudosection (bfd *abfd,
9222 char *name,
9223 size_t size,
9224 ufile_ptr filepos)
bb0082d6
AM		 9225{
9226 char buf[100];
9227 char *threaded_name;
d4c88bbb 9228 size_t len;
bb0082d6
AM		 9229 asection *sect;
9230
9231 /* Build the section name. */
9232
9233 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 9234 len = strlen (buf) + 1;
a50b1753 9235 threaded_name = (char *) bfd_alloc (abfd, len);
bb0082d6 9236 if (threaded_name == NULL)
b34976b6 9237 return FALSE;
d4c88bbb 9238 memcpy (threaded_name, buf, len);
bb0082d6 9239
117ed4f8
AM		 9240 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9241 SEC_HAS_CONTENTS);
bb0082d6 9242 if (sect == NULL)
b34976b6 9243 return FALSE;
eea6121a 9244 sect->size = size;
bb0082d6 9245 sect->filepos = filepos;
bb0082d6
AM		 9246 sect->alignment_power = 2;
9247
936e320b 9248 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM		 9249}
9250
58e07198
CZ		 9251static bfd_boolean
9252elfcore_make_auxv_note_section (bfd *abfd, Elf_Internal_Note *note,
9253 size_t offs)
9254{
9255 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9256 SEC_HAS_CONTENTS);
9257
9258 if (sect == NULL)
9259 return FALSE;
9260
9261 sect->size = note->descsz - offs;
9262 sect->filepos = note->descpos + offs;
9263 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9264
9265 return TRUE;
9266}
9267
252b5132 9268/* prstatus_t exists on:
4a938328 9269 solaris 2.5+
252b5132
RH		 9270 linux 2.[01] + glibc
9271 unixware 4.2
9272*/
9273
9274#if defined (HAVE_PRSTATUS_T)
a7b97311 9275
b34976b6 9276static bfd_boolean
217aa764 9277elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 9278{
eea6121a 9279 size_t size;
7ee38065 9280 int offset;
252b5132 9281
4a938328
MS		 9282 if (note->descsz == sizeof (prstatus_t))
9283 {
9284 prstatus_t prstat;
252b5132 9285
eea6121a 9286 size = sizeof (prstat.pr_reg);
7ee38065 9287 offset = offsetof (prstatus_t, pr_reg);
4a938328 9288 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 9289
fa49d224
NC		 9290 /* Do not overwrite the core signal if it
9291 has already been set by another thread. */
228e534f
AM		 9292 if (elf_tdata (abfd)->core->signal == 0)
9293 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9294 if (elf_tdata (abfd)->core->pid == 0)
9295 elf_tdata (abfd)->core->pid = prstat.pr_pid;
252b5132 9296
4a938328
MS		 9297 /* pr_who exists on:
9298 solaris 2.5+
9299 unixware 4.2
9300 pr_who doesn't exist on:
9301 linux 2.[01]
9302 */
252b5132 9303#if defined (HAVE_PRSTATUS_T_PR_WHO)
228e534f 9304 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 9305#else
228e534f 9306 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
252b5132 9307#endif
4a938328 9308 }
7ee38065 9309#if defined (HAVE_PRSTATUS32_T)
4a938328
MS		 9310 else if (note->descsz == sizeof (prstatus32_t))
9311 {
9312 /* 64-bit host, 32-bit corefile */
9313 prstatus32_t prstat;
9314
eea6121a 9315 size = sizeof (prstat.pr_reg);
7ee38065 9316 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS		 9317 memcpy (&prstat, note->descdata, sizeof (prstat));
9318
fa49d224
NC		 9319 /* Do not overwrite the core signal if it
9320 has already been set by another thread. */
228e534f
AM		 9321 if (elf_tdata (abfd)->core->signal == 0)
9322 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9323 if (elf_tdata (abfd)->core->pid == 0)
9324 elf_tdata (abfd)->core->pid = prstat.pr_pid;
4a938328
MS		 9325
9326 /* pr_who exists on:
9327 solaris 2.5+
9328 unixware 4.2
9329 pr_who doesn't exist on:
9330 linux 2.[01]
9331 */
7ee38065 9332#if defined (HAVE_PRSTATUS32_T_PR_WHO)
228e534f 9333 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 9334#else
228e534f 9335 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
4a938328
MS		 9336#endif
9337 }
7ee38065 9338#endif /* HAVE_PRSTATUS32_T */
4a938328
MS		 9339 else
9340 {
9341 /* Fail - we don't know how to handle any other
9342 note size (ie. data object type). */
b34976b6 9343 return TRUE;
4a938328 9344 }
252b5132 9345
bb0082d6 9346 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 9347 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 9348 size, note->descpos + offset);
252b5132
RH		 9349}
9350#endif /* defined (HAVE_PRSTATUS_T) */
9351
bb0082d6 9352/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 9353static bfd_boolean
217aa764
AM		 9354elfcore_make_note_pseudosection (bfd *abfd,
9355 char *name,
9356 Elf_Internal_Note *note)
252b5132 9357{
936e320b
AM		 9358 return _bfd_elfcore_make_pseudosection (abfd, name,
9359 note->descsz, note->descpos);
252b5132
RH		 9360}
9361
ff08c6bb
JB		 9362/* There isn't a consistent prfpregset_t across platforms,
9363 but it doesn't matter, because we don't have to pick this
c044fabd
KH		 9364 data structure apart. */
9365
b34976b6 9366static bfd_boolean
217aa764 9367elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 9368{
9369 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9370}
9371
ff08c6bb 9372/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
971d4640 9373 type of NT_PRXFPREG. Just include the whole note's contents
ff08c6bb 9374 literally. */
c044fabd 9375
b34976b6 9376static bfd_boolean
217aa764 9377elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 9378{
9379 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9380}
9381
4339cae0
L		 9382/* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9383 with a note type of NT_X86_XSTATE. Just include the whole note's
9384 contents literally. */
9385
9386static bfd_boolean
9387elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9388{
9389 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9390}
9391
97753bd5
AM		 9392static bfd_boolean
9393elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9394{
9395 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9396}
9397
89eeb0bc
LM		 9398static bfd_boolean
9399elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9400{
9401 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9402}
97753bd5 9403
cb2366c1
EBM		 9404static bfd_boolean
9405elfcore_grok_ppc_tar (bfd *abfd, Elf_Internal_Note *note)
9406{
9407 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tar", note);
9408}
9409
9410static bfd_boolean
9411elfcore_grok_ppc_ppr (bfd *abfd, Elf_Internal_Note *note)
9412{
9413 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ppr", note);
9414}
9415
9416static bfd_boolean
9417elfcore_grok_ppc_dscr (bfd *abfd, Elf_Internal_Note *note)
9418{
9419 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-dscr", note);
9420}
9421
9422static bfd_boolean
9423elfcore_grok_ppc_ebb (bfd *abfd, Elf_Internal_Note *note)
9424{
9425 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ebb", note);
9426}
9427
9428static bfd_boolean
9429elfcore_grok_ppc_pmu (bfd *abfd, Elf_Internal_Note *note)
9430{
9431 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-pmu", note);
9432}
9433
9434static bfd_boolean
9435elfcore_grok_ppc_tm_cgpr (bfd *abfd, Elf_Internal_Note *note)
9436{
9437 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cgpr", note);
9438}
9439
9440static bfd_boolean
9441elfcore_grok_ppc_tm_cfpr (bfd *abfd, Elf_Internal_Note *note)
9442{
9443 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cfpr", note);
9444}
9445
9446static bfd_boolean
9447elfcore_grok_ppc_tm_cvmx (bfd *abfd, Elf_Internal_Note *note)
9448{
9449 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvmx", note);
9450}
9451
9452static bfd_boolean
9453elfcore_grok_ppc_tm_cvsx (bfd *abfd, Elf_Internal_Note *note)
9454{
9455 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvsx", note);
9456}
9457
9458static bfd_boolean
9459elfcore_grok_ppc_tm_spr (bfd *abfd, Elf_Internal_Note *note)
9460{
9461 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-spr", note);
9462}
9463
9464static bfd_boolean
9465elfcore_grok_ppc_tm_ctar (bfd *abfd, Elf_Internal_Note *note)
9466{
9467 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-ctar", note);
9468}
9469
9470static bfd_boolean
9471elfcore_grok_ppc_tm_cppr (bfd *abfd, Elf_Internal_Note *note)
9472{
9473 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cppr", note);
9474}
9475
9476static bfd_boolean
9477elfcore_grok_ppc_tm_cdscr (bfd *abfd, Elf_Internal_Note *note)
9478{
9479 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cdscr", note);
9480}
9481
0675e188
UW		 9482static bfd_boolean
9483elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9484{
9485 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9486}
9487
d7eeb400
MS		 9488static bfd_boolean
9489elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9490{
9491 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9492}
9493
9494static bfd_boolean
9495elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9496{
9497 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9498}
9499
9500static bfd_boolean
9501elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9502{
9503 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9504}
9505
9506static bfd_boolean
9507elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9508{
9509 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9510}
9511
9512static bfd_boolean
9513elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9514{
9515 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9516}
9517
355b81d9
UW		 9518static bfd_boolean
9519elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9520{
9521 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9522}
9523
9524static bfd_boolean
9525elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9526{
9527 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9528}
9529
abb3f6cc
NC		 9530static bfd_boolean
9531elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9532{
9533 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9534}
9535
4ef9f41a
AA		 9536static bfd_boolean
9537elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9538{
9539 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9540}
9541
9542static bfd_boolean
9543elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9544{
9545 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9546}
9547
88ab90e8
AA		 9548static bfd_boolean
9549elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9550{
9551 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9552}
9553
9554static bfd_boolean
9555elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9556{
9557 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9558}
9559
faa9a424
UW		 9560static bfd_boolean
9561elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9562{
9563 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9564}
9565
652451f8
YZ		 9566static bfd_boolean
9567elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9568{
9569 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9570}
9571
9572static bfd_boolean
9573elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9574{
9575 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9576}
9577
9578static bfd_boolean
9579elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9580{
9581 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9582}
9583
ad1cc4e4
AH		 9584static bfd_boolean
9585elfcore_grok_aarch_sve (bfd *abfd, Elf_Internal_Note *note)
9586{
9587 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-sve", note);
9588}
9589
e6c3b5bf
AH		 9590static bfd_boolean
9591elfcore_grok_aarch_pauth (bfd *abfd, Elf_Internal_Note *note)
9592{
9593 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-pauth", note);
9594}
9595
252b5132 9596#if defined (HAVE_PRPSINFO_T)
4a938328 9597typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 9598#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 9599typedef prpsinfo32_t elfcore_psinfo32_t;
9600#endif
252b5132
RH		 9601#endif
9602
9603#if defined (HAVE_PSINFO_T)
4a938328 9604typedef psinfo_t elfcore_psinfo_t;
7ee38065 9605#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 9606typedef psinfo32_t elfcore_psinfo32_t;
9607#endif
252b5132
RH		 9608#endif
9609
252b5132
RH		 9610/* return a malloc'ed copy of a string at START which is at
9611 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 9612 the copy will always have a terminating '\0'. */
252b5132 9613
936e320b 9614char *
217aa764 9615_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 9616{
dc810e39 9617 char *dups;
a50b1753 9618 char *end = (char *) memchr (start, '\0', max);
dc810e39 9619 size_t len;
252b5132
RH		 9620
9621 if (end == NULL)
9622 len = max;
9623 else
9624 len = end - start;
9625
a50b1753 9626 dups = (char *) bfd_alloc (abfd, len + 1);
dc810e39 9627 if (dups == NULL)
252b5132
RH		 9628 return NULL;
9629
dc810e39
AM		 9630 memcpy (dups, start, len);
9631 dups[len] = '\0';
252b5132 9632
dc810e39 9633 return dups;
252b5132
RH		 9634}
9635
bb0082d6 9636#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 9637static bfd_boolean
217aa764 9638elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 9639{
4a938328
MS		 9640 if (note->descsz == sizeof (elfcore_psinfo_t))
9641 {
9642 elfcore_psinfo_t psinfo;
252b5132 9643
7ee38065 9644 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 9645
335e41d4 9646#if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
228e534f 9647 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 9648#endif
228e534f 9649 elf_tdata (abfd)->core->program
936e320b
AM		 9650 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9651 sizeof (psinfo.pr_fname));
252b5132 9652
228e534f 9653 elf_tdata (abfd)->core->command
936e320b
AM		 9654 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9655 sizeof (psinfo.pr_psargs));
4a938328 9656 }
7ee38065 9657#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS		 9658 else if (note->descsz == sizeof (elfcore_psinfo32_t))
9659 {
9660 /* 64-bit host, 32-bit corefile */
9661 elfcore_psinfo32_t psinfo;
9662
7ee38065 9663 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 9664
335e41d4 9665#if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
228e534f 9666 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 9667#endif
228e534f 9668 elf_tdata (abfd)->core->program
936e320b
AM		 9669 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9670 sizeof (psinfo.pr_fname));
4a938328 9671
228e534f 9672 elf_tdata (abfd)->core->command
936e320b
AM		 9673 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9674 sizeof (psinfo.pr_psargs));
4a938328
MS		 9675 }
9676#endif
9677
9678 else
9679 {
9680 /* Fail - we don't know how to handle any other
9681 note size (ie. data object type). */
b34976b6 9682 return TRUE;
4a938328 9683 }
252b5132
RH		 9684
9685 /* Note that for some reason, a spurious space is tacked
9686 onto the end of the args in some (at least one anyway)
c044fabd 9687 implementations, so strip it off if it exists. */
252b5132
RH		 9688
9689 {
228e534f 9690 char *command = elf_tdata (abfd)->core->command;
252b5132
RH		 9691 int n = strlen (command);
9692
9693 if (0 < n && command[n - 1] == ' ')
9694 command[n - 1] = '\0';
9695 }
9696
b34976b6 9697 return TRUE;
252b5132
RH		 9698}
9699#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9700
252b5132 9701#if defined (HAVE_PSTATUS_T)
b34976b6 9702static bfd_boolean
217aa764 9703elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 9704{
f572a39d
AM		 9705 if (note->descsz == sizeof (pstatus_t)
9706#if defined (HAVE_PXSTATUS_T)
9707 || note->descsz == sizeof (pxstatus_t)
9708#endif
9709 )
4a938328
MS		 9710 {
9711 pstatus_t pstat;
252b5132 9712
4a938328 9713 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 9714
228e534f 9715 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328 9716 }
7ee38065 9717#if defined (HAVE_PSTATUS32_T)
4a938328
MS		 9718 else if (note->descsz == sizeof (pstatus32_t))
9719 {
9720 /* 64-bit host, 32-bit corefile */
9721 pstatus32_t pstat;
252b5132 9722
4a938328 9723 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 9724
228e534f 9725 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328
MS		 9726 }
9727#endif
252b5132
RH		 9728 /* Could grab some more details from the "representative"
9729 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 9730 NT_LWPSTATUS note, presumably. */
252b5132 9731
b34976b6 9732 return TRUE;
252b5132
RH		 9733}
9734#endif /* defined (HAVE_PSTATUS_T) */
9735
252b5132 9736#if defined (HAVE_LWPSTATUS_T)
b34976b6 9737static bfd_boolean
217aa764 9738elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH		 9739{
9740 lwpstatus_t lwpstat;
9741 char buf[100];
c044fabd 9742 char *name;
d4c88bbb 9743 size_t len;
c044fabd 9744 asection *sect;
252b5132 9745
f572a39d
AM		 9746 if (note->descsz != sizeof (lwpstat)
9747#if defined (HAVE_LWPXSTATUS_T)
9748 && note->descsz != sizeof (lwpxstatus_t)
9749#endif
9750 )
b34976b6 9751 return TRUE;
252b5132
RH		 9752
9753 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9754
228e534f 9755 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
a1504221
JB		 9756 /* Do not overwrite the core signal if it has already been set by
9757 another thread. */
228e534f
AM		 9758 if (elf_tdata (abfd)->core->signal == 0)
9759 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
252b5132 9760
c044fabd 9761 /* Make a ".reg/999" section. */
252b5132
RH		 9762
9763 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 9764 len = strlen (buf) + 1;
217aa764 9765 name = bfd_alloc (abfd, len);
252b5132 9766 if (name == NULL)
b34976b6 9767 return FALSE;
d4c88bbb 9768 memcpy (name, buf, len);
252b5132 9769
117ed4f8 9770 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 9771 if (sect == NULL)
b34976b6 9772 return FALSE;
252b5132
RH		 9773
9774#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 9775 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH		 9776 sect->filepos = note->descpos
9777 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9778#endif
9779
9780#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 9781 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH		 9782 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9783#endif
9784
252b5132
RH		 9785 sect->alignment_power = 2;
9786
9787 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 9788 return FALSE;
252b5132
RH		 9789
9790 /* Make a ".reg2/999" section */
9791
9792 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 9793 len = strlen (buf) + 1;
217aa764 9794 name = bfd_alloc (abfd, len);
252b5132 9795 if (name == NULL)
b34976b6 9796 return FALSE;
d4c88bbb 9797 memcpy (name, buf, len);
252b5132 9798
117ed4f8 9799 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 9800 if (sect == NULL)
b34976b6 9801 return FALSE;
252b5132
RH		 9802
9803#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 9804 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH		 9805 sect->filepos = note->descpos
9806 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9807#endif
9808
9809#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 9810 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH		 9811 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9812#endif
9813
252b5132
RH		 9814 sect->alignment_power = 2;
9815
936e320b 9816 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH		 9817}
9818#endif /* defined (HAVE_LWPSTATUS_T) */
9819
b34976b6 9820static bfd_boolean
217aa764 9821elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC		 9822{
9823 char buf[30];
c044fabd 9824 char *name;
d4c88bbb 9825 size_t len;
c044fabd 9826 asection *sect;
4a6636fb
PA		 9827 int type;
9828 int is_active_thread;
9829 bfd_vma base_addr;
16e9c715 9830
4a6636fb 9831 if (note->descsz < 728)
b34976b6 9832 return TRUE;
16e9c715 9833
4a6636fb
PA		 9834 if (! CONST_STRNEQ (note->namedata, "win32"))
9835 return TRUE;
9836
9837 type = bfd_get_32 (abfd, note->descdata);
c044fabd 9838
4a6636fb 9839 switch (type)
16e9c715 9840 {
4a6636fb 9841 case 1 /* NOTE_INFO_PROCESS */:
228e534f 9842 /* FIXME: need to add ->core->command. */
4a6636fb 9843 /* process_info.pid */
228e534f 9844 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
4a6636fb 9845 /* process_info.signal */
228e534f 9846 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
c044fabd 9847 break;
16e9c715 9848
4a6636fb 9849 case 2 /* NOTE_INFO_THREAD */:
16e9c715 9850 /* Make a ".reg/999" section. */
4a6636fb
PA		 9851 /* thread_info.tid */
9852 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
c044fabd 9853
d4c88bbb 9854 len = strlen (buf) + 1;
a50b1753 9855 name = (char *) bfd_alloc (abfd, len);
16e9c715 9856 if (name == NULL)
b34976b6 9857 return FALSE;
c044fabd 9858
d4c88bbb 9859 memcpy (name, buf, len);
16e9c715 9860
117ed4f8 9861 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 9862 if (sect == NULL)
b34976b6 9863 return FALSE;
c044fabd 9864
4a6636fb
PA		 9865 /* sizeof (thread_info.thread_context) */
9866 sect->size = 716;
9867 /* offsetof (thread_info.thread_context) */
9868 sect->filepos = note->descpos + 12;
16e9c715
NC		 9869 sect->alignment_power = 2;
9870
4a6636fb
PA		 9871 /* thread_info.is_active_thread */
9872 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9873
9874 if (is_active_thread)
16e9c715 9875 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 9876 return FALSE;
16e9c715
NC		 9877 break;
9878
4a6636fb 9879 case 3 /* NOTE_INFO_MODULE */:
16e9c715 9880 /* Make a ".module/xxxxxxxx" section. */
4a6636fb
PA		 9881 /* module_info.base_address */
9882 base_addr = bfd_get_32 (abfd, note->descdata + 4);
0af1713e 9883 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
c044fabd 9884
d4c88bbb 9885 len = strlen (buf) + 1;
a50b1753 9886 name = (char *) bfd_alloc (abfd, len);
16e9c715 9887 if (name == NULL)
b34976b6 9888 return FALSE;
c044fabd 9889
d4c88bbb 9890 memcpy (name, buf, len);
252b5132 9891
117ed4f8 9892 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 9893
16e9c715 9894 if (sect == NULL)
b34976b6 9895 return FALSE;
c044fabd 9896
eea6121a 9897 sect->size = note->descsz;
16e9c715 9898 sect->filepos = note->descpos;
16e9c715
NC		 9899 sect->alignment_power = 2;
9900 break;
9901
9902 default:
b34976b6 9903 return TRUE;
16e9c715
NC		 9904 }
9905
b34976b6 9906 return TRUE;
16e9c715 9907}
252b5132 9908
b34976b6 9909static bfd_boolean
217aa764 9910elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 9911{
9c5bfbb7 9912 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 9913
252b5132
RH		 9914 switch (note->type)
9915 {
9916 default:
b34976b6 9917 return TRUE;
252b5132 9918
252b5132 9919 case NT_PRSTATUS:
bb0082d6
AM		 9920 if (bed->elf_backend_grok_prstatus)
9921 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 9922 return TRUE;
bb0082d6 9923#if defined (HAVE_PRSTATUS_T)
252b5132 9924 return elfcore_grok_prstatus (abfd, note);
bb0082d6 9925#else
b34976b6 9926 return TRUE;
252b5132
RH		 9927#endif
9928
9929#if defined (HAVE_PSTATUS_T)
9930 case NT_PSTATUS:
9931 return elfcore_grok_pstatus (abfd, note);
9932#endif
9933
9934#if defined (HAVE_LWPSTATUS_T)
9935 case NT_LWPSTATUS:
9936 return elfcore_grok_lwpstatus (abfd, note);
9937#endif
9938
9939 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
9940 return elfcore_grok_prfpreg (abfd, note);
9941
c044fabd 9942 case NT_WIN32PSTATUS:
16e9c715 9943 return elfcore_grok_win32pstatus (abfd, note);
16e9c715 9944
c044fabd 9945 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK		 9946 if (note->namesz == 6
9947 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB		 9948 return elfcore_grok_prxfpreg (abfd, note);
9949 else
b34976b6 9950 return TRUE;
ff08c6bb 9951
4339cae0
L		 9952 case NT_X86_XSTATE: /* Linux XSAVE extension */
9953 if (note->namesz == 6
9954 && strcmp (note->namedata, "LINUX") == 0)
9955 return elfcore_grok_xstatereg (abfd, note);
9956 else
9957 return TRUE;
9958
97753bd5
AM		 9959 case NT_PPC_VMX:
9960 if (note->namesz == 6
9961 && strcmp (note->namedata, "LINUX") == 0)
9962 return elfcore_grok_ppc_vmx (abfd, note);
9963 else
9964 return TRUE;
9965
89eeb0bc
LM		 9966 case NT_PPC_VSX:
9967 if (note->namesz == 6
07d6d2b8
AM		 9968 && strcmp (note->namedata, "LINUX") == 0)
9969 return elfcore_grok_ppc_vsx (abfd, note);
89eeb0bc 9970 else
07d6d2b8 9971 return TRUE;
89eeb0bc 9972
cb2366c1
EBM		 9973 case NT_PPC_TAR:
9974 if (note->namesz == 6
4b24dd1a
AM		 9975 && strcmp (note->namedata, "LINUX") == 0)
9976 return elfcore_grok_ppc_tar (abfd, note);
cb2366c1 9977 else
4b24dd1a 9978 return TRUE;
cb2366c1
EBM		 9979
9980 case NT_PPC_PPR:
9981 if (note->namesz == 6
4b24dd1a
AM		 9982 && strcmp (note->namedata, "LINUX") == 0)
9983 return elfcore_grok_ppc_ppr (abfd, note);
cb2366c1 9984 else
4b24dd1a 9985 return TRUE;
cb2366c1
EBM		 9986
9987 case NT_PPC_DSCR:
9988 if (note->namesz == 6
4b24dd1a
AM		 9989 && strcmp (note->namedata, "LINUX") == 0)
9990 return elfcore_grok_ppc_dscr (abfd, note);
cb2366c1 9991 else
4b24dd1a 9992 return TRUE;
cb2366c1
EBM		 9993
9994 case NT_PPC_EBB:
9995 if (note->namesz == 6
4b24dd1a
AM		 9996 && strcmp (note->namedata, "LINUX") == 0)
9997 return elfcore_grok_ppc_ebb (abfd, note);
cb2366c1 9998 else
4b24dd1a 9999 return TRUE;
cb2366c1
EBM		 10000
10001 case NT_PPC_PMU:
10002 if (note->namesz == 6
4b24dd1a
AM		 10003 && strcmp (note->namedata, "LINUX") == 0)
10004 return elfcore_grok_ppc_pmu (abfd, note);
cb2366c1 10005 else
4b24dd1a 10006 return TRUE;
cb2366c1
EBM		 10007
10008 case NT_PPC_TM_CGPR:
10009 if (note->namesz == 6
4b24dd1a
AM		 10010 && strcmp (note->namedata, "LINUX") == 0)
10011 return elfcore_grok_ppc_tm_cgpr (abfd, note);
cb2366c1 10012 else
4b24dd1a 10013 return TRUE;
cb2366c1
EBM		 10014
10015 case NT_PPC_TM_CFPR:
10016 if (note->namesz == 6
4b24dd1a
AM		 10017 && strcmp (note->namedata, "LINUX") == 0)
10018 return elfcore_grok_ppc_tm_cfpr (abfd, note);
cb2366c1 10019 else
4b24dd1a 10020 return TRUE;
cb2366c1
EBM		 10021
10022 case NT_PPC_TM_CVMX:
10023 if (note->namesz == 6
4b24dd1a
AM		 10024 && strcmp (note->namedata, "LINUX") == 0)
10025 return elfcore_grok_ppc_tm_cvmx (abfd, note);
cb2366c1 10026 else
4b24dd1a 10027 return TRUE;
cb2366c1
EBM		 10028
10029 case NT_PPC_TM_CVSX:
10030 if (note->namesz == 6
4b24dd1a
AM		 10031 && strcmp (note->namedata, "LINUX") == 0)
10032 return elfcore_grok_ppc_tm_cvsx (abfd, note);
cb2366c1 10033 else
4b24dd1a 10034 return TRUE;
cb2366c1
EBM		 10035
10036 case NT_PPC_TM_SPR:
10037 if (note->namesz == 6
4b24dd1a
AM		 10038 && strcmp (note->namedata, "LINUX") == 0)
10039 return elfcore_grok_ppc_tm_spr (abfd, note);
cb2366c1 10040 else
4b24dd1a 10041 return TRUE;
cb2366c1
EBM		 10042
10043 case NT_PPC_TM_CTAR:
10044 if (note->namesz == 6
4b24dd1a
AM		 10045 && strcmp (note->namedata, "LINUX") == 0)
10046 return elfcore_grok_ppc_tm_ctar (abfd, note);
cb2366c1 10047 else
4b24dd1a 10048 return TRUE;
cb2366c1
EBM		 10049
10050 case NT_PPC_TM_CPPR:
10051 if (note->namesz == 6
4b24dd1a
AM		 10052 && strcmp (note->namedata, "LINUX") == 0)
10053 return elfcore_grok_ppc_tm_cppr (abfd, note);
cb2366c1 10054 else
4b24dd1a 10055 return TRUE;
cb2366c1
EBM		 10056
10057 case NT_PPC_TM_CDSCR:
10058 if (note->namesz == 6
4b24dd1a
AM		 10059 && strcmp (note->namedata, "LINUX") == 0)
10060 return elfcore_grok_ppc_tm_cdscr (abfd, note);
cb2366c1 10061 else
4b24dd1a 10062 return TRUE;
cb2366c1 10063
0675e188
UW		 10064 case NT_S390_HIGH_GPRS:
10065 if (note->namesz == 6
07d6d2b8
AM		 10066 && strcmp (note->namedata, "LINUX") == 0)
10067 return elfcore_grok_s390_high_gprs (abfd, note);
0675e188 10068 else
07d6d2b8 10069 return TRUE;
0675e188 10070
d7eeb400
MS		 10071 case NT_S390_TIMER:
10072 if (note->namesz == 6
07d6d2b8
AM		 10073 && strcmp (note->namedata, "LINUX") == 0)
10074 return elfcore_grok_s390_timer (abfd, note);
d7eeb400 10075 else
07d6d2b8 10076 return TRUE;
d7eeb400
MS		 10077
10078 case NT_S390_TODCMP:
10079 if (note->namesz == 6
07d6d2b8
AM		 10080 && strcmp (note->namedata, "LINUX") == 0)
10081 return elfcore_grok_s390_todcmp (abfd, note);
d7eeb400 10082 else
07d6d2b8 10083 return TRUE;
d7eeb400
MS		 10084
10085 case NT_S390_TODPREG:
10086 if (note->namesz == 6
07d6d2b8
AM		 10087 && strcmp (note->namedata, "LINUX") == 0)
10088 return elfcore_grok_s390_todpreg (abfd, note);
d7eeb400 10089 else
07d6d2b8 10090 return TRUE;
d7eeb400
MS		 10091
10092 case NT_S390_CTRS:
10093 if (note->namesz == 6
07d6d2b8
AM		 10094 && strcmp (note->namedata, "LINUX") == 0)
10095 return elfcore_grok_s390_ctrs (abfd, note);
d7eeb400 10096 else
07d6d2b8 10097 return TRUE;
d7eeb400
MS		 10098
10099 case NT_S390_PREFIX:
10100 if (note->namesz == 6
07d6d2b8
AM		 10101 && strcmp (note->namedata, "LINUX") == 0)
10102 return elfcore_grok_s390_prefix (abfd, note);
d7eeb400 10103 else
07d6d2b8 10104 return TRUE;
d7eeb400 10105
355b81d9
UW		 10106 case NT_S390_LAST_BREAK:
10107 if (note->namesz == 6
07d6d2b8
AM		 10108 && strcmp (note->namedata, "LINUX") == 0)
10109 return elfcore_grok_s390_last_break (abfd, note);
355b81d9 10110 else
07d6d2b8 10111 return TRUE;
355b81d9
UW		 10112
10113 case NT_S390_SYSTEM_CALL:
10114 if (note->namesz == 6
07d6d2b8
AM		 10115 && strcmp (note->namedata, "LINUX") == 0)
10116 return elfcore_grok_s390_system_call (abfd, note);
355b81d9 10117 else
07d6d2b8 10118 return TRUE;
355b81d9 10119
abb3f6cc
NC		 10120 case NT_S390_TDB:
10121 if (note->namesz == 6
07d6d2b8
AM		 10122 && strcmp (note->namedata, "LINUX") == 0)
10123 return elfcore_grok_s390_tdb (abfd, note);
abb3f6cc 10124 else
07d6d2b8 10125 return TRUE;
abb3f6cc 10126
4ef9f41a
AA		 10127 case NT_S390_VXRS_LOW:
10128 if (note->namesz == 6
10129 && strcmp (note->namedata, "LINUX") == 0)
10130 return elfcore_grok_s390_vxrs_low (abfd, note);
10131 else
10132 return TRUE;
10133
10134 case NT_S390_VXRS_HIGH:
10135 if (note->namesz == 6
10136 && strcmp (note->namedata, "LINUX") == 0)
10137 return elfcore_grok_s390_vxrs_high (abfd, note);
10138 else
10139 return TRUE;
10140
88ab90e8
AA		 10141 case NT_S390_GS_CB:
10142 if (note->namesz == 6
10143 && strcmp (note->namedata, "LINUX") == 0)
8fe09d74 10144 return elfcore_grok_s390_gs_cb (abfd, note);
88ab90e8
AA		 10145 else
10146 return TRUE;
10147
10148 case NT_S390_GS_BC:
10149 if (note->namesz == 6
10150 && strcmp (note->namedata, "LINUX") == 0)
8fe09d74 10151 return elfcore_grok_s390_gs_bc (abfd, note);
88ab90e8
AA		 10152 else
10153 return TRUE;
10154
faa9a424
UW		 10155 case NT_ARM_VFP:
10156 if (note->namesz == 6
10157 && strcmp (note->namedata, "LINUX") == 0)
10158 return elfcore_grok_arm_vfp (abfd, note);
10159 else
10160 return TRUE;
10161
652451f8
YZ		 10162 case NT_ARM_TLS:
10163 if (note->namesz == 6
10164 && strcmp (note->namedata, "LINUX") == 0)
10165 return elfcore_grok_aarch_tls (abfd, note);
10166 else
10167 return TRUE;
10168
10169 case NT_ARM_HW_BREAK:
10170 if (note->namesz == 6
10171 && strcmp (note->namedata, "LINUX") == 0)
10172 return elfcore_grok_aarch_hw_break (abfd, note);
10173 else
10174 return TRUE;
10175
10176 case NT_ARM_HW_WATCH:
10177 if (note->namesz == 6
10178 && strcmp (note->namedata, "LINUX") == 0)
10179 return elfcore_grok_aarch_hw_watch (abfd, note);
10180 else
10181 return TRUE;
10182
ad1cc4e4
AH		 10183 case NT_ARM_SVE:
10184 if (note->namesz == 6
10185 && strcmp (note->namedata, "LINUX") == 0)
10186 return elfcore_grok_aarch_sve (abfd, note);
10187 else
10188 return TRUE;
10189
e6c3b5bf
AH		 10190 case NT_ARM_PAC_MASK:
10191 if (note->namesz == 6
10192 && strcmp (note->namedata, "LINUX") == 0)
10193 return elfcore_grok_aarch_pauth (abfd, note);
10194 else
10195 return TRUE;
10196
252b5132
RH		 10197 case NT_PRPSINFO:
10198 case NT_PSINFO:
bb0082d6
AM		 10199 if (bed->elf_backend_grok_psinfo)
10200 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 10201 return TRUE;
bb0082d6 10202#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 10203 return elfcore_grok_psinfo (abfd, note);
bb0082d6 10204#else
b34976b6 10205 return TRUE;
252b5132 10206#endif
3333a7c3
RM		 10207
10208 case NT_AUXV:
58e07198 10209 return elfcore_make_auxv_note_section (abfd, note, 0);
9015683b 10210
451b7c33
TT		 10211 case NT_FILE:
10212 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
10213 note);
10214
9015683b
TT		 10215 case NT_SIGINFO:
10216 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
10217 note);
5b2c414d 10218
252b5132
RH		 10219 }
10220}
10221
718175fa
JK		 10222static bfd_boolean
10223elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
10224{
c74f7d1c 10225 struct bfd_build_id* build_id;
30e8ee25
AM		 10226
10227 if (note->descsz == 0)
10228 return FALSE;
10229
c74f7d1c
JT		 10230 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
10231 if (build_id == NULL)
718175fa
JK		 10232 return FALSE;
10233
c74f7d1c
JT		 10234 build_id->size = note->descsz;
10235 memcpy (build_id->data, note->descdata, note->descsz);
10236 abfd->build_id = build_id;
718175fa
JK		 10237
10238 return TRUE;
10239}
10240
10241static bfd_boolean
10242elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
10243{
10244 switch (note->type)
10245 {
10246 default:
10247 return TRUE;
10248
46bed679
L		 10249 case NT_GNU_PROPERTY_TYPE_0:
10250 return _bfd_elf_parse_gnu_properties (abfd, note);
10251
718175fa
JK		 10252 case NT_GNU_BUILD_ID:
10253 return elfobj_grok_gnu_build_id (abfd, note);
10254 }
10255}
10256
e21e5835
NC		 10257static bfd_boolean
10258elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
10259{
10260 struct sdt_note *cur =
7a6e0d89
AM		 10261 (struct sdt_note *) bfd_alloc (abfd,
10262 sizeof (struct sdt_note) + note->descsz);
e21e5835
NC		 10263
10264 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
10265 cur->size = (bfd_size_type) note->descsz;
10266 memcpy (cur->data, note->descdata, note->descsz);
10267
10268 elf_tdata (abfd)->sdt_note_head = cur;
10269
10270 return TRUE;
10271}
10272
10273static bfd_boolean
10274elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
10275{
10276 switch (note->type)
10277 {
10278 case NT_STAPSDT:
10279 return elfobj_grok_stapsdt_note_1 (abfd, note);
10280
10281 default:
10282 return TRUE;
10283 }
10284}
10285
aa1ed4a9
JB		 10286static bfd_boolean
10287elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
10288{
10289 size_t offset;
10290
b5430a3c 10291 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
aa1ed4a9 10292 {
b5430a3c 10293 case ELFCLASS32:
0064d223
JB		 10294 if (note->descsz < 108)
10295 return FALSE;
aa1ed4a9
JB		 10296 break;
10297
b5430a3c 10298 case ELFCLASS64:
0064d223
JB		 10299 if (note->descsz < 120)
10300 return FALSE;
aa1ed4a9
JB		 10301 break;
10302
10303 default:
10304 return FALSE;
10305 }
10306
0064d223
JB		 10307 /* Check for version 1 in pr_version. */
10308 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10309 return FALSE;
80a04378 10310
0064d223
JB		 10311 offset = 4;
10312
10313 /* Skip over pr_psinfosz. */
b5430a3c 10314 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
0064d223
JB		 10315 offset += 4;
10316 else
10317 {
10318 offset += 4; /* Padding before pr_psinfosz. */
10319 offset += 8;
10320 }
10321
aa1ed4a9
JB		 10322 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10323 elf_tdata (abfd)->core->program
10324 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
10325 offset += 17;
10326
10327 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10328 elf_tdata (abfd)->core->command
10329 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
0064d223
JB		 10330 offset += 81;
10331
10332 /* Padding before pr_pid. */
10333 offset += 2;
10334
10335 /* The pr_pid field was added in version "1a". */
10336 if (note->descsz < offset + 4)
10337 return TRUE;
10338
10339 elf_tdata (abfd)->core->pid
10340 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
aa1ed4a9
JB		 10341
10342 return TRUE;
10343}
10344
10345static bfd_boolean
10346elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10347{
10348 size_t offset;
10349 size_t size;
24d3e51b 10350 size_t min_size;
aa1ed4a9 10351
24d3e51b
NC		 10352 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10353 Also compute minimum size of this note. */
b5430a3c 10354 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
aa1ed4a9 10355 {
b5430a3c 10356 case ELFCLASS32:
24d3e51b
NC		 10357 offset = 4 + 4;
10358 min_size = offset + (4 * 2) + 4 + 4 + 4;
aa1ed4a9
JB		 10359 break;
10360
b5430a3c 10361 case ELFCLASS64:
24d3e51b
NC		 10362 offset = 4 + 4 + 8; /* Includes padding before pr_statussz. */
10363 min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
aa1ed4a9
JB		 10364 break;
10365
10366 default:
10367 return FALSE;
10368 }
10369
24d3e51b
NC		 10370 if (note->descsz < min_size)
10371 return FALSE;
10372
10373 /* Check for version 1 in pr_version. */
10374 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10375 return FALSE;
aa1ed4a9 10376
24d3e51b
NC		 10377 /* Extract size of pr_reg from pr_gregsetsz. */
10378 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
b5430a3c 10379 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
24d3e51b
NC		 10380 {
10381 size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10382 offset += 4 * 2;
10383 }
b5430a3c 10384 else
24d3e51b
NC		 10385 {
10386 size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10387 offset += 8 * 2;
10388 }
aa1ed4a9 10389
24d3e51b 10390 /* Skip over pr_osreldate. */
aa1ed4a9
JB		 10391 offset += 4;
10392
24d3e51b 10393 /* Read signal from pr_cursig. */
aa1ed4a9
JB		 10394 if (elf_tdata (abfd)->core->signal == 0)
10395 elf_tdata (abfd)->core->signal
10396 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10397 offset += 4;
10398
24d3e51b 10399 /* Read TID from pr_pid. */
aa1ed4a9
JB		 10400 elf_tdata (abfd)->core->lwpid
10401 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10402 offset += 4;
10403
24d3e51b 10404 /* Padding before pr_reg. */
b5430a3c 10405 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
aa1ed4a9
JB		 10406 offset += 4;
10407
24d3e51b
NC		 10408 /* Make sure that there is enough data remaining in the note. */
10409 if ((note->descsz - offset) < size)
10410 return FALSE;
10411
aa1ed4a9
JB		 10412 /* Make a ".reg/999" section and a ".reg" section. */
10413 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10414 size, note->descpos + offset);
10415}
10416
10417static bfd_boolean
10418elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10419{
544c67cd
JB		 10420 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10421
aa1ed4a9
JB		 10422 switch (note->type)
10423 {
10424 case NT_PRSTATUS:
544c67cd
JB		 10425 if (bed->elf_backend_grok_freebsd_prstatus)
10426 if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10427 return TRUE;
aa1ed4a9
JB		 10428 return elfcore_grok_freebsd_prstatus (abfd, note);
10429
10430 case NT_FPREGSET:
10431 return elfcore_grok_prfpreg (abfd, note);
10432
10433 case NT_PRPSINFO:
10434 return elfcore_grok_freebsd_psinfo (abfd, note);
10435
10436 case NT_FREEBSD_THRMISC:
10437 if (note->namesz == 8)
10438 return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10439 else
10440 return TRUE;
10441
ddb2bbcf
JB		 10442 case NT_FREEBSD_PROCSTAT_PROC:
10443 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10444 note);
10445
10446 case NT_FREEBSD_PROCSTAT_FILES:
10447 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10448 note);
10449
10450 case NT_FREEBSD_PROCSTAT_VMMAP:
10451 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10452 note);
10453
3350c5f5 10454 case NT_FREEBSD_PROCSTAT_AUXV:
58e07198 10455 return elfcore_make_auxv_note_section (abfd, note, 4);
3350c5f5 10456
aa1ed4a9
JB		 10457 case NT_X86_XSTATE:
10458 if (note->namesz == 8)
10459 return elfcore_grok_xstatereg (abfd, note);
10460 else
10461 return TRUE;
10462
e6f3b9c3
JB		 10463 case NT_FREEBSD_PTLWPINFO:
10464 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10465 note);
10466
6d5be5d6
JB		 10467 case NT_ARM_VFP:
10468 return elfcore_grok_arm_vfp (abfd, note);
10469
aa1ed4a9
JB		 10470 default:
10471 return TRUE;
10472 }
10473}
10474
b34976b6 10475static bfd_boolean
217aa764 10476elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM		 10477{
10478 char *cp;
10479
10480 cp = strchr (note->namedata, '@');
10481 if (cp != NULL)
10482 {
d2b64500 10483 *lwpidp = atoi(cp + 1);
b34976b6 10484 return TRUE;
50b2bdb7 10485 }
b34976b6 10486 return FALSE;
50b2bdb7
AM		 10487}
10488
b34976b6 10489static bfd_boolean
217aa764 10490elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7 10491{
80a04378
NC		 10492 if (note->descsz <= 0x7c + 31)
10493 return FALSE;
10494
50b2bdb7 10495 /* Signal number at offset 0x08. */
228e534f 10496 elf_tdata (abfd)->core->signal
50b2bdb7
AM		 10497 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10498
10499 /* Process ID at offset 0x50. */
228e534f 10500 elf_tdata (abfd)->core->pid
50b2bdb7
AM		 10501 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10502
10503 /* Command name at 0x7c (max 32 bytes, including nul). */
228e534f 10504 elf_tdata (abfd)->core->command
50b2bdb7
AM		 10505 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10506
7720ba9f
MK		 10507 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10508 note);
50b2bdb7
AM		 10509}
10510
b34976b6 10511static bfd_boolean
217aa764 10512elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 10513{
10514 int lwp;
10515
10516 if (elfcore_netbsd_get_lwpid (note, &lwp))
228e534f 10517 elf_tdata (abfd)->core->lwpid = lwp;
50b2bdb7 10518
58e07198 10519 switch (note->type)
50b2bdb7 10520 {
58e07198 10521 case NT_NETBSDCORE_PROCINFO:
50b2bdb7 10522 /* NetBSD-specific core "procinfo". Note that we expect to
08a40648
AM		 10523 find this note before any of the others, which is fine,
10524 since the kernel writes this note out first when it
10525 creates a core file. */
50b2bdb7 10526 return elfcore_grok_netbsd_procinfo (abfd, note);
58e07198
CZ		 10527#ifdef NT_NETBSDCORE_AUXV
10528 case NT_NETBSDCORE_AUXV:
10529 /* NetBSD-specific Elf Auxiliary Vector data. */
10530 return elfcore_make_auxv_note_section (abfd, note, 4);
10531#endif
10532 default:
10533 break;
50b2bdb7
AM		 10534 }
10535
58e07198 10536 /* As of March 2017 there are no other machine-independent notes
b4db1224
JT		 10537 defined for NetBSD core files. If the note type is less
10538 than the start of the machine-dependent note types, we don't
10539 understand it. */
47d9a591 10540
b4db1224 10541 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 10542 return TRUE;
50b2bdb7
AM		 10543
10544
10545 switch (bfd_get_arch (abfd))
10546 {
08a40648
AM		 10547 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10548 PT_GETFPREGS == mach+2. */
50b2bdb7
AM		 10549
10550 case bfd_arch_alpha:
10551 case bfd_arch_sparc:
10552 switch (note->type)
08a40648
AM		 10553 {
10554 case NT_NETBSDCORE_FIRSTMACH+0:
10555 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 10556
08a40648
AM		 10557 case NT_NETBSDCORE_FIRSTMACH+2:
10558 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 10559
08a40648
AM		 10560 default:
10561 return TRUE;
10562 }
50b2bdb7 10563
58e07198
CZ		 10564 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10565 There's also old PT___GETREGS40 == mach + 1 for old reg
10566 structure which lacks GBR. */
10567
10568 case bfd_arch_sh:
10569 switch (note->type)
10570 {
10571 case NT_NETBSDCORE_FIRSTMACH+3:
10572 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10573
10574 case NT_NETBSDCORE_FIRSTMACH+5:
10575 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10576
10577 default:
10578 return TRUE;
10579 }
10580
08a40648
AM		 10581 /* On all other arch's, PT_GETREGS == mach+1 and
10582 PT_GETFPREGS == mach+3. */
50b2bdb7
AM		 10583
10584 default:
10585 switch (note->type)
08a40648
AM		 10586 {
10587 case NT_NETBSDCORE_FIRSTMACH+1:
10588 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 10589
08a40648
AM		 10590 case NT_NETBSDCORE_FIRSTMACH+3:
10591 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 10592
08a40648
AM		 10593 default:
10594 return TRUE;
10595 }
50b2bdb7
AM		 10596 }
10597 /* NOTREACHED */
10598}
10599
67cc5033
MK		 10600static bfd_boolean
10601elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10602{
80a04378
NC		 10603 if (note->descsz <= 0x48 + 31)
10604 return FALSE;
10605
67cc5033 10606 /* Signal number at offset 0x08. */
228e534f 10607 elf_tdata (abfd)->core->signal
67cc5033
MK		 10608 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10609
10610 /* Process ID at offset 0x20. */
228e534f 10611 elf_tdata (abfd)->core->pid
67cc5033
MK		 10612 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10613
10614 /* Command name at 0x48 (max 32 bytes, including nul). */
228e534f 10615 elf_tdata (abfd)->core->command
67cc5033
MK		 10616 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10617
10618 return TRUE;
10619}
10620
10621static bfd_boolean
10622elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10623{
10624 if (note->type == NT_OPENBSD_PROCINFO)
10625 return elfcore_grok_openbsd_procinfo (abfd, note);
10626
10627 if (note->type == NT_OPENBSD_REGS)
10628 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10629
10630 if (note->type == NT_OPENBSD_FPREGS)
10631 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10632
10633 if (note->type == NT_OPENBSD_XFPREGS)
10634 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10635
10636 if (note->type == NT_OPENBSD_AUXV)
58e07198 10637 return elfcore_make_auxv_note_section (abfd, note, 0);
67cc5033
MK		 10638
10639 if (note->type == NT_OPENBSD_WCOOKIE)
10640 {
10641 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10642 SEC_HAS_CONTENTS);
10643
10644 if (sect == NULL)
10645 return FALSE;
10646 sect->size = note->descsz;
10647 sect->filepos = note->descpos;
10648 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10649
10650 return TRUE;
10651 }
10652
10653 return TRUE;
10654}
10655
07c6e936 10656static bfd_boolean
d3fd4074 10657elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC		 10658{
10659 void *ddata = note->descdata;
10660 char buf[100];
10661 char *name;
10662 asection *sect;
f8843e87
AM		 10663 short sig;
10664 unsigned flags;
07c6e936 10665
80a04378
NC		 10666 if (note->descsz < 16)
10667 return FALSE;
10668
07c6e936 10669 /* nto_procfs_status 'pid' field is at offset 0. */
228e534f 10670 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
07c6e936 10671
f8843e87
AM		 10672 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10673 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10674
10675 /* nto_procfs_status 'flags' field is at offset 8. */
10676 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC		 10677
10678 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM		 10679 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10680 {
228e534f
AM		 10681 elf_tdata (abfd)->core->signal = sig;
10682 elf_tdata (abfd)->core->lwpid = *tid;
f8843e87 10683 }
07c6e936 10684
f8843e87
AM		 10685 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10686 do not come from signals so we make sure we set the current
10687 thread just in case. */
10688 if (flags & 0x00000080)
228e534f 10689 elf_tdata (abfd)->core->lwpid = *tid;
07c6e936
NC		 10690
10691 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 10692 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 10693
a50b1753 10694 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 10695 if (name == NULL)
10696 return FALSE;
10697 strcpy (name, buf);
10698
117ed4f8 10699 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 10700 if (sect == NULL)
10701 return FALSE;
10702
07d6d2b8
AM		 10703 sect->size = note->descsz;
10704 sect->filepos = note->descpos;
07c6e936
NC		 10705 sect->alignment_power = 2;
10706
10707 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10708}
10709
10710static bfd_boolean
d69f560c
KW		 10711elfcore_grok_nto_regs (bfd *abfd,
10712 Elf_Internal_Note *note,
d3fd4074 10713 long tid,
d69f560c 10714 char *base)
07c6e936
NC		 10715{
10716 char buf[100];
10717 char *name;
10718 asection *sect;
10719
d69f560c 10720 /* Make a "(base)/%d" section. */
d3fd4074 10721 sprintf (buf, "%s/%ld", base, tid);
07c6e936 10722
a50b1753 10723 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 10724 if (name == NULL)
10725 return FALSE;
10726 strcpy (name, buf);
10727
117ed4f8 10728 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 10729 if (sect == NULL)
10730 return FALSE;
10731
07d6d2b8
AM		 10732 sect->size = note->descsz;
10733 sect->filepos = note->descpos;
07c6e936
NC		 10734 sect->alignment_power = 2;
10735
f8843e87 10736 /* This is the current thread. */
228e534f 10737 if (elf_tdata (abfd)->core->lwpid == tid)
d69f560c 10738 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM		 10739
10740 return TRUE;
07c6e936
NC		 10741}
10742
10743#define BFD_QNT_CORE_INFO 7
10744#define BFD_QNT_CORE_STATUS 8
10745#define BFD_QNT_CORE_GREG 9
10746#define BFD_QNT_CORE_FPREG 10
10747
10748static bfd_boolean
217aa764 10749elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC		 10750{
10751 /* Every GREG section has a STATUS section before it. Store the
811072d8 10752 tid from the previous call to pass down to the next gregs
07c6e936 10753 function. */
d3fd4074 10754 static long tid = 1;
07c6e936
NC		 10755
10756 switch (note->type)
10757 {
d69f560c
KW		 10758 case BFD_QNT_CORE_INFO:
10759 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10760 case BFD_QNT_CORE_STATUS:
10761 return elfcore_grok_nto_status (abfd, note, &tid);
10762 case BFD_QNT_CORE_GREG:
10763 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10764 case BFD_QNT_CORE_FPREG:
10765 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10766 default:
10767 return TRUE;
07c6e936
NC		 10768 }
10769}
10770
b15fa79e
AM		 10771static bfd_boolean
10772elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10773{
10774 char *name;
10775 asection *sect;
10776 size_t len;
10777
10778 /* Use note name as section name. */
10779 len = note->namesz;
a50b1753 10780 name = (char *) bfd_alloc (abfd, len);
b15fa79e
AM		 10781 if (name == NULL)
10782 return FALSE;
10783 memcpy (name, note->namedata, len);
10784 name[len - 1] = '\0';
10785
10786 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10787 if (sect == NULL)
10788 return FALSE;
10789
07d6d2b8
AM		 10790 sect->size = note->descsz;
10791 sect->filepos = note->descpos;
b15fa79e
AM		 10792 sect->alignment_power = 1;
10793
10794 return TRUE;
10795}
10796
7c76fa91
MS		 10797/* Function: elfcore_write_note
10798
47d9a591 10799 Inputs:
a39f3346 10800 buffer to hold note, and current size of buffer
7c76fa91
MS		 10801 name of note
10802 type of note
10803 data for note
10804 size of data for note
10805
a39f3346
AM		 10806 Writes note to end of buffer. ELF64 notes are written exactly as
10807 for ELF32, despite the current (as of 2006) ELF gabi specifying
10808 that they ought to have 8-byte namesz and descsz field, and have
10809 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10810
7c76fa91 10811 Return:
a39f3346 10812 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS		 10813
10814char *
a39f3346 10815elfcore_write_note (bfd *abfd,
217aa764 10816 char *buf,
a39f3346 10817 int *bufsiz,
217aa764 10818 const char *name,
a39f3346 10819 int type,
217aa764 10820 const void *input,
a39f3346 10821 int size)
7c76fa91
MS		 10822{
10823 Elf_External_Note *xnp;
d4c88bbb 10824 size_t namesz;
d4c88bbb 10825 size_t newspace;
a39f3346 10826 char *dest;
7c76fa91 10827
d4c88bbb 10828 namesz = 0;
d4c88bbb 10829 if (name != NULL)
a39f3346 10830 namesz = strlen (name) + 1;
d4c88bbb 10831
a39f3346 10832 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 10833
a50b1753 10834 buf = (char *) realloc (buf, *bufsiz + newspace);
14b1c01e
AM		 10835 if (buf == NULL)
10836 return buf;
a39f3346 10837 dest = buf + *bufsiz;
7c76fa91
MS		 10838 *bufsiz += newspace;
10839 xnp = (Elf_External_Note *) dest;
10840 H_PUT_32 (abfd, namesz, xnp->namesz);
10841 H_PUT_32 (abfd, size, xnp->descsz);
10842 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM		 10843 dest = xnp->name;
10844 if (name != NULL)
10845 {
10846 memcpy (dest, name, namesz);
10847 dest += namesz;
a39f3346 10848 while (namesz & 3)
d4c88bbb
AM		 10849 {
10850 *dest++ = '\0';
a39f3346 10851 ++namesz;
d4c88bbb
AM		 10852 }
10853 }
10854 memcpy (dest, input, size);
a39f3346
AM		 10855 dest += size;
10856 while (size & 3)
10857 {
10858 *dest++ = '\0';
10859 ++size;
10860 }
10861 return buf;
7c76fa91
MS		 10862}
10863
602f1657
AM		 10864/* gcc-8 warns (*) on all the strncpy calls in this function about
10865 possible string truncation. The "truncation" is not a bug. We
10866 have an external representation of structs with fields that are not
10867 necessarily NULL terminated and corresponding internal
10868 representation fields that are one larger so that they can always
10869 be NULL terminated.
10870 gcc versions between 4.2 and 4.6 do not allow pragma control of
10871 diagnostics inside functions, giving a hard error if you try to use
10872 the finer control available with later versions.
10873 gcc prior to 4.2 warns about diagnostic push and pop.
10874 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10875 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10876 (*) Depending on your system header files! */
d99b4b92 10877#if GCC_VERSION >= 8000
602f1657
AM		 10878# pragma GCC diagnostic push
10879# pragma GCC diagnostic ignored "-Wstringop-truncation"
d99b4b92 10880#endif
7c76fa91 10881char *
217aa764
AM		 10882elfcore_write_prpsinfo (bfd *abfd,
10883 char *buf,
10884 int *bufsiz,
10885 const char *fname,
10886 const char *psargs)
7c76fa91 10887{
183e98be
AM		 10888 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10889
10890 if (bed->elf_backend_write_core_note != NULL)
10891 {
10892 char *ret;
10893 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10894 NT_PRPSINFO, fname, psargs);
10895 if (ret != NULL)
10896 return ret;
10897 }
7c76fa91 10898
1f20dca5 10899#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
602f1657 10900# if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
183e98be
AM		 10901 if (bed->s->elfclass == ELFCLASS32)
10902 {
602f1657 10903# if defined (HAVE_PSINFO32_T)
183e98be
AM		 10904 psinfo32_t data;
10905 int note_type = NT_PSINFO;
602f1657 10906# else
183e98be
AM		 10907 prpsinfo32_t data;
10908 int note_type = NT_PRPSINFO;
602f1657 10909# endif
183e98be
AM		 10910
10911 memset (&data, 0, sizeof (data));
10912 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10913 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10914 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 10915 "CORE", note_type, &data, sizeof (data));
183e98be
AM		 10916 }
10917 else
602f1657 10918# endif
183e98be 10919 {
602f1657 10920# if defined (HAVE_PSINFO_T)
183e98be
AM		 10921 psinfo_t data;
10922 int note_type = NT_PSINFO;
602f1657 10923# else
183e98be
AM		 10924 prpsinfo_t data;
10925 int note_type = NT_PRPSINFO;
602f1657 10926# endif
7c76fa91 10927
183e98be
AM		 10928 memset (&data, 0, sizeof (data));
10929 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10930 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10931 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 10932 "CORE", note_type, &data, sizeof (data));
183e98be 10933 }
7c76fa91
MS		 10934#endif /* PSINFO_T or PRPSINFO_T */
10935
1f20dca5
UW		 10936 free (buf);
10937 return NULL;
10938}
d99b4b92 10939#if GCC_VERSION >= 8000
602f1657 10940# pragma GCC diagnostic pop
d99b4b92 10941#endif
1f20dca5 10942
70a38d42
SDJ		 10943char *
10944elfcore_write_linux_prpsinfo32
10945 (bfd *abfd, char *buf, int *bufsiz,
10946 const struct elf_internal_linux_prpsinfo *prpsinfo)
10947{
a2f63b2e
MR		 10948 if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10949 {
10950 struct elf_external_linux_prpsinfo32_ugid16 data;
10951
10952 swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10953 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10954 &data, sizeof (data));
10955 }
10956 else
10957 {
10958 struct elf_external_linux_prpsinfo32_ugid32 data;
70a38d42 10959
a2f63b2e
MR		 10960 swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10961 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10962 &data, sizeof (data));
10963 }
70a38d42
SDJ		 10964}
10965
10966char *
10967elfcore_write_linux_prpsinfo64
10968 (bfd *abfd, char *buf, int *bufsiz,
10969 const struct elf_internal_linux_prpsinfo *prpsinfo)
10970{
3c9a7b0d
MR		 10971 if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10972 {
10973 struct elf_external_linux_prpsinfo64_ugid16 data;
10974
10975 swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10976 return elfcore_write_note (abfd, buf, bufsiz,
10977 "CORE", NT_PRPSINFO, &data, sizeof (data));
10978 }
10979 else
10980 {
10981 struct elf_external_linux_prpsinfo64_ugid32 data;
70a38d42 10982
3c9a7b0d
MR		 10983 swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10984 return elfcore_write_note (abfd, buf, bufsiz,
10985 "CORE", NT_PRPSINFO, &data, sizeof (data));
10986 }
70a38d42
SDJ		 10987}
10988
7c76fa91 10989char *
217aa764
AM		 10990elfcore_write_prstatus (bfd *abfd,
10991 char *buf,
10992 int *bufsiz,
10993 long pid,
10994 int cursig,
10995 const void *gregs)
7c76fa91 10996{
183e98be 10997 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 10998
183e98be
AM		 10999 if (bed->elf_backend_write_core_note != NULL)
11000 {
11001 char *ret;
11002 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
11003 NT_PRSTATUS,
11004 pid, cursig, gregs);
11005 if (ret != NULL)
11006 return ret;
11007 }
11008
1f20dca5 11009#if defined (HAVE_PRSTATUS_T)
183e98be
AM		 11010#if defined (HAVE_PRSTATUS32_T)
11011 if (bed->s->elfclass == ELFCLASS32)
11012 {
11013 prstatus32_t prstat;
11014
11015 memset (&prstat, 0, sizeof (prstat));
11016 prstat.pr_pid = pid;
11017 prstat.pr_cursig = cursig;
11018 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 11019 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM		 11020 NT_PRSTATUS, &prstat, sizeof (prstat));
11021 }
11022 else
11023#endif
11024 {
11025 prstatus_t prstat;
11026
11027 memset (&prstat, 0, sizeof (prstat));
11028 prstat.pr_pid = pid;
11029 prstat.pr_cursig = cursig;
11030 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 11031 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM		 11032 NT_PRSTATUS, &prstat, sizeof (prstat));
11033 }
7c76fa91
MS		 11034#endif /* HAVE_PRSTATUS_T */
11035
1f20dca5
UW		 11036 free (buf);
11037 return NULL;
11038}
11039
51316059
MS		 11040#if defined (HAVE_LWPSTATUS_T)
11041char *
217aa764
AM		 11042elfcore_write_lwpstatus (bfd *abfd,
11043 char *buf,
11044 int *bufsiz,
11045 long pid,
11046 int cursig,
11047 const void *gregs)
51316059
MS		 11048{
11049 lwpstatus_t lwpstat;
183e98be 11050 const char *note_name = "CORE";
51316059
MS		 11051
11052 memset (&lwpstat, 0, sizeof (lwpstat));
11053 lwpstat.pr_lwpid = pid >> 16;
11054 lwpstat.pr_cursig = cursig;
11055#if defined (HAVE_LWPSTATUS_T_PR_REG)
d1e8523e 11056 memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
51316059
MS		 11057#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11058#if !defined(gregs)
11059 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
11060 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
11061#else
11062 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
11063 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
11064#endif
11065#endif
47d9a591 11066 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 11067 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
11068}
11069#endif /* HAVE_LWPSTATUS_T */
11070
7c76fa91
MS		 11071#if defined (HAVE_PSTATUS_T)
11072char *
217aa764
AM		 11073elfcore_write_pstatus (bfd *abfd,
11074 char *buf,
11075 int *bufsiz,
11076 long pid,
6c10990d
NC		 11077 int cursig ATTRIBUTE_UNUSED,
11078 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91 11079{
183e98be
AM		 11080 const char *note_name = "CORE";
11081#if defined (HAVE_PSTATUS32_T)
11082 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 11083
183e98be
AM		 11084 if (bed->s->elfclass == ELFCLASS32)
11085 {
11086 pstatus32_t pstat;
11087
11088 memset (&pstat, 0, sizeof (pstat));
11089 pstat.pr_pid = pid & 0xffff;
11090 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11091 NT_PSTATUS, &pstat, sizeof (pstat));
11092 return buf;
11093 }
11094 else
11095#endif
11096 {
11097 pstatus_t pstat;
11098
11099 memset (&pstat, 0, sizeof (pstat));
11100 pstat.pr_pid = pid & 0xffff;
11101 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11102 NT_PSTATUS, &pstat, sizeof (pstat));
11103 return buf;
11104 }
7c76fa91
MS		 11105}
11106#endif /* HAVE_PSTATUS_T */
11107
11108char *
217aa764
AM		 11109elfcore_write_prfpreg (bfd *abfd,
11110 char *buf,
11111 int *bufsiz,
11112 const void *fpregs,
11113 int size)
7c76fa91 11114{
183e98be 11115 const char *note_name = "CORE";
47d9a591 11116 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 11117 note_name, NT_FPREGSET, fpregs, size);
11118}
11119
11120char *
217aa764
AM		 11121elfcore_write_prxfpreg (bfd *abfd,
11122 char *buf,
11123 int *bufsiz,
11124 const void *xfpregs,
11125 int size)
7c76fa91
MS		 11126{
11127 char *note_name = "LINUX";
47d9a591 11128 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 11129 note_name, NT_PRXFPREG, xfpregs, size);
11130}
11131
4339cae0
L		 11132char *
11133elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
11134 const void *xfpregs, int size)
11135{
97de3545
JB		 11136 char *note_name;
11137 if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
11138 note_name = "FreeBSD";
11139 else
11140 note_name = "LINUX";
4339cae0
L		 11141 return elfcore_write_note (abfd, buf, bufsiz,
11142 note_name, NT_X86_XSTATE, xfpregs, size);
11143}
11144
97753bd5
AM		 11145char *
11146elfcore_write_ppc_vmx (bfd *abfd,
11147 char *buf,
11148 int *bufsiz,
11149 const void *ppc_vmx,
11150 int size)
11151{
11152 char *note_name = "LINUX";
11153 return elfcore_write_note (abfd, buf, bufsiz,
11154 note_name, NT_PPC_VMX, ppc_vmx, size);
11155}
11156
89eeb0bc
LM		 11157char *
11158elfcore_write_ppc_vsx (bfd *abfd,
07d6d2b8
AM		 11159 char *buf,
11160 int *bufsiz,
11161 const void *ppc_vsx,
11162 int size)
89eeb0bc
LM		 11163{
11164 char *note_name = "LINUX";
11165 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11166 note_name, NT_PPC_VSX, ppc_vsx, size);
89eeb0bc
LM		 11167}
11168
cb2366c1
EBM		 11169char *
11170elfcore_write_ppc_tar (bfd *abfd,
4b24dd1a
AM		 11171 char *buf,
11172 int *bufsiz,
11173 const void *ppc_tar,
11174 int size)
cb2366c1
EBM		 11175{
11176 char *note_name = "LINUX";
11177 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11178 note_name, NT_PPC_TAR, ppc_tar, size);
cb2366c1
EBM		 11179}
11180
11181char *
11182elfcore_write_ppc_ppr (bfd *abfd,
4b24dd1a
AM		 11183 char *buf,
11184 int *bufsiz,
11185 const void *ppc_ppr,
11186 int size)
cb2366c1
EBM		 11187{
11188 char *note_name = "LINUX";
11189 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11190 note_name, NT_PPC_PPR, ppc_ppr, size);
cb2366c1
EBM		 11191}
11192
11193char *
11194elfcore_write_ppc_dscr (bfd *abfd,
4b24dd1a
AM		 11195 char *buf,
11196 int *bufsiz,
11197 const void *ppc_dscr,
11198 int size)
cb2366c1
EBM		 11199{
11200 char *note_name = "LINUX";
11201 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11202 note_name, NT_PPC_DSCR, ppc_dscr, size);
cb2366c1
EBM		 11203}
11204
11205char *
11206elfcore_write_ppc_ebb (bfd *abfd,
4b24dd1a
AM		 11207 char *buf,
11208 int *bufsiz,
11209 const void *ppc_ebb,
11210 int size)
cb2366c1
EBM		 11211{
11212 char *note_name = "LINUX";
11213 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11214 note_name, NT_PPC_EBB, ppc_ebb, size);
cb2366c1
EBM		 11215}
11216
11217char *
11218elfcore_write_ppc_pmu (bfd *abfd,
4b24dd1a
AM		 11219 char *buf,
11220 int *bufsiz,
11221 const void *ppc_pmu,
11222 int size)
cb2366c1
EBM		 11223{
11224 char *note_name = "LINUX";
11225 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11226 note_name, NT_PPC_PMU, ppc_pmu, size);
cb2366c1
EBM		 11227}
11228
11229char *
11230elfcore_write_ppc_tm_cgpr (bfd *abfd,
4b24dd1a
AM		 11231 char *buf,
11232 int *bufsiz,
11233 const void *ppc_tm_cgpr,
11234 int size)
cb2366c1
EBM		 11235{
11236 char *note_name = "LINUX";
11237 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11238 note_name, NT_PPC_TM_CGPR, ppc_tm_cgpr, size);
cb2366c1
EBM		 11239}
11240
11241char *
11242elfcore_write_ppc_tm_cfpr (bfd *abfd,
4b24dd1a
AM		 11243 char *buf,
11244 int *bufsiz,
11245 const void *ppc_tm_cfpr,
11246 int size)
cb2366c1
EBM		 11247{
11248 char *note_name = "LINUX";
11249 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11250 note_name, NT_PPC_TM_CFPR, ppc_tm_cfpr, size);
cb2366c1
EBM		 11251}
11252
11253char *
11254elfcore_write_ppc_tm_cvmx (bfd *abfd,
4b24dd1a
AM		 11255 char *buf,
11256 int *bufsiz,
11257 const void *ppc_tm_cvmx,
11258 int size)
cb2366c1
EBM		 11259{
11260 char *note_name = "LINUX";
11261 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11262 note_name, NT_PPC_TM_CVMX, ppc_tm_cvmx, size);
cb2366c1
EBM		 11263}
11264
11265char *
11266elfcore_write_ppc_tm_cvsx (bfd *abfd,
4b24dd1a
AM		 11267 char *buf,
11268 int *bufsiz,
11269 const void *ppc_tm_cvsx,
11270 int size)
cb2366c1
EBM		 11271{
11272 char *note_name = "LINUX";
11273 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11274 note_name, NT_PPC_TM_CVSX, ppc_tm_cvsx, size);
cb2366c1
EBM		 11275}
11276
11277char *
11278elfcore_write_ppc_tm_spr (bfd *abfd,
4b24dd1a
AM		 11279 char *buf,
11280 int *bufsiz,
11281 const void *ppc_tm_spr,
11282 int size)
cb2366c1
EBM		 11283{
11284 char *note_name = "LINUX";
11285 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11286 note_name, NT_PPC_TM_SPR, ppc_tm_spr, size);
cb2366c1
EBM		 11287}
11288
11289char *
11290elfcore_write_ppc_tm_ctar (bfd *abfd,
4b24dd1a
AM		 11291 char *buf,
11292 int *bufsiz,
11293 const void *ppc_tm_ctar,
11294 int size)
cb2366c1
EBM		 11295{
11296 char *note_name = "LINUX";
11297 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11298 note_name, NT_PPC_TM_CTAR, ppc_tm_ctar, size);
cb2366c1
EBM		 11299}
11300
11301char *
11302elfcore_write_ppc_tm_cppr (bfd *abfd,
4b24dd1a
AM		 11303 char *buf,
11304 int *bufsiz,
11305 const void *ppc_tm_cppr,
11306 int size)
cb2366c1
EBM		 11307{
11308 char *note_name = "LINUX";
11309 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11310 note_name, NT_PPC_TM_CPPR, ppc_tm_cppr, size);
cb2366c1
EBM		 11311}
11312
11313char *
11314elfcore_write_ppc_tm_cdscr (bfd *abfd,
4b24dd1a
AM		 11315 char *buf,
11316 int *bufsiz,
11317 const void *ppc_tm_cdscr,
11318 int size)
cb2366c1
EBM		 11319{
11320 char *note_name = "LINUX";
11321 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11322 note_name, NT_PPC_TM_CDSCR, ppc_tm_cdscr, size);
cb2366c1
EBM		 11323}
11324
0675e188
UW		 11325static char *
11326elfcore_write_s390_high_gprs (bfd *abfd,
11327 char *buf,
11328 int *bufsiz,
11329 const void *s390_high_gprs,
11330 int size)
11331{
11332 char *note_name = "LINUX";
11333 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11334 note_name, NT_S390_HIGH_GPRS,
0675e188
UW		 11335 s390_high_gprs, size);
11336}
11337
d7eeb400
MS		 11338char *
11339elfcore_write_s390_timer (bfd *abfd,
07d6d2b8
AM		 11340 char *buf,
11341 int *bufsiz,
11342 const void *s390_timer,
11343 int size)
d7eeb400
MS		 11344{
11345 char *note_name = "LINUX";
11346 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11347 note_name, NT_S390_TIMER, s390_timer, size);
d7eeb400
MS		 11348}
11349
11350char *
11351elfcore_write_s390_todcmp (bfd *abfd,
07d6d2b8
AM		 11352 char *buf,
11353 int *bufsiz,
11354 const void *s390_todcmp,
11355 int size)
d7eeb400
MS		 11356{
11357 char *note_name = "LINUX";
11358 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11359 note_name, NT_S390_TODCMP, s390_todcmp, size);
d7eeb400
MS		 11360}
11361
11362char *
11363elfcore_write_s390_todpreg (bfd *abfd,
07d6d2b8
AM		 11364 char *buf,
11365 int *bufsiz,
11366 const void *s390_todpreg,
11367 int size)
d7eeb400
MS		 11368{
11369 char *note_name = "LINUX";
11370 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11371 note_name, NT_S390_TODPREG, s390_todpreg, size);
d7eeb400
MS		 11372}
11373
11374char *
11375elfcore_write_s390_ctrs (bfd *abfd,
07d6d2b8
AM		 11376 char *buf,
11377 int *bufsiz,
11378 const void *s390_ctrs,
11379 int size)
d7eeb400
MS		 11380{
11381 char *note_name = "LINUX";
11382 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11383 note_name, NT_S390_CTRS, s390_ctrs, size);
d7eeb400
MS		 11384}
11385
11386char *
11387elfcore_write_s390_prefix (bfd *abfd,
07d6d2b8
AM		 11388 char *buf,
11389 int *bufsiz,
11390 const void *s390_prefix,
11391 int size)
d7eeb400
MS		 11392{
11393 char *note_name = "LINUX";
11394 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11395 note_name, NT_S390_PREFIX, s390_prefix, size);
d7eeb400
MS		 11396}
11397
355b81d9
UW		 11398char *
11399elfcore_write_s390_last_break (bfd *abfd,
11400 char *buf,
11401 int *bufsiz,
11402 const void *s390_last_break,
11403 int size)
11404{
11405 char *note_name = "LINUX";
11406 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11407 note_name, NT_S390_LAST_BREAK,
355b81d9
UW		 11408 s390_last_break, size);
11409}
11410
11411char *
11412elfcore_write_s390_system_call (bfd *abfd,
11413 char *buf,
11414 int *bufsiz,
11415 const void *s390_system_call,
11416 int size)
11417{
11418 char *note_name = "LINUX";
11419 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11420 note_name, NT_S390_SYSTEM_CALL,
355b81d9
UW		 11421 s390_system_call, size);
11422}
11423
abb3f6cc
NC		 11424char *
11425elfcore_write_s390_tdb (bfd *abfd,
11426 char *buf,
11427 int *bufsiz,
11428 const void *s390_tdb,
11429 int size)
11430{
11431 char *note_name = "LINUX";
11432 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11433 note_name, NT_S390_TDB, s390_tdb, size);
abb3f6cc
NC		 11434}
11435
4ef9f41a
AA		 11436char *
11437elfcore_write_s390_vxrs_low (bfd *abfd,
11438 char *buf,
11439 int *bufsiz,
11440 const void *s390_vxrs_low,
11441 int size)
11442{
11443 char *note_name = "LINUX";
11444 return elfcore_write_note (abfd, buf, bufsiz,
11445 note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
11446}
11447
11448char *
11449elfcore_write_s390_vxrs_high (bfd *abfd,
11450 char *buf,
11451 int *bufsiz,
11452 const void *s390_vxrs_high,
11453 int size)
11454{
11455 char *note_name = "LINUX";
11456 return elfcore_write_note (abfd, buf, bufsiz,
11457 note_name, NT_S390_VXRS_HIGH,
11458 s390_vxrs_high, size);
11459}
11460
88ab90e8
AA		 11461char *
11462elfcore_write_s390_gs_cb (bfd *abfd,
11463 char *buf,
11464 int *bufsiz,
11465 const void *s390_gs_cb,
11466 int size)
11467{
11468 char *note_name = "LINUX";
11469 return elfcore_write_note (abfd, buf, bufsiz,
11470 note_name, NT_S390_GS_CB,
11471 s390_gs_cb, size);
11472}
11473
11474char *
11475elfcore_write_s390_gs_bc (bfd *abfd,
11476 char *buf,
11477 int *bufsiz,
11478 const void *s390_gs_bc,
11479 int size)
11480{
11481 char *note_name = "LINUX";
11482 return elfcore_write_note (abfd, buf, bufsiz,
11483 note_name, NT_S390_GS_BC,
11484 s390_gs_bc, size);
11485}
11486
faa9a424
UW		 11487char *
11488elfcore_write_arm_vfp (bfd *abfd,
11489 char *buf,
11490 int *bufsiz,
11491 const void *arm_vfp,
11492 int size)
11493{
11494 char *note_name = "LINUX";
11495 return elfcore_write_note (abfd, buf, bufsiz,
11496 note_name, NT_ARM_VFP, arm_vfp, size);
11497}
11498
652451f8
YZ		 11499char *
11500elfcore_write_aarch_tls (bfd *abfd,
11501 char *buf,
11502 int *bufsiz,
11503 const void *aarch_tls,
11504 int size)
11505{
11506 char *note_name = "LINUX";
11507 return elfcore_write_note (abfd, buf, bufsiz,
11508 note_name, NT_ARM_TLS, aarch_tls, size);
11509}
11510
11511char *
11512elfcore_write_aarch_hw_break (bfd *abfd,
11513 char *buf,
11514 int *bufsiz,
11515 const void *aarch_hw_break,
11516 int size)
11517{
11518 char *note_name = "LINUX";
11519 return elfcore_write_note (abfd, buf, bufsiz,
11520 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11521}
11522
11523char *
11524elfcore_write_aarch_hw_watch (bfd *abfd,
11525 char *buf,
11526 int *bufsiz,
11527 const void *aarch_hw_watch,
11528 int size)
11529{
11530 char *note_name = "LINUX";
11531 return elfcore_write_note (abfd, buf, bufsiz,
11532 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11533}
11534
ad1cc4e4
AH		 11535char *
11536elfcore_write_aarch_sve (bfd *abfd,
11537 char *buf,
11538 int *bufsiz,
11539 const void *aarch_sve,
11540 int size)
11541{
11542 char *note_name = "LINUX";
11543 return elfcore_write_note (abfd, buf, bufsiz,
11544 note_name, NT_ARM_SVE, aarch_sve, size);
11545}
11546
e6c3b5bf
AH		 11547char *
11548elfcore_write_aarch_pauth (bfd *abfd,
11549 char *buf,
11550 int *bufsiz,
11551 const void *aarch_pauth,
11552 int size)
11553{
11554 char *note_name = "LINUX";
11555 return elfcore_write_note (abfd, buf, bufsiz,
11556 note_name, NT_ARM_PAC_MASK, aarch_pauth, size);
11557}
11558
bb864ac1
CES		 11559char *
11560elfcore_write_register_note (bfd *abfd,
11561 char *buf,
11562 int *bufsiz,
11563 const char *section,
11564 const void *data,
11565 int size)
11566{
11567 if (strcmp (section, ".reg2") == 0)
11568 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11569 if (strcmp (section, ".reg-xfp") == 0)
11570 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
4339cae0
L		 11571 if (strcmp (section, ".reg-xstate") == 0)
11572 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
bb864ac1
CES		 11573 if (strcmp (section, ".reg-ppc-vmx") == 0)
11574 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
89eeb0bc
LM		 11575 if (strcmp (section, ".reg-ppc-vsx") == 0)
11576 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
cb2366c1
EBM		 11577 if (strcmp (section, ".reg-ppc-tar") == 0)
11578 return elfcore_write_ppc_tar (abfd, buf, bufsiz, data, size);
11579 if (strcmp (section, ".reg-ppc-ppr") == 0)
11580 return elfcore_write_ppc_ppr (abfd, buf, bufsiz, data, size);
11581 if (strcmp (section, ".reg-ppc-dscr") == 0)
11582 return elfcore_write_ppc_dscr (abfd, buf, bufsiz, data, size);
11583 if (strcmp (section, ".reg-ppc-ebb") == 0)
11584 return elfcore_write_ppc_ebb (abfd, buf, bufsiz, data, size);
11585 if (strcmp (section, ".reg-ppc-pmu") == 0)
11586 return elfcore_write_ppc_pmu (abfd, buf, bufsiz, data, size);
11587 if (strcmp (section, ".reg-ppc-tm-cgpr") == 0)
11588 return elfcore_write_ppc_tm_cgpr (abfd, buf, bufsiz, data, size);
11589 if (strcmp (section, ".reg-ppc-tm-cfpr") == 0)
11590 return elfcore_write_ppc_tm_cfpr (abfd, buf, bufsiz, data, size);
11591 if (strcmp (section, ".reg-ppc-tm-cvmx") == 0)
11592 return elfcore_write_ppc_tm_cvmx (abfd, buf, bufsiz, data, size);
11593 if (strcmp (section, ".reg-ppc-tm-cvsx") == 0)
11594 return elfcore_write_ppc_tm_cvsx (abfd, buf, bufsiz, data, size);
11595 if (strcmp (section, ".reg-ppc-tm-spr") == 0)
11596 return elfcore_write_ppc_tm_spr (abfd, buf, bufsiz, data, size);
11597 if (strcmp (section, ".reg-ppc-tm-ctar") == 0)
11598 return elfcore_write_ppc_tm_ctar (abfd, buf, bufsiz, data, size);
11599 if (strcmp (section, ".reg-ppc-tm-cppr") == 0)
11600 return elfcore_write_ppc_tm_cppr (abfd, buf, bufsiz, data, size);
11601 if (strcmp (section, ".reg-ppc-tm-cdscr") == 0)
11602 return elfcore_write_ppc_tm_cdscr (abfd, buf, bufsiz, data, size);
0675e188
UW		 11603 if (strcmp (section, ".reg-s390-high-gprs") == 0)
11604 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
d7eeb400
MS		 11605 if (strcmp (section, ".reg-s390-timer") == 0)
11606 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11607 if (strcmp (section, ".reg-s390-todcmp") == 0)
11608 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11609 if (strcmp (section, ".reg-s390-todpreg") == 0)
11610 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11611 if (strcmp (section, ".reg-s390-ctrs") == 0)
11612 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11613 if (strcmp (section, ".reg-s390-prefix") == 0)
11614 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
355b81d9
UW		 11615 if (strcmp (section, ".reg-s390-last-break") == 0)
11616 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11617 if (strcmp (section, ".reg-s390-system-call") == 0)
11618 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
abb3f6cc
NC		 11619 if (strcmp (section, ".reg-s390-tdb") == 0)
11620 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
4ef9f41a
AA		 11621 if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11622 return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11623 if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11624 return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
88ab90e8
AA		 11625 if (strcmp (section, ".reg-s390-gs-cb") == 0)
11626 return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11627 if (strcmp (section, ".reg-s390-gs-bc") == 0)
11628 return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
faa9a424
UW		 11629 if (strcmp (section, ".reg-arm-vfp") == 0)
11630 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
652451f8
YZ		 11631 if (strcmp (section, ".reg-aarch-tls") == 0)
11632 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11633 if (strcmp (section, ".reg-aarch-hw-break") == 0)
11634 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11635 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11636 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
ad1cc4e4
AH		 11637 if (strcmp (section, ".reg-aarch-sve") == 0)
11638 return elfcore_write_aarch_sve (abfd, buf, bufsiz, data, size);
e6c3b5bf
AH		 11639 if (strcmp (section, ".reg-aarch-pauth") == 0)
11640 return elfcore_write_aarch_pauth (abfd, buf, bufsiz, data, size);
bb864ac1
CES		 11641 return NULL;
11642}
11643
b34976b6 11644static bfd_boolean
276da9b3
L		 11645elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11646 size_t align)
252b5132 11647{
c044fabd 11648 char *p;
252b5132 11649
276da9b3
L		 11650 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11651 gABI specifies that PT_NOTE alignment should be aligned to 4
11652 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11653 align is less than 4, we use 4 byte alignment. */
11654 if (align < 4)
11655 align = 4;
ef135d43
NC		 11656 if (align != 4 && align != 8)
11657 return FALSE;
276da9b3 11658
252b5132
RH		 11659 p = buf;
11660 while (p < buf + size)
11661 {
c044fabd 11662 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH		 11663 Elf_Internal_Note in;
11664
baea7ef1
AM		 11665 if (offsetof (Elf_External_Note, name) > buf - p + size)
11666 return FALSE;
11667
dc810e39 11668 in.type = H_GET_32 (abfd, xnp->type);
252b5132 11669
dc810e39 11670 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132 11671 in.namedata = xnp->name;
baea7ef1
AM		 11672 if (in.namesz > buf - in.namedata + size)
11673 return FALSE;
252b5132 11674
dc810e39 11675 in.descsz = H_GET_32 (abfd, xnp->descsz);
276da9b3 11676 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
252b5132 11677 in.descpos = offset + (in.descdata - buf);
baea7ef1
AM		 11678 if (in.descsz != 0
11679 && (in.descdata >= buf + size
11680 || in.descsz > buf - in.descdata + size))
11681 return FALSE;
252b5132 11682
718175fa 11683 switch (bfd_get_format (abfd))
07d6d2b8 11684 {
718175fa
JK		 11685 default:
11686 return TRUE;
11687
11688 case bfd_core:
f64e188b 11689 {
8acbedd6 11690#define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
f64e188b 11691 struct
718175fa 11692 {
f64e188b 11693 const char * string;
8acbedd6 11694 size_t len;
f64e188b 11695 bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
718175fa 11696 }
f64e188b 11697 grokers[] =
b15fa79e 11698 {
8acbedd6 11699 GROKER_ELEMENT ("", elfcore_grok_note),
aa1ed4a9 11700 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
8acbedd6
KS		 11701 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11702 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11703 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11704 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
f64e188b 11705 };
8acbedd6 11706#undef GROKER_ELEMENT
f64e188b
NC		 11707 int i;
11708
11709 for (i = ARRAY_SIZE (grokers); i--;)
8acbedd6
KS		 11710 {
11711 if (in.namesz >= grokers[i].len
11712 && strncmp (in.namedata, grokers[i].string,
11713 grokers[i].len) == 0)
11714 {
11715 if (! grokers[i].func (abfd, & in))
11716 return FALSE;
11717 break;
11718 }
11719 }
f64e188b
NC		 11720 break;
11721 }
718175fa
JK		 11722
11723 case bfd_object:
11724 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11725 {
11726 if (! elfobj_grok_gnu_note (abfd, &in))
11727 return FALSE;
11728 }
e21e5835
NC		 11729 else if (in.namesz == sizeof "stapsdt"
11730 && strcmp (in.namedata, "stapsdt") == 0)
11731 {
11732 if (! elfobj_grok_stapsdt_note (abfd, &in))
11733 return FALSE;
11734 }
718175fa 11735 break;
08a40648 11736 }
252b5132 11737
276da9b3 11738 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
252b5132
RH		 11739 }
11740
718175fa
JK		 11741 return TRUE;
11742}
11743
11744static bfd_boolean
276da9b3
L		 11745elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11746 size_t align)
718175fa
JK		 11747{
11748 char *buf;
11749
957e1fc1 11750 if (size == 0 || (size + 1) == 0)
718175fa
JK		 11751 return TRUE;
11752
11753 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11754 return FALSE;
11755
f64e188b 11756 buf = (char *) bfd_malloc (size + 1);
718175fa
JK		 11757 if (buf == NULL)
11758 return FALSE;
11759
f64e188b
NC		 11760 /* PR 17512: file: ec08f814
11761 0-termintate the buffer so that string searches will not overflow. */
11762 buf[size] = 0;
11763
718175fa 11764 if (bfd_bread (buf, size, abfd) != size
276da9b3 11765 || !elf_parse_notes (abfd, buf, size, offset, align))
718175fa
JK		 11766 {
11767 free (buf);
11768 return FALSE;
11769 }
11770
252b5132 11771 free (buf);
b34976b6 11772 return TRUE;
252b5132 11773}
98d8431c
JB		 11774\f
11775/* Providing external access to the ELF program header table. */
11776
11777/* Return an upper bound on the number of bytes required to store a
11778 copy of ABFD's program header table entries. Return -1 if an error
11779 occurs; bfd_get_error will return an appropriate code. */
c044fabd 11780
98d8431c 11781long
217aa764 11782bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB		 11783{
11784 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11785 {
11786 bfd_set_error (bfd_error_wrong_format);
11787 return -1;
11788 }
11789
936e320b 11790 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB		 11791}
11792
98d8431c
JB		 11793/* Copy ABFD's program header table entries to *PHDRS. The entries
11794 will be stored as an array of Elf_Internal_Phdr structures, as
11795 defined in include/elf/internal.h. To find out how large the
11796 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11797
11798 Return the number of program header table entries read, or -1 if an
11799 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 11800
98d8431c 11801int
217aa764 11802bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB		 11803{
11804 int num_phdrs;
11805
11806 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11807 {
11808 bfd_set_error (bfd_error_wrong_format);
11809 return -1;
11810 }
11811
11812 num_phdrs = elf_elfheader (abfd)->e_phnum;
01bcaf63
TT		 11813 if (num_phdrs != 0)
11814 memcpy (phdrs, elf_tdata (abfd)->phdr,
11815 num_phdrs * sizeof (Elf_Internal_Phdr));
98d8431c
JB		 11816
11817 return num_phdrs;
11818}
ae4221d7 11819
db6751f2 11820enum elf_reloc_type_class
7e612e98
AM		 11821_bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11822 const asection *rel_sec ATTRIBUTE_UNUSED,
11823 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ		 11824{
11825 return reloc_class_normal;
11826}
f8df10f4 11827
47d9a591 11828/* For RELA architectures, return the relocation value for a
f8df10f4
JJ		 11829 relocation against a local symbol. */
11830
11831bfd_vma
217aa764
AM		 11832_bfd_elf_rela_local_sym (bfd *abfd,
11833 Elf_Internal_Sym *sym,
8517fae7 11834 asection **psec,
217aa764 11835 Elf_Internal_Rela *rel)
f8df10f4 11836{
8517fae7 11837 asection *sec = *psec;
f8df10f4
JJ		 11838 bfd_vma relocation;
11839
6835821b
AM		 11840 relocation = (sec->output_section->vma
11841 + sec->output_offset
11842 + sym->st_value);
f8df10f4 11843 if ((sec->flags & SEC_MERGE)
c629eae0 11844 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 11845 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
f8df10f4 11846 {
f8df10f4 11847 rel->r_addend =
8517fae7 11848 _bfd_merged_section_offset (abfd, psec,
65765700 11849 elf_section_data (sec)->sec_info,
753731ee
AM		 11850 sym->st_value + rel->r_addend);
11851 if (sec != *psec)
11852 {
11853 /* If we have changed the section, and our original section is
11854 marked with SEC_EXCLUDE, it means that the original
11855 SEC_MERGE section has been completely subsumed in some
11856 other SEC_MERGE section. In this case, we need to leave
11857 some info around for --emit-relocs. */
11858 if ((sec->flags & SEC_EXCLUDE) != 0)
11859 sec->kept_section = *psec;
11860 sec = *psec;
11861 }
8517fae7
AM		 11862 rel->r_addend -= relocation;
11863 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ		 11864 }
11865 return relocation;
11866}
c629eae0
JJ		 11867
11868bfd_vma
217aa764
AM		 11869_bfd_elf_rel_local_sym (bfd *abfd,
11870 Elf_Internal_Sym *sym,
11871 asection **psec,
11872 bfd_vma addend)
47d9a591 11873{
c629eae0
JJ		 11874 asection *sec = *psec;
11875
6835821b 11876 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
c629eae0
JJ		 11877 return sym->st_value + addend;
11878
11879 return _bfd_merged_section_offset (abfd, psec,
65765700 11880 elf_section_data (sec)->sec_info,
753731ee 11881 sym->st_value + addend);
c629eae0
JJ		 11882}
11883
37b01f6a
DG		 11884/* Adjust an address within a section. Given OFFSET within SEC, return
11885 the new offset within the section, based upon changes made to the
11886 section. Returns -1 if the offset is now invalid.
11887 The offset (in abnd out) is in target sized bytes, however big a
11888 byte may be. */
11889
c629eae0 11890bfd_vma
217aa764 11891_bfd_elf_section_offset (bfd *abfd,
92e4ec35 11892 struct bfd_link_info *info,
217aa764
AM		 11893 asection *sec,
11894 bfd_vma offset)
c629eae0 11895{
68bfbfcc 11896 switch (sec->sec_info_type)
65765700 11897 {
dbaa2011 11898 case SEC_INFO_TYPE_STABS:
eea6121a
AM		 11899 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11900 offset);
dbaa2011 11901 case SEC_INFO_TYPE_EH_FRAME:
92e4ec35 11902 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
37b01f6a 11903
65765700 11904 default:
310fd250
L		 11905 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11906 {
37b01f6a 11907 /* Reverse the offset. */
310fd250
L		 11908 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11909 bfd_size_type address_size = bed->s->arch_size / 8;
37b01f6a
DG		 11910
11911 /* address_size and sec->size are in octets. Convert
11912 to bytes before subtracting the original offset. */
11913 offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
310fd250 11914 }
65765700
JJ		 11915 return offset;
11916 }
c629eae0 11917}
3333a7c3
RM		 11918\f
11919/* Create a new BFD as if by bfd_openr. Rather than opening a file,
11920 reconstruct an ELF file by reading the segments out of remote memory
11921 based on the ELF file header at EHDR_VMA and the ELF program headers it
11922 points to. If not null, *LOADBASEP is filled in with the difference
11923 between the VMAs from which the segments were read, and the VMAs the
11924 file headers (and hence BFD's idea of each section's VMA) put them at.
11925
11926 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11927 remote memory at target address VMA into the local buffer at MYADDR; it
11928 should return zero on success or an `errno' code on failure. TEMPL must
11929 be a BFD for an ELF target with the word size and byte order found in
11930 the remote memory. */
11931
11932bfd *
217aa764
AM		 11933bfd_elf_bfd_from_remote_memory
11934 (bfd *templ,
11935 bfd_vma ehdr_vma,
f0a5d95a 11936 bfd_size_type size,
217aa764 11937 bfd_vma *loadbasep,
fe78531d 11938 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
3333a7c3
RM		 11939{
11940 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
5979d6b6 11941 (templ, ehdr_vma, size, loadbasep, target_read_memory);
3333a7c3 11942}
4c45e5c9
JJ		 11943\f
11944long
c9727e01
AM		 11945_bfd_elf_get_synthetic_symtab (bfd *abfd,
11946 long symcount ATTRIBUTE_UNUSED,
11947 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 11948 long dynsymcount,
c9727e01
AM		 11949 asymbol **dynsyms,
11950 asymbol **ret)
4c45e5c9
JJ		 11951{
11952 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11953 asection *relplt;
11954 asymbol *s;
11955 const char *relplt_name;
11956 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11957 arelent *p;
11958 long count, i, n;
11959 size_t size;
11960 Elf_Internal_Shdr *hdr;
11961 char *names;
11962 asection *plt;
11963
8615f3f2
AM		 11964 *ret = NULL;
11965
90e3cdf2
JJ		 11966 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11967 return 0;
11968
8615f3f2
AM		 11969 if (dynsymcount <= 0)
11970 return 0;
11971
4c45e5c9
JJ		 11972 if (!bed->plt_sym_val)
11973 return 0;
11974
11975 relplt_name = bed->relplt_name;
11976 if (relplt_name == NULL)
d35fd659 11977 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
4c45e5c9
JJ		 11978 relplt = bfd_get_section_by_name (abfd, relplt_name);
11979 if (relplt == NULL)
11980 return 0;
11981
11982 hdr = &elf_section_data (relplt)->this_hdr;
11983 if (hdr->sh_link != elf_dynsymtab (abfd)
11984 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11985 return 0;
11986
11987 plt = bfd_get_section_by_name (abfd, ".plt");
11988 if (plt == NULL)
11989 return 0;
11990
11991 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 11992 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ		 11993 return -1;
11994
eea6121a 11995 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ		 11996 size = count * sizeof (asymbol);
11997 p = relplt->relocation;
cb53bf42 11998 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
041de40d
AM		 11999 {
12000 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
12001 if (p->addend != 0)
12002 {
12003#ifdef BFD64
12004 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
12005#else
12006 size += sizeof ("+0x") - 1 + 8;
12007#endif
12008 }
12009 }
4c45e5c9 12010
a50b1753 12011 s = *ret = (asymbol *) bfd_malloc (size);
4c45e5c9
JJ		 12012 if (s == NULL)
12013 return -1;
12014
12015 names = (char *) (s + count);
12016 p = relplt->relocation;
12017 n = 0;
cb53bf42 12018 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ		 12019 {
12020 size_t len;
12021 bfd_vma addr;
12022
12023 addr = bed->plt_sym_val (i, plt, p);
12024 if (addr == (bfd_vma) -1)
12025 continue;
12026
12027 *s = **p->sym_ptr_ptr;
65a7a66f
AM		 12028 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12029 we are defining a symbol, ensure one of them is set. */
12030 if ((s->flags & BSF_LOCAL) == 0)
12031 s->flags |= BSF_GLOBAL;
6ba2a415 12032 s->flags |= BSF_SYNTHETIC;
4c45e5c9
JJ		 12033 s->section = plt;
12034 s->value = addr - plt->vma;
12035 s->name = names;
8f39ba8e 12036 s->udata.p = NULL;
4c45e5c9
JJ		 12037 len = strlen ((*p->sym_ptr_ptr)->name);
12038 memcpy (names, (*p->sym_ptr_ptr)->name, len);
12039 names += len;
041de40d
AM		 12040 if (p->addend != 0)
12041 {
1d770845 12042 char buf[30], *a;
d324f6d6 12043
041de40d
AM		 12044 memcpy (names, "+0x", sizeof ("+0x") - 1);
12045 names += sizeof ("+0x") - 1;
1d770845
L		 12046 bfd_sprintf_vma (abfd, buf, p->addend);
12047 for (a = buf; *a == '0'; ++a)
12048 ;
12049 len = strlen (a);
12050 memcpy (names, a, len);
12051 names += len;
041de40d 12052 }
4c45e5c9
JJ		 12053 memcpy (names, "@plt", sizeof ("@plt"));
12054 names += sizeof ("@plt");
8f39ba8e 12055 ++s, ++n;
4c45e5c9
JJ		 12056 }
12057
12058 return n;
12059}
3d7f7666 12060
821e6ff6
AM		 12061/* It is only used by x86-64 so far.
12062 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
7eacd66b
AM		 12063 but current usage would allow all of _bfd_std_section to be zero. */
12064static const asymbol lcomm_sym
12065 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
3b22753a 12066asection _bfd_elf_large_com_section
7eacd66b 12067 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
821e6ff6 12068 "LARGE_COMMON", 0, SEC_IS_COMMON);
ecca9871 12069
d1036acb 12070void
78245035
L		 12071_bfd_elf_post_process_headers (bfd * abfd,
12072 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
d1036acb
L		 12073{
12074 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
12075
12076 i_ehdrp = elf_elfheader (abfd);
12077
12078 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
d8045f23
NC		 12079
12080 /* To make things simpler for the loader on Linux systems we set the
9c55345c 12081 osabi field to ELFOSABI_GNU if the binary contains symbols of
f64b2e8d 12082 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
d8045f23 12083 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
f64b2e8d 12084 && elf_tdata (abfd)->has_gnu_symbols)
9c55345c 12085 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
d1036acb 12086}
fcb93ecf
PB		 12087
12088
12089/* Return TRUE for ELF symbol types that represent functions.
12090 This is the default version of this function, which is sufficient for
d8045f23 12091 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
fcb93ecf
PB		 12092
12093bfd_boolean
12094_bfd_elf_is_function_type (unsigned int type)
12095{
d8045f23
NC		 12096 return (type == STT_FUNC
12097 || type == STT_GNU_IFUNC);
fcb93ecf 12098}
9f296da3 12099
aef36ac1
AM		 12100/* If the ELF symbol SYM might be a function in SEC, return the
12101 function size and set *CODE_OFF to the function's entry point,
12102 otherwise return zero. */
9f296da3 12103
aef36ac1
AM		 12104bfd_size_type
12105_bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
12106 bfd_vma *code_off)
9f296da3 12107{
aef36ac1
AM		 12108 bfd_size_type size;
12109
ff9e0f5b 12110 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
aef36ac1
AM		 12111 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
12112 || sym->section != sec)
12113 return 0;
ff9e0f5b 12114
ff9e0f5b 12115 *code_off = sym->value;
aef36ac1
AM		 12116 size = 0;
12117 if (!(sym->flags & BSF_SYNTHETIC))
12118 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
12119 if (size == 0)
12120 size = 1;
12121 return size;
9f296da3 12122}
GDB Binutils - Deliverables
This page took 2.233588 seconds and 4 git commands to generate.