gdb: Make use of gdb::option framework for some info commands
[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
1faa385f
NC
5813/* Determine if a bfd is a debuginfo file. Unfortunately there
5814 is no defined method for detecting such files, so we have to
5815 use heuristics instead. */
5816
5817bfd_boolean
5818is_debuginfo_file (bfd *abfd)
5819{
5820 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_elf_flavour)
5821 return FALSE;
5822
5823 Elf_Internal_Shdr **start_headers = elf_elfsections (abfd);
5824 Elf_Internal_Shdr **end_headers = start_headers + elf_numsections (abfd);
5825 Elf_Internal_Shdr **headerp;
5826
5827 for (headerp = start_headers; headerp < end_headers; headerp ++)
5828 {
5829 Elf_Internal_Shdr *header = * headerp;
5830
5831 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
5832 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
5833 if ((header->sh_flags & SHF_ALLOC) == SHF_ALLOC
5834 && header->sh_type != SHT_NOBITS
5835 && header->sh_type != SHT_NOTE)
5836 return FALSE;
5837 }
5838
5839 return TRUE;
5840}
5841
f3520d2f
AM
5842/* Assign file positions for the other sections. */
5843
5844static bfd_boolean
5845assign_file_positions_for_non_load_sections (bfd *abfd,
5846 struct bfd_link_info *link_info)
5847{
5848 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5849 Elf_Internal_Shdr **i_shdrpp;
e06efbf1 5850 Elf_Internal_Shdr **hdrpp, **end_hdrpp;
f3520d2f
AM
5851 Elf_Internal_Phdr *phdrs;
5852 Elf_Internal_Phdr *p;
5853 struct elf_segment_map *m;
62655c7b 5854 struct elf_segment_map *hdrs_segment;
f3520d2f
AM
5855 bfd_vma filehdr_vaddr, filehdr_paddr;
5856 bfd_vma phdrs_vaddr, phdrs_paddr;
5857 file_ptr off;
f3520d2f
AM
5858 unsigned int count;
5859
5c182d5f 5860 i_shdrpp = elf_elfsections (abfd);
e06efbf1 5861 end_hdrpp = i_shdrpp + elf_numsections (abfd);
12bd6957 5862 off = elf_next_file_pos (abfd);
e06efbf1 5863 for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5c182d5f 5864 {
5c182d5f
AM
5865 Elf_Internal_Shdr *hdr;
5866
5867 hdr = *hdrpp;
5868 if (hdr->bfd_section != NULL
252e386e
AM
5869 && (hdr->bfd_section->filepos != 0
5870 || (hdr->sh_type == SHT_NOBITS
5871 && hdr->contents == NULL)))
627b32bc 5872 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5c182d5f
AM
5873 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5874 {
1faa385f
NC
5875 if (hdr->sh_size != 0
5876 /* PR 24717 - debuginfo files are known to be not strictly
5877 compliant with the ELF standard. In particular they often
5878 have .note.gnu.property sections that are outside of any
5879 loadable segment. This is not a problem for such files,
5880 so do not warn about them. */
5881 && ! is_debuginfo_file (abfd))
4eca0228 5882 _bfd_error_handler
695344c0 5883 /* xgettext:c-format */
871b3ab2 5884 (_("%pB: warning: allocated section `%s' not in segment"),
e8d2ba53
AM
5885 abfd,
5886 (hdr->bfd_section == NULL
5887 ? "*unknown*"
5888 : hdr->bfd_section->name));
3ba71138
L
5889 /* We don't need to page align empty sections. */
5890 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5c182d5f
AM
5891 off += vma_page_aligned_bias (hdr->sh_addr, off,
5892 bed->maxpagesize);
5893 else
5894 off += vma_page_aligned_bias (hdr->sh_addr, off,
5895 hdr->sh_addralign);
5896 off = _bfd_elf_assign_file_position_for_section (hdr, off,
5897 FALSE);
5898 }
5899 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5900 && hdr->bfd_section == NULL)
0ce398f1
L
5901 || (hdr->bfd_section != NULL
5902 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5903 /* Compress DWARF debug sections. */
12bd6957 5904 || hdr == i_shdrpp[elf_onesymtab (abfd)]
6a40cf0c
NC
5905 || (elf_symtab_shndx_list (abfd) != NULL
5906 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
3e19fb8f
L
5907 || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5908 || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5c182d5f
AM
5909 hdr->sh_offset = -1;
5910 else
5911 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5c182d5f
AM
5912 }
5913
252b5132
RH
5914 /* Now that we have set the section file positions, we can set up
5915 the file positions for the non PT_LOAD segments. */
f3520d2f
AM
5916 count = 0;
5917 filehdr_vaddr = 0;
5918 filehdr_paddr = 0;
5919 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5920 phdrs_paddr = 0;
62655c7b 5921 hdrs_segment = NULL;
f3520d2f 5922 phdrs = elf_tdata (abfd)->phdr;
12bd6957 5923 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
f3520d2f
AM
5924 {
5925 ++count;
5926 if (p->p_type != PT_LOAD)
5927 continue;
5928
5929 if (m->includes_filehdr)
5930 {
5931 filehdr_vaddr = p->p_vaddr;
5932 filehdr_paddr = p->p_paddr;
5933 }
5934 if (m->includes_phdrs)
5935 {
5936 phdrs_vaddr = p->p_vaddr;
5937 phdrs_paddr = p->p_paddr;
5938 if (m->includes_filehdr)
5939 {
62655c7b 5940 hdrs_segment = m;
f3520d2f
AM
5941 phdrs_vaddr += bed->s->sizeof_ehdr;
5942 phdrs_paddr += bed->s->sizeof_ehdr;
5943 }
5944 }
5945 }
5946
62655c7b
RM
5947 if (hdrs_segment != NULL && link_info != NULL)
5948 {
5949 /* There is a segment that contains both the file headers and the
5950 program headers, so provide a symbol __ehdr_start pointing there.
5951 A program can use this to examine itself robustly. */
5952
5953 struct elf_link_hash_entry *hash
5954 = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5955 FALSE, FALSE, TRUE);
5956 /* If the symbol was referenced and not defined, define it. */
5957 if (hash != NULL
5958 && (hash->root.type == bfd_link_hash_new
5959 || hash->root.type == bfd_link_hash_undefined
5960 || hash->root.type == bfd_link_hash_undefweak
5961 || hash->root.type == bfd_link_hash_common))
5962 {
5963 asection *s = NULL;
5964 if (hdrs_segment->count != 0)
5965 /* The segment contains sections, so use the first one. */
5966 s = hdrs_segment->sections[0];
5967 else
5968 /* Use the first (i.e. lowest-addressed) section in any segment. */
12bd6957 5969 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62655c7b
RM
5970 if (m->count != 0)
5971 {
5972 s = m->sections[0];
5973 break;
5974 }
5975
5976 if (s != NULL)
5977 {
5978 hash->root.u.def.value = filehdr_vaddr - s->vma;
5979 hash->root.u.def.section = s;
5980 }
5981 else
5982 {
5983 hash->root.u.def.value = filehdr_vaddr;
5984 hash->root.u.def.section = bfd_abs_section_ptr;
5985 }
5986
5987 hash->root.type = bfd_link_hash_defined;
5988 hash->def_regular = 1;
5989 hash->non_elf = 0;
5990 }
5991 }
5992
12bd6957 5993 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
252b5132 5994 {
129af99f 5995 if (p->p_type == PT_GNU_RELRO)
252b5132 5996 {
f2731e0c 5997 bfd_vma start, end;
01f7e10c 5998 bfd_boolean ok;
1ea63fd2 5999
129af99f 6000 if (link_info != NULL)
8c37241b 6001 {
129af99f 6002 /* During linking the range of the RELRO segment is passed
f2731e0c
AM
6003 in link_info. Note that there may be padding between
6004 relro_start and the first RELRO section. */
6005 start = link_info->relro_start;
6006 end = link_info->relro_end;
6007 }
6008 else if (m->count != 0)
6009 {
6010 if (!m->p_size_valid)
6011 abort ();
6012 start = m->sections[0]->vma;
6013 end = start + m->p_size;
6014 }
6015 else
6016 {
6017 start = 0;
6018 end = 0;
6019 }
6020
01f7e10c 6021 ok = FALSE;
f2731e0c
AM
6022 if (start < end)
6023 {
6024 struct elf_segment_map *lm;
6025 const Elf_Internal_Phdr *lp;
6026 unsigned int i;
6027
6028 /* Find a LOAD segment containing a section in the RELRO
6029 segment. */
12bd6957 6030 for (lm = elf_seg_map (abfd), lp = phdrs;
3146fac4
AM
6031 lm != NULL;
6032 lm = lm->next, lp++)
8c37241b
JJ
6033 {
6034 if (lp->p_type == PT_LOAD
3146fac4 6035 && lm->count != 0
dbc88fc1
AM
6036 && (lm->sections[lm->count - 1]->vma
6037 + (!IS_TBSS (lm->sections[lm->count - 1])
6038 ? lm->sections[lm->count - 1]->size
6039 : 0)) > start
f2731e0c 6040 && lm->sections[0]->vma < end)
8c37241b
JJ
6041 break;
6042 }
f2731e0c 6043
01f7e10c 6044 if (lm != NULL)
129af99f 6045 {
01f7e10c
AM
6046 /* Find the section starting the RELRO segment. */
6047 for (i = 0; i < lm->count; i++)
6048 {
6049 asection *s = lm->sections[i];
6050 if (s->vma >= start
6051 && s->vma < end
6052 && s->size != 0)
6053 break;
6054 }
6055
6056 if (i < lm->count)
6057 {
6058 p->p_vaddr = lm->sections[i]->vma;
6059 p->p_paddr = lm->sections[i]->lma;
6060 p->p_offset = lm->sections[i]->filepos;
6061 p->p_memsz = end - p->p_vaddr;
6062 p->p_filesz = p->p_memsz;
6063
6064 /* The RELRO segment typically ends a few bytes
6065 into .got.plt but other layouts are possible.
6066 In cases where the end does not match any
6067 loaded section (for instance is in file
6068 padding), trim p_filesz back to correspond to
6069 the end of loaded section contents. */
6070 if (p->p_filesz > lp->p_vaddr + lp->p_filesz - p->p_vaddr)
6071 p->p_filesz = lp->p_vaddr + lp->p_filesz - p->p_vaddr;
6072
6073 /* Preserve the alignment and flags if they are
6074 valid. The gold linker generates RW/4 for
6075 the PT_GNU_RELRO section. It is better for
6076 objcopy/strip to honor these attributes
6077 otherwise gdb will choke when using separate
6078 debug files. */
6079 if (!m->p_align_valid)
6080 p->p_align = 1;
6081 if (!m->p_flags_valid)
6082 p->p_flags = PF_R;
6083 ok = TRUE;
6084 }
129af99f 6085 }
b84a33b5 6086 }
01f7e10c
AM
6087 if (link_info != NULL)
6088 BFD_ASSERT (ok);
6089 if (!ok)
6090 memset (p, 0, sizeof *p);
129af99f 6091 }
04c3a755
NS
6092 else if (p->p_type == PT_GNU_STACK)
6093 {
6094 if (m->p_size_valid)
6095 p->p_memsz = m->p_size;
6096 }
129af99f
AS
6097 else if (m->count != 0)
6098 {
e06efbf1 6099 unsigned int i;
1a9ccd70 6100
129af99f
AS
6101 if (p->p_type != PT_LOAD
6102 && (p->p_type != PT_NOTE
6103 || bfd_get_format (abfd) != bfd_core))
6104 {
1a9ccd70
NC
6105 /* A user specified segment layout may include a PHDR
6106 segment that overlaps with a LOAD segment... */
6107 if (p->p_type == PT_PHDR)
6108 {
6109 m->count = 0;
6110 continue;
6111 }
6112
c86934ce
NC
6113 if (m->includes_filehdr || m->includes_phdrs)
6114 {
b1fa9dd6 6115 /* PR 17512: file: 2195325e. */
4eca0228 6116 _bfd_error_handler
871b3ab2 6117 (_("%pB: error: non-load segment %d includes file header "
76cfced5
AM
6118 "and/or program header"),
6119 abfd, (int) (p - phdrs));
c86934ce
NC
6120 return FALSE;
6121 }
129af99f 6122
86b2281f 6123 p->p_filesz = 0;
129af99f 6124 p->p_offset = m->sections[0]->filepos;
86b2281f
AM
6125 for (i = m->count; i-- != 0;)
6126 {
6127 asection *sect = m->sections[i];
6128 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
6129 if (hdr->sh_type != SHT_NOBITS)
6130 {
6131 p->p_filesz = (sect->filepos - m->sections[0]->filepos
6132 + hdr->sh_size);
6133 break;
6134 }
6135 }
129af99f
AS
6136 }
6137 }
6138 else if (m->includes_filehdr)
6139 {
6140 p->p_vaddr = filehdr_vaddr;
6141 if (! m->p_paddr_valid)
6142 p->p_paddr = filehdr_paddr;
6143 }
6144 else if (m->includes_phdrs)
6145 {
6146 p->p_vaddr = phdrs_vaddr;
6147 if (! m->p_paddr_valid)
6148 p->p_paddr = phdrs_paddr;
252b5132
RH
6149 }
6150 }
6151
12bd6957 6152 elf_next_file_pos (abfd) = off;
252b5132 6153
b34976b6 6154 return TRUE;
252b5132
RH
6155}
6156
6a40cf0c
NC
6157static elf_section_list *
6158find_section_in_list (unsigned int i, elf_section_list * list)
6159{
6160 for (;list != NULL; list = list->next)
6161 if (list->ndx == i)
6162 break;
6163 return list;
6164}
6165
252b5132
RH
6166/* Work out the file positions of all the sections. This is called by
6167 _bfd_elf_compute_section_file_positions. All the section sizes and
6168 VMAs must be known before this is called.
6169
e0638f70
AM
6170 Reloc sections come in two flavours: Those processed specially as
6171 "side-channel" data attached to a section to which they apply, and
6172 those that bfd doesn't process as relocations. The latter sort are
6173 stored in a normal bfd section by bfd_section_from_shdr. We don't
6174 consider the former sort here, unless they form part of the loadable
6175 image. Reloc sections not assigned here will be handled later by
6176 assign_file_positions_for_relocs.
252b5132
RH
6177
6178 We also don't set the positions of the .symtab and .strtab here. */
6179
b34976b6 6180static bfd_boolean
c84fca4d
AO
6181assign_file_positions_except_relocs (bfd *abfd,
6182 struct bfd_link_info *link_info)
252b5132 6183{
5c182d5f
AM
6184 struct elf_obj_tdata *tdata = elf_tdata (abfd);
6185 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
9c5bfbb7 6186 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH
6187
6188 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
6189 && bfd_get_format (abfd) != bfd_core)
6190 {
5c182d5f
AM
6191 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
6192 unsigned int num_sec = elf_numsections (abfd);
252b5132
RH
6193 Elf_Internal_Shdr **hdrpp;
6194 unsigned int i;
a485e98e 6195 file_ptr off;
252b5132
RH
6196
6197 /* Start after the ELF header. */
6198 off = i_ehdrp->e_ehsize;
6199
6200 /* We are not creating an executable, which means that we are
6201 not creating a program header, and that the actual order of
6202 the sections in the file is unimportant. */
9ad5cbcf 6203 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH
6204 {
6205 Elf_Internal_Shdr *hdr;
6206
6207 hdr = *hdrpp;
e0638f70
AM
6208 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
6209 && hdr->bfd_section == NULL)
0ce398f1
L
6210 || (hdr->bfd_section != NULL
6211 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
6212 /* Compress DWARF debug sections. */
12bd6957 6213 || i == elf_onesymtab (abfd)
6a40cf0c
NC
6214 || (elf_symtab_shndx_list (abfd) != NULL
6215 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
3e19fb8f
L
6216 || i == elf_strtab_sec (abfd)
6217 || i == elf_shstrtab_sec (abfd))
252b5132
RH
6218 {
6219 hdr->sh_offset = -1;
252b5132 6220 }
9ad5cbcf 6221 else
b34976b6 6222 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 6223 }
a485e98e
AM
6224
6225 elf_next_file_pos (abfd) = off;
252b5132
RH
6226 }
6227 else
6228 {
f3520d2f
AM
6229 unsigned int alloc;
6230
252b5132 6231 /* Assign file positions for the loaded sections based on the
08a40648 6232 assignment of sections to segments. */
f3520d2f
AM
6233 if (!assign_file_positions_for_load_sections (abfd, link_info))
6234 return FALSE;
6235
6236 /* And for non-load sections. */
6237 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
6238 return FALSE;
6239
e36284ab
AM
6240 if (bed->elf_backend_modify_program_headers != NULL)
6241 {
6242 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
6243 return FALSE;
6244 }
6245
58e7ebac 6246 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
0e1862bb 6247 if (link_info != NULL && bfd_link_pie (link_info))
58e7ebac
L
6248 {
6249 unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
6250 Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
6251 Elf_Internal_Phdr *end_segment = &segment[num_segments];
6252
6253 /* Find the lowest p_vaddr in PT_LOAD segments. */
6254 bfd_vma p_vaddr = (bfd_vma) -1;
6255 for (; segment < end_segment; segment++)
6256 if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
6257 p_vaddr = segment->p_vaddr;
6258
6259 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6260 segments is non-zero. */
6261 if (p_vaddr)
6262 i_ehdrp->e_type = ET_EXEC;
6263 }
6264
f3520d2f 6265 /* Write out the program headers. */
6838f2be 6266 alloc = elf_elfheader (abfd)->e_phnum;
1a9ccd70
NC
6267 if (alloc == 0)
6268 return TRUE;
6269
1a9ccd70
NC
6270 /* PR ld/20815 - Check that the program header segment, if present, will
6271 be loaded into memory. FIXME: The check below is not sufficient as
6272 really all PT_LOAD segments should be checked before issuing an error
6273 message. Plus the PHDR segment does not have to be the first segment
6274 in the program header table. But this version of the check should
cd584857
NC
6275 catch all real world use cases.
6276
6277 FIXME: We used to have code here to sort the PT_LOAD segments into
6278 ascending order, as per the ELF spec. But this breaks some programs,
6279 including the Linux kernel. But really either the spec should be
07d6d2b8 6280 changed or the programs updated. */
1a9ccd70 6281 if (alloc > 1
cd584857 6282 && tdata->phdr[0].p_type == PT_PHDR
d00dd7dc
AM
6283 && (bed->elf_backend_allow_non_load_phdr == NULL
6284 || !bed->elf_backend_allow_non_load_phdr (abfd, tdata->phdr,
6285 alloc))
cd584857
NC
6286 && tdata->phdr[1].p_type == PT_LOAD
6287 && (tdata->phdr[1].p_vaddr > tdata->phdr[0].p_vaddr
6838f2be
AM
6288 || (tdata->phdr[1].p_vaddr + tdata->phdr[1].p_memsz
6289 < tdata->phdr[0].p_vaddr + tdata->phdr[0].p_memsz)))
1a9ccd70
NC
6290 {
6291 /* The fix for this error is usually to edit the linker script being
6292 used and set up the program headers manually. Either that or
6293 leave room for the headers at the start of the SECTIONS. */
6838f2be
AM
6294 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6295 " by LOAD segment"),
1a9ccd70 6296 abfd);
1a9ccd70
NC
6297 return FALSE;
6298 }
6299
f3520d2f 6300 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
cd584857
NC
6301 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
6302 return FALSE;
252b5132
RH
6303 }
6304
b34976b6 6305 return TRUE;
252b5132
RH
6306}
6307
b34976b6 6308static bfd_boolean
217aa764 6309prep_headers (bfd *abfd)
252b5132 6310{
3d540e93 6311 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
2b0f7ef9 6312 struct elf_strtab_hash *shstrtab;
9c5bfbb7 6313 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH
6314
6315 i_ehdrp = elf_elfheader (abfd);
252b5132 6316
2b0f7ef9 6317 shstrtab = _bfd_elf_strtab_init ();
252b5132 6318 if (shstrtab == NULL)
b34976b6 6319 return FALSE;
252b5132
RH
6320
6321 elf_shstrtab (abfd) = shstrtab;
6322
6323 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
6324 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
6325 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
6326 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
6327
6328 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
6329 i_ehdrp->e_ident[EI_DATA] =
6330 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
6331 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
6332
252b5132
RH
6333 if ((abfd->flags & DYNAMIC) != 0)
6334 i_ehdrp->e_type = ET_DYN;
6335 else if ((abfd->flags & EXEC_P) != 0)
6336 i_ehdrp->e_type = ET_EXEC;
6337 else if (bfd_get_format (abfd) == bfd_core)
6338 i_ehdrp->e_type = ET_CORE;
6339 else
6340 i_ehdrp->e_type = ET_REL;
6341
6342 switch (bfd_get_arch (abfd))
6343 {
6344 case bfd_arch_unknown:
6345 i_ehdrp->e_machine = EM_NONE;
6346 break;
aa4f99bb
AO
6347
6348 /* There used to be a long list of cases here, each one setting
6349 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6350 in the corresponding bfd definition. To avoid duplication,
6351 the switch was removed. Machines that need special handling
6352 can generally do it in elf_backend_final_write_processing(),
6353 unless they need the information earlier than the final write.
6354 Such need can generally be supplied by replacing the tests for
6355 e_machine with the conditions used to determine it. */
252b5132 6356 default:
9c5bfbb7
AM
6357 i_ehdrp->e_machine = bed->elf_machine_code;
6358 }
aa4f99bb 6359
252b5132
RH
6360 i_ehdrp->e_version = bed->s->ev_current;
6361 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
6362
c044fabd 6363 /* No program header, for now. */
252b5132
RH
6364 i_ehdrp->e_phoff = 0;
6365 i_ehdrp->e_phentsize = 0;
6366 i_ehdrp->e_phnum = 0;
6367
c044fabd 6368 /* Each bfd section is section header entry. */
252b5132
RH
6369 i_ehdrp->e_entry = bfd_get_start_address (abfd);
6370 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
6371
c044fabd 6372 /* If we're building an executable, we'll need a program header table. */
252b5132 6373 if (abfd->flags & EXEC_P)
0e71e495
BE
6374 /* It all happens later. */
6375 ;
252b5132
RH
6376 else
6377 {
6378 i_ehdrp->e_phentsize = 0;
252b5132
RH
6379 i_ehdrp->e_phoff = 0;
6380 }
6381
6382 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 6383 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 6384 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 6385 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 6386 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 6387 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132 6388 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
17ca87fc 6389 || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
252b5132 6390 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 6391 return FALSE;
252b5132 6392
b34976b6 6393 return TRUE;
252b5132
RH
6394}
6395
6396/* Assign file positions for all the reloc sections which are not part
a485e98e 6397 of the loadable file image, and the file position of section headers. */
252b5132 6398
0ce398f1
L
6399static bfd_boolean
6400_bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
252b5132
RH
6401{
6402 file_ptr off;
e06efbf1 6403 Elf_Internal_Shdr **shdrpp, **end_shdrpp;
3e19fb8f 6404 Elf_Internal_Shdr *shdrp;
a485e98e
AM
6405 Elf_Internal_Ehdr *i_ehdrp;
6406 const struct elf_backend_data *bed;
252b5132 6407
12bd6957 6408 off = elf_next_file_pos (abfd);
252b5132 6409
e06efbf1
L
6410 shdrpp = elf_elfsections (abfd);
6411 end_shdrpp = shdrpp + elf_numsections (abfd);
6412 for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
252b5132 6413 {
252b5132 6414 shdrp = *shdrpp;
0ce398f1
L
6415 if (shdrp->sh_offset == -1)
6416 {
3e19fb8f 6417 asection *sec = shdrp->bfd_section;
0ce398f1
L
6418 bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
6419 || shdrp->sh_type == SHT_RELA);
6420 if (is_rel
3e19fb8f 6421 || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
0ce398f1
L
6422 {
6423 if (!is_rel)
6424 {
3e19fb8f
L
6425 const char *name = sec->name;
6426 struct bfd_elf_section_data *d;
6427
0ce398f1 6428 /* Compress DWARF debug sections. */
3e19fb8f 6429 if (!bfd_compress_section (abfd, sec,
0ce398f1
L
6430 shdrp->contents))
6431 return FALSE;
3e19fb8f
L
6432
6433 if (sec->compress_status == COMPRESS_SECTION_DONE
6434 && (abfd->flags & BFD_COMPRESS_GABI) == 0)
6435 {
6436 /* If section is compressed with zlib-gnu, convert
6437 section name from .debug_* to .zdebug_*. */
6438 char *new_name
6439 = convert_debug_to_zdebug (abfd, name);
6440 if (new_name == NULL)
6441 return FALSE;
6442 name = new_name;
6443 }
dd905818 6444 /* Add section name to section name section. */
3e19fb8f
L
6445 if (shdrp->sh_name != (unsigned int) -1)
6446 abort ();
6447 shdrp->sh_name
6448 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
6449 name, FALSE);
6450 d = elf_section_data (sec);
6451
dd905818 6452 /* Add reloc section name to section name section. */
3e19fb8f
L
6453 if (d->rel.hdr
6454 && !_bfd_elf_set_reloc_sh_name (abfd,
6455 d->rel.hdr,
6456 name, FALSE))
6457 return FALSE;
6458 if (d->rela.hdr
6459 && !_bfd_elf_set_reloc_sh_name (abfd,
6460 d->rela.hdr,
91cb26da 6461 name, TRUE))
3e19fb8f
L
6462 return FALSE;
6463
0ce398f1 6464 /* Update section size and contents. */
3e19fb8f
L
6465 shdrp->sh_size = sec->size;
6466 shdrp->contents = sec->contents;
0ce398f1
L
6467 shdrp->bfd_section->contents = NULL;
6468 }
6469 off = _bfd_elf_assign_file_position_for_section (shdrp,
6470 off,
6471 TRUE);
6472 }
6473 }
252b5132
RH
6474 }
6475
3e19fb8f
L
6476 /* Place section name section after DWARF debug sections have been
6477 compressed. */
6478 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6479 shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6480 shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6481 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6482
6483 /* Place the section headers. */
a485e98e
AM
6484 i_ehdrp = elf_elfheader (abfd);
6485 bed = get_elf_backend_data (abfd);
6486 off = align_file_position (off, 1 << bed->s->log_file_align);
6487 i_ehdrp->e_shoff = off;
6488 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
12bd6957 6489 elf_next_file_pos (abfd) = off;
0ce398f1
L
6490
6491 return TRUE;
252b5132
RH
6492}
6493
b34976b6 6494bfd_boolean
217aa764 6495_bfd_elf_write_object_contents (bfd *abfd)
252b5132 6496{
9c5bfbb7 6497 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 6498 Elf_Internal_Shdr **i_shdrp;
b34976b6 6499 bfd_boolean failed;
9ad5cbcf 6500 unsigned int count, num_sec;
30e8ee25 6501 struct elf_obj_tdata *t;
252b5132
RH
6502
6503 if (! abfd->output_has_begun
217aa764 6504 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 6505 return FALSE;
db727370
JL
6506 /* Do not rewrite ELF data when the BFD has been opened for update.
6507 abfd->output_has_begun was set to TRUE on opening, so creation of new
6508 sections, and modification of existing section sizes was restricted.
6509 This means the ELF header, program headers and section headers can't have
6510 changed.
6511 If the contents of any sections has been modified, then those changes have
6512 already been written to the BFD. */
6513 else if (abfd->direction == both_direction)
6514 {
6515 BFD_ASSERT (abfd->output_has_begun);
6516 return TRUE;
6517 }
252b5132
RH
6518
6519 i_shdrp = elf_elfsections (abfd);
252b5132 6520
b34976b6 6521 failed = FALSE;
252b5132
RH
6522 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6523 if (failed)
b34976b6 6524 return FALSE;
252b5132 6525
0ce398f1
L
6526 if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6527 return FALSE;
252b5132 6528
c044fabd 6529 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM
6530 num_sec = elf_numsections (abfd);
6531 for (count = 1; count < num_sec; count++)
252b5132 6532 {
3e19fb8f
L
6533 i_shdrp[count]->sh_name
6534 = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6535 i_shdrp[count]->sh_name);
252b5132 6536 if (bed->elf_backend_section_processing)
75506100
MR
6537 if (!(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]))
6538 return FALSE;
252b5132
RH
6539 if (i_shdrp[count]->contents)
6540 {
dc810e39
AM
6541 bfd_size_type amt = i_shdrp[count]->sh_size;
6542
252b5132 6543 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 6544 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 6545 return FALSE;
252b5132
RH
6546 }
6547 }
6548
6549 /* Write out the section header names. */
30e8ee25 6550 t = elf_tdata (abfd);
26ae6d5e 6551 if (elf_shstrtab (abfd) != NULL
30e8ee25 6552 && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
08a40648 6553 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
b34976b6 6554 return FALSE;
252b5132
RH
6555
6556 if (bed->elf_backend_final_write_processing)
12bd6957 6557 (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
252b5132 6558
ff59fc36
RM
6559 if (!bed->s->write_shdrs_and_ehdr (abfd))
6560 return FALSE;
6561
6562 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
c0355132
AM
6563 if (t->o->build_id.after_write_object_contents != NULL)
6564 return (*t->o->build_id.after_write_object_contents) (abfd);
ff59fc36
RM
6565
6566 return TRUE;
252b5132
RH
6567}
6568
b34976b6 6569bfd_boolean
217aa764 6570_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 6571{
c044fabd 6572 /* Hopefully this can be done just like an object file. */
252b5132
RH
6573 return _bfd_elf_write_object_contents (abfd);
6574}
c044fabd
KH
6575
6576/* Given a section, search the header to find them. */
6577
cb33740c 6578unsigned int
198beae2 6579_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 6580{
9c5bfbb7 6581 const struct elf_backend_data *bed;
91d6fa6a 6582 unsigned int sec_index;
252b5132 6583
9ad5cbcf
AM
6584 if (elf_section_data (asect) != NULL
6585 && elf_section_data (asect)->this_idx != 0)
6586 return elf_section_data (asect)->this_idx;
6587
6588 if (bfd_is_abs_section (asect))
91d6fa6a 6589 sec_index = SHN_ABS;
af746e92 6590 else if (bfd_is_com_section (asect))
91d6fa6a 6591 sec_index = SHN_COMMON;
af746e92 6592 else if (bfd_is_und_section (asect))
91d6fa6a 6593 sec_index = SHN_UNDEF;
af746e92 6594 else
91d6fa6a 6595 sec_index = SHN_BAD;
252b5132 6596
af746e92 6597 bed = get_elf_backend_data (abfd);
252b5132
RH
6598 if (bed->elf_backend_section_from_bfd_section)
6599 {
91d6fa6a 6600 int retval = sec_index;
9ad5cbcf 6601
af746e92
AM
6602 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6603 return retval;
252b5132
RH
6604 }
6605
91d6fa6a 6606 if (sec_index == SHN_BAD)
af746e92 6607 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 6608
91d6fa6a 6609 return sec_index;
252b5132
RH
6610}
6611
6612/* Given a BFD symbol, return the index in the ELF symbol table, or -1
6613 on error. */
6614
6615int
217aa764 6616_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH
6617{
6618 asymbol *asym_ptr = *asym_ptr_ptr;
6619 int idx;
6620 flagword flags = asym_ptr->flags;
6621
6622 /* When gas creates relocations against local labels, it creates its
6623 own symbol for the section, but does put the symbol into the
6624 symbol chain, so udata is 0. When the linker is generating
6625 relocatable output, this section symbol may be for one of the
6626 input sections rather than the output section. */
6627 if (asym_ptr->udata.i == 0
6628 && (flags & BSF_SECTION_SYM)
6629 && asym_ptr->section)
6630 {
5372391b 6631 asection *sec;
252b5132
RH
6632 int indx;
6633
5372391b
AM
6634 sec = asym_ptr->section;
6635 if (sec->owner != abfd && sec->output_section != NULL)
6636 sec = sec->output_section;
6637 if (sec->owner == abfd
6638 && (indx = sec->index) < elf_num_section_syms (abfd)
4e89ac30 6639 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH
6640 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6641 }
6642
6643 idx = asym_ptr->udata.i;
6644
6645 if (idx == 0)
6646 {
6647 /* This case can occur when using --strip-symbol on a symbol
08a40648 6648 which is used in a relocation entry. */
4eca0228 6649 _bfd_error_handler
695344c0 6650 /* xgettext:c-format */
871b3ab2 6651 (_("%pB: symbol `%s' required but not present"),
d003868e 6652 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH
6653 bfd_set_error (bfd_error_no_symbols);
6654 return -1;
6655 }
6656
6657#if DEBUG & 4
6658 {
6659 fprintf (stderr,
cd9af601
AM
6660 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6661 (long) asym_ptr, asym_ptr->name, idx, flags);
252b5132
RH
6662 fflush (stderr);
6663 }
6664#endif
6665
6666 return idx;
6667}
6668
84d1d650 6669/* Rewrite program header information. */
252b5132 6670
b34976b6 6671static bfd_boolean
84d1d650 6672rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
252b5132 6673{
b34976b6
AM
6674 Elf_Internal_Ehdr *iehdr;
6675 struct elf_segment_map *map;
6676 struct elf_segment_map *map_first;
6677 struct elf_segment_map **pointer_to_map;
6678 Elf_Internal_Phdr *segment;
6679 asection *section;
6680 unsigned int i;
6681 unsigned int num_segments;
6682 bfd_boolean phdr_included = FALSE;
5c44b38e 6683 bfd_boolean p_paddr_valid;
b34976b6
AM
6684 bfd_vma maxpagesize;
6685 struct elf_segment_map *phdr_adjust_seg = NULL;
6686 unsigned int phdr_adjust_num = 0;
9c5bfbb7 6687 const struct elf_backend_data *bed;
bc67d8a6 6688
caf47ea6 6689 bed = get_elf_backend_data (ibfd);
252b5132
RH
6690 iehdr = elf_elfheader (ibfd);
6691
bc67d8a6 6692 map_first = NULL;
c044fabd 6693 pointer_to_map = &map_first;
252b5132
RH
6694
6695 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC
6696 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6697
6698 /* Returns the end address of the segment + 1. */
aecc8f8a
AM
6699#define SEGMENT_END(segment, start) \
6700 (start + (segment->p_memsz > segment->p_filesz \
6701 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 6702
eecdbe52
JJ
6703#define SECTION_SIZE(section, segment) \
6704 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6705 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 6706 ? section->size : 0)
eecdbe52 6707
b34976b6 6708 /* Returns TRUE if the given section is contained within
bc67d8a6 6709 the given segment. VMA addresses are compared. */
aecc8f8a
AM
6710#define IS_CONTAINED_BY_VMA(section, segment) \
6711 (section->vma >= segment->p_vaddr \
eecdbe52 6712 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 6713 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 6714
b34976b6 6715 /* Returns TRUE if the given section is contained within
bc67d8a6 6716 the given segment. LMA addresses are compared. */
aecc8f8a
AM
6717#define IS_CONTAINED_BY_LMA(section, segment, base) \
6718 (section->lma >= base \
beab4532 6719 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
eecdbe52 6720 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 6721 <= SEGMENT_END (segment, base)))
252b5132 6722
0efc80c8
L
6723 /* Handle PT_NOTE segment. */
6724#define IS_NOTE(p, s) \
aecc8f8a 6725 (p->p_type == PT_NOTE \
0efc80c8 6726 && elf_section_type (s) == SHT_NOTE \
aecc8f8a 6727 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 6728 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 6729 <= p->p_offset + p->p_filesz))
252b5132 6730
0efc80c8
L
6731 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6732 etc. */
6733#define IS_COREFILE_NOTE(p, s) \
6734 (IS_NOTE (p, s) \
6735 && bfd_get_format (ibfd) == bfd_core \
6736 && s->vma == 0 \
6737 && s->lma == 0)
6738
252b5132
RH
6739 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6740 linker, which generates a PT_INTERP section with p_vaddr and
6741 p_memsz set to 0. */
aecc8f8a
AM
6742#define IS_SOLARIS_PT_INTERP(p, s) \
6743 (p->p_vaddr == 0 \
6744 && p->p_paddr == 0 \
6745 && p->p_memsz == 0 \
6746 && p->p_filesz > 0 \
6747 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 6748 && s->size > 0 \
aecc8f8a 6749 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 6750 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 6751 <= p->p_offset + p->p_filesz))
5c440b1e 6752
bc67d8a6
NC
6753 /* Decide if the given section should be included in the given segment.
6754 A section will be included if:
f5ffc919 6755 1. It is within the address space of the segment -- we use the LMA
08a40648 6756 if that is set for the segment and the VMA otherwise,
0efc80c8 6757 2. It is an allocated section or a NOTE section in a PT_NOTE
d324f6d6 6758 segment.
bc67d8a6 6759 3. There is an output section associated with it,
eecdbe52 6760 4. The section has not already been allocated to a previous segment.
2b05f1b7 6761 5. PT_GNU_STACK segments do not include any sections.
03394ac9 6762 6. PT_TLS segment includes only SHF_TLS sections.
6f79b219
JJ
6763 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6764 8. PT_DYNAMIC should not contain empty sections at the beginning
08a40648 6765 (with the possible exception of .dynamic). */
9f17e2a6 6766#define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
2b05f1b7
L
6767 ((((segment->p_paddr \
6768 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6769 : IS_CONTAINED_BY_VMA (section, segment)) \
6770 && (section->flags & SEC_ALLOC) != 0) \
0efc80c8 6771 || IS_NOTE (segment, section)) \
2b05f1b7
L
6772 && segment->p_type != PT_GNU_STACK \
6773 && (segment->p_type != PT_TLS \
6774 || (section->flags & SEC_THREAD_LOCAL)) \
6775 && (segment->p_type == PT_LOAD \
6776 || segment->p_type == PT_TLS \
6777 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6778 && (segment->p_type != PT_DYNAMIC \
6779 || SECTION_SIZE (section, segment) > 0 \
6780 || (segment->p_paddr \
6781 ? segment->p_paddr != section->lma \
6782 : segment->p_vaddr != section->vma) \
6783 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6784 == 0)) \
9933dc52 6785 && (segment->p_type != PT_LOAD || !section->segment_mark))
bc67d8a6 6786
9f17e2a6
L
6787/* If the output section of a section in the input segment is NULL,
6788 it is removed from the corresponding output segment. */
6789#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6790 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6791 && section->output_section != NULL)
6792
b34976b6 6793 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC
6794#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6795 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6796
6797 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6798 their VMA address ranges and their LMA address ranges overlap.
6799 It is possible to have overlapping VMA ranges without overlapping LMA
6800 ranges. RedBoot images for example can have both .data and .bss mapped
6801 to the same VMA range, but with the .data section mapped to a different
6802 LMA. */
aecc8f8a 6803#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea 6804 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
08a40648 6805 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
b5f852ea 6806 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
08a40648 6807 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC
6808
6809 /* Initialise the segment mark field. */
6810 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 6811 section->segment_mark = FALSE;
bc67d8a6 6812
5c44b38e
AM
6813 /* The Solaris linker creates program headers in which all the
6814 p_paddr fields are zero. When we try to objcopy or strip such a
6815 file, we get confused. Check for this case, and if we find it
6816 don't set the p_paddr_valid fields. */
6817 p_paddr_valid = FALSE;
6818 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6819 i < num_segments;
6820 i++, segment++)
6821 if (segment->p_paddr != 0)
6822 {
6823 p_paddr_valid = TRUE;
6824 break;
6825 }
6826
252b5132 6827 /* Scan through the segments specified in the program header
bc67d8a6 6828 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 6829 in the loadable segments. These can be created by weird
aecc8f8a 6830 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC
6831 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6832 i < num_segments;
c044fabd 6833 i++, segment++)
252b5132 6834 {
252b5132 6835 unsigned int j;
c044fabd 6836 Elf_Internal_Phdr *segment2;
252b5132 6837
aecc8f8a
AM
6838 if (segment->p_type == PT_INTERP)
6839 for (section = ibfd->sections; section; section = section->next)
6840 if (IS_SOLARIS_PT_INTERP (segment, section))
6841 {
6842 /* Mininal change so that the normal section to segment
4cc11e76 6843 assignment code will work. */
aecc8f8a
AM
6844 segment->p_vaddr = section->vma;
6845 break;
6846 }
6847
bc67d8a6 6848 if (segment->p_type != PT_LOAD)
b10a8ae0
L
6849 {
6850 /* Remove PT_GNU_RELRO segment. */
6851 if (segment->p_type == PT_GNU_RELRO)
6852 segment->p_type = PT_NULL;
6853 continue;
6854 }
c044fabd 6855
bc67d8a6 6856 /* Determine if this segment overlaps any previous segments. */
0067a569 6857 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
bc67d8a6
NC
6858 {
6859 bfd_signed_vma extra_length;
c044fabd 6860
bc67d8a6 6861 if (segment2->p_type != PT_LOAD
0067a569 6862 || !SEGMENT_OVERLAPS (segment, segment2))
bc67d8a6 6863 continue;
c044fabd 6864
bc67d8a6
NC
6865 /* Merge the two segments together. */
6866 if (segment2->p_vaddr < segment->p_vaddr)
6867 {
c044fabd 6868 /* Extend SEGMENT2 to include SEGMENT and then delete
08a40648 6869 SEGMENT. */
0067a569
AM
6870 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6871 - SEGMENT_END (segment2, segment2->p_vaddr));
c044fabd 6872
bc67d8a6
NC
6873 if (extra_length > 0)
6874 {
0067a569 6875 segment2->p_memsz += extra_length;
bc67d8a6
NC
6876 segment2->p_filesz += extra_length;
6877 }
c044fabd 6878
bc67d8a6 6879 segment->p_type = PT_NULL;
c044fabd 6880
bc67d8a6
NC
6881 /* Since we have deleted P we must restart the outer loop. */
6882 i = 0;
6883 segment = elf_tdata (ibfd)->phdr;
6884 break;
6885 }
6886 else
6887 {
c044fabd 6888 /* Extend SEGMENT to include SEGMENT2 and then delete
08a40648 6889 SEGMENT2. */
0067a569
AM
6890 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6891 - SEGMENT_END (segment, segment->p_vaddr));
c044fabd 6892
bc67d8a6
NC
6893 if (extra_length > 0)
6894 {
0067a569 6895 segment->p_memsz += extra_length;
bc67d8a6
NC
6896 segment->p_filesz += extra_length;
6897 }
c044fabd 6898
bc67d8a6
NC
6899 segment2->p_type = PT_NULL;
6900 }
6901 }
6902 }
c044fabd 6903
bc67d8a6
NC
6904 /* The second scan attempts to assign sections to segments. */
6905 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6906 i < num_segments;
0067a569 6907 i++, segment++)
bc67d8a6 6908 {
0067a569
AM
6909 unsigned int section_count;
6910 asection **sections;
6911 asection *output_section;
6912 unsigned int isec;
9933dc52
AM
6913 asection *matching_lma;
6914 asection *suggested_lma;
0067a569 6915 unsigned int j;
dc810e39 6916 bfd_size_type amt;
0067a569 6917 asection *first_section;
bc67d8a6
NC
6918
6919 if (segment->p_type == PT_NULL)
6920 continue;
c044fabd 6921
9f17e2a6 6922 first_section = NULL;
bc67d8a6 6923 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC
6924 for (section = ibfd->sections, section_count = 0;
6925 section != NULL;
6926 section = section->next)
9f17e2a6
L
6927 {
6928 /* Find the first section in the input segment, which may be
6929 removed from the corresponding output segment. */
6930 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6931 {
6932 if (first_section == NULL)
6933 first_section = section;
6934 if (section->output_section != NULL)
6935 ++section_count;
6936 }
6937 }
811072d8 6938
b5f852ea
NC
6939 /* Allocate a segment map big enough to contain
6940 all of the sections we have selected. */
00bee008
AM
6941 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
6942 amt += (bfd_size_type) section_count * sizeof (asection *);
a50b1753 6943 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 6944 if (map == NULL)
b34976b6 6945 return FALSE;
252b5132
RH
6946
6947 /* Initialise the fields of the segment map. Default to
6948 using the physical address of the segment in the input BFD. */
0067a569
AM
6949 map->next = NULL;
6950 map->p_type = segment->p_type;
6951 map->p_flags = segment->p_flags;
bc67d8a6 6952 map->p_flags_valid = 1;
55d55ac7 6953
9f17e2a6
L
6954 /* If the first section in the input segment is removed, there is
6955 no need to preserve segment physical address in the corresponding
6956 output segment. */
945c025a 6957 if (!first_section || first_section->output_section != NULL)
9f17e2a6
L
6958 {
6959 map->p_paddr = segment->p_paddr;
5c44b38e 6960 map->p_paddr_valid = p_paddr_valid;
9f17e2a6 6961 }
252b5132
RH
6962
6963 /* Determine if this segment contains the ELF file header
6964 and if it contains the program headers themselves. */
bc67d8a6
NC
6965 map->includes_filehdr = (segment->p_offset == 0
6966 && segment->p_filesz >= iehdr->e_ehsize);
bc67d8a6 6967 map->includes_phdrs = 0;
252b5132 6968
0067a569 6969 if (!phdr_included || segment->p_type != PT_LOAD)
252b5132 6970 {
bc67d8a6
NC
6971 map->includes_phdrs =
6972 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6973 && (segment->p_offset + segment->p_filesz
252b5132
RH
6974 >= ((bfd_vma) iehdr->e_phoff
6975 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 6976
bc67d8a6 6977 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 6978 phdr_included = TRUE;
252b5132
RH
6979 }
6980
bc67d8a6 6981 if (section_count == 0)
252b5132
RH
6982 {
6983 /* Special segments, such as the PT_PHDR segment, may contain
6984 no sections, but ordinary, loadable segments should contain
1ed89aa9 6985 something. They are allowed by the ELF spec however, so only
07d6d2b8 6986 a warning is produced.
f98450c6
NC
6987 There is however the valid use case of embedded systems which
6988 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6989 flash memory with zeros. No warning is shown for that case. */
6990 if (segment->p_type == PT_LOAD
6991 && (segment->p_filesz > 0 || segment->p_memsz == 0))
6992 /* xgettext:c-format */
9793eb77
AM
6993 _bfd_error_handler
6994 (_("%pB: warning: empty loadable segment detected"
6995 " at vaddr=%#" PRIx64 ", is this intentional?"),
6996 ibfd, (uint64_t) segment->p_vaddr);
252b5132 6997
5d695627 6998 map->p_vaddr_offset = segment->p_vaddr;
bc67d8a6 6999 map->count = 0;
c044fabd
KH
7000 *pointer_to_map = map;
7001 pointer_to_map = &map->next;
252b5132
RH
7002
7003 continue;
7004 }
7005
7006 /* Now scan the sections in the input BFD again and attempt
7007 to add their corresponding output sections to the segment map.
7008 The problem here is how to handle an output section which has
7009 been moved (ie had its LMA changed). There are four possibilities:
7010
7011 1. None of the sections have been moved.
7012 In this case we can continue to use the segment LMA from the
7013 input BFD.
7014
7015 2. All of the sections have been moved by the same amount.
7016 In this case we can change the segment's LMA to match the LMA
7017 of the first section.
7018
7019 3. Some of the sections have been moved, others have not.
7020 In this case those sections which have not been moved can be
7021 placed in the current segment which will have to have its size,
7022 and possibly its LMA changed, and a new segment or segments will
7023 have to be created to contain the other sections.
7024
b5f852ea 7025 4. The sections have been moved, but not by the same amount.
252b5132
RH
7026 In this case we can change the segment's LMA to match the LMA
7027 of the first section and we will have to create a new segment
7028 or segments to contain the other sections.
7029
7030 In order to save time, we allocate an array to hold the section
7031 pointers that we are interested in. As these sections get assigned
7032 to a segment, they are removed from this array. */
7033
a50b1753 7034 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
252b5132 7035 if (sections == NULL)
b34976b6 7036 return FALSE;
252b5132
RH
7037
7038 /* Step One: Scan for segment vs section LMA conflicts.
7039 Also add the sections to the section array allocated above.
7040 Also add the sections to the current segment. In the common
7041 case, where the sections have not been moved, this means that
7042 we have completely filled the segment, and there is nothing
7043 more to do. */
252b5132 7044 isec = 0;
9933dc52
AM
7045 matching_lma = NULL;
7046 suggested_lma = NULL;
252b5132 7047
461c4b2e 7048 for (section = first_section, j = 0;
bc67d8a6
NC
7049 section != NULL;
7050 section = section->next)
252b5132 7051 {
caf47ea6 7052 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 7053 {
bc67d8a6
NC
7054 output_section = section->output_section;
7055
0067a569 7056 sections[j++] = section;
252b5132
RH
7057
7058 /* The Solaris native linker always sets p_paddr to 0.
7059 We try to catch that case here, and set it to the
5e8d7549
NC
7060 correct value. Note - some backends require that
7061 p_paddr be left as zero. */
5c44b38e 7062 if (!p_paddr_valid
4455705d 7063 && segment->p_vaddr != 0
0067a569 7064 && !bed->want_p_paddr_set_to_zero
252b5132 7065 && isec == 0
bc67d8a6 7066 && output_section->lma != 0
9933dc52
AM
7067 && (align_power (segment->p_vaddr
7068 + (map->includes_filehdr
7069 ? iehdr->e_ehsize : 0)
7070 + (map->includes_phdrs
7071 ? iehdr->e_phnum * iehdr->e_phentsize
7072 : 0),
7073 output_section->alignment_power)
7074 == output_section->vma))
bc67d8a6 7075 map->p_paddr = segment->p_vaddr;
252b5132
RH
7076
7077 /* Match up the physical address of the segment with the
7078 LMA address of the output section. */
bc67d8a6 7079 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549 7080 || IS_COREFILE_NOTE (segment, section)
0067a569
AM
7081 || (bed->want_p_paddr_set_to_zero
7082 && IS_CONTAINED_BY_VMA (output_section, segment)))
252b5132 7083 {
9933dc52
AM
7084 if (matching_lma == NULL
7085 || output_section->lma < matching_lma->lma)
7086 matching_lma = output_section;
252b5132
RH
7087
7088 /* We assume that if the section fits within the segment
bc67d8a6 7089 then it does not overlap any other section within that
252b5132 7090 segment. */
0067a569
AM
7091 map->sections[isec++] = output_section;
7092 }
9933dc52
AM
7093 else if (suggested_lma == NULL)
7094 suggested_lma = output_section;
147d51c2
L
7095
7096 if (j == section_count)
7097 break;
252b5132
RH
7098 }
7099 }
7100
bc67d8a6 7101 BFD_ASSERT (j == section_count);
252b5132
RH
7102
7103 /* Step Two: Adjust the physical address of the current segment,
7104 if necessary. */
bc67d8a6 7105 if (isec == section_count)
252b5132
RH
7106 {
7107 /* All of the sections fitted within the segment as currently
7108 specified. This is the default case. Add the segment to
7109 the list of built segments and carry on to process the next
7110 program header in the input BFD. */
bc67d8a6 7111 map->count = section_count;
c044fabd
KH
7112 *pointer_to_map = map;
7113 pointer_to_map = &map->next;
08a40648 7114
5c44b38e
AM
7115 if (p_paddr_valid
7116 && !bed->want_p_paddr_set_to_zero
9933dc52 7117 && matching_lma->lma != map->p_paddr
5c44b38e
AM
7118 && !map->includes_filehdr
7119 && !map->includes_phdrs)
3271a814
NS
7120 /* There is some padding before the first section in the
7121 segment. So, we must account for that in the output
7122 segment's vma. */
5d695627 7123 map->p_vaddr_offset = map->p_paddr - matching_lma->lma;
08a40648 7124
252b5132
RH
7125 free (sections);
7126 continue;
7127 }
252b5132
RH
7128 else
7129 {
9933dc52
AM
7130 /* Change the current segment's physical address to match
7131 the LMA of the first section that fitted, or if no
7132 section fitted, the first section. */
7133 if (matching_lma == NULL)
7134 matching_lma = suggested_lma;
7135
7136 map->p_paddr = matching_lma->lma;
72730e0c 7137
bc67d8a6
NC
7138 /* Offset the segment physical address from the lma
7139 to allow for space taken up by elf headers. */
9933dc52 7140 if (map->includes_phdrs)
010c8431 7141 {
9933dc52
AM
7142 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7143
7144 /* iehdr->e_phnum is just an estimate of the number
7145 of program headers that we will need. Make a note
7146 here of the number we used and the segment we chose
7147 to hold these headers, so that we can adjust the
7148 offset when we know the correct value. */
7149 phdr_adjust_num = iehdr->e_phnum;
7150 phdr_adjust_seg = map;
010c8431 7151 }
252b5132 7152
9933dc52 7153 if (map->includes_filehdr)
bc67d8a6 7154 {
9933dc52
AM
7155 bfd_vma align = (bfd_vma) 1 << matching_lma->alignment_power;
7156 map->p_paddr -= iehdr->e_ehsize;
7157 /* We've subtracted off the size of headers from the
7158 first section lma, but there may have been some
7159 alignment padding before that section too. Try to
7160 account for that by adjusting the segment lma down to
7161 the same alignment. */
7162 if (segment->p_align != 0 && segment->p_align < align)
7163 align = segment->p_align;
7164 map->p_paddr &= -align;
bc67d8a6 7165 }
252b5132
RH
7166 }
7167
7168 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 7169 those that fit to the current segment and removing them from the
252b5132
RH
7170 sections array; but making sure not to leave large gaps. Once all
7171 possible sections have been assigned to the current segment it is
7172 added to the list of built segments and if sections still remain
7173 to be assigned, a new segment is constructed before repeating
7174 the loop. */
7175 isec = 0;
7176 do
7177 {
bc67d8a6 7178 map->count = 0;
9933dc52 7179 suggested_lma = NULL;
252b5132
RH
7180
7181 /* Fill the current segment with sections that fit. */
bc67d8a6 7182 for (j = 0; j < section_count; j++)
252b5132 7183 {
bc67d8a6 7184 section = sections[j];
252b5132 7185
bc67d8a6 7186 if (section == NULL)
252b5132
RH
7187 continue;
7188
bc67d8a6 7189 output_section = section->output_section;
252b5132 7190
bc67d8a6 7191 BFD_ASSERT (output_section != NULL);
c044fabd 7192
bc67d8a6
NC
7193 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7194 || IS_COREFILE_NOTE (segment, section))
252b5132 7195 {
bc67d8a6 7196 if (map->count == 0)
252b5132
RH
7197 {
7198 /* If the first section in a segment does not start at
bc67d8a6
NC
7199 the beginning of the segment, then something is
7200 wrong. */
9933dc52
AM
7201 if (align_power (map->p_paddr
7202 + (map->includes_filehdr
7203 ? iehdr->e_ehsize : 0)
7204 + (map->includes_phdrs
7205 ? iehdr->e_phnum * iehdr->e_phentsize
7206 : 0),
7207 output_section->alignment_power)
7208 != output_section->lma)
252b5132
RH
7209 abort ();
7210 }
7211 else
7212 {
0067a569 7213 asection *prev_sec;
252b5132 7214
bc67d8a6 7215 prev_sec = map->sections[map->count - 1];
252b5132
RH
7216
7217 /* If the gap between the end of the previous section
bc67d8a6
NC
7218 and the start of this section is more than
7219 maxpagesize then we need to start a new segment. */
eea6121a 7220 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 7221 maxpagesize)
caf47ea6 7222 < BFD_ALIGN (output_section->lma, maxpagesize))
0067a569 7223 || (prev_sec->lma + prev_sec->size
079e9a2f 7224 > output_section->lma))
252b5132 7225 {
9933dc52
AM
7226 if (suggested_lma == NULL)
7227 suggested_lma = output_section;
252b5132
RH
7228
7229 continue;
7230 }
7231 }
7232
bc67d8a6 7233 map->sections[map->count++] = output_section;
252b5132
RH
7234 ++isec;
7235 sections[j] = NULL;
9933dc52
AM
7236 if (segment->p_type == PT_LOAD)
7237 section->segment_mark = TRUE;
0067a569 7238 }
9933dc52
AM
7239 else if (suggested_lma == NULL)
7240 suggested_lma = output_section;
252b5132
RH
7241 }
7242
beab4532
NC
7243 /* PR 23932. A corrupt input file may contain sections that cannot
7244 be assigned to any segment - because for example they have a
7245 negative size - or segments that do not contain any sections. */
7246 if (map->count == 0)
7247 {
7248 bfd_set_error (bfd_error_bad_value);
7249 free (sections);
7250 return FALSE;
7251 }
252b5132
RH
7252
7253 /* Add the current segment to the list of built segments. */
c044fabd
KH
7254 *pointer_to_map = map;
7255 pointer_to_map = &map->next;
252b5132 7256
bc67d8a6 7257 if (isec < section_count)
252b5132
RH
7258 {
7259 /* We still have not allocated all of the sections to
7260 segments. Create a new segment here, initialise it
7261 and carry on looping. */
00bee008
AM
7262 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7263 amt += (bfd_size_type) section_count * sizeof (asection *);
5964fc3a 7264 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 7265 if (map == NULL)
5ed6aba4
NC
7266 {
7267 free (sections);
7268 return FALSE;
7269 }
252b5132
RH
7270
7271 /* Initialise the fields of the segment map. Set the physical
7272 physical address to the LMA of the first section that has
7273 not yet been assigned. */
0067a569
AM
7274 map->next = NULL;
7275 map->p_type = segment->p_type;
7276 map->p_flags = segment->p_flags;
7277 map->p_flags_valid = 1;
9933dc52 7278 map->p_paddr = suggested_lma->lma;
5c44b38e 7279 map->p_paddr_valid = p_paddr_valid;
bc67d8a6 7280 map->includes_filehdr = 0;
0067a569 7281 map->includes_phdrs = 0;
252b5132
RH
7282 }
7283 }
bc67d8a6 7284 while (isec < section_count);
252b5132
RH
7285
7286 free (sections);
7287 }
7288
12bd6957 7289 elf_seg_map (obfd) = map_first;
bc67d8a6
NC
7290
7291 /* If we had to estimate the number of program headers that were
9ad5cbcf 7292 going to be needed, then check our estimate now and adjust
bc67d8a6
NC
7293 the offset if necessary. */
7294 if (phdr_adjust_seg != NULL)
7295 {
7296 unsigned int count;
c044fabd 7297
bc67d8a6 7298 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 7299 count++;
252b5132 7300
bc67d8a6
NC
7301 if (count > phdr_adjust_num)
7302 phdr_adjust_seg->p_paddr
7303 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
9933dc52
AM
7304
7305 for (map = map_first; map != NULL; map = map->next)
7306 if (map->p_type == PT_PHDR)
7307 {
7308 bfd_vma adjust
7309 = phdr_adjust_seg->includes_filehdr ? iehdr->e_ehsize : 0;
7310 map->p_paddr = phdr_adjust_seg->p_paddr + adjust;
7311 break;
7312 }
bc67d8a6 7313 }
c044fabd 7314
bc67d8a6 7315#undef SEGMENT_END
eecdbe52 7316#undef SECTION_SIZE
bc67d8a6
NC
7317#undef IS_CONTAINED_BY_VMA
7318#undef IS_CONTAINED_BY_LMA
0efc80c8 7319#undef IS_NOTE
252b5132 7320#undef IS_COREFILE_NOTE
bc67d8a6 7321#undef IS_SOLARIS_PT_INTERP
9f17e2a6 7322#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC
7323#undef INCLUDE_SECTION_IN_SEGMENT
7324#undef SEGMENT_AFTER_SEGMENT
7325#undef SEGMENT_OVERLAPS
b34976b6 7326 return TRUE;
252b5132
RH
7327}
7328
84d1d650
L
7329/* Copy ELF program header information. */
7330
7331static bfd_boolean
7332copy_elf_program_header (bfd *ibfd, bfd *obfd)
7333{
7334 Elf_Internal_Ehdr *iehdr;
7335 struct elf_segment_map *map;
7336 struct elf_segment_map *map_first;
7337 struct elf_segment_map **pointer_to_map;
7338 Elf_Internal_Phdr *segment;
7339 unsigned int i;
7340 unsigned int num_segments;
7341 bfd_boolean phdr_included = FALSE;
88967714 7342 bfd_boolean p_paddr_valid;
84d1d650
L
7343
7344 iehdr = elf_elfheader (ibfd);
7345
7346 map_first = NULL;
7347 pointer_to_map = &map_first;
7348
88967714
AM
7349 /* If all the segment p_paddr fields are zero, don't set
7350 map->p_paddr_valid. */
7351 p_paddr_valid = FALSE;
84d1d650 7352 num_segments = elf_elfheader (ibfd)->e_phnum;
88967714
AM
7353 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7354 i < num_segments;
7355 i++, segment++)
7356 if (segment->p_paddr != 0)
7357 {
7358 p_paddr_valid = TRUE;
7359 break;
7360 }
7361
84d1d650
L
7362 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7363 i < num_segments;
7364 i++, segment++)
7365 {
7366 asection *section;
7367 unsigned int section_count;
7368 bfd_size_type amt;
7369 Elf_Internal_Shdr *this_hdr;
53020534 7370 asection *first_section = NULL;
a76e6f2f 7371 asection *lowest_section;
2542e49e 7372 bfd_boolean no_contents = TRUE;
84d1d650 7373
84d1d650
L
7374 /* Compute how many sections are in this segment. */
7375 for (section = ibfd->sections, section_count = 0;
7376 section != NULL;
7377 section = section->next)
7378 {
7379 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7380 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
3271a814 7381 {
a76e6f2f
AM
7382 if (first_section == NULL)
7383 first_section = section;
2542e49e
JL
7384 if (elf_section_type (section) != SHT_NOBITS)
7385 no_contents = FALSE;
3271a814
NS
7386 section_count++;
7387 }
84d1d650
L
7388 }
7389
7390 /* Allocate a segment map big enough to contain
7391 all of the sections we have selected. */
00bee008
AM
7392 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7393 amt += (bfd_size_type) section_count * sizeof (asection *);
a50b1753 7394 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
84d1d650
L
7395 if (map == NULL)
7396 return FALSE;
7397
7398 /* Initialize the fields of the output segment map with the
7399 input segment. */
7400 map->next = NULL;
7401 map->p_type = segment->p_type;
7402 map->p_flags = segment->p_flags;
7403 map->p_flags_valid = 1;
7404 map->p_paddr = segment->p_paddr;
88967714 7405 map->p_paddr_valid = p_paddr_valid;
3f570048
AM
7406 map->p_align = segment->p_align;
7407 map->p_align_valid = 1;
3271a814 7408 map->p_vaddr_offset = 0;
84d1d650 7409
04c3a755
NS
7410 if (map->p_type == PT_GNU_RELRO
7411 || map->p_type == PT_GNU_STACK)
b10a8ae0
L
7412 {
7413 /* The PT_GNU_RELRO segment may contain the first a few
7414 bytes in the .got.plt section even if the whole .got.plt
7415 section isn't in the PT_GNU_RELRO segment. We won't
04c3a755
NS
7416 change the size of the PT_GNU_RELRO segment.
7417 Similarly, PT_GNU_STACK size is significant on uclinux
7418 systems. */
9433b9b1 7419 map->p_size = segment->p_memsz;
b10a8ae0
L
7420 map->p_size_valid = 1;
7421 }
7422
84d1d650
L
7423 /* Determine if this segment contains the ELF file header
7424 and if it contains the program headers themselves. */
7425 map->includes_filehdr = (segment->p_offset == 0
7426 && segment->p_filesz >= iehdr->e_ehsize);
7427
7428 map->includes_phdrs = 0;
7429 if (! phdr_included || segment->p_type != PT_LOAD)
7430 {
7431 map->includes_phdrs =
7432 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7433 && (segment->p_offset + segment->p_filesz
7434 >= ((bfd_vma) iehdr->e_phoff
7435 + iehdr->e_phnum * iehdr->e_phentsize)));
7436
7437 if (segment->p_type == PT_LOAD && map->includes_phdrs)
7438 phdr_included = TRUE;
7439 }
7440
bbefd0a9 7441 lowest_section = NULL;
84d1d650
L
7442 if (section_count != 0)
7443 {
7444 unsigned int isec = 0;
7445
53020534 7446 for (section = first_section;
84d1d650
L
7447 section != NULL;
7448 section = section->next)
7449 {
7450 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7451 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
53020534
L
7452 {
7453 map->sections[isec++] = section->output_section;
a76e6f2f
AM
7454 if ((section->flags & SEC_ALLOC) != 0)
7455 {
7456 bfd_vma seg_off;
7457
bbefd0a9
AM
7458 if (lowest_section == NULL
7459 || section->lma < lowest_section->lma)
fb8a5684
AM
7460 lowest_section = section;
7461
a76e6f2f
AM
7462 /* Section lmas are set up from PT_LOAD header
7463 p_paddr in _bfd_elf_make_section_from_shdr.
7464 If this header has a p_paddr that disagrees
7465 with the section lma, flag the p_paddr as
7466 invalid. */
7467 if ((section->flags & SEC_LOAD) != 0)
7468 seg_off = this_hdr->sh_offset - segment->p_offset;
7469 else
7470 seg_off = this_hdr->sh_addr - segment->p_vaddr;
7471 if (section->lma - segment->p_paddr != seg_off)
7472 map->p_paddr_valid = FALSE;
7473 }
53020534
L
7474 if (isec == section_count)
7475 break;
7476 }
84d1d650
L
7477 }
7478 }
7479
a76e6f2f 7480 if (map->includes_filehdr && lowest_section != NULL)
2542e49e
JL
7481 {
7482 /* Try to keep the space used by the headers plus any
7483 padding fixed. If there are sections with file contents
7484 in this segment then the lowest sh_offset is the best
7485 guess. Otherwise the segment only has file contents for
7486 the headers, and p_filesz is the best guess. */
7487 if (no_contents)
7488 map->header_size = segment->p_filesz;
7489 else
7490 map->header_size = lowest_section->filepos;
7491 }
d324f6d6 7492
5d695627
AM
7493 if (section_count == 0)
7494 map->p_vaddr_offset = segment->p_vaddr;
7495 else if (!map->includes_phdrs
7496 && !map->includes_filehdr
7497 && map->p_paddr_valid)
7498 /* Account for padding before the first section. */
7499 map->p_vaddr_offset = (segment->p_paddr
7500 - (lowest_section ? lowest_section->lma : 0));
a76e6f2f 7501
84d1d650
L
7502 map->count = section_count;
7503 *pointer_to_map = map;
7504 pointer_to_map = &map->next;
7505 }
7506
12bd6957 7507 elf_seg_map (obfd) = map_first;
84d1d650
L
7508 return TRUE;
7509}
7510
7511/* Copy private BFD data. This copies or rewrites ELF program header
7512 information. */
7513
7514static bfd_boolean
7515copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7516{
84d1d650
L
7517 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7518 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7519 return TRUE;
7520
7521 if (elf_tdata (ibfd)->phdr == NULL)
7522 return TRUE;
7523
7524 if (ibfd->xvec == obfd->xvec)
7525 {
cb3ff1e5
NC
7526 /* Check to see if any sections in the input BFD
7527 covered by ELF program header have changed. */
d55ce4e2 7528 Elf_Internal_Phdr *segment;
84d1d650
L
7529 asection *section, *osec;
7530 unsigned int i, num_segments;
7531 Elf_Internal_Shdr *this_hdr;
147d51c2
L
7532 const struct elf_backend_data *bed;
7533
7534 bed = get_elf_backend_data (ibfd);
7535
7536 /* Regenerate the segment map if p_paddr is set to 0. */
7537 if (bed->want_p_paddr_set_to_zero)
7538 goto rewrite;
84d1d650
L
7539
7540 /* Initialize the segment mark field. */
7541 for (section = obfd->sections; section != NULL;
7542 section = section->next)
7543 section->segment_mark = FALSE;
7544
7545 num_segments = elf_elfheader (ibfd)->e_phnum;
7546 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7547 i < num_segments;
7548 i++, segment++)
7549 {
5f6999aa
NC
7550 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7551 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7552 which severly confuses things, so always regenerate the segment
7553 map in this case. */
7554 if (segment->p_paddr == 0
7555 && segment->p_memsz == 0
7556 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
cb3ff1e5 7557 goto rewrite;
5f6999aa 7558
84d1d650
L
7559 for (section = ibfd->sections;
7560 section != NULL; section = section->next)
7561 {
7562 /* We mark the output section so that we know it comes
7563 from the input BFD. */
7564 osec = section->output_section;
7565 if (osec)
7566 osec->segment_mark = TRUE;
7567
7568 /* Check if this section is covered by the segment. */
7569 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 7570 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
84d1d650
L
7571 {
7572 /* FIXME: Check if its output section is changed or
7573 removed. What else do we need to check? */
7574 if (osec == NULL
7575 || section->flags != osec->flags
7576 || section->lma != osec->lma
7577 || section->vma != osec->vma
7578 || section->size != osec->size
7579 || section->rawsize != osec->rawsize
7580 || section->alignment_power != osec->alignment_power)
7581 goto rewrite;
7582 }
7583 }
7584 }
7585
cb3ff1e5 7586 /* Check to see if any output section do not come from the
84d1d650
L
7587 input BFD. */
7588 for (section = obfd->sections; section != NULL;
7589 section = section->next)
7590 {
535b785f 7591 if (!section->segment_mark)
84d1d650
L
7592 goto rewrite;
7593 else
7594 section->segment_mark = FALSE;
7595 }
7596
7597 return copy_elf_program_header (ibfd, obfd);
7598 }
7599
7600rewrite:
f1d85785
L
7601 if (ibfd->xvec == obfd->xvec)
7602 {
7603 /* When rewriting program header, set the output maxpagesize to
7604 the maximum alignment of input PT_LOAD segments. */
7605 Elf_Internal_Phdr *segment;
7606 unsigned int i;
7607 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7608 bfd_vma maxpagesize = 0;
7609
7610 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7611 i < num_segments;
7612 i++, segment++)
7613 if (segment->p_type == PT_LOAD
7614 && maxpagesize < segment->p_align)
c86934ce
NC
7615 {
7616 /* PR 17512: file: f17299af. */
7617 if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
695344c0 7618 /* xgettext:c-format */
2dcf00ce
AM
7619 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7620 PRIx64 " is too large"),
7621 ibfd, (uint64_t) segment->p_align);
c86934ce
NC
7622 else
7623 maxpagesize = segment->p_align;
7624 }
f1d85785
L
7625
7626 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7627 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7628 }
7629
84d1d650
L
7630 return rewrite_elf_program_header (ibfd, obfd);
7631}
7632
ccd2ec6a
L
7633/* Initialize private output section information from input section. */
7634
7635bfd_boolean
7636_bfd_elf_init_private_section_data (bfd *ibfd,
7637 asection *isec,
7638 bfd *obfd,
7639 asection *osec,
7640 struct bfd_link_info *link_info)
7641
7642{
7643 Elf_Internal_Shdr *ihdr, *ohdr;
0e1862bb
L
7644 bfd_boolean final_link = (link_info != NULL
7645 && !bfd_link_relocatable (link_info));
ccd2ec6a
L
7646
7647 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7648 || obfd->xvec->flavour != bfd_target_elf_flavour)
7649 return TRUE;
7650
ba85c43e
NC
7651 BFD_ASSERT (elf_section_data (osec) != NULL);
7652
dfa7b0b8
AM
7653 /* For objcopy and relocatable link, don't copy the output ELF
7654 section type from input if the output BFD section flags have been
7655 set to something different. For a final link allow some flags
7656 that the linker clears to differ. */
42bb2e33 7657 if (elf_section_type (osec) == SHT_NULL
dfa7b0b8
AM
7658 && (osec->flags == isec->flags
7659 || (final_link
7660 && ((osec->flags ^ isec->flags)
0814be7d 7661 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
42bb2e33 7662 elf_section_type (osec) = elf_section_type (isec);
d270463e
L
7663
7664 /* FIXME: Is this correct for all OS/PROC specific flags? */
7665 elf_section_flags (osec) |= (elf_section_flags (isec)
7666 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a 7667
a91e1603
L
7668 /* Copy sh_info from input for mbind section. */
7669 if (elf_section_flags (isec) & SHF_GNU_MBIND)
7670 elf_section_data (osec)->this_hdr.sh_info
7671 = elf_section_data (isec)->this_hdr.sh_info;
7672
ccd2ec6a
L
7673 /* Set things up for objcopy and relocatable link. The output
7674 SHT_GROUP section will have its elf_next_in_group pointing back
7675 to the input group members. Ignore linker created group section.
7676 See elfNN_ia64_object_p in elfxx-ia64.c. */
7bdf4127
AB
7677 if ((link_info == NULL
7678 || !link_info->resolve_section_groups)
7679 && (elf_sec_group (isec) == NULL
7680 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
ccd2ec6a 7681 {
7bdf4127
AB
7682 if (elf_section_flags (isec) & SHF_GROUP)
7683 elf_section_flags (osec) |= SHF_GROUP;
7684 elf_next_in_group (osec) = elf_next_in_group (isec);
7685 elf_section_data (osec)->group = elf_section_data (isec)->group;
ccd2ec6a
L
7686 }
7687
7bdf4127
AB
7688 /* If not decompress, preserve SHF_COMPRESSED. */
7689 if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7690 elf_section_flags (osec) |= (elf_section_flags (isec)
7691 & SHF_COMPRESSED);
7692
ccd2ec6a
L
7693 ihdr = &elf_section_data (isec)->this_hdr;
7694
7695 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7696 don't use the output section of the linked-to section since it
7697 may be NULL at this point. */
7698 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7699 {
7700 ohdr = &elf_section_data (osec)->this_hdr;
7701 ohdr->sh_flags |= SHF_LINK_ORDER;
7702 elf_linked_to_section (osec) = elf_linked_to_section (isec);
7703 }
7704
7705 osec->use_rela_p = isec->use_rela_p;
7706
7707 return TRUE;
7708}
7709
252b5132
RH
7710/* Copy private section information. This copies over the entsize
7711 field, and sometimes the info field. */
7712
b34976b6 7713bfd_boolean
217aa764
AM
7714_bfd_elf_copy_private_section_data (bfd *ibfd,
7715 asection *isec,
7716 bfd *obfd,
7717 asection *osec)
252b5132
RH
7718{
7719 Elf_Internal_Shdr *ihdr, *ohdr;
7720
7721 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7722 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 7723 return TRUE;
252b5132 7724
252b5132
RH
7725 ihdr = &elf_section_data (isec)->this_hdr;
7726 ohdr = &elf_section_data (osec)->this_hdr;
7727
7728 ohdr->sh_entsize = ihdr->sh_entsize;
7729
7730 if (ihdr->sh_type == SHT_SYMTAB
7731 || ihdr->sh_type == SHT_DYNSYM
7732 || ihdr->sh_type == SHT_GNU_verneed
7733 || ihdr->sh_type == SHT_GNU_verdef)
7734 ohdr->sh_info = ihdr->sh_info;
7735
ccd2ec6a
L
7736 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7737 NULL);
252b5132
RH
7738}
7739
d0bf826b
AM
7740/* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7741 necessary if we are removing either the SHT_GROUP section or any of
7742 the group member sections. DISCARDED is the value that a section's
7743 output_section has if the section will be discarded, NULL when this
7744 function is called from objcopy, bfd_abs_section_ptr when called
7745 from the linker. */
80fccad2
BW
7746
7747bfd_boolean
d0bf826b 7748_bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
80fccad2 7749{
30288845
AM
7750 asection *isec;
7751
30288845 7752 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
415f38a6 7753 if (elf_section_type (isec) == SHT_GROUP)
30288845
AM
7754 {
7755 asection *first = elf_next_in_group (isec);
7756 asection *s = first;
d0bf826b
AM
7757 bfd_size_type removed = 0;
7758
30288845
AM
7759 while (s != NULL)
7760 {
415f38a6
AM
7761 /* If this member section is being output but the
7762 SHT_GROUP section is not, then clear the group info
7763 set up by _bfd_elf_copy_private_section_data. */
d0bf826b
AM
7764 if (s->output_section != discarded
7765 && isec->output_section == discarded)
30288845
AM
7766 {
7767 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7768 elf_group_name (s->output_section) = NULL;
7769 }
415f38a6
AM
7770 /* Conversely, if the member section is not being output
7771 but the SHT_GROUP section is, then adjust its size. */
d0bf826b
AM
7772 else if (s->output_section == discarded
7773 && isec->output_section != discarded)
6e5e9d58
AM
7774 {
7775 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7776 removed += 4;
7777 if (elf_sec->rel.hdr != NULL
7778 && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7779 removed += 4;
7780 if (elf_sec->rela.hdr != NULL
7781 && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7782 removed += 4;
7783 }
30288845
AM
7784 s = elf_next_in_group (s);
7785 if (s == first)
7786 break;
7787 }
d0bf826b
AM
7788 if (removed != 0)
7789 {
7790 if (discarded != NULL)
7791 {
7792 /* If we've been called for ld -r, then we need to
6e5e9d58 7793 adjust the input section size. */
d0bf826b
AM
7794 if (isec->rawsize == 0)
7795 isec->rawsize = isec->size;
7796 isec->size = isec->rawsize - removed;
6e5e9d58
AM
7797 if (isec->size <= 4)
7798 {
7799 isec->size = 0;
7800 isec->flags |= SEC_EXCLUDE;
7801 }
d0bf826b
AM
7802 }
7803 else
7804 {
7805 /* Adjust the output section size when called from
7806 objcopy. */
7807 isec->output_section->size -= removed;
6e5e9d58
AM
7808 if (isec->output_section->size <= 4)
7809 {
7810 isec->output_section->size = 0;
7811 isec->output_section->flags |= SEC_EXCLUDE;
7812 }
d0bf826b
AM
7813 }
7814 }
30288845
AM
7815 }
7816
80fccad2
BW
7817 return TRUE;
7818}
7819
d0bf826b
AM
7820/* Copy private header information. */
7821
7822bfd_boolean
7823_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7824{
7825 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7826 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7827 return TRUE;
7828
7829 /* Copy over private BFD data if it has not already been copied.
7830 This must be done here, rather than in the copy_private_bfd_data
7831 entry point, because the latter is called after the section
7832 contents have been set, which means that the program headers have
7833 already been worked out. */
12bd6957 7834 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
d0bf826b
AM
7835 {
7836 if (! copy_private_bfd_data (ibfd, obfd))
7837 return FALSE;
7838 }
7839
7840 return _bfd_elf_fixup_group_sections (ibfd, NULL);
7841}
7842
252b5132
RH
7843/* Copy private symbol information. If this symbol is in a section
7844 which we did not map into a BFD section, try to map the section
7845 index correctly. We use special macro definitions for the mapped
7846 section indices; these definitions are interpreted by the
7847 swap_out_syms function. */
7848
9ad5cbcf
AM
7849#define MAP_ONESYMTAB (SHN_HIOS + 1)
7850#define MAP_DYNSYMTAB (SHN_HIOS + 2)
7851#define MAP_STRTAB (SHN_HIOS + 3)
7852#define MAP_SHSTRTAB (SHN_HIOS + 4)
7853#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 7854
b34976b6 7855bfd_boolean
217aa764
AM
7856_bfd_elf_copy_private_symbol_data (bfd *ibfd,
7857 asymbol *isymarg,
7858 bfd *obfd,
7859 asymbol *osymarg)
252b5132
RH
7860{
7861 elf_symbol_type *isym, *osym;
7862
7863 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7864 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 7865 return TRUE;
252b5132
RH
7866
7867 isym = elf_symbol_from (ibfd, isymarg);
7868 osym = elf_symbol_from (obfd, osymarg);
7869
7870 if (isym != NULL
8424d8f5 7871 && isym->internal_elf_sym.st_shndx != 0
252b5132
RH
7872 && osym != NULL
7873 && bfd_is_abs_section (isym->symbol.section))
7874 {
7875 unsigned int shndx;
7876
7877 shndx = isym->internal_elf_sym.st_shndx;
7878 if (shndx == elf_onesymtab (ibfd))
7879 shndx = MAP_ONESYMTAB;
7880 else if (shndx == elf_dynsymtab (ibfd))
7881 shndx = MAP_DYNSYMTAB;
12bd6957 7882 else if (shndx == elf_strtab_sec (ibfd))
252b5132 7883 shndx = MAP_STRTAB;
12bd6957 7884 else if (shndx == elf_shstrtab_sec (ibfd))
252b5132 7885 shndx = MAP_SHSTRTAB;
6a40cf0c 7886 else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
9ad5cbcf 7887 shndx = MAP_SYM_SHNDX;
252b5132
RH
7888 osym->internal_elf_sym.st_shndx = shndx;
7889 }
7890
b34976b6 7891 return TRUE;
252b5132
RH
7892}
7893
7894/* Swap out the symbols. */
7895
b34976b6 7896static bfd_boolean
217aa764 7897swap_out_syms (bfd *abfd,
ef10c3ac 7898 struct elf_strtab_hash **sttp,
217aa764 7899 int relocatable_p)
252b5132 7900{
9c5bfbb7 7901 const struct elf_backend_data *bed;
079e9a2f
AM
7902 int symcount;
7903 asymbol **syms;
ef10c3ac 7904 struct elf_strtab_hash *stt;
079e9a2f 7905 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 7906 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 7907 Elf_Internal_Shdr *symstrtab_hdr;
ef10c3ac 7908 struct elf_sym_strtab *symstrtab;
f075ee0c
AM
7909 bfd_byte *outbound_syms;
7910 bfd_byte *outbound_shndx;
ef10c3ac
L
7911 unsigned long outbound_syms_index;
7912 unsigned long outbound_shndx_index;
079e9a2f 7913 int idx;
12bd6957 7914 unsigned int num_locals;
079e9a2f 7915 bfd_size_type amt;
174fd7f9 7916 bfd_boolean name_local_sections;
252b5132 7917
12bd6957 7918 if (!elf_map_symbols (abfd, &num_locals))
b34976b6 7919 return FALSE;
252b5132 7920
c044fabd 7921 /* Dump out the symtabs. */
ef10c3ac 7922 stt = _bfd_elf_strtab_init ();
079e9a2f 7923 if (stt == NULL)
b34976b6 7924 return FALSE;
252b5132 7925
079e9a2f
AM
7926 bed = get_elf_backend_data (abfd);
7927 symcount = bfd_get_symcount (abfd);
7928 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7929 symtab_hdr->sh_type = SHT_SYMTAB;
7930 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7931 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
12bd6957 7932 symtab_hdr->sh_info = num_locals + 1;
72de5009 7933 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
079e9a2f
AM
7934
7935 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7936 symstrtab_hdr->sh_type = SHT_STRTAB;
7937
ef10c3ac 7938 /* Allocate buffer to swap out the .strtab section. */
7a6e0d89
AM
7939 symstrtab = (struct elf_sym_strtab *) bfd_malloc2 (symcount + 1,
7940 sizeof (*symstrtab));
ef10c3ac
L
7941 if (symstrtab == NULL)
7942 {
7943 _bfd_elf_strtab_free (stt);
7944 return FALSE;
7945 }
7946
a50b1753 7947 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
07d6d2b8 7948 bed->s->sizeof_sym);
079e9a2f 7949 if (outbound_syms == NULL)
5ed6aba4 7950 {
ef10c3ac
L
7951error_return:
7952 _bfd_elf_strtab_free (stt);
7953 free (symstrtab);
5ed6aba4
NC
7954 return FALSE;
7955 }
217aa764 7956 symtab_hdr->contents = outbound_syms;
ef10c3ac 7957 outbound_syms_index = 0;
252b5132 7958
9ad5cbcf 7959 outbound_shndx = NULL;
ef10c3ac 7960 outbound_shndx_index = 0;
6a40cf0c
NC
7961
7962 if (elf_symtab_shndx_list (abfd))
9ad5cbcf 7963 {
6a40cf0c
NC
7964 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7965 if (symtab_shndx_hdr->sh_name != 0)
7966 {
7967 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7968 outbound_shndx = (bfd_byte *)
7969 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7970 if (outbound_shndx == NULL)
7971 goto error_return;
5ed6aba4 7972
6a40cf0c
NC
7973 symtab_shndx_hdr->contents = outbound_shndx;
7974 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7975 symtab_shndx_hdr->sh_size = amt;
7976 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7977 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7978 }
7979 /* FIXME: What about any other headers in the list ? */
9ad5cbcf
AM
7980 }
7981
589e6347 7982 /* Now generate the data (for "contents"). */
079e9a2f
AM
7983 {
7984 /* Fill in zeroth symbol and swap it out. */
7985 Elf_Internal_Sym sym;
7986 sym.st_name = 0;
7987 sym.st_value = 0;
7988 sym.st_size = 0;
7989 sym.st_info = 0;
7990 sym.st_other = 0;
7991 sym.st_shndx = SHN_UNDEF;
35fc36a8 7992 sym.st_target_internal = 0;
ef10c3ac
L
7993 symstrtab[0].sym = sym;
7994 symstrtab[0].dest_index = outbound_syms_index;
7995 symstrtab[0].destshndx_index = outbound_shndx_index;
7996 outbound_syms_index++;
9ad5cbcf 7997 if (outbound_shndx != NULL)
ef10c3ac 7998 outbound_shndx_index++;
079e9a2f 7999 }
252b5132 8000
174fd7f9
RS
8001 name_local_sections
8002 = (bed->elf_backend_name_local_section_symbols
8003 && bed->elf_backend_name_local_section_symbols (abfd));
8004
079e9a2f 8005 syms = bfd_get_outsymbols (abfd);
ef10c3ac 8006 for (idx = 0; idx < symcount;)
252b5132 8007 {
252b5132 8008 Elf_Internal_Sym sym;
079e9a2f
AM
8009 bfd_vma value = syms[idx]->value;
8010 elf_symbol_type *type_ptr;
8011 flagword flags = syms[idx]->flags;
8012 int type;
252b5132 8013
174fd7f9
RS
8014 if (!name_local_sections
8015 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM
8016 {
8017 /* Local section symbols have no name. */
ef10c3ac 8018 sym.st_name = (unsigned long) -1;
079e9a2f
AM
8019 }
8020 else
8021 {
ef10c3ac
L
8022 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8023 to get the final offset for st_name. */
8024 sym.st_name
8025 = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
8026 FALSE);
079e9a2f 8027 if (sym.st_name == (unsigned long) -1)
ef10c3ac 8028 goto error_return;
079e9a2f 8029 }
252b5132 8030
079e9a2f 8031 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 8032
079e9a2f
AM
8033 if ((flags & BSF_SECTION_SYM) == 0
8034 && bfd_is_com_section (syms[idx]->section))
8035 {
8036 /* ELF common symbols put the alignment into the `value' field,
8037 and the size into the `size' field. This is backwards from
8038 how BFD handles it, so reverse it here. */
8039 sym.st_size = value;
8040 if (type_ptr == NULL
8041 || type_ptr->internal_elf_sym.st_value == 0)
8042 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
8043 else
8044 sym.st_value = type_ptr->internal_elf_sym.st_value;
8045 sym.st_shndx = _bfd_elf_section_from_bfd_section
8046 (abfd, syms[idx]->section);
8047 }
8048 else
8049 {
8050 asection *sec = syms[idx]->section;
cb33740c 8051 unsigned int shndx;
252b5132 8052
079e9a2f
AM
8053 if (sec->output_section)
8054 {
8055 value += sec->output_offset;
8056 sec = sec->output_section;
8057 }
589e6347 8058
079e9a2f
AM
8059 /* Don't add in the section vma for relocatable output. */
8060 if (! relocatable_p)
8061 value += sec->vma;
8062 sym.st_value = value;
8063 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
8064
8065 if (bfd_is_abs_section (sec)
8066 && type_ptr != NULL
8067 && type_ptr->internal_elf_sym.st_shndx != 0)
8068 {
8069 /* This symbol is in a real ELF section which we did
8070 not create as a BFD section. Undo the mapping done
8071 by copy_private_symbol_data. */
8072 shndx = type_ptr->internal_elf_sym.st_shndx;
8073 switch (shndx)
8074 {
8075 case MAP_ONESYMTAB:
8076 shndx = elf_onesymtab (abfd);
8077 break;
8078 case MAP_DYNSYMTAB:
8079 shndx = elf_dynsymtab (abfd);
8080 break;
8081 case MAP_STRTAB:
12bd6957 8082 shndx = elf_strtab_sec (abfd);
079e9a2f
AM
8083 break;
8084 case MAP_SHSTRTAB:
12bd6957 8085 shndx = elf_shstrtab_sec (abfd);
079e9a2f 8086 break;
9ad5cbcf 8087 case MAP_SYM_SHNDX:
6a40cf0c
NC
8088 if (elf_symtab_shndx_list (abfd))
8089 shndx = elf_symtab_shndx_list (abfd)->ndx;
9ad5cbcf 8090 break;
079e9a2f 8091 default:
15bc576a 8092 shndx = SHN_ABS;
079e9a2f
AM
8093 break;
8094 }
8095 }
8096 else
8097 {
8098 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 8099
cb33740c 8100 if (shndx == SHN_BAD)
079e9a2f
AM
8101 {
8102 asection *sec2;
8103
8104 /* Writing this would be a hell of a lot easier if
8105 we had some decent documentation on bfd, and
8106 knew what to expect of the library, and what to
8107 demand of applications. For example, it
8108 appears that `objcopy' might not set the
8109 section of a symbol to be a section that is
8110 actually in the output file. */
8111 sec2 = bfd_get_section_by_name (abfd, sec->name);
5df1bc57
AM
8112 if (sec2 != NULL)
8113 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
8114 if (shndx == SHN_BAD)
589e6347 8115 {
695344c0 8116 /* xgettext:c-format */
9793eb77
AM
8117 _bfd_error_handler
8118 (_("unable to find equivalent output section"
8119 " for symbol '%s' from section '%s'"),
8120 syms[idx]->name ? syms[idx]->name : "<Local sym>",
8121 sec->name);
811072d8 8122 bfd_set_error (bfd_error_invalid_operation);
ef10c3ac 8123 goto error_return;
589e6347 8124 }
079e9a2f
AM
8125 }
8126 }
252b5132 8127
079e9a2f
AM
8128 sym.st_shndx = shndx;
8129 }
252b5132 8130
13ae64f3
JJ
8131 if ((flags & BSF_THREAD_LOCAL) != 0)
8132 type = STT_TLS;
d8045f23
NC
8133 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
8134 type = STT_GNU_IFUNC;
13ae64f3 8135 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM
8136 type = STT_FUNC;
8137 else if ((flags & BSF_OBJECT) != 0)
8138 type = STT_OBJECT;
d9352518
DB
8139 else if ((flags & BSF_RELC) != 0)
8140 type = STT_RELC;
8141 else if ((flags & BSF_SRELC) != 0)
8142 type = STT_SRELC;
079e9a2f
AM
8143 else
8144 type = STT_NOTYPE;
252b5132 8145
13ae64f3
JJ
8146 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
8147 type = STT_TLS;
8148
589e6347 8149 /* Processor-specific types. */
079e9a2f
AM
8150 if (type_ptr != NULL
8151 && bed->elf_backend_get_symbol_type)
8152 type = ((*bed->elf_backend_get_symbol_type)
8153 (&type_ptr->internal_elf_sym, type));
252b5132 8154
079e9a2f
AM
8155 if (flags & BSF_SECTION_SYM)
8156 {
8157 if (flags & BSF_GLOBAL)
8158 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8159 else
8160 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
8161 }
8162 else if (bfd_is_com_section (syms[idx]->section))
0a40daed 8163 {
b8871f35
L
8164 if (type != STT_TLS)
8165 {
8166 if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8167 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8168 ? STT_COMMON : STT_OBJECT);
8169 else
8170 type = ((flags & BSF_ELF_COMMON) != 0
8171 ? STT_COMMON : STT_OBJECT);
8172 }
8173 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
0a40daed 8174 }
079e9a2f
AM
8175 else if (bfd_is_und_section (syms[idx]->section))
8176 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8177 ? STB_WEAK
8178 : STB_GLOBAL),
8179 type);
8180 else if (flags & BSF_FILE)
8181 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8182 else
8183 {
8184 int bind = STB_LOCAL;
252b5132 8185
079e9a2f
AM
8186 if (flags & BSF_LOCAL)
8187 bind = STB_LOCAL;
3e7a7d11
NC
8188 else if (flags & BSF_GNU_UNIQUE)
8189 bind = STB_GNU_UNIQUE;
079e9a2f
AM
8190 else if (flags & BSF_WEAK)
8191 bind = STB_WEAK;
8192 else if (flags & BSF_GLOBAL)
8193 bind = STB_GLOBAL;
252b5132 8194
079e9a2f
AM
8195 sym.st_info = ELF_ST_INFO (bind, type);
8196 }
252b5132 8197
079e9a2f 8198 if (type_ptr != NULL)
35fc36a8
RS
8199 {
8200 sym.st_other = type_ptr->internal_elf_sym.st_other;
8201 sym.st_target_internal
8202 = type_ptr->internal_elf_sym.st_target_internal;
8203 }
079e9a2f 8204 else
35fc36a8
RS
8205 {
8206 sym.st_other = 0;
8207 sym.st_target_internal = 0;
8208 }
252b5132 8209
ef10c3ac
L
8210 idx++;
8211 symstrtab[idx].sym = sym;
8212 symstrtab[idx].dest_index = outbound_syms_index;
8213 symstrtab[idx].destshndx_index = outbound_shndx_index;
8214
8215 outbound_syms_index++;
9ad5cbcf 8216 if (outbound_shndx != NULL)
ef10c3ac
L
8217 outbound_shndx_index++;
8218 }
8219
8220 /* Finalize the .strtab section. */
8221 _bfd_elf_strtab_finalize (stt);
8222
8223 /* Swap out the .strtab section. */
8224 for (idx = 0; idx <= symcount; idx++)
8225 {
8226 struct elf_sym_strtab *elfsym = &symstrtab[idx];
8227 if (elfsym->sym.st_name == (unsigned long) -1)
8228 elfsym->sym.st_name = 0;
8229 else
8230 elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8231 elfsym->sym.st_name);
8232 bed->s->swap_symbol_out (abfd, &elfsym->sym,
8233 (outbound_syms
8234 + (elfsym->dest_index
8235 * bed->s->sizeof_sym)),
8236 (outbound_shndx
8237 + (elfsym->destshndx_index
8238 * sizeof (Elf_External_Sym_Shndx))));
079e9a2f 8239 }
ef10c3ac 8240 free (symstrtab);
252b5132 8241
079e9a2f 8242 *sttp = stt;
ef10c3ac 8243 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
079e9a2f 8244 symstrtab_hdr->sh_type = SHT_STRTAB;
84865015 8245 symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
079e9a2f
AM
8246 symstrtab_hdr->sh_addr = 0;
8247 symstrtab_hdr->sh_entsize = 0;
8248 symstrtab_hdr->sh_link = 0;
8249 symstrtab_hdr->sh_info = 0;
8250 symstrtab_hdr->sh_addralign = 1;
252b5132 8251
b34976b6 8252 return TRUE;
252b5132
RH
8253}
8254
8255/* Return the number of bytes required to hold the symtab vector.
8256
8257 Note that we base it on the count plus 1, since we will null terminate
8258 the vector allocated based on this size. However, the ELF symbol table
8259 always has a dummy entry as symbol #0, so it ends up even. */
8260
8261long
217aa764 8262_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132 8263{
3a551c7a 8264 bfd_size_type symcount;
252b5132
RH
8265 long symtab_size;
8266 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8267
8268 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3a551c7a
AM
8269 if (symcount >= LONG_MAX / sizeof (asymbol *))
8270 {
8271 bfd_set_error (bfd_error_file_too_big);
8272 return -1;
8273 }
b99d1833
AM
8274 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8275 if (symcount > 0)
8276 symtab_size -= sizeof (asymbol *);
252b5132
RH
8277
8278 return symtab_size;
8279}
8280
8281long
217aa764 8282_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132 8283{
3a551c7a 8284 bfd_size_type symcount;
252b5132
RH
8285 long symtab_size;
8286 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8287
8288 if (elf_dynsymtab (abfd) == 0)
8289 {
8290 bfd_set_error (bfd_error_invalid_operation);
8291 return -1;
8292 }
8293
8294 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3a551c7a
AM
8295 if (symcount >= LONG_MAX / sizeof (asymbol *))
8296 {
8297 bfd_set_error (bfd_error_file_too_big);
8298 return -1;
8299 }
b99d1833
AM
8300 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8301 if (symcount > 0)
8302 symtab_size -= sizeof (asymbol *);
252b5132
RH
8303
8304 return symtab_size;
8305}
8306
8307long
217aa764
AM
8308_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8309 sec_ptr asect)
252b5132 8310{
242a1159 8311#if SIZEOF_LONG == SIZEOF_INT
7a6e0d89
AM
8312 if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
8313 {
8314 bfd_set_error (bfd_error_file_too_big);
8315 return -1;
8316 }
242a1159 8317#endif
252b5132
RH
8318 return (asect->reloc_count + 1) * sizeof (arelent *);
8319}
8320
8321/* Canonicalize the relocs. */
8322
8323long
217aa764
AM
8324_bfd_elf_canonicalize_reloc (bfd *abfd,
8325 sec_ptr section,
8326 arelent **relptr,
8327 asymbol **symbols)
252b5132
RH
8328{
8329 arelent *tblptr;
8330 unsigned int i;
9c5bfbb7 8331 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 8332
b34976b6 8333 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH
8334 return -1;
8335
8336 tblptr = section->relocation;
8337 for (i = 0; i < section->reloc_count; i++)
8338 *relptr++ = tblptr++;
8339
8340 *relptr = NULL;
8341
8342 return section->reloc_count;
8343}
8344
8345long
6cee3f79 8346_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 8347{
9c5bfbb7 8348 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 8349 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH
8350
8351 if (symcount >= 0)
8352 bfd_get_symcount (abfd) = symcount;
8353 return symcount;
8354}
8355
8356long
217aa764
AM
8357_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8358 asymbol **allocation)
252b5132 8359{
9c5bfbb7 8360 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 8361 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ
8362
8363 if (symcount >= 0)
8364 bfd_get_dynamic_symcount (abfd) = symcount;
8365 return symcount;
252b5132
RH
8366}
8367
8615f3f2
AM
8368/* Return the size required for the dynamic reloc entries. Any loadable
8369 section that was actually installed in the BFD, and has type SHT_REL
8370 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8371 dynamic reloc section. */
252b5132
RH
8372
8373long
217aa764 8374_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132 8375{
3a551c7a 8376 bfd_size_type count;
252b5132
RH
8377 asection *s;
8378
8379 if (elf_dynsymtab (abfd) == 0)
8380 {
8381 bfd_set_error (bfd_error_invalid_operation);
8382 return -1;
8383 }
8384
3a551c7a 8385 count = 1;
252b5132 8386 for (s = abfd->sections; s != NULL; s = s->next)
266b05cf 8387 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH
8388 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8389 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
3a551c7a
AM
8390 {
8391 count += s->size / elf_section_data (s)->this_hdr.sh_entsize;
8392 if (count > LONG_MAX / sizeof (arelent *))
8393 {
8394 bfd_set_error (bfd_error_file_too_big);
8395 return -1;
8396 }
8397 }
8398 return count * sizeof (arelent *);
252b5132
RH
8399}
8400
8615f3f2
AM
8401/* Canonicalize the dynamic relocation entries. Note that we return the
8402 dynamic relocations as a single block, although they are actually
8403 associated with particular sections; the interface, which was
8404 designed for SunOS style shared libraries, expects that there is only
8405 one set of dynamic relocs. Any loadable section that was actually
8406 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8407 dynamic symbol table, is considered to be a dynamic reloc section. */
252b5132
RH
8408
8409long
217aa764
AM
8410_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8411 arelent **storage,
8412 asymbol **syms)
252b5132 8413{
217aa764 8414 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH
8415 asection *s;
8416 long ret;
8417
8418 if (elf_dynsymtab (abfd) == 0)
8419 {
8420 bfd_set_error (bfd_error_invalid_operation);
8421 return -1;
8422 }
8423
8424 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8425 ret = 0;
8426 for (s = abfd->sections; s != NULL; s = s->next)
8427 {
266b05cf 8428 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH
8429 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8430 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8431 {
8432 arelent *p;
8433 long count, i;
8434
b34976b6 8435 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 8436 return -1;
eea6121a 8437 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH
8438 p = s->relocation;
8439 for (i = 0; i < count; i++)
8440 *storage++ = p++;
8441 ret += count;
8442 }
8443 }
8444
8445 *storage = NULL;
8446
8447 return ret;
8448}
8449\f
8450/* Read in the version information. */
8451
b34976b6 8452bfd_boolean
fc0e6df6 8453_bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
252b5132
RH
8454{
8455 bfd_byte *contents = NULL;
fc0e6df6
PB
8456 unsigned int freeidx = 0;
8457
8458 if (elf_dynverref (abfd) != 0)
8459 {
8460 Elf_Internal_Shdr *hdr;
8461 Elf_External_Verneed *everneed;
8462 Elf_Internal_Verneed *iverneed;
8463 unsigned int i;
d0fb9a8d 8464 bfd_byte *contents_end;
fc0e6df6
PB
8465
8466 hdr = &elf_tdata (abfd)->dynverref_hdr;
8467
bd61e135
AM
8468 if (hdr->sh_info == 0
8469 || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
d0fb9a8d 8470 {
601a03ba 8471error_return_bad_verref:
4eca0228 8472 _bfd_error_handler
871b3ab2 8473 (_("%pB: .gnu.version_r invalid entry"), abfd);
601a03ba 8474 bfd_set_error (bfd_error_bad_value);
d0fb9a8d
JJ
8475error_return_verref:
8476 elf_tdata (abfd)->verref = NULL;
8477 elf_tdata (abfd)->cverrefs = 0;
8478 goto error_return;
8479 }
601a03ba 8480
7e56c51c
NC
8481 ufile_ptr filesize = bfd_get_file_size (abfd);
8482 if (filesize > 0 && filesize < hdr->sh_size)
8483 {
8484 /* PR 24708: Avoid attempts to allocate a ridiculous amount
8485 of memory. */
8486 bfd_set_error (bfd_error_no_memory);
8487 _bfd_error_handler
8488 /* xgettext:c-format */
8489 (_("error: %pB version reference section is too large (%#" PRIx64 " bytes)"),
8490 abfd, (uint64_t) hdr->sh_size);
8491 goto error_return_verref;
8492 }
601a03ba
AM
8493 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8494 if (contents == NULL)
8495 goto error_return_verref;
8496
fc0e6df6
PB
8497 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8498 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
d0fb9a8d 8499 goto error_return_verref;
fc0e6df6 8500
601a03ba 8501 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
bd61e135 8502 bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
601a03ba
AM
8503
8504 if (elf_tdata (abfd)->verref == NULL)
d0fb9a8d
JJ
8505 goto error_return_verref;
8506
8507 BFD_ASSERT (sizeof (Elf_External_Verneed)
8508 == sizeof (Elf_External_Vernaux));
8509 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
fc0e6df6
PB
8510 everneed = (Elf_External_Verneed *) contents;
8511 iverneed = elf_tdata (abfd)->verref;
8512 for (i = 0; i < hdr->sh_info; i++, iverneed++)
8513 {
8514 Elf_External_Vernaux *evernaux;
8515 Elf_Internal_Vernaux *ivernaux;
8516 unsigned int j;
8517
8518 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8519
8520 iverneed->vn_bfd = abfd;
8521
8522 iverneed->vn_filename =
8523 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8524 iverneed->vn_file);
8525 if (iverneed->vn_filename == NULL)
601a03ba 8526 goto error_return_bad_verref;
fc0e6df6 8527
d0fb9a8d
JJ
8528 if (iverneed->vn_cnt == 0)
8529 iverneed->vn_auxptr = NULL;
8530 else
8531 {
a50b1753 8532 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
07d6d2b8
AM
8533 bfd_alloc2 (abfd, iverneed->vn_cnt,
8534 sizeof (Elf_Internal_Vernaux));
d0fb9a8d
JJ
8535 if (iverneed->vn_auxptr == NULL)
8536 goto error_return_verref;
8537 }
8538
8539 if (iverneed->vn_aux
8540 > (size_t) (contents_end - (bfd_byte *) everneed))
601a03ba 8541 goto error_return_bad_verref;
fc0e6df6
PB
8542
8543 evernaux = ((Elf_External_Vernaux *)
8544 ((bfd_byte *) everneed + iverneed->vn_aux));
8545 ivernaux = iverneed->vn_auxptr;
8546 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8547 {
8548 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8549
8550 ivernaux->vna_nodename =
8551 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8552 ivernaux->vna_name);
8553 if (ivernaux->vna_nodename == NULL)
601a03ba 8554 goto error_return_bad_verref;
fc0e6df6 8555
25ff461f
AM
8556 if (ivernaux->vna_other > freeidx)
8557 freeidx = ivernaux->vna_other;
8558
8559 ivernaux->vna_nextptr = NULL;
8560 if (ivernaux->vna_next == 0)
8561 {
8562 iverneed->vn_cnt = j + 1;
8563 break;
8564 }
fc0e6df6
PB
8565 if (j + 1 < iverneed->vn_cnt)
8566 ivernaux->vna_nextptr = ivernaux + 1;
fc0e6df6 8567
d0fb9a8d
JJ
8568 if (ivernaux->vna_next
8569 > (size_t) (contents_end - (bfd_byte *) evernaux))
601a03ba 8570 goto error_return_bad_verref;
d0fb9a8d 8571
fc0e6df6
PB
8572 evernaux = ((Elf_External_Vernaux *)
8573 ((bfd_byte *) evernaux + ivernaux->vna_next));
fc0e6df6
PB
8574 }
8575
25ff461f
AM
8576 iverneed->vn_nextref = NULL;
8577 if (iverneed->vn_next == 0)
8578 break;
fc0e6df6
PB
8579 if (i + 1 < hdr->sh_info)
8580 iverneed->vn_nextref = iverneed + 1;
fc0e6df6 8581
d0fb9a8d
JJ
8582 if (iverneed->vn_next
8583 > (size_t) (contents_end - (bfd_byte *) everneed))
601a03ba 8584 goto error_return_bad_verref;
d0fb9a8d 8585
fc0e6df6
PB
8586 everneed = ((Elf_External_Verneed *)
8587 ((bfd_byte *) everneed + iverneed->vn_next));
8588 }
25ff461f 8589 elf_tdata (abfd)->cverrefs = i;
fc0e6df6
PB
8590
8591 free (contents);
8592 contents = NULL;
8593 }
252b5132
RH
8594
8595 if (elf_dynverdef (abfd) != 0)
8596 {
8597 Elf_Internal_Shdr *hdr;
8598 Elf_External_Verdef *everdef;
8599 Elf_Internal_Verdef *iverdef;
f631889e
UD
8600 Elf_Internal_Verdef *iverdefarr;
8601 Elf_Internal_Verdef iverdefmem;
252b5132 8602 unsigned int i;
062e2358 8603 unsigned int maxidx;
d0fb9a8d 8604 bfd_byte *contents_end_def, *contents_end_aux;
252b5132
RH
8605
8606 hdr = &elf_tdata (abfd)->dynverdef_hdr;
8607
601a03ba
AM
8608 if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8609 {
8610 error_return_bad_verdef:
4eca0228 8611 _bfd_error_handler
871b3ab2 8612 (_("%pB: .gnu.version_d invalid entry"), abfd);
601a03ba
AM
8613 bfd_set_error (bfd_error_bad_value);
8614 error_return_verdef:
8615 elf_tdata (abfd)->verdef = NULL;
8616 elf_tdata (abfd)->cverdefs = 0;
8617 goto error_return;
8618 }
8619
a50b1753 8620 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
252b5132 8621 if (contents == NULL)
601a03ba 8622 goto error_return_verdef;
252b5132 8623 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 8624 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
601a03ba 8625 goto error_return_verdef;
d0fb9a8d
JJ
8626
8627 BFD_ASSERT (sizeof (Elf_External_Verdef)
8628 >= sizeof (Elf_External_Verdaux));
8629 contents_end_def = contents + hdr->sh_size
8630 - sizeof (Elf_External_Verdef);
8631 contents_end_aux = contents + hdr->sh_size
8632 - sizeof (Elf_External_Verdaux);
8633
f631889e
UD
8634 /* We know the number of entries in the section but not the maximum
8635 index. Therefore we have to run through all entries and find
8636 the maximum. */
252b5132 8637 everdef = (Elf_External_Verdef *) contents;
f631889e
UD
8638 maxidx = 0;
8639 for (i = 0; i < hdr->sh_info; ++i)
8640 {
8641 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8642
601a03ba
AM
8643 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8644 goto error_return_bad_verdef;
062e2358
AM
8645 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8646 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e 8647
25ff461f
AM
8648 if (iverdefmem.vd_next == 0)
8649 break;
8650
d0fb9a8d
JJ
8651 if (iverdefmem.vd_next
8652 > (size_t) (contents_end_def - (bfd_byte *) everdef))
601a03ba 8653 goto error_return_bad_verdef;
d0fb9a8d 8654
f631889e
UD
8655 everdef = ((Elf_External_Verdef *)
8656 ((bfd_byte *) everdef + iverdefmem.vd_next));
8657 }
8658
fc0e6df6
PB
8659 if (default_imported_symver)
8660 {
8661 if (freeidx > maxidx)
8662 maxidx = ++freeidx;
8663 else
8664 freeidx = ++maxidx;
8665 }
201159ec 8666
601a03ba
AM
8667 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8668 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
f631889e 8669 if (elf_tdata (abfd)->verdef == NULL)
601a03ba 8670 goto error_return_verdef;
f631889e
UD
8671
8672 elf_tdata (abfd)->cverdefs = maxidx;
8673
8674 everdef = (Elf_External_Verdef *) contents;
8675 iverdefarr = elf_tdata (abfd)->verdef;
8676 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH
8677 {
8678 Elf_External_Verdaux *everdaux;
8679 Elf_Internal_Verdaux *iverdaux;
8680 unsigned int j;
8681
f631889e
UD
8682 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8683
d0fb9a8d 8684 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
601a03ba 8685 goto error_return_bad_verdef;
d0fb9a8d 8686
f631889e 8687 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
595bce75 8688 memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
252b5132
RH
8689
8690 iverdef->vd_bfd = abfd;
8691
d0fb9a8d
JJ
8692 if (iverdef->vd_cnt == 0)
8693 iverdef->vd_auxptr = NULL;
8694 else
8695 {
a50b1753 8696 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
07d6d2b8
AM
8697 bfd_alloc2 (abfd, iverdef->vd_cnt,
8698 sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ
8699 if (iverdef->vd_auxptr == NULL)
8700 goto error_return_verdef;
8701 }
8702
8703 if (iverdef->vd_aux
8704 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
601a03ba 8705 goto error_return_bad_verdef;
252b5132
RH
8706
8707 everdaux = ((Elf_External_Verdaux *)
8708 ((bfd_byte *) everdef + iverdef->vd_aux));
8709 iverdaux = iverdef->vd_auxptr;
8710 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8711 {
8712 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8713
8714 iverdaux->vda_nodename =
8715 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8716 iverdaux->vda_name);
8717 if (iverdaux->vda_nodename == NULL)
601a03ba 8718 goto error_return_bad_verdef;
252b5132 8719
25ff461f
AM
8720 iverdaux->vda_nextptr = NULL;
8721 if (iverdaux->vda_next == 0)
8722 {
8723 iverdef->vd_cnt = j + 1;
8724 break;
8725 }
252b5132
RH
8726 if (j + 1 < iverdef->vd_cnt)
8727 iverdaux->vda_nextptr = iverdaux + 1;
252b5132 8728
d0fb9a8d
JJ
8729 if (iverdaux->vda_next
8730 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
601a03ba 8731 goto error_return_bad_verdef;
d0fb9a8d 8732
252b5132
RH
8733 everdaux = ((Elf_External_Verdaux *)
8734 ((bfd_byte *) everdaux + iverdaux->vda_next));
8735 }
8736
595bce75 8737 iverdef->vd_nodename = NULL;
d0fb9a8d
JJ
8738 if (iverdef->vd_cnt)
8739 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
252b5132 8740
25ff461f
AM
8741 iverdef->vd_nextdef = NULL;
8742 if (iverdef->vd_next == 0)
8743 break;
d0fb9a8d 8744 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
252b5132 8745 iverdef->vd_nextdef = iverdef + 1;
252b5132
RH
8746
8747 everdef = ((Elf_External_Verdef *)
8748 ((bfd_byte *) everdef + iverdef->vd_next));
8749 }
8750
8751 free (contents);
8752 contents = NULL;
8753 }
fc0e6df6 8754 else if (default_imported_symver)
252b5132 8755 {
fc0e6df6
PB
8756 if (freeidx < 3)
8757 freeidx = 3;
8758 else
8759 freeidx++;
252b5132 8760
a50b1753 8761 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
07d6d2b8 8762 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
fc0e6df6 8763 if (elf_tdata (abfd)->verdef == NULL)
252b5132
RH
8764 goto error_return;
8765
fc0e6df6
PB
8766 elf_tdata (abfd)->cverdefs = freeidx;
8767 }
252b5132 8768
fc0e6df6
PB
8769 /* Create a default version based on the soname. */
8770 if (default_imported_symver)
8771 {
8772 Elf_Internal_Verdef *iverdef;
8773 Elf_Internal_Verdaux *iverdaux;
252b5132 8774
5bb3703f 8775 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
252b5132 8776
fc0e6df6
PB
8777 iverdef->vd_version = VER_DEF_CURRENT;
8778 iverdef->vd_flags = 0;
8779 iverdef->vd_ndx = freeidx;
8780 iverdef->vd_cnt = 1;
252b5132 8781
fc0e6df6 8782 iverdef->vd_bfd = abfd;
252b5132 8783
fc0e6df6
PB
8784 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8785 if (iverdef->vd_nodename == NULL)
d0fb9a8d 8786 goto error_return_verdef;
fc0e6df6 8787 iverdef->vd_nextdef = NULL;
601a03ba
AM
8788 iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8789 bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
d0fb9a8d
JJ
8790 if (iverdef->vd_auxptr == NULL)
8791 goto error_return_verdef;
252b5132 8792
fc0e6df6
PB
8793 iverdaux = iverdef->vd_auxptr;
8794 iverdaux->vda_nodename = iverdef->vd_nodename;
252b5132
RH
8795 }
8796
b34976b6 8797 return TRUE;
252b5132
RH
8798
8799 error_return:
5ed6aba4 8800 if (contents != NULL)
252b5132 8801 free (contents);
b34976b6 8802 return FALSE;
252b5132
RH
8803}
8804\f
8805asymbol *
217aa764 8806_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH
8807{
8808 elf_symbol_type *newsym;
8809
7a6e0d89 8810 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (*newsym));
252b5132
RH
8811 if (!newsym)
8812 return NULL;
201159ec
NC
8813 newsym->symbol.the_bfd = abfd;
8814 return &newsym->symbol;
252b5132
RH
8815}
8816
8817void
217aa764
AM
8818_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8819 asymbol *symbol,
8820 symbol_info *ret)
252b5132
RH
8821{
8822 bfd_symbol_info (symbol, ret);
8823}
8824
8825/* Return whether a symbol name implies a local symbol. Most targets
8826 use this function for the is_local_label_name entry point, but some
8827 override it. */
8828
b34976b6 8829bfd_boolean
217aa764
AM
8830_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8831 const char *name)
252b5132
RH
8832{
8833 /* Normal local symbols start with ``.L''. */
8834 if (name[0] == '.' && name[1] == 'L')
b34976b6 8835 return TRUE;
252b5132
RH
8836
8837 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8838 DWARF debugging symbols starting with ``..''. */
8839 if (name[0] == '.' && name[1] == '.')
b34976b6 8840 return TRUE;
252b5132
RH
8841
8842 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8843 emitting DWARF debugging output. I suspect this is actually a
8844 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8845 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8846 underscore to be emitted on some ELF targets). For ease of use,
8847 we treat such symbols as local. */
8848 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 8849 return TRUE;
252b5132 8850
b1fa9dd6
NC
8851 /* Treat assembler generated fake symbols, dollar local labels and
8852 forward-backward labels (aka local labels) as locals.
8853 These labels have the form:
8854
07d6d2b8 8855 L0^A.* (fake symbols)
b1fa9dd6
NC
8856
8857 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8858
8859 Versions which start with .L will have already been matched above,
8860 so we only need to match the rest. */
8861 if (name[0] == 'L' && ISDIGIT (name[1]))
8862 {
8863 bfd_boolean ret = FALSE;
8864 const char * p;
8865 char c;
8866
8867 for (p = name + 2; (c = *p); p++)
8868 {
8869 if (c == 1 || c == 2)
8870 {
8871 if (c == 1 && p == name + 2)
8872 /* A fake symbol. */
8873 return TRUE;
8874
8875 /* FIXME: We are being paranoid here and treating symbols like
8876 L0^Bfoo as if there were non-local, on the grounds that the
8877 assembler will never generate them. But can any symbol
8878 containing an ASCII value in the range 1-31 ever be anything
8879 other than some kind of local ? */
8880 ret = TRUE;
8881 }
8882
8883 if (! ISDIGIT (c))
8884 {
8885 ret = FALSE;
8886 break;
8887 }
8888 }
8889 return ret;
8890 }
ffa54770 8891
b34976b6 8892 return FALSE;
252b5132
RH
8893}
8894
8895alent *
217aa764
AM
8896_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8897 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH
8898{
8899 abort ();
8900 return NULL;
8901}
8902
b34976b6 8903bfd_boolean
217aa764
AM
8904_bfd_elf_set_arch_mach (bfd *abfd,
8905 enum bfd_architecture arch,
8906 unsigned long machine)
252b5132
RH
8907{
8908 /* If this isn't the right architecture for this backend, and this
8909 isn't the generic backend, fail. */
8910 if (arch != get_elf_backend_data (abfd)->arch
8911 && arch != bfd_arch_unknown
8912 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 8913 return FALSE;
252b5132
RH
8914
8915 return bfd_default_set_arch_mach (abfd, arch, machine);
8916}
8917
d1fad7c6
NC
8918/* Find the nearest line to a particular section and offset,
8919 for error reporting. */
8920
b34976b6 8921bfd_boolean
217aa764 8922_bfd_elf_find_nearest_line (bfd *abfd,
217aa764 8923 asymbol **symbols,
fb167eb2 8924 asection *section,
217aa764
AM
8925 bfd_vma offset,
8926 const char **filename_ptr,
8927 const char **functionname_ptr,
fb167eb2
AM
8928 unsigned int *line_ptr,
8929 unsigned int *discriminator_ptr)
d1fad7c6 8930{
b34976b6 8931 bfd_boolean found;
d1fad7c6 8932
fb167eb2 8933 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
4e8a9624 8934 filename_ptr, functionname_ptr,
fb167eb2
AM
8935 line_ptr, discriminator_ptr,
8936 dwarf_debug_sections, 0,
e00e8198
AM
8937 &elf_tdata (abfd)->dwarf2_find_line_info)
8938 || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8939 filename_ptr, functionname_ptr,
8940 line_ptr))
d1fad7c6
NC
8941 {
8942 if (!*functionname_ptr)
e00e8198
AM
8943 _bfd_elf_find_function (abfd, symbols, section, offset,
8944 *filename_ptr ? NULL : filename_ptr,
8945 functionname_ptr);
b34976b6 8946 return TRUE;
d1fad7c6
NC
8947 }
8948
8949 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM
8950 &found, filename_ptr,
8951 functionname_ptr, line_ptr,
8952 &elf_tdata (abfd)->line_info))
b34976b6 8953 return FALSE;
dc43ada5 8954 if (found && (*functionname_ptr || *line_ptr))
b34976b6 8955 return TRUE;
d1fad7c6
NC
8956
8957 if (symbols == NULL)
b34976b6 8958 return FALSE;
d1fad7c6 8959
e00e8198
AM
8960 if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8961 filename_ptr, functionname_ptr))
b34976b6 8962 return FALSE;
d1fad7c6 8963
252b5132 8964 *line_ptr = 0;
b34976b6 8965 return TRUE;
252b5132
RH
8966}
8967
5420f73d
L
8968/* Find the line for a symbol. */
8969
8970bfd_boolean
8971_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8972 const char **filename_ptr, unsigned int *line_ptr)
9b8d1a36 8973{
fb167eb2
AM
8974 return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8975 filename_ptr, NULL, line_ptr, NULL,
8976 dwarf_debug_sections, 0,
8977 &elf_tdata (abfd)->dwarf2_find_line_info);
5420f73d
L
8978}
8979
4ab527b0
FF
8980/* After a call to bfd_find_nearest_line, successive calls to
8981 bfd_find_inliner_info can be used to get source information about
8982 each level of function inlining that terminated at the address
8983 passed to bfd_find_nearest_line. Currently this is only supported
8984 for DWARF2 with appropriate DWARF3 extensions. */
8985
8986bfd_boolean
8987_bfd_elf_find_inliner_info (bfd *abfd,
8988 const char **filename_ptr,
8989 const char **functionname_ptr,
8990 unsigned int *line_ptr)
8991{
8992 bfd_boolean found;
8993 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8994 functionname_ptr, line_ptr,
8995 & elf_tdata (abfd)->dwarf2_find_line_info);
8996 return found;
8997}
8998
252b5132 8999int
a6b96beb 9000_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 9001{
8ded5a0f
AM
9002 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9003 int ret = bed->s->sizeof_ehdr;
252b5132 9004
0e1862bb 9005 if (!bfd_link_relocatable (info))
8ded5a0f 9006 {
12bd6957 9007 bfd_size_type phdr_size = elf_program_header_size (abfd);
8ded5a0f 9008
62d7a5f6
AM
9009 if (phdr_size == (bfd_size_type) -1)
9010 {
9011 struct elf_segment_map *m;
9012
9013 phdr_size = 0;
12bd6957 9014 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62d7a5f6 9015 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 9016
62d7a5f6
AM
9017 if (phdr_size == 0)
9018 phdr_size = get_program_header_size (abfd, info);
9019 }
8ded5a0f 9020
12bd6957 9021 elf_program_header_size (abfd) = phdr_size;
8ded5a0f
AM
9022 ret += phdr_size;
9023 }
9024
252b5132
RH
9025 return ret;
9026}
9027
b34976b6 9028bfd_boolean
217aa764
AM
9029_bfd_elf_set_section_contents (bfd *abfd,
9030 sec_ptr section,
0f867abe 9031 const void *location,
217aa764
AM
9032 file_ptr offset,
9033 bfd_size_type count)
252b5132
RH
9034{
9035 Elf_Internal_Shdr *hdr;
1b6aeedb 9036 file_ptr pos;
252b5132
RH
9037
9038 if (! abfd->output_has_begun
217aa764 9039 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 9040 return FALSE;
252b5132 9041
0ce398f1
L
9042 if (!count)
9043 return TRUE;
9044
252b5132 9045 hdr = &elf_section_data (section)->this_hdr;
0ce398f1
L
9046 if (hdr->sh_offset == (file_ptr) -1)
9047 {
9048 /* We must compress this section. Write output to the buffer. */
9049 unsigned char *contents = hdr->contents;
9050 if ((offset + count) > hdr->sh_size
9051 || (section->flags & SEC_ELF_COMPRESS) == 0
9052 || contents == NULL)
9053 abort ();
9054 memcpy (contents + offset, location, count);
9055 return TRUE;
9056 }
dc810e39
AM
9057 pos = hdr->sh_offset + offset;
9058 if (bfd_seek (abfd, pos, SEEK_SET) != 0
9059 || bfd_bwrite (location, count, abfd) != count)
b34976b6 9060 return FALSE;
252b5132 9061
b34976b6 9062 return TRUE;
252b5132
RH
9063}
9064
f3185997 9065bfd_boolean
217aa764
AM
9066_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
9067 arelent *cache_ptr ATTRIBUTE_UNUSED,
9068 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH
9069{
9070 abort ();
f3185997 9071 return FALSE;
252b5132
RH
9072}
9073
252b5132
RH
9074/* Try to convert a non-ELF reloc into an ELF one. */
9075
b34976b6 9076bfd_boolean
217aa764 9077_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 9078{
c044fabd 9079 /* Check whether we really have an ELF howto. */
252b5132
RH
9080
9081 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
9082 {
9083 bfd_reloc_code_real_type code;
9084 reloc_howto_type *howto;
9085
9086 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 9087 equivalent ELF reloc. */
252b5132
RH
9088
9089 if (areloc->howto->pc_relative)
9090 {
9091 switch (areloc->howto->bitsize)
9092 {
9093 case 8:
9094 code = BFD_RELOC_8_PCREL;
9095 break;
9096 case 12:
9097 code = BFD_RELOC_12_PCREL;
9098 break;
9099 case 16:
9100 code = BFD_RELOC_16_PCREL;
9101 break;
9102 case 24:
9103 code = BFD_RELOC_24_PCREL;
9104 break;
9105 case 32:
9106 code = BFD_RELOC_32_PCREL;
9107 break;
9108 case 64:
9109 code = BFD_RELOC_64_PCREL;
9110 break;
9111 default:
9112 goto fail;
9113 }
9114
9115 howto = bfd_reloc_type_lookup (abfd, code);
9116
9117 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
9118 {
9119 if (howto->pcrel_offset)
9120 areloc->addend += areloc->address;
9121 else
9122 areloc->addend -= areloc->address; /* addend is unsigned!! */
9123 }
9124 }
9125 else
9126 {
9127 switch (areloc->howto->bitsize)
9128 {
9129 case 8:
9130 code = BFD_RELOC_8;
9131 break;
9132 case 14:
9133 code = BFD_RELOC_14;
9134 break;
9135 case 16:
9136 code = BFD_RELOC_16;
9137 break;
9138 case 26:
9139 code = BFD_RELOC_26;
9140 break;
9141 case 32:
9142 code = BFD_RELOC_32;
9143 break;
9144 case 64:
9145 code = BFD_RELOC_64;
9146 break;
9147 default:
9148 goto fail;
9149 }
9150
9151 howto = bfd_reloc_type_lookup (abfd, code);
9152 }
9153
9154 if (howto)
9155 areloc->howto = howto;
9156 else
9157 goto fail;
9158 }
9159
b34976b6 9160 return TRUE;
252b5132
RH
9161
9162 fail:
0aa13fee
AM
9163 /* xgettext:c-format */
9164 _bfd_error_handler (_("%pB: %s unsupported"),
9165 abfd, areloc->howto->name);
252b5132 9166 bfd_set_error (bfd_error_bad_value);
b34976b6 9167 return FALSE;
252b5132
RH
9168}
9169
b34976b6 9170bfd_boolean
217aa764 9171_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132 9172{
d9071b0c
TG
9173 struct elf_obj_tdata *tdata = elf_tdata (abfd);
9174 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
252b5132 9175 {
c0355132 9176 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
2b0f7ef9 9177 _bfd_elf_strtab_free (elf_shstrtab (abfd));
d9071b0c 9178 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
252b5132
RH
9179 }
9180
9181 return _bfd_generic_close_and_cleanup (abfd);
9182}
9183
9184/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9185 in the relocation's offset. Thus we cannot allow any sort of sanity
9186 range-checking to interfere. There is nothing else to do in processing
9187 this reloc. */
9188
9189bfd_reloc_status_type
217aa764
AM
9190_bfd_elf_rel_vtable_reloc_fn
9191 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 9192 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM
9193 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9194 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH
9195{
9196 return bfd_reloc_ok;
9197}
252b5132
RH
9198\f
9199/* Elf core file support. Much of this only works on native
9200 toolchains, since we rely on knowing the
9201 machine-dependent procfs structure in order to pick
c044fabd 9202 out details about the corefile. */
252b5132
RH
9203
9204#ifdef HAVE_SYS_PROCFS_H
16231b7b
DG
9205/* Needed for new procfs interface on sparc-solaris. */
9206# define _STRUCTURED_PROC 1
252b5132
RH
9207# include <sys/procfs.h>
9208#endif
9209
261b8d08
PA
9210/* Return a PID that identifies a "thread" for threaded cores, or the
9211 PID of the main process for non-threaded cores. */
252b5132
RH
9212
9213static int
217aa764 9214elfcore_make_pid (bfd *abfd)
252b5132 9215{
261b8d08
PA
9216 int pid;
9217
228e534f 9218 pid = elf_tdata (abfd)->core->lwpid;
261b8d08 9219 if (pid == 0)
228e534f 9220 pid = elf_tdata (abfd)->core->pid;
261b8d08
PA
9221
9222 return pid;
252b5132
RH
9223}
9224
252b5132
RH
9225/* If there isn't a section called NAME, make one, using
9226 data from SECT. Note, this function will generate a
9227 reference to NAME, so you shouldn't deallocate or
c044fabd 9228 overwrite it. */
252b5132 9229
b34976b6 9230static bfd_boolean
217aa764 9231elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 9232{
c044fabd 9233 asection *sect2;
252b5132
RH
9234
9235 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 9236 return TRUE;
252b5132 9237
117ed4f8 9238 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 9239 if (sect2 == NULL)
b34976b6 9240 return FALSE;
252b5132 9241
eea6121a 9242 sect2->size = sect->size;
252b5132 9243 sect2->filepos = sect->filepos;
252b5132 9244 sect2->alignment_power = sect->alignment_power;
b34976b6 9245 return TRUE;
252b5132
RH
9246}
9247
bb0082d6
AM
9248/* Create a pseudosection containing SIZE bytes at FILEPOS. This
9249 actually creates up to two pseudosections:
9250 - For the single-threaded case, a section named NAME, unless
9251 such a section already exists.
9252 - For the multi-threaded case, a section named "NAME/PID", where
9253 PID is elfcore_make_pid (abfd).
24d3e51b 9254 Both pseudosections have identical contents. */
b34976b6 9255bfd_boolean
217aa764
AM
9256_bfd_elfcore_make_pseudosection (bfd *abfd,
9257 char *name,
9258 size_t size,
9259 ufile_ptr filepos)
bb0082d6
AM
9260{
9261 char buf[100];
9262 char *threaded_name;
d4c88bbb 9263 size_t len;
bb0082d6
AM
9264 asection *sect;
9265
9266 /* Build the section name. */
9267
9268 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 9269 len = strlen (buf) + 1;
a50b1753 9270 threaded_name = (char *) bfd_alloc (abfd, len);
bb0082d6 9271 if (threaded_name == NULL)
b34976b6 9272 return FALSE;
d4c88bbb 9273 memcpy (threaded_name, buf, len);
bb0082d6 9274
117ed4f8
AM
9275 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9276 SEC_HAS_CONTENTS);
bb0082d6 9277 if (sect == NULL)
b34976b6 9278 return FALSE;
eea6121a 9279 sect->size = size;
bb0082d6 9280 sect->filepos = filepos;
bb0082d6
AM
9281 sect->alignment_power = 2;
9282
936e320b 9283 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM
9284}
9285
58e07198
CZ
9286static bfd_boolean
9287elfcore_make_auxv_note_section (bfd *abfd, Elf_Internal_Note *note,
9288 size_t offs)
9289{
9290 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9291 SEC_HAS_CONTENTS);
9292
9293 if (sect == NULL)
9294 return FALSE;
9295
9296 sect->size = note->descsz - offs;
9297 sect->filepos = note->descpos + offs;
9298 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9299
9300 return TRUE;
9301}
9302
252b5132 9303/* prstatus_t exists on:
4a938328 9304 solaris 2.5+
252b5132
RH
9305 linux 2.[01] + glibc
9306 unixware 4.2
9307*/
9308
9309#if defined (HAVE_PRSTATUS_T)
a7b97311 9310
b34976b6 9311static bfd_boolean
217aa764 9312elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 9313{
eea6121a 9314 size_t size;
7ee38065 9315 int offset;
252b5132 9316
4a938328
MS
9317 if (note->descsz == sizeof (prstatus_t))
9318 {
9319 prstatus_t prstat;
252b5132 9320
eea6121a 9321 size = sizeof (prstat.pr_reg);
7ee38065 9322 offset = offsetof (prstatus_t, pr_reg);
4a938328 9323 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 9324
fa49d224
NC
9325 /* Do not overwrite the core signal if it
9326 has already been set by another thread. */
228e534f
AM
9327 if (elf_tdata (abfd)->core->signal == 0)
9328 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9329 if (elf_tdata (abfd)->core->pid == 0)
9330 elf_tdata (abfd)->core->pid = prstat.pr_pid;
252b5132 9331
4a938328
MS
9332 /* pr_who exists on:
9333 solaris 2.5+
9334 unixware 4.2
9335 pr_who doesn't exist on:
9336 linux 2.[01]
9337 */
252b5132 9338#if defined (HAVE_PRSTATUS_T_PR_WHO)
228e534f 9339 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 9340#else
228e534f 9341 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
252b5132 9342#endif
4a938328 9343 }
7ee38065 9344#if defined (HAVE_PRSTATUS32_T)
4a938328
MS
9345 else if (note->descsz == sizeof (prstatus32_t))
9346 {
9347 /* 64-bit host, 32-bit corefile */
9348 prstatus32_t prstat;
9349
eea6121a 9350 size = sizeof (prstat.pr_reg);
7ee38065 9351 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS
9352 memcpy (&prstat, note->descdata, sizeof (prstat));
9353
fa49d224
NC
9354 /* Do not overwrite the core signal if it
9355 has already been set by another thread. */
228e534f
AM
9356 if (elf_tdata (abfd)->core->signal == 0)
9357 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9358 if (elf_tdata (abfd)->core->pid == 0)
9359 elf_tdata (abfd)->core->pid = prstat.pr_pid;
4a938328
MS
9360
9361 /* pr_who exists on:
9362 solaris 2.5+
9363 unixware 4.2
9364 pr_who doesn't exist on:
9365 linux 2.[01]
9366 */
7ee38065 9367#if defined (HAVE_PRSTATUS32_T_PR_WHO)
228e534f 9368 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 9369#else
228e534f 9370 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
4a938328
MS
9371#endif
9372 }
7ee38065 9373#endif /* HAVE_PRSTATUS32_T */
4a938328
MS
9374 else
9375 {
9376 /* Fail - we don't know how to handle any other
9377 note size (ie. data object type). */
b34976b6 9378 return TRUE;
4a938328 9379 }
252b5132 9380
bb0082d6 9381 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 9382 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 9383 size, note->descpos + offset);
252b5132
RH
9384}
9385#endif /* defined (HAVE_PRSTATUS_T) */
9386
bb0082d6 9387/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 9388static bfd_boolean
217aa764
AM
9389elfcore_make_note_pseudosection (bfd *abfd,
9390 char *name,
9391 Elf_Internal_Note *note)
252b5132 9392{
936e320b
AM
9393 return _bfd_elfcore_make_pseudosection (abfd, name,
9394 note->descsz, note->descpos);
252b5132
RH
9395}
9396
ff08c6bb
JB
9397/* There isn't a consistent prfpregset_t across platforms,
9398 but it doesn't matter, because we don't have to pick this
c044fabd
KH
9399 data structure apart. */
9400
b34976b6 9401static bfd_boolean
217aa764 9402elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB
9403{
9404 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9405}
9406
ff08c6bb 9407/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
971d4640 9408 type of NT_PRXFPREG. Just include the whole note's contents
ff08c6bb 9409 literally. */
c044fabd 9410
b34976b6 9411static bfd_boolean
217aa764 9412elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB
9413{
9414 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9415}
9416
4339cae0
L
9417/* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9418 with a note type of NT_X86_XSTATE. Just include the whole note's
9419 contents literally. */
9420
9421static bfd_boolean
9422elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9423{
9424 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9425}
9426
97753bd5
AM
9427static bfd_boolean
9428elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9429{
9430 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9431}
9432
89eeb0bc
LM
9433static bfd_boolean
9434elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9435{
9436 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9437}
97753bd5 9438
cb2366c1
EBM
9439static bfd_boolean
9440elfcore_grok_ppc_tar (bfd *abfd, Elf_Internal_Note *note)
9441{
9442 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tar", note);
9443}
9444
9445static bfd_boolean
9446elfcore_grok_ppc_ppr (bfd *abfd, Elf_Internal_Note *note)
9447{
9448 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ppr", note);
9449}
9450
9451static bfd_boolean
9452elfcore_grok_ppc_dscr (bfd *abfd, Elf_Internal_Note *note)
9453{
9454 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-dscr", note);
9455}
9456
9457static bfd_boolean
9458elfcore_grok_ppc_ebb (bfd *abfd, Elf_Internal_Note *note)
9459{
9460 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ebb", note);
9461}
9462
9463static bfd_boolean
9464elfcore_grok_ppc_pmu (bfd *abfd, Elf_Internal_Note *note)
9465{
9466 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-pmu", note);
9467}
9468
9469static bfd_boolean
9470elfcore_grok_ppc_tm_cgpr (bfd *abfd, Elf_Internal_Note *note)
9471{
9472 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cgpr", note);
9473}
9474
9475static bfd_boolean
9476elfcore_grok_ppc_tm_cfpr (bfd *abfd, Elf_Internal_Note *note)
9477{
9478 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cfpr", note);
9479}
9480
9481static bfd_boolean
9482elfcore_grok_ppc_tm_cvmx (bfd *abfd, Elf_Internal_Note *note)
9483{
9484 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvmx", note);
9485}
9486
9487static bfd_boolean
9488elfcore_grok_ppc_tm_cvsx (bfd *abfd, Elf_Internal_Note *note)
9489{
9490 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvsx", note);
9491}
9492
9493static bfd_boolean
9494elfcore_grok_ppc_tm_spr (bfd *abfd, Elf_Internal_Note *note)
9495{
9496 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-spr", note);
9497}
9498
9499static bfd_boolean
9500elfcore_grok_ppc_tm_ctar (bfd *abfd, Elf_Internal_Note *note)
9501{
9502 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-ctar", note);
9503}
9504
9505static bfd_boolean
9506elfcore_grok_ppc_tm_cppr (bfd *abfd, Elf_Internal_Note *note)
9507{
9508 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cppr", note);
9509}
9510
9511static bfd_boolean
9512elfcore_grok_ppc_tm_cdscr (bfd *abfd, Elf_Internal_Note *note)
9513{
9514 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cdscr", note);
9515}
9516
0675e188
UW
9517static bfd_boolean
9518elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9519{
9520 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9521}
9522
d7eeb400
MS
9523static bfd_boolean
9524elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9525{
9526 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9527}
9528
9529static bfd_boolean
9530elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9531{
9532 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9533}
9534
9535static bfd_boolean
9536elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9537{
9538 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9539}
9540
9541static bfd_boolean
9542elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9543{
9544 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9545}
9546
9547static bfd_boolean
9548elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9549{
9550 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9551}
9552
355b81d9
UW
9553static bfd_boolean
9554elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9555{
9556 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9557}
9558
9559static bfd_boolean
9560elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9561{
9562 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9563}
9564
abb3f6cc
NC
9565static bfd_boolean
9566elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9567{
9568 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9569}
9570
4ef9f41a
AA
9571static bfd_boolean
9572elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9573{
9574 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9575}
9576
9577static bfd_boolean
9578elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9579{
9580 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9581}
9582
88ab90e8
AA
9583static bfd_boolean
9584elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9585{
9586 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9587}
9588
9589static bfd_boolean
9590elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9591{
9592 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9593}
9594
faa9a424
UW
9595static bfd_boolean
9596elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9597{
9598 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9599}
9600
652451f8
YZ
9601static bfd_boolean
9602elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9603{
9604 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9605}
9606
9607static bfd_boolean
9608elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9609{
9610 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9611}
9612
9613static bfd_boolean
9614elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9615{
9616 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9617}
9618
ad1cc4e4
AH
9619static bfd_boolean
9620elfcore_grok_aarch_sve (bfd *abfd, Elf_Internal_Note *note)
9621{
9622 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-sve", note);
9623}
9624
e6c3b5bf
AH
9625static bfd_boolean
9626elfcore_grok_aarch_pauth (bfd *abfd, Elf_Internal_Note *note)
9627{
9628 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-pauth", note);
9629}
9630
252b5132 9631#if defined (HAVE_PRPSINFO_T)
4a938328 9632typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 9633#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS
9634typedef prpsinfo32_t elfcore_psinfo32_t;
9635#endif
252b5132
RH
9636#endif
9637
9638#if defined (HAVE_PSINFO_T)
4a938328 9639typedef psinfo_t elfcore_psinfo_t;
7ee38065 9640#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS
9641typedef psinfo32_t elfcore_psinfo32_t;
9642#endif
252b5132
RH
9643#endif
9644
252b5132
RH
9645/* return a malloc'ed copy of a string at START which is at
9646 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 9647 the copy will always have a terminating '\0'. */
252b5132 9648
936e320b 9649char *
217aa764 9650_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 9651{
dc810e39 9652 char *dups;
a50b1753 9653 char *end = (char *) memchr (start, '\0', max);
dc810e39 9654 size_t len;
252b5132
RH
9655
9656 if (end == NULL)
9657 len = max;
9658 else
9659 len = end - start;
9660
a50b1753 9661 dups = (char *) bfd_alloc (abfd, len + 1);
dc810e39 9662 if (dups == NULL)
252b5132
RH
9663 return NULL;
9664
dc810e39
AM
9665 memcpy (dups, start, len);
9666 dups[len] = '\0';
252b5132 9667
dc810e39 9668 return dups;
252b5132
RH
9669}
9670
bb0082d6 9671#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 9672static bfd_boolean
217aa764 9673elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 9674{
4a938328
MS
9675 if (note->descsz == sizeof (elfcore_psinfo_t))
9676 {
9677 elfcore_psinfo_t psinfo;
252b5132 9678
7ee38065 9679 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 9680
335e41d4 9681#if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
228e534f 9682 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 9683#endif
228e534f 9684 elf_tdata (abfd)->core->program
936e320b
AM
9685 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9686 sizeof (psinfo.pr_fname));
252b5132 9687
228e534f 9688 elf_tdata (abfd)->core->command
936e320b
AM
9689 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9690 sizeof (psinfo.pr_psargs));
4a938328 9691 }
7ee38065 9692#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS
9693 else if (note->descsz == sizeof (elfcore_psinfo32_t))
9694 {
9695 /* 64-bit host, 32-bit corefile */
9696 elfcore_psinfo32_t psinfo;
9697
7ee38065 9698 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 9699
335e41d4 9700#if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
228e534f 9701 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 9702#endif
228e534f 9703 elf_tdata (abfd)->core->program
936e320b
AM
9704 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9705 sizeof (psinfo.pr_fname));
4a938328 9706
228e534f 9707 elf_tdata (abfd)->core->command
936e320b
AM
9708 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9709 sizeof (psinfo.pr_psargs));
4a938328
MS
9710 }
9711#endif
9712
9713 else
9714 {
9715 /* Fail - we don't know how to handle any other
9716 note size (ie. data object type). */
b34976b6 9717 return TRUE;
4a938328 9718 }
252b5132
RH
9719
9720 /* Note that for some reason, a spurious space is tacked
9721 onto the end of the args in some (at least one anyway)
c044fabd 9722 implementations, so strip it off if it exists. */
252b5132
RH
9723
9724 {
228e534f 9725 char *command = elf_tdata (abfd)->core->command;
252b5132
RH
9726 int n = strlen (command);
9727
9728 if (0 < n && command[n - 1] == ' ')
9729 command[n - 1] = '\0';
9730 }
9731
b34976b6 9732 return TRUE;
252b5132
RH
9733}
9734#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9735
252b5132 9736#if defined (HAVE_PSTATUS_T)
b34976b6 9737static bfd_boolean
217aa764 9738elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 9739{
f572a39d
AM
9740 if (note->descsz == sizeof (pstatus_t)
9741#if defined (HAVE_PXSTATUS_T)
9742 || note->descsz == sizeof (pxstatus_t)
9743#endif
9744 )
4a938328
MS
9745 {
9746 pstatus_t pstat;
252b5132 9747
4a938328 9748 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 9749
228e534f 9750 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328 9751 }
7ee38065 9752#if defined (HAVE_PSTATUS32_T)
4a938328
MS
9753 else if (note->descsz == sizeof (pstatus32_t))
9754 {
9755 /* 64-bit host, 32-bit corefile */
9756 pstatus32_t pstat;
252b5132 9757
4a938328 9758 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 9759
228e534f 9760 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328
MS
9761 }
9762#endif
252b5132
RH
9763 /* Could grab some more details from the "representative"
9764 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 9765 NT_LWPSTATUS note, presumably. */
252b5132 9766
b34976b6 9767 return TRUE;
252b5132
RH
9768}
9769#endif /* defined (HAVE_PSTATUS_T) */
9770
252b5132 9771#if defined (HAVE_LWPSTATUS_T)
b34976b6 9772static bfd_boolean
217aa764 9773elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH
9774{
9775 lwpstatus_t lwpstat;
9776 char buf[100];
c044fabd 9777 char *name;
d4c88bbb 9778 size_t len;
c044fabd 9779 asection *sect;
252b5132 9780
f572a39d
AM
9781 if (note->descsz != sizeof (lwpstat)
9782#if defined (HAVE_LWPXSTATUS_T)
9783 && note->descsz != sizeof (lwpxstatus_t)
9784#endif
9785 )
b34976b6 9786 return TRUE;
252b5132
RH
9787
9788 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9789
228e534f 9790 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
a1504221
JB
9791 /* Do not overwrite the core signal if it has already been set by
9792 another thread. */
228e534f
AM
9793 if (elf_tdata (abfd)->core->signal == 0)
9794 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
252b5132 9795
c044fabd 9796 /* Make a ".reg/999" section. */
252b5132
RH
9797
9798 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 9799 len = strlen (buf) + 1;
217aa764 9800 name = bfd_alloc (abfd, len);
252b5132 9801 if (name == NULL)
b34976b6 9802 return FALSE;
d4c88bbb 9803 memcpy (name, buf, len);
252b5132 9804
117ed4f8 9805 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 9806 if (sect == NULL)
b34976b6 9807 return FALSE;
252b5132
RH
9808
9809#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 9810 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH
9811 sect->filepos = note->descpos
9812 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9813#endif
9814
9815#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 9816 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH
9817 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9818#endif
9819
252b5132
RH
9820 sect->alignment_power = 2;
9821
9822 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 9823 return FALSE;
252b5132
RH
9824
9825 /* Make a ".reg2/999" section */
9826
9827 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 9828 len = strlen (buf) + 1;
217aa764 9829 name = bfd_alloc (abfd, len);
252b5132 9830 if (name == NULL)
b34976b6 9831 return FALSE;
d4c88bbb 9832 memcpy (name, buf, len);
252b5132 9833
117ed4f8 9834 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 9835 if (sect == NULL)
b34976b6 9836 return FALSE;
252b5132
RH
9837
9838#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 9839 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH
9840 sect->filepos = note->descpos
9841 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9842#endif
9843
9844#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 9845 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH
9846 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9847#endif
9848
252b5132
RH
9849 sect->alignment_power = 2;
9850
936e320b 9851 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH
9852}
9853#endif /* defined (HAVE_LWPSTATUS_T) */
9854
b34976b6 9855static bfd_boolean
217aa764 9856elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC
9857{
9858 char buf[30];
c044fabd 9859 char *name;
d4c88bbb 9860 size_t len;
c044fabd 9861 asection *sect;
4a6636fb
PA
9862 int type;
9863 int is_active_thread;
9864 bfd_vma base_addr;
16e9c715 9865
4a6636fb 9866 if (note->descsz < 728)
b34976b6 9867 return TRUE;
16e9c715 9868
4a6636fb
PA
9869 if (! CONST_STRNEQ (note->namedata, "win32"))
9870 return TRUE;
9871
9872 type = bfd_get_32 (abfd, note->descdata);
c044fabd 9873
4a6636fb 9874 switch (type)
16e9c715 9875 {
4a6636fb 9876 case 1 /* NOTE_INFO_PROCESS */:
228e534f 9877 /* FIXME: need to add ->core->command. */
4a6636fb 9878 /* process_info.pid */
228e534f 9879 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
4a6636fb 9880 /* process_info.signal */
228e534f 9881 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
c044fabd 9882 break;
16e9c715 9883
4a6636fb 9884 case 2 /* NOTE_INFO_THREAD */:
16e9c715 9885 /* Make a ".reg/999" section. */
4a6636fb
PA
9886 /* thread_info.tid */
9887 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
c044fabd 9888
d4c88bbb 9889 len = strlen (buf) + 1;
a50b1753 9890 name = (char *) bfd_alloc (abfd, len);
16e9c715 9891 if (name == NULL)
b34976b6 9892 return FALSE;
c044fabd 9893
d4c88bbb 9894 memcpy (name, buf, len);
16e9c715 9895
117ed4f8 9896 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 9897 if (sect == NULL)
b34976b6 9898 return FALSE;
c044fabd 9899
4a6636fb
PA
9900 /* sizeof (thread_info.thread_context) */
9901 sect->size = 716;
9902 /* offsetof (thread_info.thread_context) */
9903 sect->filepos = note->descpos + 12;
16e9c715
NC
9904 sect->alignment_power = 2;
9905
4a6636fb
PA
9906 /* thread_info.is_active_thread */
9907 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9908
9909 if (is_active_thread)
16e9c715 9910 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 9911 return FALSE;
16e9c715
NC
9912 break;
9913
4a6636fb 9914 case 3 /* NOTE_INFO_MODULE */:
16e9c715 9915 /* Make a ".module/xxxxxxxx" section. */
4a6636fb
PA
9916 /* module_info.base_address */
9917 base_addr = bfd_get_32 (abfd, note->descdata + 4);
0af1713e 9918 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
c044fabd 9919
d4c88bbb 9920 len = strlen (buf) + 1;
a50b1753 9921 name = (char *) bfd_alloc (abfd, len);
16e9c715 9922 if (name == NULL)
b34976b6 9923 return FALSE;
c044fabd 9924
d4c88bbb 9925 memcpy (name, buf, len);
252b5132 9926
117ed4f8 9927 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 9928
16e9c715 9929 if (sect == NULL)
b34976b6 9930 return FALSE;
c044fabd 9931
eea6121a 9932 sect->size = note->descsz;
16e9c715 9933 sect->filepos = note->descpos;
16e9c715
NC
9934 sect->alignment_power = 2;
9935 break;
9936
9937 default:
b34976b6 9938 return TRUE;
16e9c715
NC
9939 }
9940
b34976b6 9941 return TRUE;
16e9c715 9942}
252b5132 9943
b34976b6 9944static bfd_boolean
217aa764 9945elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 9946{
9c5bfbb7 9947 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 9948
252b5132
RH
9949 switch (note->type)
9950 {
9951 default:
b34976b6 9952 return TRUE;
252b5132 9953
252b5132 9954 case NT_PRSTATUS:
bb0082d6
AM
9955 if (bed->elf_backend_grok_prstatus)
9956 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 9957 return TRUE;
bb0082d6 9958#if defined (HAVE_PRSTATUS_T)
252b5132 9959 return elfcore_grok_prstatus (abfd, note);
bb0082d6 9960#else
b34976b6 9961 return TRUE;
252b5132
RH
9962#endif
9963
9964#if defined (HAVE_PSTATUS_T)
9965 case NT_PSTATUS:
9966 return elfcore_grok_pstatus (abfd, note);
9967#endif
9968
9969#if defined (HAVE_LWPSTATUS_T)
9970 case NT_LWPSTATUS:
9971 return elfcore_grok_lwpstatus (abfd, note);
9972#endif
9973
9974 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
9975 return elfcore_grok_prfpreg (abfd, note);
9976
c044fabd 9977 case NT_WIN32PSTATUS:
16e9c715 9978 return elfcore_grok_win32pstatus (abfd, note);
16e9c715 9979
c044fabd 9980 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK
9981 if (note->namesz == 6
9982 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB
9983 return elfcore_grok_prxfpreg (abfd, note);
9984 else
b34976b6 9985 return TRUE;
ff08c6bb 9986
4339cae0
L
9987 case NT_X86_XSTATE: /* Linux XSAVE extension */
9988 if (note->namesz == 6
9989 && strcmp (note->namedata, "LINUX") == 0)
9990 return elfcore_grok_xstatereg (abfd, note);
9991 else
9992 return TRUE;
9993
97753bd5
AM
9994 case NT_PPC_VMX:
9995 if (note->namesz == 6
9996 && strcmp (note->namedata, "LINUX") == 0)
9997 return elfcore_grok_ppc_vmx (abfd, note);
9998 else
9999 return TRUE;
10000
89eeb0bc
LM
10001 case NT_PPC_VSX:
10002 if (note->namesz == 6
07d6d2b8
AM
10003 && strcmp (note->namedata, "LINUX") == 0)
10004 return elfcore_grok_ppc_vsx (abfd, note);
89eeb0bc 10005 else
07d6d2b8 10006 return TRUE;
89eeb0bc 10007
cb2366c1
EBM
10008 case NT_PPC_TAR:
10009 if (note->namesz == 6
4b24dd1a
AM
10010 && strcmp (note->namedata, "LINUX") == 0)
10011 return elfcore_grok_ppc_tar (abfd, note);
cb2366c1 10012 else
4b24dd1a 10013 return TRUE;
cb2366c1
EBM
10014
10015 case NT_PPC_PPR:
10016 if (note->namesz == 6
4b24dd1a
AM
10017 && strcmp (note->namedata, "LINUX") == 0)
10018 return elfcore_grok_ppc_ppr (abfd, note);
cb2366c1 10019 else
4b24dd1a 10020 return TRUE;
cb2366c1
EBM
10021
10022 case NT_PPC_DSCR:
10023 if (note->namesz == 6
4b24dd1a
AM
10024 && strcmp (note->namedata, "LINUX") == 0)
10025 return elfcore_grok_ppc_dscr (abfd, note);
cb2366c1 10026 else
4b24dd1a 10027 return TRUE;
cb2366c1
EBM
10028
10029 case NT_PPC_EBB:
10030 if (note->namesz == 6
4b24dd1a
AM
10031 && strcmp (note->namedata, "LINUX") == 0)
10032 return elfcore_grok_ppc_ebb (abfd, note);
cb2366c1 10033 else
4b24dd1a 10034 return TRUE;
cb2366c1
EBM
10035
10036 case NT_PPC_PMU:
10037 if (note->namesz == 6
4b24dd1a
AM
10038 && strcmp (note->namedata, "LINUX") == 0)
10039 return elfcore_grok_ppc_pmu (abfd, note);
cb2366c1 10040 else
4b24dd1a 10041 return TRUE;
cb2366c1
EBM
10042
10043 case NT_PPC_TM_CGPR:
10044 if (note->namesz == 6
4b24dd1a
AM
10045 && strcmp (note->namedata, "LINUX") == 0)
10046 return elfcore_grok_ppc_tm_cgpr (abfd, note);
cb2366c1 10047 else
4b24dd1a 10048 return TRUE;
cb2366c1
EBM
10049
10050 case NT_PPC_TM_CFPR:
10051 if (note->namesz == 6
4b24dd1a
AM
10052 && strcmp (note->namedata, "LINUX") == 0)
10053 return elfcore_grok_ppc_tm_cfpr (abfd, note);
cb2366c1 10054 else
4b24dd1a 10055 return TRUE;
cb2366c1
EBM
10056
10057 case NT_PPC_TM_CVMX:
10058 if (note->namesz == 6
4b24dd1a
AM
10059 && strcmp (note->namedata, "LINUX") == 0)
10060 return elfcore_grok_ppc_tm_cvmx (abfd, note);
cb2366c1 10061 else
4b24dd1a 10062 return TRUE;
cb2366c1
EBM
10063
10064 case NT_PPC_TM_CVSX:
10065 if (note->namesz == 6
4b24dd1a
AM
10066 && strcmp (note->namedata, "LINUX") == 0)
10067 return elfcore_grok_ppc_tm_cvsx (abfd, note);
cb2366c1 10068 else
4b24dd1a 10069 return TRUE;
cb2366c1
EBM
10070
10071 case NT_PPC_TM_SPR:
10072 if (note->namesz == 6
4b24dd1a
AM
10073 && strcmp (note->namedata, "LINUX") == 0)
10074 return elfcore_grok_ppc_tm_spr (abfd, note);
cb2366c1 10075 else
4b24dd1a 10076 return TRUE;
cb2366c1
EBM
10077
10078 case NT_PPC_TM_CTAR:
10079 if (note->namesz == 6
4b24dd1a
AM
10080 && strcmp (note->namedata, "LINUX") == 0)
10081 return elfcore_grok_ppc_tm_ctar (abfd, note);
cb2366c1 10082 else
4b24dd1a 10083 return TRUE;
cb2366c1
EBM
10084
10085 case NT_PPC_TM_CPPR:
10086 if (note->namesz == 6
4b24dd1a
AM
10087 && strcmp (note->namedata, "LINUX") == 0)
10088 return elfcore_grok_ppc_tm_cppr (abfd, note);
cb2366c1 10089 else
4b24dd1a 10090 return TRUE;
cb2366c1
EBM
10091
10092 case NT_PPC_TM_CDSCR:
10093 if (note->namesz == 6
4b24dd1a
AM
10094 && strcmp (note->namedata, "LINUX") == 0)
10095 return elfcore_grok_ppc_tm_cdscr (abfd, note);
cb2366c1 10096 else
4b24dd1a 10097 return TRUE;
cb2366c1 10098
0675e188
UW
10099 case NT_S390_HIGH_GPRS:
10100 if (note->namesz == 6
07d6d2b8
AM
10101 && strcmp (note->namedata, "LINUX") == 0)
10102 return elfcore_grok_s390_high_gprs (abfd, note);
0675e188 10103 else
07d6d2b8 10104 return TRUE;
0675e188 10105
d7eeb400
MS
10106 case NT_S390_TIMER:
10107 if (note->namesz == 6
07d6d2b8
AM
10108 && strcmp (note->namedata, "LINUX") == 0)
10109 return elfcore_grok_s390_timer (abfd, note);
d7eeb400 10110 else
07d6d2b8 10111 return TRUE;
d7eeb400
MS
10112
10113 case NT_S390_TODCMP:
10114 if (note->namesz == 6
07d6d2b8
AM
10115 && strcmp (note->namedata, "LINUX") == 0)
10116 return elfcore_grok_s390_todcmp (abfd, note);
d7eeb400 10117 else
07d6d2b8 10118 return TRUE;
d7eeb400
MS
10119
10120 case NT_S390_TODPREG:
10121 if (note->namesz == 6
07d6d2b8
AM
10122 && strcmp (note->namedata, "LINUX") == 0)
10123 return elfcore_grok_s390_todpreg (abfd, note);
d7eeb400 10124 else
07d6d2b8 10125 return TRUE;
d7eeb400
MS
10126
10127 case NT_S390_CTRS:
10128 if (note->namesz == 6
07d6d2b8
AM
10129 && strcmp (note->namedata, "LINUX") == 0)
10130 return elfcore_grok_s390_ctrs (abfd, note);
d7eeb400 10131 else
07d6d2b8 10132 return TRUE;
d7eeb400
MS
10133
10134 case NT_S390_PREFIX:
10135 if (note->namesz == 6
07d6d2b8
AM
10136 && strcmp (note->namedata, "LINUX") == 0)
10137 return elfcore_grok_s390_prefix (abfd, note);
d7eeb400 10138 else
07d6d2b8 10139 return TRUE;
d7eeb400 10140
355b81d9
UW
10141 case NT_S390_LAST_BREAK:
10142 if (note->namesz == 6
07d6d2b8
AM
10143 && strcmp (note->namedata, "LINUX") == 0)
10144 return elfcore_grok_s390_last_break (abfd, note);
355b81d9 10145 else
07d6d2b8 10146 return TRUE;
355b81d9
UW
10147
10148 case NT_S390_SYSTEM_CALL:
10149 if (note->namesz == 6
07d6d2b8
AM
10150 && strcmp (note->namedata, "LINUX") == 0)
10151 return elfcore_grok_s390_system_call (abfd, note);
355b81d9 10152 else
07d6d2b8 10153 return TRUE;
355b81d9 10154
abb3f6cc
NC
10155 case NT_S390_TDB:
10156 if (note->namesz == 6
07d6d2b8
AM
10157 && strcmp (note->namedata, "LINUX") == 0)
10158 return elfcore_grok_s390_tdb (abfd, note);
abb3f6cc 10159 else
07d6d2b8 10160 return TRUE;
abb3f6cc 10161
4ef9f41a
AA
10162 case NT_S390_VXRS_LOW:
10163 if (note->namesz == 6
10164 && strcmp (note->namedata, "LINUX") == 0)
10165 return elfcore_grok_s390_vxrs_low (abfd, note);
10166 else
10167 return TRUE;
10168
10169 case NT_S390_VXRS_HIGH:
10170 if (note->namesz == 6
10171 && strcmp (note->namedata, "LINUX") == 0)
10172 return elfcore_grok_s390_vxrs_high (abfd, note);
10173 else
10174 return TRUE;
10175
88ab90e8
AA
10176 case NT_S390_GS_CB:
10177 if (note->namesz == 6
10178 && strcmp (note->namedata, "LINUX") == 0)
8fe09d74 10179 return elfcore_grok_s390_gs_cb (abfd, note);
88ab90e8
AA
10180 else
10181 return TRUE;
10182
10183 case NT_S390_GS_BC:
10184 if (note->namesz == 6
10185 && strcmp (note->namedata, "LINUX") == 0)
8fe09d74 10186 return elfcore_grok_s390_gs_bc (abfd, note);
88ab90e8
AA
10187 else
10188 return TRUE;
10189
faa9a424
UW
10190 case NT_ARM_VFP:
10191 if (note->namesz == 6
10192 && strcmp (note->namedata, "LINUX") == 0)
10193 return elfcore_grok_arm_vfp (abfd, note);
10194 else
10195 return TRUE;
10196
652451f8
YZ
10197 case NT_ARM_TLS:
10198 if (note->namesz == 6
10199 && strcmp (note->namedata, "LINUX") == 0)
10200 return elfcore_grok_aarch_tls (abfd, note);
10201 else
10202 return TRUE;
10203
10204 case NT_ARM_HW_BREAK:
10205 if (note->namesz == 6
10206 && strcmp (note->namedata, "LINUX") == 0)
10207 return elfcore_grok_aarch_hw_break (abfd, note);
10208 else
10209 return TRUE;
10210
10211 case NT_ARM_HW_WATCH:
10212 if (note->namesz == 6
10213 && strcmp (note->namedata, "LINUX") == 0)
10214 return elfcore_grok_aarch_hw_watch (abfd, note);
10215 else
10216 return TRUE;
10217
ad1cc4e4
AH
10218 case NT_ARM_SVE:
10219 if (note->namesz == 6
10220 && strcmp (note->namedata, "LINUX") == 0)
10221 return elfcore_grok_aarch_sve (abfd, note);
10222 else
10223 return TRUE;
10224
e6c3b5bf
AH
10225 case NT_ARM_PAC_MASK:
10226 if (note->namesz == 6
10227 && strcmp (note->namedata, "LINUX") == 0)
10228 return elfcore_grok_aarch_pauth (abfd, note);
10229 else
10230 return TRUE;
10231
252b5132
RH
10232 case NT_PRPSINFO:
10233 case NT_PSINFO:
bb0082d6
AM
10234 if (bed->elf_backend_grok_psinfo)
10235 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 10236 return TRUE;
bb0082d6 10237#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 10238 return elfcore_grok_psinfo (abfd, note);
bb0082d6 10239#else
b34976b6 10240 return TRUE;
252b5132 10241#endif
3333a7c3
RM
10242
10243 case NT_AUXV:
58e07198 10244 return elfcore_make_auxv_note_section (abfd, note, 0);
9015683b 10245
451b7c33
TT
10246 case NT_FILE:
10247 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
10248 note);
10249
9015683b
TT
10250 case NT_SIGINFO:
10251 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
10252 note);
5b2c414d 10253
252b5132
RH
10254 }
10255}
10256
718175fa
JK
10257static bfd_boolean
10258elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
10259{
c74f7d1c 10260 struct bfd_build_id* build_id;
30e8ee25
AM
10261
10262 if (note->descsz == 0)
10263 return FALSE;
10264
c74f7d1c
JT
10265 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
10266 if (build_id == NULL)
718175fa
JK
10267 return FALSE;
10268
c74f7d1c
JT
10269 build_id->size = note->descsz;
10270 memcpy (build_id->data, note->descdata, note->descsz);
10271 abfd->build_id = build_id;
718175fa
JK
10272
10273 return TRUE;
10274}
10275
10276static bfd_boolean
10277elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
10278{
10279 switch (note->type)
10280 {
10281 default:
10282 return TRUE;
10283
46bed679
L
10284 case NT_GNU_PROPERTY_TYPE_0:
10285 return _bfd_elf_parse_gnu_properties (abfd, note);
10286
718175fa
JK
10287 case NT_GNU_BUILD_ID:
10288 return elfobj_grok_gnu_build_id (abfd, note);
10289 }
10290}
10291
e21e5835
NC
10292static bfd_boolean
10293elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
10294{
10295 struct sdt_note *cur =
7a6e0d89
AM
10296 (struct sdt_note *) bfd_alloc (abfd,
10297 sizeof (struct sdt_note) + note->descsz);
e21e5835
NC
10298
10299 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
10300 cur->size = (bfd_size_type) note->descsz;
10301 memcpy (cur->data, note->descdata, note->descsz);
10302
10303 elf_tdata (abfd)->sdt_note_head = cur;
10304
10305 return TRUE;
10306}
10307
10308static bfd_boolean
10309elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
10310{
10311 switch (note->type)
10312 {
10313 case NT_STAPSDT:
10314 return elfobj_grok_stapsdt_note_1 (abfd, note);
10315
10316 default:
10317 return TRUE;
10318 }
10319}
10320
aa1ed4a9
JB
10321static bfd_boolean
10322elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
10323{
10324 size_t offset;
10325
b5430a3c 10326 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
aa1ed4a9 10327 {
b5430a3c 10328 case ELFCLASS32:
0064d223
JB
10329 if (note->descsz < 108)
10330 return FALSE;
aa1ed4a9
JB
10331 break;
10332
b5430a3c 10333 case ELFCLASS64:
0064d223
JB
10334 if (note->descsz < 120)
10335 return FALSE;
aa1ed4a9
JB
10336 break;
10337
10338 default:
10339 return FALSE;
10340 }
10341
0064d223
JB
10342 /* Check for version 1 in pr_version. */
10343 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10344 return FALSE;
80a04378 10345
0064d223
JB
10346 offset = 4;
10347
10348 /* Skip over pr_psinfosz. */
b5430a3c 10349 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
0064d223
JB
10350 offset += 4;
10351 else
10352 {
10353 offset += 4; /* Padding before pr_psinfosz. */
10354 offset += 8;
10355 }
10356
aa1ed4a9
JB
10357 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10358 elf_tdata (abfd)->core->program
10359 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
10360 offset += 17;
10361
10362 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10363 elf_tdata (abfd)->core->command
10364 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
0064d223
JB
10365 offset += 81;
10366
10367 /* Padding before pr_pid. */
10368 offset += 2;
10369
10370 /* The pr_pid field was added in version "1a". */
10371 if (note->descsz < offset + 4)
10372 return TRUE;
10373
10374 elf_tdata (abfd)->core->pid
10375 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
aa1ed4a9
JB
10376
10377 return TRUE;
10378}
10379
10380static bfd_boolean
10381elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10382{
10383 size_t offset;
10384 size_t size;
24d3e51b 10385 size_t min_size;
aa1ed4a9 10386
24d3e51b
NC
10387 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10388 Also compute minimum size of this note. */
b5430a3c 10389 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
aa1ed4a9 10390 {
b5430a3c 10391 case ELFCLASS32:
24d3e51b
NC
10392 offset = 4 + 4;
10393 min_size = offset + (4 * 2) + 4 + 4 + 4;
aa1ed4a9
JB
10394 break;
10395
b5430a3c 10396 case ELFCLASS64:
24d3e51b
NC
10397 offset = 4 + 4 + 8; /* Includes padding before pr_statussz. */
10398 min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
aa1ed4a9
JB
10399 break;
10400
10401 default:
10402 return FALSE;
10403 }
10404
24d3e51b
NC
10405 if (note->descsz < min_size)
10406 return FALSE;
10407
10408 /* Check for version 1 in pr_version. */
10409 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10410 return FALSE;
aa1ed4a9 10411
24d3e51b
NC
10412 /* Extract size of pr_reg from pr_gregsetsz. */
10413 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
b5430a3c 10414 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
24d3e51b
NC
10415 {
10416 size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10417 offset += 4 * 2;
10418 }
b5430a3c 10419 else
24d3e51b
NC
10420 {
10421 size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10422 offset += 8 * 2;
10423 }
aa1ed4a9 10424
24d3e51b 10425 /* Skip over pr_osreldate. */
aa1ed4a9
JB
10426 offset += 4;
10427
24d3e51b 10428 /* Read signal from pr_cursig. */
aa1ed4a9
JB
10429 if (elf_tdata (abfd)->core->signal == 0)
10430 elf_tdata (abfd)->core->signal
10431 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10432 offset += 4;
10433
24d3e51b 10434 /* Read TID from pr_pid. */
aa1ed4a9
JB
10435 elf_tdata (abfd)->core->lwpid
10436 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10437 offset += 4;
10438
24d3e51b 10439 /* Padding before pr_reg. */
b5430a3c 10440 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
aa1ed4a9
JB
10441 offset += 4;
10442
24d3e51b
NC
10443 /* Make sure that there is enough data remaining in the note. */
10444 if ((note->descsz - offset) < size)
10445 return FALSE;
10446
aa1ed4a9
JB
10447 /* Make a ".reg/999" section and a ".reg" section. */
10448 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10449 size, note->descpos + offset);
10450}
10451
10452static bfd_boolean
10453elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10454{
544c67cd
JB
10455 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10456
aa1ed4a9
JB
10457 switch (note->type)
10458 {
10459 case NT_PRSTATUS:
544c67cd
JB
10460 if (bed->elf_backend_grok_freebsd_prstatus)
10461 if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10462 return TRUE;
aa1ed4a9
JB
10463 return elfcore_grok_freebsd_prstatus (abfd, note);
10464
10465 case NT_FPREGSET:
10466 return elfcore_grok_prfpreg (abfd, note);
10467
10468 case NT_PRPSINFO:
10469 return elfcore_grok_freebsd_psinfo (abfd, note);
10470
10471 case NT_FREEBSD_THRMISC:
10472 if (note->namesz == 8)
10473 return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10474 else
10475 return TRUE;
10476
ddb2bbcf
JB
10477 case NT_FREEBSD_PROCSTAT_PROC:
10478 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10479 note);
10480
10481 case NT_FREEBSD_PROCSTAT_FILES:
10482 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10483 note);
10484
10485 case NT_FREEBSD_PROCSTAT_VMMAP:
10486 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10487 note);
10488
3350c5f5 10489 case NT_FREEBSD_PROCSTAT_AUXV:
58e07198 10490 return elfcore_make_auxv_note_section (abfd, note, 4);
3350c5f5 10491
aa1ed4a9
JB
10492 case NT_X86_XSTATE:
10493 if (note->namesz == 8)
10494 return elfcore_grok_xstatereg (abfd, note);
10495 else
10496 return TRUE;
10497
e6f3b9c3
JB
10498 case NT_FREEBSD_PTLWPINFO:
10499 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10500 note);
10501
6d5be5d6
JB
10502 case NT_ARM_VFP:
10503 return elfcore_grok_arm_vfp (abfd, note);
10504
aa1ed4a9
JB
10505 default:
10506 return TRUE;
10507 }
10508}
10509
b34976b6 10510static bfd_boolean
217aa764 10511elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM
10512{
10513 char *cp;
10514
10515 cp = strchr (note->namedata, '@');
10516 if (cp != NULL)
10517 {
d2b64500 10518 *lwpidp = atoi(cp + 1);
b34976b6 10519 return TRUE;
50b2bdb7 10520 }
b34976b6 10521 return FALSE;
50b2bdb7
AM
10522}
10523
b34976b6 10524static bfd_boolean
217aa764 10525elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7 10526{
80a04378
NC
10527 if (note->descsz <= 0x7c + 31)
10528 return FALSE;
10529
50b2bdb7 10530 /* Signal number at offset 0x08. */
228e534f 10531 elf_tdata (abfd)->core->signal
50b2bdb7
AM
10532 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10533
10534 /* Process ID at offset 0x50. */
228e534f 10535 elf_tdata (abfd)->core->pid
50b2bdb7
AM
10536 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10537
10538 /* Command name at 0x7c (max 32 bytes, including nul). */
228e534f 10539 elf_tdata (abfd)->core->command
50b2bdb7
AM
10540 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10541
7720ba9f
MK
10542 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10543 note);
50b2bdb7
AM
10544}
10545
b34976b6 10546static bfd_boolean
217aa764 10547elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM
10548{
10549 int lwp;
10550
10551 if (elfcore_netbsd_get_lwpid (note, &lwp))
228e534f 10552 elf_tdata (abfd)->core->lwpid = lwp;
50b2bdb7 10553
58e07198 10554 switch (note->type)
50b2bdb7 10555 {
58e07198 10556 case NT_NETBSDCORE_PROCINFO:
50b2bdb7 10557 /* NetBSD-specific core "procinfo". Note that we expect to
08a40648
AM
10558 find this note before any of the others, which is fine,
10559 since the kernel writes this note out first when it
10560 creates a core file. */
50b2bdb7 10561 return elfcore_grok_netbsd_procinfo (abfd, note);
58e07198
CZ
10562#ifdef NT_NETBSDCORE_AUXV
10563 case NT_NETBSDCORE_AUXV:
10564 /* NetBSD-specific Elf Auxiliary Vector data. */
10565 return elfcore_make_auxv_note_section (abfd, note, 4);
10566#endif
10567 default:
10568 break;
50b2bdb7
AM
10569 }
10570
58e07198 10571 /* As of March 2017 there are no other machine-independent notes
b4db1224
JT
10572 defined for NetBSD core files. If the note type is less
10573 than the start of the machine-dependent note types, we don't
10574 understand it. */
47d9a591 10575
b4db1224 10576 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 10577 return TRUE;
50b2bdb7
AM
10578
10579
10580 switch (bfd_get_arch (abfd))
10581 {
08a40648
AM
10582 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10583 PT_GETFPREGS == mach+2. */
50b2bdb7
AM
10584
10585 case bfd_arch_alpha:
10586 case bfd_arch_sparc:
10587 switch (note->type)
08a40648
AM
10588 {
10589 case NT_NETBSDCORE_FIRSTMACH+0:
10590 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 10591
08a40648
AM
10592 case NT_NETBSDCORE_FIRSTMACH+2:
10593 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 10594
08a40648
AM
10595 default:
10596 return TRUE;
10597 }
50b2bdb7 10598
58e07198
CZ
10599 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10600 There's also old PT___GETREGS40 == mach + 1 for old reg
10601 structure which lacks GBR. */
10602
10603 case bfd_arch_sh:
10604 switch (note->type)
10605 {
10606 case NT_NETBSDCORE_FIRSTMACH+3:
10607 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10608
10609 case NT_NETBSDCORE_FIRSTMACH+5:
10610 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10611
10612 default:
10613 return TRUE;
10614 }
10615
08a40648
AM
10616 /* On all other arch's, PT_GETREGS == mach+1 and
10617 PT_GETFPREGS == mach+3. */
50b2bdb7
AM
10618
10619 default:
10620 switch (note->type)
08a40648
AM
10621 {
10622 case NT_NETBSDCORE_FIRSTMACH+1:
10623 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 10624
08a40648
AM
10625 case NT_NETBSDCORE_FIRSTMACH+3:
10626 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 10627
08a40648
AM
10628 default:
10629 return TRUE;
10630 }
50b2bdb7
AM
10631 }
10632 /* NOTREACHED */
10633}
10634
67cc5033
MK
10635static bfd_boolean
10636elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10637{
80a04378
NC
10638 if (note->descsz <= 0x48 + 31)
10639 return FALSE;
10640
67cc5033 10641 /* Signal number at offset 0x08. */
228e534f 10642 elf_tdata (abfd)->core->signal
67cc5033
MK
10643 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10644
10645 /* Process ID at offset 0x20. */
228e534f 10646 elf_tdata (abfd)->core->pid
67cc5033
MK
10647 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10648
10649 /* Command name at 0x48 (max 32 bytes, including nul). */
228e534f 10650 elf_tdata (abfd)->core->command
67cc5033
MK
10651 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10652
10653 return TRUE;
10654}
10655
10656static bfd_boolean
10657elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10658{
10659 if (note->type == NT_OPENBSD_PROCINFO)
10660 return elfcore_grok_openbsd_procinfo (abfd, note);
10661
10662 if (note->type == NT_OPENBSD_REGS)
10663 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10664
10665 if (note->type == NT_OPENBSD_FPREGS)
10666 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10667
10668 if (note->type == NT_OPENBSD_XFPREGS)
10669 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10670
10671 if (note->type == NT_OPENBSD_AUXV)
58e07198 10672 return elfcore_make_auxv_note_section (abfd, note, 0);
67cc5033
MK
10673
10674 if (note->type == NT_OPENBSD_WCOOKIE)
10675 {
10676 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10677 SEC_HAS_CONTENTS);
10678
10679 if (sect == NULL)
10680 return FALSE;
10681 sect->size = note->descsz;
10682 sect->filepos = note->descpos;
10683 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10684
10685 return TRUE;
10686 }
10687
10688 return TRUE;
10689}
10690
07c6e936 10691static bfd_boolean
d3fd4074 10692elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC
10693{
10694 void *ddata = note->descdata;
10695 char buf[100];
10696 char *name;
10697 asection *sect;
f8843e87
AM
10698 short sig;
10699 unsigned flags;
07c6e936 10700
80a04378
NC
10701 if (note->descsz < 16)
10702 return FALSE;
10703
07c6e936 10704 /* nto_procfs_status 'pid' field is at offset 0. */
228e534f 10705 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
07c6e936 10706
f8843e87
AM
10707 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10708 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10709
10710 /* nto_procfs_status 'flags' field is at offset 8. */
10711 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC
10712
10713 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM
10714 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10715 {
228e534f
AM
10716 elf_tdata (abfd)->core->signal = sig;
10717 elf_tdata (abfd)->core->lwpid = *tid;
f8843e87 10718 }
07c6e936 10719
f8843e87
AM
10720 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10721 do not come from signals so we make sure we set the current
10722 thread just in case. */
10723 if (flags & 0x00000080)
228e534f 10724 elf_tdata (abfd)->core->lwpid = *tid;
07c6e936
NC
10725
10726 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 10727 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 10728
a50b1753 10729 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC
10730 if (name == NULL)
10731 return FALSE;
10732 strcpy (name, buf);
10733
117ed4f8 10734 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC
10735 if (sect == NULL)
10736 return FALSE;
10737
07d6d2b8
AM
10738 sect->size = note->descsz;
10739 sect->filepos = note->descpos;
07c6e936
NC
10740 sect->alignment_power = 2;
10741
10742 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10743}
10744
10745static bfd_boolean
d69f560c
KW
10746elfcore_grok_nto_regs (bfd *abfd,
10747 Elf_Internal_Note *note,
d3fd4074 10748 long tid,
d69f560c 10749 char *base)
07c6e936
NC
10750{
10751 char buf[100];
10752 char *name;
10753 asection *sect;
10754
d69f560c 10755 /* Make a "(base)/%d" section. */
d3fd4074 10756 sprintf (buf, "%s/%ld", base, tid);
07c6e936 10757
a50b1753 10758 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC
10759 if (name == NULL)
10760 return FALSE;
10761 strcpy (name, buf);
10762
117ed4f8 10763 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC
10764 if (sect == NULL)
10765 return FALSE;
10766
07d6d2b8
AM
10767 sect->size = note->descsz;
10768 sect->filepos = note->descpos;
07c6e936
NC
10769 sect->alignment_power = 2;
10770
f8843e87 10771 /* This is the current thread. */
228e534f 10772 if (elf_tdata (abfd)->core->lwpid == tid)
d69f560c 10773 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM
10774
10775 return TRUE;
07c6e936
NC
10776}
10777
10778#define BFD_QNT_CORE_INFO 7
10779#define BFD_QNT_CORE_STATUS 8
10780#define BFD_QNT_CORE_GREG 9
10781#define BFD_QNT_CORE_FPREG 10
10782
10783static bfd_boolean
217aa764 10784elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC
10785{
10786 /* Every GREG section has a STATUS section before it. Store the
811072d8 10787 tid from the previous call to pass down to the next gregs
07c6e936 10788 function. */
d3fd4074 10789 static long tid = 1;
07c6e936
NC
10790
10791 switch (note->type)
10792 {
d69f560c
KW
10793 case BFD_QNT_CORE_INFO:
10794 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10795 case BFD_QNT_CORE_STATUS:
10796 return elfcore_grok_nto_status (abfd, note, &tid);
10797 case BFD_QNT_CORE_GREG:
10798 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10799 case BFD_QNT_CORE_FPREG:
10800 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10801 default:
10802 return TRUE;
07c6e936
NC
10803 }
10804}
10805
b15fa79e
AM
10806static bfd_boolean
10807elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10808{
10809 char *name;
10810 asection *sect;
10811 size_t len;
10812
10813 /* Use note name as section name. */
10814 len = note->namesz;
a50b1753 10815 name = (char *) bfd_alloc (abfd, len);
b15fa79e
AM
10816 if (name == NULL)
10817 return FALSE;
10818 memcpy (name, note->namedata, len);
10819 name[len - 1] = '\0';
10820
10821 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10822 if (sect == NULL)
10823 return FALSE;
10824
07d6d2b8
AM
10825 sect->size = note->descsz;
10826 sect->filepos = note->descpos;
b15fa79e
AM
10827 sect->alignment_power = 1;
10828
10829 return TRUE;
10830}
10831
7c76fa91
MS
10832/* Function: elfcore_write_note
10833
47d9a591 10834 Inputs:
a39f3346 10835 buffer to hold note, and current size of buffer
7c76fa91
MS
10836 name of note
10837 type of note
10838 data for note
10839 size of data for note
10840
a39f3346
AM
10841 Writes note to end of buffer. ELF64 notes are written exactly as
10842 for ELF32, despite the current (as of 2006) ELF gabi specifying
10843 that they ought to have 8-byte namesz and descsz field, and have
10844 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10845
7c76fa91 10846 Return:
a39f3346 10847 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS
10848
10849char *
a39f3346 10850elfcore_write_note (bfd *abfd,
217aa764 10851 char *buf,
a39f3346 10852 int *bufsiz,
217aa764 10853 const char *name,
a39f3346 10854 int type,
217aa764 10855 const void *input,
a39f3346 10856 int size)
7c76fa91
MS
10857{
10858 Elf_External_Note *xnp;
d4c88bbb 10859 size_t namesz;
d4c88bbb 10860 size_t newspace;
a39f3346 10861 char *dest;
7c76fa91 10862
d4c88bbb 10863 namesz = 0;
d4c88bbb 10864 if (name != NULL)
a39f3346 10865 namesz = strlen (name) + 1;
d4c88bbb 10866
a39f3346 10867 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 10868
a50b1753 10869 buf = (char *) realloc (buf, *bufsiz + newspace);
14b1c01e
AM
10870 if (buf == NULL)
10871 return buf;
a39f3346 10872 dest = buf + *bufsiz;
7c76fa91
MS
10873 *bufsiz += newspace;
10874 xnp = (Elf_External_Note *) dest;
10875 H_PUT_32 (abfd, namesz, xnp->namesz);
10876 H_PUT_32 (abfd, size, xnp->descsz);
10877 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM
10878 dest = xnp->name;
10879 if (name != NULL)
10880 {
10881 memcpy (dest, name, namesz);
10882 dest += namesz;
a39f3346 10883 while (namesz & 3)
d4c88bbb
AM
10884 {
10885 *dest++ = '\0';
a39f3346 10886 ++namesz;
d4c88bbb
AM
10887 }
10888 }
10889 memcpy (dest, input, size);
a39f3346
AM
10890 dest += size;
10891 while (size & 3)
10892 {
10893 *dest++ = '\0';
10894 ++size;
10895 }
10896 return buf;
7c76fa91
MS
10897}
10898
602f1657
AM
10899/* gcc-8 warns (*) on all the strncpy calls in this function about
10900 possible string truncation. The "truncation" is not a bug. We
10901 have an external representation of structs with fields that are not
10902 necessarily NULL terminated and corresponding internal
10903 representation fields that are one larger so that they can always
10904 be NULL terminated.
10905 gcc versions between 4.2 and 4.6 do not allow pragma control of
10906 diagnostics inside functions, giving a hard error if you try to use
10907 the finer control available with later versions.
10908 gcc prior to 4.2 warns about diagnostic push and pop.
10909 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10910 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10911 (*) Depending on your system header files! */
d99b4b92 10912#if GCC_VERSION >= 8000
602f1657
AM
10913# pragma GCC diagnostic push
10914# pragma GCC diagnostic ignored "-Wstringop-truncation"
d99b4b92 10915#endif
7c76fa91 10916char *
217aa764
AM
10917elfcore_write_prpsinfo (bfd *abfd,
10918 char *buf,
10919 int *bufsiz,
10920 const char *fname,
10921 const char *psargs)
7c76fa91 10922{
183e98be
AM
10923 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10924
10925 if (bed->elf_backend_write_core_note != NULL)
10926 {
10927 char *ret;
10928 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10929 NT_PRPSINFO, fname, psargs);
10930 if (ret != NULL)
10931 return ret;
10932 }
7c76fa91 10933
1f20dca5 10934#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
602f1657 10935# if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
183e98be
AM
10936 if (bed->s->elfclass == ELFCLASS32)
10937 {
602f1657 10938# if defined (HAVE_PSINFO32_T)
183e98be
AM
10939 psinfo32_t data;
10940 int note_type = NT_PSINFO;
602f1657 10941# else
183e98be
AM
10942 prpsinfo32_t data;
10943 int note_type = NT_PRPSINFO;
602f1657 10944# endif
183e98be
AM
10945
10946 memset (&data, 0, sizeof (data));
10947 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10948 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10949 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 10950 "CORE", note_type, &data, sizeof (data));
183e98be
AM
10951 }
10952 else
602f1657 10953# endif
183e98be 10954 {
602f1657 10955# if defined (HAVE_PSINFO_T)
183e98be
AM
10956 psinfo_t data;
10957 int note_type = NT_PSINFO;
602f1657 10958# else
183e98be
AM
10959 prpsinfo_t data;
10960 int note_type = NT_PRPSINFO;
602f1657 10961# endif
7c76fa91 10962
183e98be
AM
10963 memset (&data, 0, sizeof (data));
10964 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10965 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10966 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 10967 "CORE", note_type, &data, sizeof (data));
183e98be 10968 }
7c76fa91
MS
10969#endif /* PSINFO_T or PRPSINFO_T */
10970
1f20dca5
UW
10971 free (buf);
10972 return NULL;
10973}
d99b4b92 10974#if GCC_VERSION >= 8000
602f1657 10975# pragma GCC diagnostic pop
d99b4b92 10976#endif
1f20dca5 10977
70a38d42
SDJ
10978char *
10979elfcore_write_linux_prpsinfo32
10980 (bfd *abfd, char *buf, int *bufsiz,
10981 const struct elf_internal_linux_prpsinfo *prpsinfo)
10982{
a2f63b2e
MR
10983 if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10984 {
10985 struct elf_external_linux_prpsinfo32_ugid16 data;
10986
10987 swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10988 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10989 &data, sizeof (data));
10990 }
10991 else
10992 {
10993 struct elf_external_linux_prpsinfo32_ugid32 data;
70a38d42 10994
a2f63b2e
MR
10995 swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10996 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10997 &data, sizeof (data));
10998 }
70a38d42
SDJ
10999}
11000
11001char *
11002elfcore_write_linux_prpsinfo64
11003 (bfd *abfd, char *buf, int *bufsiz,
11004 const struct elf_internal_linux_prpsinfo *prpsinfo)
11005{
3c9a7b0d
MR
11006 if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
11007 {
11008 struct elf_external_linux_prpsinfo64_ugid16 data;
11009
11010 swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
11011 return elfcore_write_note (abfd, buf, bufsiz,
11012 "CORE", NT_PRPSINFO, &data, sizeof (data));
11013 }
11014 else
11015 {
11016 struct elf_external_linux_prpsinfo64_ugid32 data;
70a38d42 11017
3c9a7b0d
MR
11018 swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
11019 return elfcore_write_note (abfd, buf, bufsiz,
11020 "CORE", NT_PRPSINFO, &data, sizeof (data));
11021 }
70a38d42
SDJ
11022}
11023
7c76fa91 11024char *
217aa764
AM
11025elfcore_write_prstatus (bfd *abfd,
11026 char *buf,
11027 int *bufsiz,
11028 long pid,
11029 int cursig,
11030 const void *gregs)
7c76fa91 11031{
183e98be 11032 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 11033
183e98be
AM
11034 if (bed->elf_backend_write_core_note != NULL)
11035 {
11036 char *ret;
11037 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
11038 NT_PRSTATUS,
11039 pid, cursig, gregs);
11040 if (ret != NULL)
11041 return ret;
11042 }
11043
1f20dca5 11044#if defined (HAVE_PRSTATUS_T)
183e98be
AM
11045#if defined (HAVE_PRSTATUS32_T)
11046 if (bed->s->elfclass == ELFCLASS32)
11047 {
11048 prstatus32_t prstat;
11049
11050 memset (&prstat, 0, sizeof (prstat));
11051 prstat.pr_pid = pid;
11052 prstat.pr_cursig = cursig;
11053 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 11054 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM
11055 NT_PRSTATUS, &prstat, sizeof (prstat));
11056 }
11057 else
11058#endif
11059 {
11060 prstatus_t prstat;
11061
11062 memset (&prstat, 0, sizeof (prstat));
11063 prstat.pr_pid = pid;
11064 prstat.pr_cursig = cursig;
11065 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 11066 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM
11067 NT_PRSTATUS, &prstat, sizeof (prstat));
11068 }
7c76fa91
MS
11069#endif /* HAVE_PRSTATUS_T */
11070
1f20dca5
UW
11071 free (buf);
11072 return NULL;
11073}
11074
51316059
MS
11075#if defined (HAVE_LWPSTATUS_T)
11076char *
217aa764
AM
11077elfcore_write_lwpstatus (bfd *abfd,
11078 char *buf,
11079 int *bufsiz,
11080 long pid,
11081 int cursig,
11082 const void *gregs)
51316059
MS
11083{
11084 lwpstatus_t lwpstat;
183e98be 11085 const char *note_name = "CORE";
51316059
MS
11086
11087 memset (&lwpstat, 0, sizeof (lwpstat));
11088 lwpstat.pr_lwpid = pid >> 16;
11089 lwpstat.pr_cursig = cursig;
11090#if defined (HAVE_LWPSTATUS_T_PR_REG)
d1e8523e 11091 memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
51316059
MS
11092#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11093#if !defined(gregs)
11094 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
11095 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
11096#else
11097 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
11098 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
11099#endif
11100#endif
47d9a591 11101 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS
11102 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
11103}
11104#endif /* HAVE_LWPSTATUS_T */
11105
7c76fa91
MS
11106#if defined (HAVE_PSTATUS_T)
11107char *
217aa764
AM
11108elfcore_write_pstatus (bfd *abfd,
11109 char *buf,
11110 int *bufsiz,
11111 long pid,
6c10990d
NC
11112 int cursig ATTRIBUTE_UNUSED,
11113 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91 11114{
183e98be
AM
11115 const char *note_name = "CORE";
11116#if defined (HAVE_PSTATUS32_T)
11117 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 11118
183e98be
AM
11119 if (bed->s->elfclass == ELFCLASS32)
11120 {
11121 pstatus32_t pstat;
11122
11123 memset (&pstat, 0, sizeof (pstat));
11124 pstat.pr_pid = pid & 0xffff;
11125 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11126 NT_PSTATUS, &pstat, sizeof (pstat));
11127 return buf;
11128 }
11129 else
11130#endif
11131 {
11132 pstatus_t pstat;
11133
11134 memset (&pstat, 0, sizeof (pstat));
11135 pstat.pr_pid = pid & 0xffff;
11136 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11137 NT_PSTATUS, &pstat, sizeof (pstat));
11138 return buf;
11139 }
7c76fa91
MS
11140}
11141#endif /* HAVE_PSTATUS_T */
11142
11143char *
217aa764
AM
11144elfcore_write_prfpreg (bfd *abfd,
11145 char *buf,
11146 int *bufsiz,
11147 const void *fpregs,
11148 int size)
7c76fa91 11149{
183e98be 11150 const char *note_name = "CORE";
47d9a591 11151 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS
11152 note_name, NT_FPREGSET, fpregs, size);
11153}
11154
11155char *
217aa764
AM
11156elfcore_write_prxfpreg (bfd *abfd,
11157 char *buf,
11158 int *bufsiz,
11159 const void *xfpregs,
11160 int size)
7c76fa91
MS
11161{
11162 char *note_name = "LINUX";
47d9a591 11163 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS
11164 note_name, NT_PRXFPREG, xfpregs, size);
11165}
11166
4339cae0
L
11167char *
11168elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
11169 const void *xfpregs, int size)
11170{
97de3545
JB
11171 char *note_name;
11172 if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
11173 note_name = "FreeBSD";
11174 else
11175 note_name = "LINUX";
4339cae0
L
11176 return elfcore_write_note (abfd, buf, bufsiz,
11177 note_name, NT_X86_XSTATE, xfpregs, size);
11178}
11179
97753bd5
AM
11180char *
11181elfcore_write_ppc_vmx (bfd *abfd,
11182 char *buf,
11183 int *bufsiz,
11184 const void *ppc_vmx,
11185 int size)
11186{
11187 char *note_name = "LINUX";
11188 return elfcore_write_note (abfd, buf, bufsiz,
11189 note_name, NT_PPC_VMX, ppc_vmx, size);
11190}
11191
89eeb0bc
LM
11192char *
11193elfcore_write_ppc_vsx (bfd *abfd,
07d6d2b8
AM
11194 char *buf,
11195 int *bufsiz,
11196 const void *ppc_vsx,
11197 int size)
89eeb0bc
LM
11198{
11199 char *note_name = "LINUX";
11200 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11201 note_name, NT_PPC_VSX, ppc_vsx, size);
89eeb0bc
LM
11202}
11203
cb2366c1
EBM
11204char *
11205elfcore_write_ppc_tar (bfd *abfd,
4b24dd1a
AM
11206 char *buf,
11207 int *bufsiz,
11208 const void *ppc_tar,
11209 int size)
cb2366c1
EBM
11210{
11211 char *note_name = "LINUX";
11212 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11213 note_name, NT_PPC_TAR, ppc_tar, size);
cb2366c1
EBM
11214}
11215
11216char *
11217elfcore_write_ppc_ppr (bfd *abfd,
4b24dd1a
AM
11218 char *buf,
11219 int *bufsiz,
11220 const void *ppc_ppr,
11221 int size)
cb2366c1
EBM
11222{
11223 char *note_name = "LINUX";
11224 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11225 note_name, NT_PPC_PPR, ppc_ppr, size);
cb2366c1
EBM
11226}
11227
11228char *
11229elfcore_write_ppc_dscr (bfd *abfd,
4b24dd1a
AM
11230 char *buf,
11231 int *bufsiz,
11232 const void *ppc_dscr,
11233 int size)
cb2366c1
EBM
11234{
11235 char *note_name = "LINUX";
11236 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11237 note_name, NT_PPC_DSCR, ppc_dscr, size);
cb2366c1
EBM
11238}
11239
11240char *
11241elfcore_write_ppc_ebb (bfd *abfd,
4b24dd1a
AM
11242 char *buf,
11243 int *bufsiz,
11244 const void *ppc_ebb,
11245 int size)
cb2366c1
EBM
11246{
11247 char *note_name = "LINUX";
11248 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11249 note_name, NT_PPC_EBB, ppc_ebb, size);
cb2366c1
EBM
11250}
11251
11252char *
11253elfcore_write_ppc_pmu (bfd *abfd,
4b24dd1a
AM
11254 char *buf,
11255 int *bufsiz,
11256 const void *ppc_pmu,
11257 int size)
cb2366c1
EBM
11258{
11259 char *note_name = "LINUX";
11260 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11261 note_name, NT_PPC_PMU, ppc_pmu, size);
cb2366c1
EBM
11262}
11263
11264char *
11265elfcore_write_ppc_tm_cgpr (bfd *abfd,
4b24dd1a
AM
11266 char *buf,
11267 int *bufsiz,
11268 const void *ppc_tm_cgpr,
11269 int size)
cb2366c1
EBM
11270{
11271 char *note_name = "LINUX";
11272 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11273 note_name, NT_PPC_TM_CGPR, ppc_tm_cgpr, size);
cb2366c1
EBM
11274}
11275
11276char *
11277elfcore_write_ppc_tm_cfpr (bfd *abfd,
4b24dd1a
AM
11278 char *buf,
11279 int *bufsiz,
11280 const void *ppc_tm_cfpr,
11281 int size)
cb2366c1
EBM
11282{
11283 char *note_name = "LINUX";
11284 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11285 note_name, NT_PPC_TM_CFPR, ppc_tm_cfpr, size);
cb2366c1
EBM
11286}
11287
11288char *
11289elfcore_write_ppc_tm_cvmx (bfd *abfd,
4b24dd1a
AM
11290 char *buf,
11291 int *bufsiz,
11292 const void *ppc_tm_cvmx,
11293 int size)
cb2366c1
EBM
11294{
11295 char *note_name = "LINUX";
11296 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11297 note_name, NT_PPC_TM_CVMX, ppc_tm_cvmx, size);
cb2366c1
EBM
11298}
11299
11300char *
11301elfcore_write_ppc_tm_cvsx (bfd *abfd,
4b24dd1a
AM
11302 char *buf,
11303 int *bufsiz,
11304 const void *ppc_tm_cvsx,
11305 int size)
cb2366c1
EBM
11306{
11307 char *note_name = "LINUX";
11308 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11309 note_name, NT_PPC_TM_CVSX, ppc_tm_cvsx, size);
cb2366c1
EBM
11310}
11311
11312char *
11313elfcore_write_ppc_tm_spr (bfd *abfd,
4b24dd1a
AM
11314 char *buf,
11315 int *bufsiz,
11316 const void *ppc_tm_spr,
11317 int size)
cb2366c1
EBM
11318{
11319 char *note_name = "LINUX";
11320 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11321 note_name, NT_PPC_TM_SPR, ppc_tm_spr, size);
cb2366c1
EBM
11322}
11323
11324char *
11325elfcore_write_ppc_tm_ctar (bfd *abfd,
4b24dd1a
AM
11326 char *buf,
11327 int *bufsiz,
11328 const void *ppc_tm_ctar,
11329 int size)
cb2366c1
EBM
11330{
11331 char *note_name = "LINUX";
11332 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11333 note_name, NT_PPC_TM_CTAR, ppc_tm_ctar, size);
cb2366c1
EBM
11334}
11335
11336char *
11337elfcore_write_ppc_tm_cppr (bfd *abfd,
4b24dd1a
AM
11338 char *buf,
11339 int *bufsiz,
11340 const void *ppc_tm_cppr,
11341 int size)
cb2366c1
EBM
11342{
11343 char *note_name = "LINUX";
11344 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11345 note_name, NT_PPC_TM_CPPR, ppc_tm_cppr, size);
cb2366c1
EBM
11346}
11347
11348char *
11349elfcore_write_ppc_tm_cdscr (bfd *abfd,
4b24dd1a
AM
11350 char *buf,
11351 int *bufsiz,
11352 const void *ppc_tm_cdscr,
11353 int size)
cb2366c1
EBM
11354{
11355 char *note_name = "LINUX";
11356 return elfcore_write_note (abfd, buf, bufsiz,
4b24dd1a 11357 note_name, NT_PPC_TM_CDSCR, ppc_tm_cdscr, size);
cb2366c1
EBM
11358}
11359
0675e188
UW
11360static char *
11361elfcore_write_s390_high_gprs (bfd *abfd,
11362 char *buf,
11363 int *bufsiz,
11364 const void *s390_high_gprs,
11365 int size)
11366{
11367 char *note_name = "LINUX";
11368 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11369 note_name, NT_S390_HIGH_GPRS,
0675e188
UW
11370 s390_high_gprs, size);
11371}
11372
d7eeb400
MS
11373char *
11374elfcore_write_s390_timer (bfd *abfd,
07d6d2b8
AM
11375 char *buf,
11376 int *bufsiz,
11377 const void *s390_timer,
11378 int size)
d7eeb400
MS
11379{
11380 char *note_name = "LINUX";
11381 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11382 note_name, NT_S390_TIMER, s390_timer, size);
d7eeb400
MS
11383}
11384
11385char *
11386elfcore_write_s390_todcmp (bfd *abfd,
07d6d2b8
AM
11387 char *buf,
11388 int *bufsiz,
11389 const void *s390_todcmp,
11390 int size)
d7eeb400
MS
11391{
11392 char *note_name = "LINUX";
11393 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11394 note_name, NT_S390_TODCMP, s390_todcmp, size);
d7eeb400
MS
11395}
11396
11397char *
11398elfcore_write_s390_todpreg (bfd *abfd,
07d6d2b8
AM
11399 char *buf,
11400 int *bufsiz,
11401 const void *s390_todpreg,
11402 int size)
d7eeb400
MS
11403{
11404 char *note_name = "LINUX";
11405 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11406 note_name, NT_S390_TODPREG, s390_todpreg, size);
d7eeb400
MS
11407}
11408
11409char *
11410elfcore_write_s390_ctrs (bfd *abfd,
07d6d2b8
AM
11411 char *buf,
11412 int *bufsiz,
11413 const void *s390_ctrs,
11414 int size)
d7eeb400
MS
11415{
11416 char *note_name = "LINUX";
11417 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11418 note_name, NT_S390_CTRS, s390_ctrs, size);
d7eeb400
MS
11419}
11420
11421char *
11422elfcore_write_s390_prefix (bfd *abfd,
07d6d2b8
AM
11423 char *buf,
11424 int *bufsiz,
11425 const void *s390_prefix,
11426 int size)
d7eeb400
MS
11427{
11428 char *note_name = "LINUX";
11429 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11430 note_name, NT_S390_PREFIX, s390_prefix, size);
d7eeb400
MS
11431}
11432
355b81d9
UW
11433char *
11434elfcore_write_s390_last_break (bfd *abfd,
11435 char *buf,
11436 int *bufsiz,
11437 const void *s390_last_break,
11438 int size)
11439{
11440 char *note_name = "LINUX";
11441 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11442 note_name, NT_S390_LAST_BREAK,
355b81d9
UW
11443 s390_last_break, size);
11444}
11445
11446char *
11447elfcore_write_s390_system_call (bfd *abfd,
11448 char *buf,
11449 int *bufsiz,
11450 const void *s390_system_call,
11451 int size)
11452{
11453 char *note_name = "LINUX";
11454 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11455 note_name, NT_S390_SYSTEM_CALL,
355b81d9
UW
11456 s390_system_call, size);
11457}
11458
abb3f6cc
NC
11459char *
11460elfcore_write_s390_tdb (bfd *abfd,
11461 char *buf,
11462 int *bufsiz,
11463 const void *s390_tdb,
11464 int size)
11465{
11466 char *note_name = "LINUX";
11467 return elfcore_write_note (abfd, buf, bufsiz,
07d6d2b8 11468 note_name, NT_S390_TDB, s390_tdb, size);
abb3f6cc
NC
11469}
11470
4ef9f41a
AA
11471char *
11472elfcore_write_s390_vxrs_low (bfd *abfd,
11473 char *buf,
11474 int *bufsiz,
11475 const void *s390_vxrs_low,
11476 int size)
11477{
11478 char *note_name = "LINUX";
11479 return elfcore_write_note (abfd, buf, bufsiz,
11480 note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
11481}
11482
11483char *
11484elfcore_write_s390_vxrs_high (bfd *abfd,
11485 char *buf,
11486 int *bufsiz,
11487 const void *s390_vxrs_high,
11488 int size)
11489{
11490 char *note_name = "LINUX";
11491 return elfcore_write_note (abfd, buf, bufsiz,
11492 note_name, NT_S390_VXRS_HIGH,
11493 s390_vxrs_high, size);
11494}
11495
88ab90e8
AA
11496char *
11497elfcore_write_s390_gs_cb (bfd *abfd,
11498 char *buf,
11499 int *bufsiz,
11500 const void *s390_gs_cb,
11501 int size)
11502{
11503 char *note_name = "LINUX";
11504 return elfcore_write_note (abfd, buf, bufsiz,
11505 note_name, NT_S390_GS_CB,
11506 s390_gs_cb, size);
11507}
11508
11509char *
11510elfcore_write_s390_gs_bc (bfd *abfd,
11511 char *buf,
11512 int *bufsiz,
11513 const void *s390_gs_bc,
11514 int size)
11515{
11516 char *note_name = "LINUX";
11517 return elfcore_write_note (abfd, buf, bufsiz,
11518 note_name, NT_S390_GS_BC,
11519 s390_gs_bc, size);
11520}
11521
faa9a424
UW
11522char *
11523elfcore_write_arm_vfp (bfd *abfd,
11524 char *buf,
11525 int *bufsiz,
11526 const void *arm_vfp,
11527 int size)
11528{
11529 char *note_name = "LINUX";
11530 return elfcore_write_note (abfd, buf, bufsiz,
11531 note_name, NT_ARM_VFP, arm_vfp, size);
11532}
11533
652451f8
YZ
11534char *
11535elfcore_write_aarch_tls (bfd *abfd,
11536 char *buf,
11537 int *bufsiz,
11538 const void *aarch_tls,
11539 int size)
11540{
11541 char *note_name = "LINUX";
11542 return elfcore_write_note (abfd, buf, bufsiz,
11543 note_name, NT_ARM_TLS, aarch_tls, size);
11544}
11545
11546char *
11547elfcore_write_aarch_hw_break (bfd *abfd,
11548 char *buf,
11549 int *bufsiz,
11550 const void *aarch_hw_break,
11551 int size)
11552{
11553 char *note_name = "LINUX";
11554 return elfcore_write_note (abfd, buf, bufsiz,
11555 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11556}
11557
11558char *
11559elfcore_write_aarch_hw_watch (bfd *abfd,
11560 char *buf,
11561 int *bufsiz,
11562 const void *aarch_hw_watch,
11563 int size)
11564{
11565 char *note_name = "LINUX";
11566 return elfcore_write_note (abfd, buf, bufsiz,
11567 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11568}
11569
ad1cc4e4
AH
11570char *
11571elfcore_write_aarch_sve (bfd *abfd,
11572 char *buf,
11573 int *bufsiz,
11574 const void *aarch_sve,
11575 int size)
11576{
11577 char *note_name = "LINUX";
11578 return elfcore_write_note (abfd, buf, bufsiz,
11579 note_name, NT_ARM_SVE, aarch_sve, size);
11580}
11581
e6c3b5bf
AH
11582char *
11583elfcore_write_aarch_pauth (bfd *abfd,
11584 char *buf,
11585 int *bufsiz,
11586 const void *aarch_pauth,
11587 int size)
11588{
11589 char *note_name = "LINUX";
11590 return elfcore_write_note (abfd, buf, bufsiz,
11591 note_name, NT_ARM_PAC_MASK, aarch_pauth, size);
11592}
11593
bb864ac1
CES
11594char *
11595elfcore_write_register_note (bfd *abfd,
11596 char *buf,
11597 int *bufsiz,
11598 const char *section,
11599 const void *data,
11600 int size)
11601{
11602 if (strcmp (section, ".reg2") == 0)
11603 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11604 if (strcmp (section, ".reg-xfp") == 0)
11605 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
4339cae0
L
11606 if (strcmp (section, ".reg-xstate") == 0)
11607 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
bb864ac1
CES
11608 if (strcmp (section, ".reg-ppc-vmx") == 0)
11609 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
89eeb0bc
LM
11610 if (strcmp (section, ".reg-ppc-vsx") == 0)
11611 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
cb2366c1
EBM
11612 if (strcmp (section, ".reg-ppc-tar") == 0)
11613 return elfcore_write_ppc_tar (abfd, buf, bufsiz, data, size);
11614 if (strcmp (section, ".reg-ppc-ppr") == 0)
11615 return elfcore_write_ppc_ppr (abfd, buf, bufsiz, data, size);
11616 if (strcmp (section, ".reg-ppc-dscr") == 0)
11617 return elfcore_write_ppc_dscr (abfd, buf, bufsiz, data, size);
11618 if (strcmp (section, ".reg-ppc-ebb") == 0)
11619 return elfcore_write_ppc_ebb (abfd, buf, bufsiz, data, size);
11620 if (strcmp (section, ".reg-ppc-pmu") == 0)
11621 return elfcore_write_ppc_pmu (abfd, buf, bufsiz, data, size);
11622 if (strcmp (section, ".reg-ppc-tm-cgpr") == 0)
11623 return elfcore_write_ppc_tm_cgpr (abfd, buf, bufsiz, data, size);
11624 if (strcmp (section, ".reg-ppc-tm-cfpr") == 0)
11625 return elfcore_write_ppc_tm_cfpr (abfd, buf, bufsiz, data, size);
11626 if (strcmp (section, ".reg-ppc-tm-cvmx") == 0)
11627 return elfcore_write_ppc_tm_cvmx (abfd, buf, bufsiz, data, size);
11628 if (strcmp (section, ".reg-ppc-tm-cvsx") == 0)
11629 return elfcore_write_ppc_tm_cvsx (abfd, buf, bufsiz, data, size);
11630 if (strcmp (section, ".reg-ppc-tm-spr") == 0)
11631 return elfcore_write_ppc_tm_spr (abfd, buf, bufsiz, data, size);
11632 if (strcmp (section, ".reg-ppc-tm-ctar") == 0)
11633 return elfcore_write_ppc_tm_ctar (abfd, buf, bufsiz, data, size);
11634 if (strcmp (section, ".reg-ppc-tm-cppr") == 0)
11635 return elfcore_write_ppc_tm_cppr (abfd, buf, bufsiz, data, size);
11636 if (strcmp (section, ".reg-ppc-tm-cdscr") == 0)
11637 return elfcore_write_ppc_tm_cdscr (abfd, buf, bufsiz, data, size);
0675e188
UW
11638 if (strcmp (section, ".reg-s390-high-gprs") == 0)
11639 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
d7eeb400
MS
11640 if (strcmp (section, ".reg-s390-timer") == 0)
11641 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11642 if (strcmp (section, ".reg-s390-todcmp") == 0)
11643 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11644 if (strcmp (section, ".reg-s390-todpreg") == 0)
11645 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11646 if (strcmp (section, ".reg-s390-ctrs") == 0)
11647 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11648 if (strcmp (section, ".reg-s390-prefix") == 0)
11649 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
355b81d9
UW
11650 if (strcmp (section, ".reg-s390-last-break") == 0)
11651 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11652 if (strcmp (section, ".reg-s390-system-call") == 0)
11653 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
abb3f6cc
NC
11654 if (strcmp (section, ".reg-s390-tdb") == 0)
11655 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
4ef9f41a
AA
11656 if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11657 return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11658 if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11659 return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
88ab90e8
AA
11660 if (strcmp (section, ".reg-s390-gs-cb") == 0)
11661 return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11662 if (strcmp (section, ".reg-s390-gs-bc") == 0)
11663 return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
faa9a424
UW
11664 if (strcmp (section, ".reg-arm-vfp") == 0)
11665 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
652451f8
YZ
11666 if (strcmp (section, ".reg-aarch-tls") == 0)
11667 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11668 if (strcmp (section, ".reg-aarch-hw-break") == 0)
11669 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11670 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11671 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
ad1cc4e4
AH
11672 if (strcmp (section, ".reg-aarch-sve") == 0)
11673 return elfcore_write_aarch_sve (abfd, buf, bufsiz, data, size);
e6c3b5bf
AH
11674 if (strcmp (section, ".reg-aarch-pauth") == 0)
11675 return elfcore_write_aarch_pauth (abfd, buf, bufsiz, data, size);
bb864ac1
CES
11676 return NULL;
11677}
11678
b34976b6 11679static bfd_boolean
276da9b3
L
11680elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11681 size_t align)
252b5132 11682{
c044fabd 11683 char *p;
252b5132 11684
276da9b3
L
11685 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11686 gABI specifies that PT_NOTE alignment should be aligned to 4
11687 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11688 align is less than 4, we use 4 byte alignment. */
11689 if (align < 4)
11690 align = 4;
ef135d43
NC
11691 if (align != 4 && align != 8)
11692 return FALSE;
276da9b3 11693
252b5132
RH
11694 p = buf;
11695 while (p < buf + size)
11696 {
c044fabd 11697 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH
11698 Elf_Internal_Note in;
11699
baea7ef1
AM
11700 if (offsetof (Elf_External_Note, name) > buf - p + size)
11701 return FALSE;
11702
dc810e39 11703 in.type = H_GET_32 (abfd, xnp->type);
252b5132 11704
dc810e39 11705 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132 11706 in.namedata = xnp->name;
baea7ef1
AM
11707 if (in.namesz > buf - in.namedata + size)
11708 return FALSE;
252b5132 11709
dc810e39 11710 in.descsz = H_GET_32 (abfd, xnp->descsz);
276da9b3 11711 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
252b5132 11712 in.descpos = offset + (in.descdata - buf);
baea7ef1
AM
11713 if (in.descsz != 0
11714 && (in.descdata >= buf + size
11715 || in.descsz > buf - in.descdata + size))
11716 return FALSE;
252b5132 11717
718175fa 11718 switch (bfd_get_format (abfd))
07d6d2b8 11719 {
718175fa
JK
11720 default:
11721 return TRUE;
11722
11723 case bfd_core:
f64e188b 11724 {
8acbedd6 11725#define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
f64e188b 11726 struct
718175fa 11727 {
f64e188b 11728 const char * string;
8acbedd6 11729 size_t len;
f64e188b 11730 bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
718175fa 11731 }
f64e188b 11732 grokers[] =
b15fa79e 11733 {
8acbedd6 11734 GROKER_ELEMENT ("", elfcore_grok_note),
aa1ed4a9 11735 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
8acbedd6
KS
11736 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11737 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11738 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11739 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
f64e188b 11740 };
8acbedd6 11741#undef GROKER_ELEMENT
f64e188b
NC
11742 int i;
11743
11744 for (i = ARRAY_SIZE (grokers); i--;)
8acbedd6
KS
11745 {
11746 if (in.namesz >= grokers[i].len
11747 && strncmp (in.namedata, grokers[i].string,
11748 grokers[i].len) == 0)
11749 {
11750 if (! grokers[i].func (abfd, & in))
11751 return FALSE;
11752 break;
11753 }
11754 }
f64e188b
NC
11755 break;
11756 }
718175fa
JK
11757
11758 case bfd_object:
11759 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11760 {
11761 if (! elfobj_grok_gnu_note (abfd, &in))
11762 return FALSE;
11763 }
e21e5835
NC
11764 else if (in.namesz == sizeof "stapsdt"
11765 && strcmp (in.namedata, "stapsdt") == 0)
11766 {
11767 if (! elfobj_grok_stapsdt_note (abfd, &in))
11768 return FALSE;
11769 }
718175fa 11770 break;
08a40648 11771 }
252b5132 11772
276da9b3 11773 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
252b5132
RH
11774 }
11775
718175fa
JK
11776 return TRUE;
11777}
11778
11779static bfd_boolean
276da9b3
L
11780elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11781 size_t align)
718175fa
JK
11782{
11783 char *buf;
11784
957e1fc1 11785 if (size == 0 || (size + 1) == 0)
718175fa
JK
11786 return TRUE;
11787
11788 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11789 return FALSE;
11790
f64e188b 11791 buf = (char *) bfd_malloc (size + 1);
718175fa
JK
11792 if (buf == NULL)
11793 return FALSE;
11794
f64e188b
NC
11795 /* PR 17512: file: ec08f814
11796 0-termintate the buffer so that string searches will not overflow. */
11797 buf[size] = 0;
11798
718175fa 11799 if (bfd_bread (buf, size, abfd) != size
276da9b3 11800 || !elf_parse_notes (abfd, buf, size, offset, align))
718175fa
JK
11801 {
11802 free (buf);
11803 return FALSE;
11804 }
11805
252b5132 11806 free (buf);
b34976b6 11807 return TRUE;
252b5132 11808}
98d8431c
JB
11809\f
11810/* Providing external access to the ELF program header table. */
11811
11812/* Return an upper bound on the number of bytes required to store a
11813 copy of ABFD's program header table entries. Return -1 if an error
11814 occurs; bfd_get_error will return an appropriate code. */
c044fabd 11815
98d8431c 11816long
217aa764 11817bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB
11818{
11819 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11820 {
11821 bfd_set_error (bfd_error_wrong_format);
11822 return -1;
11823 }
11824
936e320b 11825 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB
11826}
11827
98d8431c
JB
11828/* Copy ABFD's program header table entries to *PHDRS. The entries
11829 will be stored as an array of Elf_Internal_Phdr structures, as
11830 defined in include/elf/internal.h. To find out how large the
11831 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11832
11833 Return the number of program header table entries read, or -1 if an
11834 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 11835
98d8431c 11836int
217aa764 11837bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB
11838{
11839 int num_phdrs;
11840
11841 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11842 {
11843 bfd_set_error (bfd_error_wrong_format);
11844 return -1;
11845 }
11846
11847 num_phdrs = elf_elfheader (abfd)->e_phnum;
01bcaf63
TT
11848 if (num_phdrs != 0)
11849 memcpy (phdrs, elf_tdata (abfd)->phdr,
11850 num_phdrs * sizeof (Elf_Internal_Phdr));
98d8431c
JB
11851
11852 return num_phdrs;
11853}
ae4221d7 11854
db6751f2 11855enum elf_reloc_type_class
7e612e98
AM
11856_bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11857 const asection *rel_sec ATTRIBUTE_UNUSED,
11858 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ
11859{
11860 return reloc_class_normal;
11861}
f8df10f4 11862
47d9a591 11863/* For RELA architectures, return the relocation value for a
f8df10f4
JJ
11864 relocation against a local symbol. */
11865
11866bfd_vma
217aa764
AM
11867_bfd_elf_rela_local_sym (bfd *abfd,
11868 Elf_Internal_Sym *sym,
8517fae7 11869 asection **psec,
217aa764 11870 Elf_Internal_Rela *rel)
f8df10f4 11871{
8517fae7 11872 asection *sec = *psec;
f8df10f4
JJ
11873 bfd_vma relocation;
11874
6835821b
AM
11875 relocation = (sec->output_section->vma
11876 + sec->output_offset
11877 + sym->st_value);
f8df10f4 11878 if ((sec->flags & SEC_MERGE)
c629eae0 11879 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 11880 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
f8df10f4 11881 {
f8df10f4 11882 rel->r_addend =
8517fae7 11883 _bfd_merged_section_offset (abfd, psec,
65765700 11884 elf_section_data (sec)->sec_info,
753731ee
AM
11885 sym->st_value + rel->r_addend);
11886 if (sec != *psec)
11887 {
11888 /* If we have changed the section, and our original section is
11889 marked with SEC_EXCLUDE, it means that the original
11890 SEC_MERGE section has been completely subsumed in some
11891 other SEC_MERGE section. In this case, we need to leave
11892 some info around for --emit-relocs. */
11893 if ((sec->flags & SEC_EXCLUDE) != 0)
11894 sec->kept_section = *psec;
11895 sec = *psec;
11896 }
8517fae7
AM
11897 rel->r_addend -= relocation;
11898 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ
11899 }
11900 return relocation;
11901}
c629eae0
JJ
11902
11903bfd_vma
217aa764
AM
11904_bfd_elf_rel_local_sym (bfd *abfd,
11905 Elf_Internal_Sym *sym,
11906 asection **psec,
11907 bfd_vma addend)
47d9a591 11908{
c629eae0
JJ
11909 asection *sec = *psec;
11910
6835821b 11911 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
c629eae0
JJ
11912 return sym->st_value + addend;
11913
11914 return _bfd_merged_section_offset (abfd, psec,
65765700 11915 elf_section_data (sec)->sec_info,
753731ee 11916 sym->st_value + addend);
c629eae0
JJ
11917}
11918
37b01f6a
DG
11919/* Adjust an address within a section. Given OFFSET within SEC, return
11920 the new offset within the section, based upon changes made to the
11921 section. Returns -1 if the offset is now invalid.
11922 The offset (in abnd out) is in target sized bytes, however big a
11923 byte may be. */
11924
c629eae0 11925bfd_vma
217aa764 11926_bfd_elf_section_offset (bfd *abfd,
92e4ec35 11927 struct bfd_link_info *info,
217aa764
AM
11928 asection *sec,
11929 bfd_vma offset)
c629eae0 11930{
68bfbfcc 11931 switch (sec->sec_info_type)
65765700 11932 {
dbaa2011 11933 case SEC_INFO_TYPE_STABS:
eea6121a
AM
11934 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11935 offset);
dbaa2011 11936 case SEC_INFO_TYPE_EH_FRAME:
92e4ec35 11937 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
37b01f6a 11938
65765700 11939 default:
310fd250
L
11940 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11941 {
37b01f6a 11942 /* Reverse the offset. */
310fd250
L
11943 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11944 bfd_size_type address_size = bed->s->arch_size / 8;
37b01f6a
DG
11945
11946 /* address_size and sec->size are in octets. Convert
11947 to bytes before subtracting the original offset. */
11948 offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
310fd250 11949 }
65765700
JJ
11950 return offset;
11951 }
c629eae0 11952}
3333a7c3
RM
11953\f
11954/* Create a new BFD as if by bfd_openr. Rather than opening a file,
11955 reconstruct an ELF file by reading the segments out of remote memory
11956 based on the ELF file header at EHDR_VMA and the ELF program headers it
11957 points to. If not null, *LOADBASEP is filled in with the difference
11958 between the VMAs from which the segments were read, and the VMAs the
11959 file headers (and hence BFD's idea of each section's VMA) put them at.
11960
11961 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11962 remote memory at target address VMA into the local buffer at MYADDR; it
11963 should return zero on success or an `errno' code on failure. TEMPL must
11964 be a BFD for an ELF target with the word size and byte order found in
11965 the remote memory. */
11966
11967bfd *
217aa764
AM
11968bfd_elf_bfd_from_remote_memory
11969 (bfd *templ,
11970 bfd_vma ehdr_vma,
f0a5d95a 11971 bfd_size_type size,
217aa764 11972 bfd_vma *loadbasep,
fe78531d 11973 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
3333a7c3
RM
11974{
11975 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
5979d6b6 11976 (templ, ehdr_vma, size, loadbasep, target_read_memory);
3333a7c3 11977}
4c45e5c9
JJ
11978\f
11979long
c9727e01
AM
11980_bfd_elf_get_synthetic_symtab (bfd *abfd,
11981 long symcount ATTRIBUTE_UNUSED,
11982 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 11983 long dynsymcount,
c9727e01
AM
11984 asymbol **dynsyms,
11985 asymbol **ret)
4c45e5c9
JJ
11986{
11987 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11988 asection *relplt;
11989 asymbol *s;
11990 const char *relplt_name;
11991 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11992 arelent *p;
11993 long count, i, n;
11994 size_t size;
11995 Elf_Internal_Shdr *hdr;
11996 char *names;
11997 asection *plt;
11998
8615f3f2
AM
11999 *ret = NULL;
12000
90e3cdf2
JJ
12001 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
12002 return 0;
12003
8615f3f2
AM
12004 if (dynsymcount <= 0)
12005 return 0;
12006
4c45e5c9
JJ
12007 if (!bed->plt_sym_val)
12008 return 0;
12009
12010 relplt_name = bed->relplt_name;
12011 if (relplt_name == NULL)
d35fd659 12012 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
4c45e5c9
JJ
12013 relplt = bfd_get_section_by_name (abfd, relplt_name);
12014 if (relplt == NULL)
12015 return 0;
12016
12017 hdr = &elf_section_data (relplt)->this_hdr;
12018 if (hdr->sh_link != elf_dynsymtab (abfd)
12019 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
12020 return 0;
12021
12022 plt = bfd_get_section_by_name (abfd, ".plt");
12023 if (plt == NULL)
12024 return 0;
12025
12026 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 12027 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ
12028 return -1;
12029
eea6121a 12030 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ
12031 size = count * sizeof (asymbol);
12032 p = relplt->relocation;
cb53bf42 12033 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
041de40d
AM
12034 {
12035 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
12036 if (p->addend != 0)
12037 {
12038#ifdef BFD64
12039 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
12040#else
12041 size += sizeof ("+0x") - 1 + 8;
12042#endif
12043 }
12044 }
4c45e5c9 12045
a50b1753 12046 s = *ret = (asymbol *) bfd_malloc (size);
4c45e5c9
JJ
12047 if (s == NULL)
12048 return -1;
12049
12050 names = (char *) (s + count);
12051 p = relplt->relocation;
12052 n = 0;
cb53bf42 12053 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ
12054 {
12055 size_t len;
12056 bfd_vma addr;
12057
12058 addr = bed->plt_sym_val (i, plt, p);
12059 if (addr == (bfd_vma) -1)
12060 continue;
12061
12062 *s = **p->sym_ptr_ptr;
65a7a66f
AM
12063 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12064 we are defining a symbol, ensure one of them is set. */
12065 if ((s->flags & BSF_LOCAL) == 0)
12066 s->flags |= BSF_GLOBAL;
6ba2a415 12067 s->flags |= BSF_SYNTHETIC;
4c45e5c9
JJ
12068 s->section = plt;
12069 s->value = addr - plt->vma;
12070 s->name = names;
8f39ba8e 12071 s->udata.p = NULL;
4c45e5c9
JJ
12072 len = strlen ((*p->sym_ptr_ptr)->name);
12073 memcpy (names, (*p->sym_ptr_ptr)->name, len);
12074 names += len;
041de40d
AM
12075 if (p->addend != 0)
12076 {
1d770845 12077 char buf[30], *a;
d324f6d6 12078
041de40d
AM
12079 memcpy (names, "+0x", sizeof ("+0x") - 1);
12080 names += sizeof ("+0x") - 1;
1d770845
L
12081 bfd_sprintf_vma (abfd, buf, p->addend);
12082 for (a = buf; *a == '0'; ++a)
12083 ;
12084 len = strlen (a);
12085 memcpy (names, a, len);
12086 names += len;
041de40d 12087 }
4c45e5c9
JJ
12088 memcpy (names, "@plt", sizeof ("@plt"));
12089 names += sizeof ("@plt");
8f39ba8e 12090 ++s, ++n;
4c45e5c9
JJ
12091 }
12092
12093 return n;
12094}
3d7f7666 12095
821e6ff6
AM
12096/* It is only used by x86-64 so far.
12097 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
7eacd66b
AM
12098 but current usage would allow all of _bfd_std_section to be zero. */
12099static const asymbol lcomm_sym
12100 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
3b22753a 12101asection _bfd_elf_large_com_section
7eacd66b 12102 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
821e6ff6 12103 "LARGE_COMMON", 0, SEC_IS_COMMON);
ecca9871 12104
d1036acb 12105void
78245035
L
12106_bfd_elf_post_process_headers (bfd * abfd,
12107 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
d1036acb
L
12108{
12109 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
12110
12111 i_ehdrp = elf_elfheader (abfd);
12112
12113 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
d8045f23
NC
12114
12115 /* To make things simpler for the loader on Linux systems we set the
9c55345c 12116 osabi field to ELFOSABI_GNU if the binary contains symbols of
f64b2e8d 12117 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
d8045f23 12118 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
f64b2e8d 12119 && elf_tdata (abfd)->has_gnu_symbols)
9c55345c 12120 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
d1036acb 12121}
fcb93ecf
PB
12122
12123
12124/* Return TRUE for ELF symbol types that represent functions.
12125 This is the default version of this function, which is sufficient for
d8045f23 12126 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
fcb93ecf
PB
12127
12128bfd_boolean
12129_bfd_elf_is_function_type (unsigned int type)
12130{
d8045f23
NC
12131 return (type == STT_FUNC
12132 || type == STT_GNU_IFUNC);
fcb93ecf 12133}
9f296da3 12134
aef36ac1
AM
12135/* If the ELF symbol SYM might be a function in SEC, return the
12136 function size and set *CODE_OFF to the function's entry point,
12137 otherwise return zero. */
9f296da3 12138
aef36ac1
AM
12139bfd_size_type
12140_bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
12141 bfd_vma *code_off)
9f296da3 12142{
aef36ac1
AM
12143 bfd_size_type size;
12144
ff9e0f5b 12145 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
aef36ac1
AM
12146 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
12147 || sym->section != sec)
12148 return 0;
ff9e0f5b 12149
ff9e0f5b 12150 *code_off = sym->value;
aef36ac1
AM
12151 size = 0;
12152 if (!(sym->flags & BSF_SYNTHETIC))
12153 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
12154 if (size == 0)
12155 size = 1;
12156 return size;
9f296da3 12157}
This page took 2.434154 seconds and 4 git commands to generate.